# 通过Docker安装open-webui
用Docker安装只需要一行命令
```bash
docker run -d -p 3000:8080 -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:main
```
其中的`3000`可以改成任何不冲突的端口



由于是部署在服务器上的，服务器自然没有浏览器，因此需要配置`nginx`启用反向代理，然后用浏览器访问
```nginx
server {
    listen 443 ssl;
    server_name <域名>;

    # SSL 证书配置（请确认证书包含子域名）
    ssl_certificate <SSL证书地址>;
    ssl_certificate_key <SSL私钥地址>;

    # SSL 安全配置
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
    ssl_prefer_server_ciphers off;

    # 反向代理设置
    location / {
        proxy_pass http://127.0.0.1:<端口号，按照上文设置的话是3000>;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # WebSocket支持
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';

        # 超时设置（可选）
        proxy_connect_timeout 6000s;
        proxy_send_timeout 6000s;
        proxy_read_timeout 6000s;
    }
}
```
随后访问`https://<上面设置的域名>`即可访问面板，初次使用需要注册，第一个账号自动成为管理员账户

需要注意的是，初次登录会存在“OI”结束后白屏的情况，这是因为默认的OpenAI API与LLama API处于开启状态。这时不能气馁，多次刷新页面，有小概率能成功进入。进入后来到管理员面版

![image.png](/static/img/89c8757cba20d540c2a663214cb64fa7.image.webp)

来到`设置-外部链接`，将两个API的按钮都关掉即可正常登录（这里打开是因为后面部署了模型）

![image.png](/static/img/31ada4bf5ffa8761439371aea8cb14a6.image.webp)

# 使用API访问DeepSeek R1
首先需要拿到一个API和密钥，此处不妨使用硅基流动的服务：[跳转硅基流动账户注册](https://cloud.siliconflow.cn/i/FngeZEAX)

使用我的邀请码`FngeZEAX`注册后可以获得14元的免费额度。注册完成后来到`API密钥`页面，点击新建密钥

![image.png](/static/img/ce82e0d7842f8cd1946f8f6fca1e8e7c.image.webp)

复制密钥，然后回到open-webui的管理员页面，转到`函数`，然后新建函数

![image.png](/static/img/d17ceea0d89da6e9fb0ae0f73ecdfb63.image.webp)

编辑函数文件（来自[open-webui社区](https://openwebui.com/f/zgccrui/deepseek_r1)）
```python
"""
title: DeepSeek R1
author: zgccrui
description: 在OpwenWebUI中显示DeepSeek R1模型的思维链 - 仅支持0.5.6及以上版本
version: 1.2.6
licence: MIT
"""

import json
import httpx
import re
from typing import AsyncGenerator, Callable, Awaitable
from pydantic import BaseModel, Field
import asyncio


class Pipe:
    class Valves(BaseModel):
        DEEPSEEK_API_BASE_URL: str = Field(
            default="https://api.siliconflow.cn/v1",
            description="DeepSeek API的基础请求地址",
        )
        DEEPSEEK_API_KEY: str = Field(
            default="<刚刚注册的API密钥>",
            description="用于身份验证的DeepSeek API密钥，可从控制台获取",
        )
        DEEPSEEK_API_MODEL: str = Field(
            default="deepseek-ai/DeepSeek-R1",
            description="API请求的模型名称，默认为 deepseek-reasoner ",
        )

    def __init__(self):
        self.valves = self.Valves()
        self.data_prefix = "data: "
        self.thinking = -1  # -1:未开始 0:思考中 1:已回答
        self.emitter = None

    def pipes(self):
        return [
            {
                "id": self.valves.DEEPSEEK_API_MODEL,
                "name": self.valves.DEEPSEEK_API_MODEL,
            }
        ]

    async def pipe(
        self, body: dict, __event_emitter__: Callable[[dict], Awaitable[None]] = None
    ) -> AsyncGenerator[str, None]:
        """主处理管道（已移除缓冲）"""
        self.thinking = -1
        self.emitter = __event_emitter__

        # 验证配置
        if not self.valves.DEEPSEEK_API_KEY:
            yield json.dumps({"error": "未配置API密钥"}, ensure_ascii=False)
            return

        # 准备请求参数
        headers = {
            "Authorization": f"Bearer {self.valves.DEEPSEEK_API_KEY}",
            "Content-Type": "application/json",
        }

        try:
            # 模型ID提取
            model_id = body["model"].split(".", 1)[-1]
            payload = {**body, "model": model_id}

            # 处理消息以防止连续的相同角色
            messages = payload["messages"]
            i = 0
            while i < len(messages) - 1:
                if messages[i]["role"] == messages[i + 1]["role"]:
                    # 插入具有替代角色的占位符消息
                    alternate_role = (
                        "assistant" if messages[i]["role"] == "user" else "user"
                    )
                    messages.insert(
                        i + 1,
                        {"role": alternate_role, "content": "[Unfinished thinking]"},
                    )
                i += 1

            # yield json.dumps(payload, ensure_ascii=False)

            # 发起API请求
            async with httpx.AsyncClient(http2=True) as client:
                async with client.stream(
                    "POST",
                    f"{self.valves.DEEPSEEK_API_BASE_URL}/chat/completions",
                    json=payload,
                    headers=headers,
                    timeout=300,
                ) as response:
                    # 错误处理
                    if response.status_code != 200:
                        error = await response.aread()
                        yield self._format_error(response.status_code, error)
                        return

                    # 流式处理响应
                    async for line in response.aiter_lines():
                        if not line.startswith(self.data_prefix):
                            continue

                        # 截取 JSON 字符串
                        json_str = line[len(self.data_prefix) :]

                        try:
                            data = json.loads(json_str)
                        except json.JSONDecodeError as e:
                            # 格式化错误信息，这里传入错误类型和详细原因（包括出错内容和异常信息）
                            error_detail = f"解析失败 - 内容：{json_str}，原因：{e}"
                            yield self._format_error("JSONDecodeError", error_detail)
                            return

                        choice = data.get("choices", [{}])[0]

                        # 结束条件判断
                        if choice.get("finish_reason"):
                            return

                        # 状态机处理
                        state_output = await self._update_thinking_state(
                            choice.get("delta", {})
                        )
                        if state_output:
                            yield state_output  # 直接发送状态标记
                            if state_output == "<think>":
                                yield "\n"

                        # 内容处理并立即发送
                        content = self._process_content(choice["delta"])
                        if content:
                            if content.startswith("<think>"):
                                match = re.match(r"^<think>", content)
                                if match:
                                    content = re.sub(r"^<think>", "", content)
                                    yield "<think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"

                            elif content.startswith("</think>"):
                                match = re.match(r"^</think>", content)
                                if match:
                                    content = re.sub(r"^</think>", "", content)
                                    yield "</think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"
                            yield content

        except Exception as e:
            yield self._format_exception(e)

    async def _update_thinking_state(self, delta: dict) -> str:
        """更新思考状态机（简化版）"""
        state_output = ""

        # 状态转换：未开始 -> 思考中
        if self.thinking == -1 and delta.get("reasoning_content"):
            self.thinking = 0
            state_output = "<think>"

        # 状态转换：思考中 -> 已回答
        elif (
            self.thinking == 0
            and not delta.get("reasoning_content")
            and delta.get("content")
        ):
            self.thinking = 1
            state_output = "\n</think>\n\n"

        return state_output

    def _process_content(self, delta: dict) -> str:
        """直接返回处理后的内容"""
        return delta.get("reasoning_content", "") or delta.get("content", "")

    def _format_error(self, status_code: int, error: bytes) -> str:
        """错误格式化保持不变"""
        try:
            err_msg = json.loads(error).get("message", error.decode(errors="ignore"))[
                :200
            ]
        except:
            err_msg = error.decode(errors="ignore")[:200]
        return json.dumps(
            {"error": f"HTTP {status_code}: {err_msg}"}, ensure_ascii=False
        )

    def _format_exception(self, e: Exception) -> str:
        """异常格式化保持不变"""
        err_type = type(e).__name__
        return json.dumps({"error": f"{err_type}: {str(e)}"}, ensure_ascii=False)
```

需要将`<刚刚注册的API密钥>`替换为刚刚注册的API密钥，然后点击`保存`，并启用函数

![image.png](/static/img/16a2ccefde3166be47d4e5328f800441.image.webp)

随后DeepSeek-R1就自动出现在`模型`页面中了，退出管理员面板即可与其正常对话

部署open-webui通过API使用DeepSeek R1和其他LLM

由于Minecraft基岩版发新版本后会禁止旧版本的登陆，就像这样



![image.png](/static/img/1e82ee14f34fd9fd4db223a9950fbd99.image.webp)

因此需要维护服务器的更新

# 关闭旧服务端并备份数据
如果像我一样使用`screen`命令运行服务器的话，就可以使用下面的命令
```shell
screen -r mc
```
其中`mc`是服务端的名称，如果忘记的话可以使用下面的命令查看
```shell
screen -ls
```
期望中会输出这样的结果
```shell
There are screens on:
	3235882.mc	(10/26/2024 01:04:27 AM)	(Detached)
1 Sockets in /run/screen/S-ecs-user.
```
进入服务端后台后输入`stop`命令安全关闭服务端，输出会像这样
```shell
stop
[2025-01-17 20:07:01:040 INFO] Server stop requested.
[2025-01-17 20:07:01:130 INFO] Stopping server...
Quit correctly
```
关闭服务端后`ls`能看到目录的结构
```shell
allowlist.json                 Dedicated_Server.txt        MQC-121.30.1-server.zip  release-notes.txt  world_templates
bedrock_server                 definitions                 MQC-121.40.1-server.zip  resource_packs     读我.txt
bedrock-server-1.21.42.01.zip  development_behavior_packs  MQC-SERVER               server.properties
bedrock_server_how_to.html     development_resource_packs  packet-statistics.txt    treatments
behavior_packs                 development_skin_packs      permissions.json         worlds
config                         minecraftpe                 premium_cache            worlds.zip
```
其中需要备份的文件有
1. `worlds`文件夹：保存地图数据以及模组
2. `permissions.json`：保存用户权限
3. `server.properties`：保存服务端配置
4. `allowlist.json`：玩家白名单

需要注意的是`behavior_packs`和`resource_packs`是没有作用的，模组是装在`worlds`文件夹的，不需要迁移

# 配置新服务器
首先从官网下载最新的服务端，[下载链接](https://www.minecraft.net/zh-hans/download/server/bedrock)，可以选择直接`wget`下载也可以本地下载再上传到服务器

然后使用`unzip`解压
```shell
unzip bedrock-server-1.21.51.02.zip
```
解压后的目录应当是这样的
```shell
allowlist.json  bedrock-server-1.21.51.02.zip  behavior_packs  definitions       profanity_filter.wlist  resource_packs
bedrock_server  bedrock_server_how_to.html     config          permissions.json  release-notes.txt       server.properties
```

然后需要将之前服务端的数据迁移过来，使用命令（注意此时处于`mc-server-6`目录下，`mc-server-5`是要迁移的服务端）
```shell
cp -r ../mc-server-5/worlds ./
cp ../mc-server-5/permissions.json ./
cp ../mc-server-5/server.properties ./
cp ../mc-server-5/allowlist.json ./
```

# 模组卸载
基岩版小版本之间都存在模组适配存在问题，需要卸载后再启动，模组的卸载是需要手动的。进入
```shell
worlds/Bedrock level/
```
其中的目录结构是这样的
```shell
behavior_packs/  level.dat      levelname.txt    world_behavior_pack_history.json  world_resource_pack_history.json
db/              level.dat_old  resource_packs/  world_behavior_packs.json         world_resource_packs.json
```
需要操作的是`behavior_packs`目录和`world_behavior_packs.json`文件
- `behavior_packs`：放着模组的本体
- `world_behavior_packs.json`：服务端启动时从这里看要加载什么模组

由于只安装了连锁采集模组，`world_behavior_packs.json`是这样的
```json
[{"pack_id":"05a423a2-5644-fad1-7784-a6d4c369c820","version":[121,40,1]}]
```
它对应的是`worlds/Bedrock level/behavior_packs/chain_bp`目录中`manifest.json`文件的`header`属性
```shell
pack_id->uuid, version->version
```
下面贴出`manifest.json`文件

```json
{
	"format_version": 2,
	"header": {
		"name": "MQC-121.40.1-BP-SERVER",
		"uuid": "05a423a2-5644-fad1-7784-a6d4c369c820",
		"version": [121, 40, 1],
		"min_engine_version": [1, 21, 40]
	},
	"metadata": {
		"authors": ["lxhzzy"],
		"generated_with": {
			"esbuild": ["0.19.9"],
			"gulp": ["4.0.2"]
		},
		"license": "CC-BY-ND-4.0"
	},
	"modules": [
		{
			"description": "script_modules",
			"type": "script",
			"language": "javascript",
			"uuid": "b94d62b8-345a-63de-bf91-9c4aba9e2913",
			"version": [1, 0, 0],
			"entry": "index.js"
		}
	],
	"dependencies": [
		{
			"module_name": "@minecraft/server",
			"version": "1.16.0-beta"
		},
		{
			"module_name": "@minecraft/server-ui",
			"version": "1.3.0"
		},
		{
			"module_name": "@minecraft/server-admin",
			"version": "1.0.0-beta"
		}
	],
	"capabilities": ["script_eval"]
}
```
只需要把它们都删掉就好了

# 重新启动服务端
完成这一切，回到服务端根目录执行
```shell
./bedrock_server
```
就可以启动服务端愉快地玩耍啦

记一次Minecraft基岩版服务器更新

# 符号约定
逻辑变量用大写字母$A,B,C,\cdots$表示，逻辑常数用$0,1$表示。约定上划线表示逻辑非：
$$
\overline{0} = 1, \quad \overline{1} = 0
$$

用 **+** 表示逻辑或：
$$
0 + 0 = 0, \quad 0 + 1 = 1, \quad 1 + 0 = 1, \quad 1 + 1 = 1
$$

用 **·** 表示逻辑与：
$$
0 \cdot 0 = 0, \quad 0 \cdot 1 = 0, \quad 1 \cdot 0 = 0, \quad 1 \cdot 1 = 1
$$

用 **⊕** 表示逻辑异或：
$$
0 \oplus 0 = 0, \quad 0 \oplus 1 = 1, \quad 1 \oplus 0 = 1, \quad 1 \oplus 1 = 0
$$



# 基本定律

## 单变量定律
容易验证，单个的逻辑变量满足如下的定律：
1. 恒等律
   $$
   A + 1 = 1, \quad A \cdot 0 = 0
   $$

2. 零律
   $$
   A + 0 = A, \quad A \cdot 1 = A
   $$

3. 同一律
   $$
   A + A = A, \quad A \cdot A = A
   $$

4. 互补律
   $$
   A + \overline{A} = 1, \quad A \cdot \overline{A} = 0
   $$

5. 还原律
   $$
   \overline{\overline{A}} = A
   $$

## 多变量定律
以下多变量定律也是容易验证的：
1. 交换律
   $$
   A + B = B + A, \quad A \cdot B = B \cdot A
   $$

2. 结合律
   $$
   A + (B + C) = (A + B) + C, \quad A \cdot (B \cdot C) = (A \cdot B) \cdot C
   $$

3. 分配律
   $$
   A \cdot (B + C) = A \cdot B + A \cdot C, \quad A + (B \cdot C) = (A + B) \cdot (A + C)
   $$

4. 吸收律
   $$
   A + A \cdot B = A, \quad A \cdot (A + B) = A
   $$

5. 反演律（摩根定律）
   $$
   \overline{A \cdot B} = \overline{A} + \overline{B}, \quad \overline{A + B} = \overline{A} \cdot \overline{B}
   $$

## 其他常用恒等式
### 恒等式 1
$$
A + \overline{A} \cdot B = A + B
$$
证明：
利用分配律：
$$
A + \overline{A} \cdot B = (A + \overline{A}) \cdot (A + B) = 1 \cdot (A + B) = A + B
$$

---

### 恒等式 2
$$
A \cdot (\overline{A} + B) = A \cdot B
$$
证明：
利用分配律：
$$
A \cdot (\overline{A} + B) = A \cdot \overline{A} + A \cdot B = 0 + A \cdot B = A \cdot B
$$

---

### 恒等式 3
$$
A \cdot B + \overline{A} \cdot C + B \cdot C = A \cdot B + \overline{A} \cdot C
$$
证明：
利用互补律：
$$
A \cdot B + \overline{A} \cdot C + B \cdot C = A \cdot B + \overline{A} \cdot C + (A + \overline{A}) \cdot B \cdot C
$$
利用分配律：
$$
A \cdot B + \overline{A} \cdot C + (A + \overline{A}) \cdot B \cdot C = A \cdot B + \overline{A} \cdot C + A \cdot B \cdot C + \overline{A} \cdot B \cdot C
$$
再反用分配律：
$$
A \cdot B + \overline{A} \cdot C + A \cdot B \cdot C + \overline{A} \cdot B \cdot C = A \cdot B \cdot (1 + C) + \overline{A} \cdot C \cdot (1 + B)
$$
利用恒等率：
$$
A \cdot B \cdot (1 + C) + \overline{A} \cdot C \cdot (1 + B) = A \cdot B + \overline{A} \cdot C
$$

---

# 基本定理

## 代入规则
在任意逻辑等式中，将某个变量全部替换为另一个逻辑表达式，等式仍然成立。

## 反演规则
根据反演律，在求原函数$L$的非函数时，可以对$L$做如下变换：
$$
\cdot \to +, \quad + \to \cdot, \quad 0 \to 1, \quad 1 \to 0, \quad A \to \overline{A}, \quad \overline{A} \to A
$$
所得的函数即为$L$的非函数。应用反演规则时需要注意，要保持原先的运算优先级，先与后或。例如：
$$
\overline{A \cdot B + \overline{A} \cdot (B + C)} = (\overline{A} + \overline{B}) \cdot (A + \overline{B} \cdot \overline{C})
$$

## 对偶规则
在任意逻辑等式中，将逻辑与和逻辑或互换，将逻辑常数$0$和$1$互换，等式仍然成立。例如：
$$
A + \overline{A} \cdot B = A + B \iff A \cdot (\overline{A} + B) = A \cdot B
$$
与反演规则类似，对偶规则也需要保持原先的运算优先级。

## 香农展开定理
对于任意一个逻辑函数：
$$
f(A,B,C,\cdots)
$$
可以用如下的方式展开：
$$
f(A,B,C,\cdots) = A \cdot f(1,B,C,\cdots) + \overline{A} \cdot f(0,B,C,\cdots)
$$

逻辑代数基本定律与规则

# 竞争冒险

一个逻辑门的两输入端信号同时跳变，但是时间存在差异的现象称为**竞争**。如果逻辑电路设计不好，会产生输出干扰脉冲，称为**冒险**

- 两个互补信号的或会造成竞争冒险$L=A+ \overline{A}$
- 两个互补信号的与会产生竞争冒险$L=A\cdot \overline{A}$



就像这样

<center>
    <img src="/static/img/d90c1c0c915f875e618ff6f3b0491a09.image.webp" width=70%>
</center>

考察下面的电路
<center>
    <img src="/static/img/21329a4d5bb43e443c11f466daa5ff16.image.webp" width=50%>
</center>

它的逻辑表达式是
$$
L=AC+B\overline{C}
$$

当$A=B=1$时，逻辑表达式为
$$
L=C+\overline{C}
$$

由于非门的存在，$\overline{C}$信号会晚一点跳变，这样就会使得$L$出现一个脉冲的干扰信号

# 消除竞争冒险
消去竞争冒险可以消去函数表达式中的互补项，如
$$
F=(A+B)(\overline{A}+C)
$$

当$B=C=0$时，表达式就化为了
$$
F=A\cdot\overline{A}
$$

由于$A\cdot\overline{A}$是恒为假的，那么将它化简为
$$
F=AC+\overline{A}B+BC
$$
那么就不存在竞争冒险

---

也可以增加乘积项防止互补项相加。如
$$
L=AC+B\overline{C}
$$
当$A=B+1$时就有$L=C+\overline{C}$，为了避免这种情况，鉴于它是恒为真的，可以加上$AB$
$$
L=AC+B\overline{C}+AB
$$
这样就不会出现跳变了

组合逻辑电路的竞争冒险

# 逻辑函数的形式



## 逻辑函数基本表达形式

### 与或表达式
与或表达式是指由若干**与**项以或的形式连接起来的逻辑表达式，例如
$$
F(A,B,C) = AB C + A\overline{B} C + \overline{A} BC
$$
也称之为“积之和”。

### 或与表达式
或与表达式是指由若干**或**项以与的形式连接起来的逻辑表达式，例如
$$
F(A,B,C) = (A+B+C)(A+\overline{B}+C)(\overline{A}+B+C)
$$
也称之为“和之积”。

## 最小项
最小项是指一个乘积项，它包含了所有的逻辑变量，例如三个变量的最小项有
$$
m_0 = AB C, \quad m_1 = AB \overline{C}, \quad m_2 = A\overline{B} C, \cdots
$$
$n$个变量的最小项有$2^n$个。使一个最小项为$1$的变量取值是唯一的，将此作为最小项的编号，例如
$$
AB\overline{C} \text{的编号为} 110 = 6
$$

### 最小项表达式
由若干最小项以或的形式连接起来的逻辑表达式称为最小项表达式，例如
$$
F(A,B,C) = AB C + AB \overline{C} + A\overline{B} C
$$

## 最大项
最大项是指一个和项，它包含了所有的逻辑变量，例如三个变量的最大项有
$$
M_0 = A+B+C, \quad M_1 = A+B+\overline{C}, \quad M_2 = A+\overline{B}+C, \cdots
$$
$n$个变量的最大项有$2^n$个。使一个最大项为$0$的变量取值是唯一的，将此作为最大项的编号，例如
$$
A+B+\overline{C} \text{的编号为} 001 = 1
$$

### 最大项表达式
由若干最大项以与的形式连接起来的逻辑表达式称为最大项表达式，例如
$$
F(A,B,C) = (A+B+C)(A+B+\overline{C})(A+\overline{B}+C)
$$
可以利用摩根定律将最小项表达式转化为最大项表达式，例如
$$
\begin{aligned}
    F(A,B,C) &= AB+\overline{A}C = \overline{\overline{AB+\overline{A}C}} \\
    &= \overline{(\overline{A}+\overline{B})(A+\overline{C})} \\
    &= \overline{A\overline{B}+\overline{C}\overline{B}+\overline{A}\overline{C}} \\
    &= (\overline{A}+B)(A+C)(B+C)
\end{aligned}
$$

## 卡诺图
可以用递归的方式定义卡诺图。对于单个变量，其卡诺图为

| $\overline{A}$ | $A$ |
|-----------------|-----|


添加一个变量，可以将其沿一个方向**镜像**一份，再填入新的变量

| $\overline{A}\overline{B}$ | $A\overline{B}$ | $AB$ | $\overline{A}B$ |
|----------------------------|-----------------|------|-----------------|


同样可以再添加一个变量

| $\overline{A}\overline{B}\overline{C}$ | $A\overline{B}\overline{C}$ | $AB\overline{C}$ | $\overline{A}B\overline{C}$ |
|----------------------------------------|-----------------------------|------------------|----------------------------|
| $\overline{A}\overline{B}C$            | $A\overline{B}C$            | $ABC$            | $\overline{A}BC$           |


还可以有四变量的卡诺图

| $\overline{A}\overline{B}\overline{C}\overline{D}$ | $A\overline{B}\overline{C}\overline{D}$ | $AB\overline{C}\overline{D}$ | $\overline{A}B\overline{C}\overline{D}$ |
|---------------------------------------------------|----------------------------------------|-----------------------------|---------------------------------------|
| $\overline{A}\overline{B}C\overline{D}$           | $A\overline{B}C\overline{D}$           | $ABC\overline{D}$           | $\overline{A}BC\overline{D}$          |
| $\overline{A}\overline{B}CD$                      | $A\overline{B}CD$                      | $ABCD$                      | $\overline{A}BCD$                     |
| $\overline{A}\overline{B}\overline{C}D$           | $A\overline{B}\overline{C}D$           | $AB\overline{C}D$           | $\overline{A}B\overline{C}D$          |


如此定义的表格**相邻两格仅有一个变量发生了变化**。

---

为了将表达式化为卡诺图，首先将表达式化为最小项表达式。每个最小项都对应卡诺图中的一格，将这些格填上$1$，其他格填上$0$。如对于表达式
$$
L(A,B,C,D) = ABCD + AB\overline{C}D + A\overline{B}C\overline{D} + \overline{A}BC\overline{D} + \overline{A}\overline{B}\overline{C}\overline{D}
$$
其卡诺图为

| CD/AB | 00  | 01  | 11  | 10  |
|-------|------|------|------|------|
| 00    |  1   |  0   |  0   |  0   |
| 01    |  0   |  0   |  1   |  0   |
| 11    |  0   |  0   |  1   |  0   |
| 10    |  0   |  1   |  0   |  1   |


## 最简表达式

若一个与-或表达式包含的乘积项最少，每个乘积项变量也最少，则称之为最简与-或表达式。

### 代数法化简逻辑函数
代数法化简逻辑函数通常结合使用下列四种方法：
1. 并项法
   $$
   A + \overline{A} = 1
   $$
2. 吸收法
   $$
   A + AB = A
   $$
3. 消去法
   $$
   A + \overline{A}B = A + B
   $$
4. 配项法
   $$
   A = A(B + \overline{B})
   $$

### 卡诺图化简逻辑函数
卡诺图化简逻辑函数的步骤如下：
1. 将逻辑函数化为最小项表达式；
2. 将最小项表达式填入卡诺图；
3. 将卡诺图中的$1$按$2^n$项的方式合并相邻项；
4. 读出合并后的最小项表达式。

卡诺图中相邻的项除了图中相邻外，还包括边界相邻。一个化简的例子是
$$
L(A,B,C,D) = ABCD + AB\overline{C}D + A\overline{B}C\overline{D} + \overline{A}BC\overline{D} + \overline{A}\overline{B}\overline{C}\overline{D}
$$
其卡诺图为

| CD/AB | 00  | 01  | 11  | 10  |
|-------|------|------|------|------|
| 00    |  1   |  0   |  0   |  0   |
| 01    |  0   |  0   |  1   |  0   |
| 11    |  0   |  0   |  1   |  0   |
| 10    |  0   |  1   |  0   |  1   |


注意到图中可合并的项为
$$
ABCD + AB\overline{C}D = ABD
$$
那么化简后的表达式为
$$
L(A,B,C,D) = ABD + A\overline{B}C\overline{D} + \overline{A}BC\overline{D}
$$