简化一组 AND 和 OR 子句

Posted 2023-05-08

【中文标题】简化一组 AND 和 OR 子句

【英文标题】：Simplifying a group of AND and OR clauses

【发布时间】：2011-08-18 19:58:02

【问题描述】：

所以如果我有一组 AND 和 OR 子句如下：

Y = ( A + B ) . ( A + C' ) . ( B + D' )

我可以这样简化吗：

Y = A . ( B + C' ) . ( B + D' ) ; Because A is common to ( A + B ) and ( A + C' )
Y = A . B . ( C' + D' )         ; Because B is common to ( B + C' ) and ( B + D' )

感谢您的宝贵时间。

【问题讨论】：

我想我知道我哪里出错了：当我分解出 A 时，我想我应该得到A + ( B . C' ) . ( B + D' )。这是正确的还是我又搞砸了？

【参考方案1】：

否，如果您使用以下值：

A = 1
B = 0
C = 0
D = 0

那么原始陈述是正确的，而您的简化版本是错误的。您可以通过扩展布尔表达式然后尝试以代数方式减少它来找到另一种表示它的方法，如下所示：

(A + B)(A + C')(B + D')
(AA + AC' + AB + BC')(B + D')                          // expand first 2 groups
AAB + ABC' + ABB + BBC' + AAD' + AC'D' + ABD' + BC'D'  // expand all groups
AB + ABC' + AB + BC' + AD' + AC'D' + ABD' + BC'D'      // apply identity to reduce
AB + BC' + AD'                                         // eliminate redundant expressions

最终结果在您的符号中看起来像这样

(A . B) + (B . C') + (A . D')

更进一步可以达到

B . (A + C') + (A . D')

或

A . (B + D') + (B . C')

【参考方案2】：

我能想到在这里有用的唯一等价物是

(A+B).(A+C') === A+(B.C')

这样就变成了

(A+(B.C')) 。 (B+D')

if B: --> A . D'
else: --> (A+C')

不知道这是否有助于您获得更高效/有用的东西

A   B   C'  D'  f()
TRUE    TRUE    TRUE    TRUE    TRUE
TRUE    TRUE    TRUE    FALSE   TRUE
TRUE    TRUE    FALSE   TRUE    TRUE
TRUE    TRUE    FALSE   FALSE   TRUE
TRUE    FALSE   TRUE    TRUE    TRUE
TRUE    FALSE   TRUE    FALSE   TRUE
TRUE    FALSE   FALSE   TRUE    FALSE
TRUE    FALSE   FALSE   FALSE   FALSE
FALSE   TRUE    TRUE    TRUE    TRUE
FALSE   TRUE    TRUE    FALSE   FALSE
FALSE   TRUE    FALSE   TRUE    TRUE
FALSE   TRUE    FALSE   FALSE   FALSE
FALSE   FALSE   TRUE    TRUE    FALSE
FALSE   FALSE   TRUE    FALSE   FALSE
FALSE   FALSE   FALSE   TRUE    FALSE
FALSE   FALSE   FALSE   FALSE   FALSE

在电子表格中实时观看：google docs

【讨论】：

增加了一些扣除。恕我直言，没有发现很大的简化

【参考方案3】：

eZanmoto，乍一看它似乎可以工作，但我快速浏览并为每一个都做了真值表，以下是它失败的情况：

@A = B = C = D = True
Original = True
First = True
Second = False

@A = C = True, B = D = True
Original = True
First = False
Second = False

@A = True, B = C = D = False
Original = True
First = True
Second = False

@A = C = False, B = D = True
Original = True
First = False
Second = False

@A = C = D = False, B = True
Original = True
First = False
Second = False

【参考方案4】：

迟到的答案。我最近了解了更多关于 Quine-McClusky algorithm and Karnaugh maps 的信息，这是一种系统化的方法来最小化布尔表达式。

我偶然发现this python implementation 看起来不错，并认为我会使用它来验证我之前的答案：

import logic
A,B,C,D = logic.bools('ABCD')

print logic.boolsimp((A & B) | (A & ~C) | (B & ~D))

果然打印出来了

(B & ~D) | (~C & A) | (B & A)

^{Pythonists：不要介意为逻辑运算选择奇怪的运算符；这主要是因为and、or和not在Python中不能重载}

---

完整性检查

作为健全性检查，我确实检查了算法实现“看到”我认为会导致潜在简化的等效性：

print logic.boolsimp((A & B) | (A & ~C))
print logic.boolsimp(A & (B | ~C))

打印两次相同的输出 ((~C & A) | (B & A))