Algorithm 分析1可变寄存器指令集？ 问题摘要

我需要能够为概念CPU+指令集生成指令。我有一个几乎可以工作的算法

CPU只有1个始终以1开头的可变寄存器（名为mut）和一些带有值的不可变寄存器（名为input[0..n]）。这个CPU的指令只是mut上的逻辑门，其中一个输入寄存器将结果存储回mut

我需要一个算法来生成指令，使CPU能够从某个定义的真值表中为每一组可能的输入生成正确的答案

例子 例如，我可能希望这个CPU像与门一样工作（它的真值表为

00=0,01=0,10=0,11=1

）。我应该能够将算法输入这个真值表，并让它输出指令“

和[0]以及[1]

”。如果你用你的头跟随，你可以看到只有当输入[0]和输入[1]都是1时，MUT才会保持为1

企图 目前，我有一个简单的算法实现，只需对所有可能的指令集进行广度优先搜索，在每个真值表输入/输出对上测试每一个指令集，看看它是否有效。对于我提供给算法的许多期望，它只需几级搜索即可返回正确的指令集。然而，对于其他人来说，它会在找到结果之前消耗掉我整个CPU的内存，所以我只能假设它找不到结果

问题 是否有a）任何有效的方法来设计该算法，b）任何方法来证明，对于某一指令集，任何预期的真值表都可以实现，或者c）对这个问题有任何现有的见解

我知道卡诺映射，但它们生成2D逻辑电路，而这本质上是一个一维逻辑电路

如果你有任何问题，请告诉我。这是一个很难解释的问题，但我真的需要帮助

指令集 供参考，我的说明如下：

AND[n]: MUT = MUT & INPUT[n]
OR[n]: MUT = MUT | INPUT[n]
NOT: MUT = ~MUT

---

我可能能够向CPU发送更多的指令，但理想情况下，算法可以尝试解决任何给定指令集的问题。

我同意Martin Rosenau的观点，我怀疑您的CPU是否能够在没有额外功能的情况下处理任何给定的真值表。正如您现在看到的，我不知道如何实现例如XOR

因此，我冒昧地添加了一个累加器regitser ACC（它将被初始化为False）和一个额外的命令

ACC

，它可以：

ACC <- ACC or MUT
MUT <- True

例如，从上面的示例输入中，这给出了

['和[0]'、'和[1]'、'ACC'、'NOT'、'OR[0]'、'OR[1]'、'NOT'、'ACC']

，这似乎是正确的

这是我测试过的CPU。我添加了一个重置按钮，结果将在执行结束时显示在ACC中

class CPU:
    def reset (self, inputs):
        self.MUT = True
        self.ACC = False
        self.INP = inputs [:]

    def __call__ (self, opcodes):
        for opcode in opcodes:
            if opcode == 'NOT':
                self.MUT = not self.MUT
                continue
            if opcode == 'ACC':
                self.ACC = self.ACC or self.MUT
                self.MUT = True
                continue
            if opcode [0] == 'O':
                inp = int (opcode [3:-1] )
                self.MUT = self.MUT or self.INP [inp]
                continue
            if opcode [0] == 'A':
                inp = int (opcode [4:-1] )
                self.MUT = self.MUT and self.INP [inp]
                continue
            raise Exception ('Need more dried frog pills.')
        return self.ACC

---

再一次，很抱歉，我无法按照您指定的限制回答您的问题，但希望我的代码片段对您有所帮助。

您有什么可用的说明？例如，您有条件分支指令吗？我们需要更多地了解CPU指令集。它本机可以执行哪些操作？“逻辑门”是不够的信息。我看到指令是mut形式的，指令是严格线性的——一旦启动，它就在指令中运行，没有可用的分支。我将用“指令集”编辑主题。MUT的位数有多大？一点？无界大小？如果不进行移位，则无法使用位运算进行加法。要检查所有可能的逻辑表是否都可能，您必须检查16种可能性。如果您有NOT指令，您只需检查8种可能性。我检查了NOT、AND、OR和XOR的组合是否可以在不读取输入两次的情况下工作。如果没有第二个MUT寄存器，您就无法摆脱XOR指令。首先，我必须真诚地赞扬您做出了如此出色的响应。：）我知道你现在在做什么。。。对于每个真值，检查输入是否匹配该真值条件，如果匹配，则返回真值。要检查这一点，您需要将MUT和and的值（假定为True）与所有预期为True的输入一起使用，然后翻转MUT，并将其与所有预期为False的输入一起使用。然后将其存储到ACC中。基本上，您将操作分为检查输入是否匹配任何应返回True的输入，如果匹配，则将ACC永久设置为True。这是一个简单的方法，非常聪明。然而，有几个问题……没有ACC的问题如下：像

（a或b）和（c或d）

或

（a和b）或（c和d）

这样的表达式需要对括号的结果进行操作，我们没有地方存储它们。我们也不能去掉括号。a）似乎，对于具有更多错误输出的真值表，您可以翻转ACC的工作方式，最终得到更小的指令集，对吗？b） 我希望找到一个最佳的方法。有没有想过尽可能少地使用此返回？以及c）对于不添加ACC登记册有何想法？这在我的问题领域是可能的，但我想找到一个没有ACC的解决方案。有正式的证据吗？a）和b）你是对的，结果不是最小的。我甚至不确定是尝试最小化布尔输入项，还是采用非最优代码并尝试最小化它更明智。。。至于c：如果没有ACC，我就不知道如何实现

（inp0或inp1）和（inp2或inp3）

。你不能去掉括号，也没有地方存储中间结果。这只是一个猜测，谢天谢地，当我拿到学位时，我留下了正式的证明。

class CPU:
    def reset (self, inputs):
        self.MUT = True
        self.ACC = False
        self.INP = inputs [:]

    def __call__ (self, opcodes):
        for opcode in opcodes:
            if opcode == 'NOT':
                self.MUT = not self.MUT
                continue
            if opcode == 'ACC':
                self.ACC = self.ACC or self.MUT
                self.MUT = True
                continue
            if opcode [0] == 'O':
                inp = int (opcode [3:-1] )
                self.MUT = self.MUT or self.INP [inp]
                continue
            if opcode [0] == 'A':
                inp = int (opcode [4:-1] )
                self.MUT = self.MUT and self.INP [inp]
                continue
            raise Exception ('Need more dried frog pills.')
        return self.ACC