Como mapear uma tabela verdade para funções lógicas ternárias?

Por favor seja gentil. Tenho uma pergunta espinhosa e importante de um campo diferente da engenharia, cuja resposta pode ser bastante conhecida na engenharia elétrica. Fiz uma pergunta semelhante no StackOverflow

Suponha que eu tenha uma tabela verdade de 5 entradas e 1 saída. Eu usei o algoritmo Espresso (por exemplo, Logic Friday) para minimizar a tabela e escrever alguns VHDL eficientes. Tudo funciona bem.

Em vez de minimizar e mapear a tabela verdade para portas NAND, eu gostaria de mapear para uma função lógica ternária arbitrária. Não estou interessado em lógica com valores múltiplos, mas em funções lógicas que possuem três variáveis ​​de entrada. Existem 256 dessas funções, e o NAND de 3 polegadas é apenas uma delas. Nem todas essas 256 funções podem ser interessantes: algumas se reduzem a seus dois irmãos variáveis ​​de entrada.

Pergunta : como você pode mapear uma tabela verdade (por exemplo, com 7 entradas) para qualquer uma dessas funções de 3 entradas. Uma ferramenta que faça algo semelhante seria ótima, mas um método para simplificar as funções ternárias arbitrárias seria o melhor.

Antecedentes: as CPUs modernas podem executar operações lógicas ternárias arbitrárias em registros de 512 bits (por exemplo, instrução vpternlog ), mas devido à complexidade, os compiladores deixam isso para o programador, que é um pouco ignorante sobre como otimizar isso.

Análise

Observe que a instrução codifica todas as funções ternárias possíveis. Portanto, dadas as três variáveis ​​booleanas e as operações bit a bit, podemos sempre encontrar o byte de codificação. Por exemplo, se for dada uma função

a b c | f
------+--
0 0 0 | 0
0 0 1 | 0
0 1 0 | 0
0 1 1 | 0
1 0 0 | 1
1 0 1 | 1
1 1 0 | 0
1 1 1 | 1

Como existem apenas 8 entradas para codificação e apenas 2 resultados binários, isso pode ser codificado como um número de 8 bits, neste caso 0b10110000 = 0xB0.

Otimizações

Dado um n arbitrário função arar dos valores booleanos, tudo o que precisamos fazer é converter funções binárias em funções ternárias. Podemos fazer isso, porque sabemos que podemos calcular qualquer combinação de funções. Partindo de uma árvore de sintaxe abstrata de nós unários e binários, começaríamos representando funções unárias e binárias de maneira semelhante à "codificação" acima.

Então, para o nosso f :

f = AND(a, OR(NOT(b), c)) = BIN[1000](a, BIN[1110](UNARY[10](b), c))

Usando lógica recursiva, podemos combinar BIN e UNARY em:

f = AND(a, OR(NOT(b), c)) = BIN[1000](a, BIN[1011](b, c))

Que pode então ser otimizado (regras de conversão seguem facilmente a partir da lógica booleana):

f = AND(a, OR(NOT(b), c)) = TERN[10110000](a, b, c)

Observação

Isso é muito semelhante ao modo como as tabelas de pesquisa FPGA (LUTs) são calculadas. Tenho certeza de que você pode encontrar muitos textos e algoritmos para mapear a lógica para LUTs. Por exemplo: Mapa de fluxo ( http://cadlab.cs.ucla.edu/~cong/papers/tcad94.pdf )

Trecho da minha própria resposta .

1. Traduza a tabela verdade em uma fórmula lógica; use, por exemplo, Logic Friday.
2. Armazene a fórmula lógica no formato da equação da Synopsys (.eqn).

Conteúdo de BF_Q6.eqn:

INORDER = A B C D E F; 
OUTORDER = F0 F1;
F0 = (!A*!B*!C*!D*!E*F) + (!A*!B*!C*!D*E*!F) + (!A*!B*!C*D*!E*!F) + (!A*!B*C*!D*!E*!F) + (!A*B*!C*!D*!E*!F) + (A*!B*!C*!D*!E*!F);
F1 = (!A*!B*!C*!D*E) + (!A*!B*!C*D*!E) + (!A*!B*C*!D*!E) + (!A*B*!C*!D*!E) + (A*!B*!C*!D*!E);

3. Use "ABC: um sistema para síntese e verificação seqüencial" do Berkeley Verification and Synthesis Research Center.

No ABC eu corro:

abc 01> read_eqn BF_Q6.eqn
abc 02> choice; if -K 3; ps
abc 03> lutpack -N 3 -S 3; ps
abc 04> show
abc 05> write_bench BF_Q6.bench

Pode ser necessário executar choice; if -K 3; psvárias vezes para obter melhores resultados.

O BF_Q6.bench resultante contém os 3-LUTs para um FPGA:

INPUT(A)
INPUT(B)
INPUT(C)
INPUT(D)
INPUT(E)
INPUT(F)
OUTPUT(F0)
OUTPUT(F1)
n11         = LUT 0x01 ( B, C, D )
n12         = LUT 0x1 ( A, E )
n14         = LUT 0x9 ( A, E )
n16         = LUT 0xe9 ( B, C, D )
n18         = LUT 0x2 ( n11, n14 )
F1          = LUT 0xae ( n18, n12, n16 )
n21         = LUT 0xd9 ( F, n11, n14 )
n22         = LUT 0xd9 ( F, n12, n16 )
F0          = LUT 0x95 ( F, n21, n22 )

Isso pode ser reescrito (mecanicamente) no C ++ que eu estava procurando.