Logic 优化逻辑的工具？

我正在用java编写一个处理器模拟器，控制信号非常繁琐。是否有生成以下逻辑的工具：

二进制逻辑：

输出：

if(input.subString(0,3) == "000") 
    //do something;

基本上，输出找到了输入的公共部分。在上面的例子中，它说“任何以000开头的东西都会有作用”，不管它的

00000、00001、00010、00011

优化类似于k图，只是我有100个输入，手动优化根本不实用

这里是一个k-map的例子，与我上面的例子不相关

---

输出不必是java语法，任何简化的逻辑语句都可以

，因此您有一大组长度为

N

位的字符串（其中

N

约为100），您想要一个简单的逻辑表达式来匹配这些字符串，而不是其他字符串

您可以尝试制作一个程序，为您构建内核映射。这将是一个有趣的练习。关于Kernaugh贴图我记得不多，但我认为行和列上的标签是使用灰色代码排列的

或者你可以试着让手工制作的克诺图更容易处理这个问题。对于每个字符串，找到所有字符串的公共位。然后打印一个剩余位位置的列表，供人类构建一个位置图

一些Python代码：

str_len = 5
strs = [
     [0,0,0,0,1],
     [0,0,0,0,0],
     [0,0,0,1,0],
     [0,0,0,1,1],
]
for i in range(str_len):
    if all([x[i] for x in strs]):
        print 'Bit %d is 1' % i
    elif not any([x[i] for x in strs]):
        print 'Bit %d is 0' % i
    else:
        print 'Bit %d is contingent' % i

在这一点上，您可以试着想办法对

B

剩余的或有位进行编码。在本例中，所有情况都被覆盖（您可以将其作为特殊情况进行检测，例如

N=2^B

）

寻找或有位公式的蛮力算法为：

选择下一个或有位

i

将S分为S0（位

i

=0的子集）和S1（位

i

=1的子集）

递归地分别找到S0和S1的公式f0和f1

S的公式是

（~b[i]&f0）|（b[i]&f1）

有一些优化。简单的方法是S0或S1为空——然后省略结果公式的分支。另一种是所有可能的组合都在一个集合中（类似于上面的示例）；在这种情况下，公式不需要引用位。最困难的一个是找到一个好的顺序来迭代。按顺序天真地做可能会导致一个不太理想的公式

事实上，您可以跳过上面的第一个建议，并将其运行到所有位。始终为1或0的位只会产生简单的情况，其中S0或S1为空

这段相当混乱的Python代码执行算法时进行了一些优化N.B.它没有经过太多测试，也不一定能产生最佳输出

def get_formula(S, i=0):
    # Special case where it's an empty set -- return a tautology
    if len(S) == 0:
        return '1'

    remaining_bits = len(S[0]) - i

    # Special case where no bits are left
    if remaining_bits <= 0:
        return '1'

    # Partition the set
    S0 = filter(lambda x: x[i] == 0, S)
    S1 = filter(lambda x: x[i] == 1, S)

    f0 = get_formula(S0, i+1)
    f1 = get_formula(S1, i+1)

    # Special cases where one subset is empty
    # Also special case for subformula being tautology
    if len(S1) == 0:
        if f0 == '1':
            return '~b[%d]' % i
        return '~b[%d] & (%s)' % (i, f0)
    if len(S0) == 0:
        if f1 == '1':
            return 'b[%d]' % i
        return 'b[%d] & (%s)' % (i, f1)

    # Special cases where one or both subformulas was a tautology
    if f0 == '1' and f1 == '1':
        return '1'
    if f0 == '1':
        return '~b[%d] | b[%d] & (%s)' % (i, i, f1)
    if f1 == '1':
        return '~b[%d] & (%s) | b[%d]' % (i, f0, 1)

    # General case
    return '~b[%d] & (%s) | b[%d] & (%s)' % (i, f0, i, f1)


strs = [
     [0,0,0,0,1],
     [0,0,0,0,0],
     [0,0,0,1,0],
     [0,0,0,1,1],
]

print get_formula(strs)

def get_公式（S，i=0）：
#它是一个空集的特殊情况——返回重言式
如果len=0：
返回“1”
剩余_位=len（S[0]）-i
#没有剩余位的特殊情况
如果剩余的_位那么就有一大组长度为
N
位的字符串（其中
N
大约为100位），您需要一个简单的逻辑表达式来匹配这些字符串，而不匹配其他字符串

您可以尝试制作一个程序，为您构建内核映射。这将是一个有趣的练习。关于Kernaugh贴图我记得不多，但我认为行和列上的标签是使用灰色代码排列的

或者你可以试着让手工制作的克诺图更容易处理这个问题。对于每个字符串，找到所有字符串的公共位。然后打印一个剩余位位置的列表，供人类构建一个位置图

一些Python代码：

str_len = 5
strs = [
     [0,0,0,0,1],
     [0,0,0,0,0],
     [0,0,0,1,0],
     [0,0,0,1,1],
]
for i in range(str_len):
    if all([x[i] for x in strs]):
        print 'Bit %d is 1' % i
    elif not any([x[i] for x in strs]):
        print 'Bit %d is 0' % i
    else:
        print 'Bit %d is contingent' % i

在这一点上，您可以试着想办法对
B
剩余的或有位进行编码。在本例中，所有情况都被覆盖（您可以将其作为特殊情况进行检测，例如
N=2^B
）

寻找或有位公式的蛮力算法为：

选择下一个或有位
i
将S分为S0（位
i
=0的子集）和S1（位
i
=1的子集）
递归地分别找到S0和S1的公式f0和f1
S的公式是
（~b[i]&f0）|（b[i]&f1）
有一些优化。简单的方法是S0或S1为空——然后省略结果公式的分支。另一种是所有可能的组合都在一个集合中（类似于上面的示例）；在这种情况下，公式不需要引用位。最困难的一个是找到一个好的顺序来迭代。按顺序天真地做可能会导致一个不太理想的公式

事实上，您可以跳过上面的第一个建议，并将其运行到所有位。始终为1或0的位只会产生简单的情况，其中S0或S1为空

这段相当混乱的Python代码执行算法时进行了一些优化N.B.它没有经过太多测试，也不一定能产生最佳输出

def get_formula(S, i=0):
    # Special case where it's an empty set -- return a tautology
    if len(S) == 0:
        return '1'

    remaining_bits = len(S[0]) - i

    # Special case where no bits are left
    if remaining_bits <= 0:
        return '1'

    # Partition the set
    S0 = filter(lambda x: x[i] == 0, S)
    S1 = filter(lambda x: x[i] == 1, S)

    f0 = get_formula(S0, i+1)
    f1 = get_formula(S1, i+1)

    # Special cases where one subset is empty
    # Also special case for subformula being tautology
    if len(S1) == 0:
        if f0 == '1':
            return '~b[%d]' % i
        return '~b[%d] & (%s)' % (i, f0)
    if len(S0) == 0:
        if f1 == '1':
            return 'b[%d]' % i
        return 'b[%d] & (%s)' % (i, f1)

    # Special cases where one or both subformulas was a tautology
    if f0 == '1' and f1 == '1':
        return '1'
    if f0 == '1':
        return '~b[%d] | b[%d] & (%s)' % (i, i, f1)
    if f1 == '1':
        return '~b[%d] & (%s) | b[%d]' % (i, f0, 1)

    # General case
    return '~b[%d] & (%s) | b[%d] & (%s)' % (i, f0, i, f1)


strs = [
     [0,0,0,0,1],
     [0,0,0,0,0],
     [0,0,0,1,0],
     [0,0,0,1,1],
]

print get_formula(strs)

def get_公式（S，i=0）：
#它是一个空集的特殊情况——返回重言式
如果len=0：
返回“1”
剩余_位=len（S[0]）-i
#没有剩余位的特殊情况
如果我想发布一个问题来帮助理解这个问题，是在stackoverflow上还是在meta上？如果你需要我的澄清，你可以在评论中发布。。但是如果你在寻求别人的帮助，我相信这是属于梅塔的。我不知道你想说什么，我想你需要更详细地解释你所说的生成逻辑是什么意思。哈哈，我明白了，让我再加上更多的解释。所以如果我想发布一个问题，要求帮助理解这一点