Question

设x（i，j）为变量。所有变量和常量只能有0或1的值。另外，两个变量x（i，j）和x（k，l）之和等于(x(i,j)+x(k,l)) % 2对于以下格式的给定方程，什么算法可用于找到所有x（i，j）的解，使所有x（i，j）的总和最小化：

x(0,0)  +x(0,1)  +x(0,2)  +x(1,0)  +0       +0       +x(2,0)  +0       +0       = 0
x(0,0)  +x(0,1)  +x(0,2)  +0       +x(1,1)  +0       +0       +x(2,1)  +0       = 0
x(0,0)  +x(0,1)  +x(0,2)  +0       +0       +x(1,2)  +0       +0       +x(2,2)  = 1
x(0,0)  +0       +0       +x(1,0)  +x(1,1)  +x(1,2)  +x(2,0)  +0       +0       = 0
0       +x(0,1)  +0       +x(1,0)  +x(1,1)  +x(1,2)  +0       +x(2,1)  +0       = 0
0       +0       +x(0,2)  +x(1,0)  +x(1,1)  +x(1,2)  +0       +0       +x(2,2)  = 1
x(0,0)  +0       +0       +x(1,0)  +0       +0       +x(2,0)  +x(2,1)  +x(2,2)  = 1
0       +x(0,1)  +0       +0       +x(1,1)  +0       +x(2,0)  +x(2,1)  +x(2,2)  = 1
0       +0       +x(0,2)  +0       +0       +x(1,2)  +x(2,0)  +x(2,1)  +x(2,2)  = 1

上述等式也可以看作：

x(0,0)  +x(0,1)  +x(0,2)  +x(1,0)  +x(2,0)  = 0
x(0,0)  +x(0,1)  +x(0,2)  +x(1,1)  +x(2,1)  = 0
x(0,0)  +x(0,1)  +x(0,2)  +x(1,2)  +x(2,2)  = 1
x(0,0)  +x(1,0)  +x(1,1)  +x(1,2)  +x(2,0)  = 0
x(0,1)  +x(1,0)  +x(1,1)  +x(1,2)  +x(2,1)  = 0
x(0,2)  +x(1,0)  +x(1,1)  +x(1,2)  +x(2,2)  = 1
x(0,0)  +x(1,0)  +x(2,0)  +x(2,1)  +x(2,2)  = 1
x(0,1)  +x(1,1)  +x(2,0)  +x(2,1)  +x(2,2)  = 1
x(0,2)  +x(1,2)  +x(2,0)  +x(2,1)  +x(2,2)  = 1

例如，给定的等式可以有以下两种解决方案：

x（0,2）= x（1,0）= x（1,1）= 1且所有x（i，j）= 0.在这种情况下，所有x（i，j）= 3的总和
x（2,2）= 1且所有x（i，j）= 0。在这种情况下，所有x（i，j）的总和为1

可以使用什么算法来查找以后的解决方案。我曾尝试使用gausian消除，但结果并不一致。

更多解释 关于如何获得等式的更多解释：https://math.stackexchange.com/a/441588/299278

Answer 1

重新贴标签，基础是

XOR(a, b, c, d,       g      ) = 0
XOR(a, b, c,    e,       h   ) = 0
XOR(a, b, c,       f,       i) = 1
XOR(a,       d, e, f, g      ) = 0
XOR(   b,    d, e, f,    h   ) = 0
XOR(      c, d, e, f,       i) = 1
XOR(a,       d,       g, h, i) = 1
XOR(   b,       e,    g, h, i) = 1
XOR(      c,       f, g, h, i) = 1

我们可以删除相同的子短语以找到

# removing rows
XOR(d, g) = XOR(e, h) = NOT XOR(f, i)    # -(a, b, c)
XOR(a, g) = XOR(b, h) = NOT XOR(c, i)    # -(d, e, f)
XOR(a, d) = XOR(b, e) = XOR(c, f)        # -(g, h, i)
# removing columns
XOR(b, c) = XOR(e, f) = NOT XOR(h, i)    # -(a, d, g)
XOR(a, c) = XOR(d, f) = NOT XOR(g, i)    # -(b, e, h)
XOR(a, b) = XOR(c, e) = XOR(g, h)        # -(c, f, i)

如果我们总结所有基本规则并减少 - 记住，XOR(a, a) = 0 - 我们找到

XOR(a, b, c, d, e, f, g, h, i) = 1

也就是说，任何解决方案必须包含奇数个1：1,3,5或7（我们可以轻易地丢弃9，因为它必须与我们导致0的所有基本规则相矛盾。）

让我们尝试找到只包含一个1的解决方案：

如果d或g为1，则e或h必须为1;这给了我们至少两个1，这与我们的目标相矛盾。所以d，g，e，h必须都是0和f或i必须是1.
通过相同的参数a，g，b，h为0并且c或i为1.
通过相同的参数a，d，b，e，c，f为0
显然我必须是1
检查回来，这是一个一致的解决方案，也是唯一一个包含单个解决方案的解决方案。

更一般地说 - 如果我们假设给出a，b，c，d，e：

的值

f = XOR(b, c, e)
g = XOR(a, b, c, d)
h = XOR(a, b, c, e)
i = NOT XOR(a, e)

允许我们轻松生成所有可能的解决方案：

from itertools import product

tests = [
    lambda a, b, c, d, e, f, g, h, i: a ^ b ^ c ^ d ^ g == 0,
    lambda a, b, c, d, e, f, g, h, i: a ^ b ^ c ^ e ^ h == 0,
    lambda a, b, c, d, e, f, g, h, i: a ^ b ^ c ^ f ^ i == 1,
    lambda a, b, c, d, e, f, g, h, i: a ^ d ^ e ^ f ^ g == 0,
    lambda a, b, c, d, e, f, g, h, i: b ^ d ^ e ^ f ^ h == 0,
    lambda a, b, c, d, e, f, g, h, i: c ^ d ^ e ^ f ^ i == 1,
    lambda a, b, c, d, e, f, g, h, i: a ^ d ^ g ^ h ^ i == 1,
    lambda a, b, c, d, e, f, g, h, i: b ^ e ^ g ^ h ^ i == 1,
    lambda a, b, c, d, e, f, g, h, i: c ^ f ^ g ^ h ^ i == 1
]

sols = []
for a, b, c, d, e in product([0,1], repeat=5):
    f = b ^ c ^ e
    g = a ^ b ^ c ^ d
    h = a ^ b ^ c ^ e
    i = 1 - (a ^ e)
    if all(test(a,b,c,d,e,f,g,h,i) for test in tests):
        sols.append(
            "{}   {} {} {} {} {} {} {} {} {}"
            .format(sum([a,b,c,d,e,f,g,h,i]), a,b,c,d,e,f,g,h,i)
        )
sols.sort()
print("\n".join(sols))

给出了

1   0 0 0 0 0 0 0 0 1
3   0 0 1 1 1 0 0 0 0
3   0 1 0 0 1 0 1 0 0
3   1 0 0 1 0 0 0 1 0
3   1 1 0 0 0 1 0 0 0
5   0 0 0 1 1 1 1 1 0
5   0 0 1 0 0 1 1 1 1
5   0 1 0 1 0 1 0 1 1
5   0 1 1 0 1 1 0 1 0
5   0 1 1 1 0 0 1 0 1
5   1 0 0 0 1 1 1 0 1
5   1 0 1 0 1 0 0 1 1
5   1 0 1 1 0 1 1 0 0
5   1 1 1 0 0 0 1 1 0
7   1 1 0 1 1 0 1 1 1
7   1 1 1 1 1 1 0 0 1

请注意，生成的解决方案中有一半通过了测试;这有力地表明应该有可能使一个变量依赖，但我还没有找到办法这样做。

编辑：进一步阅读后，我们可以将我们的基础表示为增强矩阵，

a b c d e f g h i x
-------------------
1 1 1 1 0 0 1 0 0 0
1 1 1 0 1 0 0 1 0 0
1 1 1 0 0 1 0 0 1 1
1 0 0 1 1 1 1 0 0 0
0 1 0 1 1 1 0 1 0 0
0 0 1 1 1 1 0 0 1 1
1 0 0 1 0 0 1 1 1 1
0 1 0 0 1 0 1 1 1 1
0 0 1 0 0 1 1 1 1 1

执行高斯缩减后，我们得到

a b c d e f g h i x
-------------------
1 0 0 0 0 1 0 1 0 0
0 1 0 0 0 1 1 0 0 0
0 0 1 0 0 1 1 1 1 1
0 0 0 1 0 1 1 0 1 1
0 0 0 0 1 1 0 1 1 1
0 0 0 0 0 0 0 0 0 0     #
0 0 0 0 0 0 0 0 0 0     # under-constrained - multiple solutions
0 0 0 0 0 0 0 0 0 0     #
0 0 0 0 0 0 0 0 0 0     #

如果我们将任意值分配给a..e，我们最终会使用

f g h i  x
-----------
1 0 1 0  a
1 1 0 0  b
1 1 1 1 1-c
1 1 0 1 1-d
1 0 1 1 1-e    # over-constrained! Some choices of a..e will not work

这正是我之前的结论，但是以更普遍适用的方式实现。

从这一点开始，您可以插入a..e的每个组合，然后再次使用高斯缩减来查找f..i的解法，或者用符号解决问题

f g h i  x
-----------
1 0 0 0  a ^ (1-c) ^ (1-d)
0 1 0 0  a ^ b ^ (1-c) ^ (1-d)
0 0 1 0  (1-c) ^ (1-d)
0 0 0 1  b ^ (1-d)
0 0 0 1  a ^ (1-e)      # over-constrained!

过度约束在这里实际上很有用;请注意b ^ (1-d) == a ^ (1-e)所以e可以作为a, b, d的函数找到。所以：

from itertools import product

for a,b,c,d in product([0,1], repeat=4):
    e = a ^ b ^ d
    f = a ^ c ^ d
    g = a ^ b ^ c ^ d
    h = c ^ d
    i = b ^ (1-d)
    print(a,b,c,d,e,f,g,h,i)

产生

0 0 0 0 0 0 0 0 1
0 0 0 1 1 1 1 1 0
0 0 1 0 0 1 1 1 1
0 0 1 1 1 0 0 0 0
0 1 0 0 1 0 1 0 0
0 1 0 1 0 1 0 1 1
0 1 1 0 1 1 0 1 0
0 1 1 1 0 0 1 0 1
1 0 0 0 1 1 1 0 1
1 0 0 1 0 0 0 1 0
1 0 1 0 1 0 0 1 1
1 0 1 1 0 1 1 0 0
1 1 0 0 0 1 0 0 0
1 1 0 1 1 0 1 1 1
1 1 1 0 0 0 1 1 0
1 1 1 1 1 1 0 0 1

最小化线性方程的解的总和

1 个答案: