❧ Aritmética Digital - I ❧

Introdução12.1

Na aula de hoje vamos sair do nível puramente simbólico da álgebra booleana e chegar a blocos aritméticos reais. Até aqui estudamos tabela-verdade, formas canônicas, minimização algébrica e Mapa de Karnaugh. Agora vamos usar exatamente esse repertório para projetar circuitos que fazem soma e subtração bit a bit.

O ponto mais importante é este. Um circuito aritmético não nasce como algo misterioso e pronto. Ele nasce da análise de uma única coluna binária. Primeiro perguntamos o que deve acontecer naquela coluna. Depois listamos todos os casos possíveis. Em seguida, transformamos a tabela em expressão lógica, minimizamos a função e, por fim, desenhamos o hardware correspondente.

Essa forma de pensar é valiosa porque ela mostra a ponte entre matemática e circuito. Quando você olha para um somador de muitos bits, não deve imaginar uma máquina fazendo uma conta inteira de uma vez. O jeito correto de enxergar é outro. O circuito resolve várias pequenas colunas de 1 bit, uma ao lado da outra, e o transporte ou empréstimo de uma delas alimenta a seguinte.

Adição Binária na Prática12.2

Antes de projetar o circuito, vejamos como a adição binária funciona como operação aritmética. A lógica é a mesma da adição decimal: somamos coluna por coluna da direita para a esquerda, e quando o resultado não cabe em um único dígito, geramos um transporte para a coluna seguinte.

Considere a soma $0110_2 + 0001_2$. Escrevemos os números alinhados pelas colunas e somamos cada posição individualmente, começando pela coluna $0$ (a mais à direita):

$$ \begin{alignedat}{5} & & 0 &\;1 &\;1 &\;0_2 &\;(6_{10}) \\ &+& 0 &\;0 &\;0 &\;1_2 &\;(1_{10}) \\ \hline & & 0 &\;1 &\;1 &\;1_2 &\;(7_{10}) \end{alignedat} $$

Coluna $0$: $0 + 1 = 1$, sem carry.
Coluna $1$: $1 + 0 = 1$, sem carry.
Coluna $2$: $1 + 0 = 1$, sem carry.
Coluna $3$: $0 + 0 = 0$, sem carry.

Nenhuma coluna individual ultrapassa $1$, portanto nunca precisamos de transporte. Esse é o caso mais simples.

A situação muda quando a soma de alguma coluna ultrapassa $1$. Por exemplo, $0111_2 + 0001_2$:

$$ \begin{alignedat}{5} & & 0 &\;1 &\;1 &\;1_2 &\;(7_{10}) \\ &+& 0 &\;0 &\;0 &\;1_2 &\;(1_{10}) \\ \hline & & 1 &\;0 &\;0 &\;0_2 &\;(8_{10}) \end{alignedat} $$

Coluna $0$: $1 + 1 = 10_2$. O bit $0$ fica na coluna e o $1$ vai como carry para a coluna $1$.
Coluna $1$: $1 + 0 + \text{carry}(1) = 10_2$, gerando carry para a coluna $2$.
Coluna $2$: $1 + 0 + \text{carry}(1) = 10_2$, gerando carry para a coluna $3$.
Coluna $3$: $0 + 0 + \text{carry}(1) = 1$, sem novo carry.

O carry gerado na coluna $0$ se propagou por três colunas consecutivas. Cada coluna que produziu $10_2$ gerou um novo carry para a seguinte, esse encadeamento é exatamente o que o circuito precisará implementar.

Meio Somador12.3

Vamos começar com a soma mais simples possível. Queremos somar dois bits, $A$ e $B$, sem considerar transporte vindo de uma coluna anterior. Esse bloco é chamado de Meio Somador porque ele resolve apenas a situação local da coluna. Ele ainda não está preparado para participar plenamente de uma soma de vários bits, justamente porque não recebe um carry in.

Antes de formalizar o circuito, precisamos entender o problema físico. Em uma conta decimal, quando somamos $7 + 8$, o resultado da coluna das unidades é $5$ e ainda sobra um transporte para a próxima casa. Em binário acontece a mesma ideia, só que com símbolos muito mais simples.

Para construir esse bloco, a primeira pergunta não deve ser “qual porta lógica usar?”, mas sim: como um circuito deve responder às quatro somas possíveis entre dois bits?

As combinações básicas são:

• $0 + 0 = 0$
• $0 + 1 = 1$
• $1 + 0 = 1$
• $1 + 1 = 10_2$

As três primeiras não causam surpresa. O resultado cabe em um único bit. O quarto caso, no entanto, exige mais cuidado. Em binário, $1 + 1$ não vale $2$ escrito como símbolo decimal. Ele vale $10_2$. Isso quer dizer duas coisas ao mesmo tempo:

• o bit que fica na coluna atual é $0$
• há um transporte de valor $1$ para a próxima coluna

Por isso, uma coluna somadora precisa produzir duas saídas:

• Soma (Sum), que é o bit que permanece naquela posição
• Carry Out, que é o transporte enviado para a coluna seguinte

Assim, no caso mais importante do Meio Somador, temos:

$$ 1 + 1 = 10_2 \Rightarrow Sum = 0, \qquad Carry\ Out = 1 $$

Isso já mostra por que uma única saída não basta. A coluna precisa dizer o que fica nela e o que precisa continuar viajando pela soma. Essa é a ideia fundamental do Meio Somador: ele transforma uma soma aritmética simples em duas informações digitais separadas, uma para a coluna atual e outra para a próxima coluna.

Agora formalizamos a tabela-verdade completa do Meio Somador.

$$ \begin{array}{c|c||c|c} A & B & Sum & Carry\ Out \\ \hline 0 & 0 & 0 & 0 \\ 0 & 1 & 1 & 0 \\ 1 & 0 & 1 & 0 \\ 1 & 1 & 0 & 1 \end{array} $$

Essa tabela deve ser lida com calma. A coluna Sum responde à pergunta “qual bit permanece aqui?”. A coluna Carry Out responde à pergunta “precisa avisar a próxima coluna que sobrou valor?”.

Vamos primeiro observar apenas a coluna da soma local.

$$ \begin{array}{c|c||c} A & B & Sum \\ \hline 0 & 0 & 0 \\ 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \end{array} $$

O padrão é muito conhecido. A saída vale $1$ exatamente quando as entradas são diferentes. Isso é precisamente o comportamento de uma porta XOR. Portanto:

$$ Sum = A \oplus B $$

Se quisermos passar pela forma canônica antes da leitura direta da porta, também podemos fazer isso. Os 1s da coluna Sum aparecem nas linhas $01$ e $10$. Logo:

$$ Sum = \bar{A}B + A\bar{B} $$

Essa é a SOP canônica da função. A leitura como XOR é a forma mais curta e mais reveladora do mesmo comportamento.

Agora olhe apenas o transporte de saída. Ele é ainda mais simples porque não depende de os bits serem diferentes, mas de os dois bits estarem ativos ao mesmo tempo.

$$ \begin{array}{c|c||c} A & B & Carry\ Out \\ \hline 0 & 0 & 0 \\ 0 & 1 & 0 \\ 1 & 0 & 0 \\ 1 & 1 & 1 \end{array} $$

Aqui a leitura é ainda mais direta. O transporte só aparece quando os dois bits locais valem $1$ ao mesmo tempo. Em qualquer outra situação, não há excesso para passar adiante. Logo:

$$ Carry\ Out = A \cdot B $$

A forma canônica já é a própria forma minimizada, porque só existe um caso em que a saída vale $1$.

Circuito final

O Meio Somador resolve perfeitamente a primeira coluna de uma soma, quando ainda não existe transporte chegando de outra posição. É por isso que ele recebe o nome de “meio”. Ele resolve a metade local do problema. Para ver por que ele não basta sozinho, considere uma conta de 2 bits:

$$ \begin{alignedat}{4} & & A_1 &\; A_0 \\ &+& B_1 &\; B_0 \\ \hline & & S_2 &\; S_1 &\; S_0 \end{alignedat} $$

A coluna $0$ soma apenas $A_0 + B_0$, o Meio Somador resolve. A coluna $1$, porém, precisa somar $A_1 + B_1$ e também o carry que pode vir da coluna $0$. O Meio Somador tem apenas duas entradas e não consegue receber carry anterior. Por isso precisamos de um bloco que aceite carry de entrada. Esse bloco é o Somador Completo.

Somador Completo12.4

O Somador Completo soma três bits ao mesmo tempo. Dois deles são os operandos locais, $A$ e $B$. O terceiro é o transporte recebido da coluna anterior, chamado de Carry In. Esse é o bloco realmente útil para construir somadores de vários bits, porque ele já nasce preparado para receber informação da etapa anterior.

Em outras palavras, o Meio Somador enxerga apenas a coluna atual. O Somador Completo enxerga a coluna atual e também a consequência do que aconteceu antes.

Agora a operação não é mais apenas $A + B$. Ela passa a ser:

$$ A + B + Carry\ In $$

Vamos olhar casos importantes com leitura aritmética.

• $0 + 0 + 0 = 0 \Rightarrow Sum = 0, Carry\ Out = 0$
• $0 + 0 + 1 = 1 \Rightarrow Sum = 1, Carry\ Out = 0$
• $1 + 0 + 1 = 10_2 \Rightarrow Sum = 0, Carry\ Out = 1$
• $1 + 1 + 0 = 10_2 \Rightarrow Sum = 0, Carry\ Out = 1$
• $1 + 1 + 1 = 11_2 \Rightarrow Sum = 1, Carry\ Out = 1$

O último caso merece atenção especial. Quando os três sinais são $1$, o total decimal é $3$. Em binário, isso é $11$. Portanto, a coluna atual guarda Sum = 1 e ainda envia Carry Out = 1 para a próxima.

Essa observação já sugere duas ideias importantes:

• a soma local depende da paridade do número de 1s
• o transporte depende de haver sinais suficientes para “estourar” a coluna

A tabela-verdade completa do Somador Completo é:

$$ \begin{array}{c|c|c||c|c} A & B & Carry\ In & Sum & Carry\ Out \\ \hline 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 1 & 0 \\ 0 & 1 & 0 & 1 & 0 \\ 0 & 1 & 1 & 0 & 1 \\ 1 & 0 & 0 & 1 & 0 \\ 1 & 0 & 1 & 0 & 1 \\ 1 & 1 & 0 & 0 & 1 \\ 1 & 1 & 1 & 1 & 1 \end{array} $$

Para ler a coluna Sum sem decorar a resposta final, observe apenas os casos em que a soma local vale $1$:

$$ 001,\ 010,\ 100,\ 111 $$

Repare no padrão. Em todas essas linhas existe um número ímpar de entradas em $1$.

• quando há exatamente um 1, Sum = 1
• quando há exatamente três 1s, Sum = 1

Essa é exatamente a assinatura lógica da XOR em cascata. Por isso:

$$ Sum = A \oplus B \oplus Carry\ In $$

Também podemos ver essa construção em duas etapas, o que ajuda no circuito:

$$ X = A \oplus B \qquad \Rightarrow \qquad Sum = X \oplus Carry\ In $$

Se quisermos a forma canônica explícita antes da forma minimizada, ela é:

$$ Sum = \bar{A}\bar{B}C_{in} + \bar{A}B\bar{C}_{in} + A\bar{B}\bar{C}_{in} + ABC_{in} $$

Essa escrita é correta, mas muito menos expressiva do que a leitura via XOR.

Agora fazemos a mesma leitura para o Carry Out. Pela tabela-verdade, o transporte de saída vale $1$ nas combinações:

$$ 011,\ 101,\ 110,\ 111 $$

Usando $C$ para representar Carry In, a SOP canônica é:

$$ Carry\ Out = \bar{A}BC + A\bar{B}C + AB\bar{C} + ABC $$

Agora colocamos esses 1s no Mapa de Karnaugh.

Cada agrupamento elimina uma variável diferente:

• o grupo 011-111 mantém $B=1$ e $C=1$, então gera $BC$
• o grupo 101-111 mantém $A=1$ e $C=1$, então gera $AC$
• o grupo 110-111 mantém $A=1$ e $B=1$, então gera $AB$

Logo, a expressão minimizada é:

$$ Carry\ Out = AB + AC + BC $$

Voltando ao nome completo da terceira variável:

$$ Carry\ Out = (A \cdot B) + (A \cdot Carry\ In) + (B \cdot Carry\ In) $$

Essa expressão tem uma interpretação física muito boa. O transporte aparece quando pelo menos dois dos três sinais de entrada são $1$. Em outras palavras, a coluna gera carry sempre que a soma local ultrapassa o que cabe em um único bit.

O Somador Completo resolve exatamente a limitação do Meio Somador. Agora já temos um bloco capaz de ocupar as colunas internas de uma soma de vários bits. Mas, antes de seguir para a subtração, vale dar um passo essencial. Precisamos entender como esses blocos pequenos são encadeados para formar um somador grande.

Do Somador de 1 Bit ao Somador de 8 Bits12.5

Até aqui o Somador Completo apareceu como função lógica. Agora vamos olhar para ele como ele realmente fica em um projeto no Logisim. Em vez de pensar só em tabela-verdade, vamos ler o circuito montado e usar essa leitura para entender como nasce um somador de 8 bits. Observe primeiro o circuito abaixo:

Em vez de tentar decorar o desenho inteiro, leia apenas o papel de cada sinal:

• A e B são os bits da coluna atual
• Cin é o transporte que chega da coluna anterior
• S é o bit de soma que fica nesta coluna
• Cout é o transporte que sai para a próxima coluna

O detalhe mais importante da imagem é que o Cin foi ligado em uma constante 0. Isso quer dizer que esse bloco está funcionando como a primeira coluna de uma soma, onde ainda não existe transporte vindo de outra etapa.

Por isso, essa primeira posição poderia ser implementada também com um Meio Somador. Aqui foi usado um Somador Completo com Cin = 0 porque, no Logisim, isso deixa a construção mais uniforme e facilita repetir o mesmo bloco várias vezes.

Depois de entender essa primeira imagem, a pergunta natural é esta. Se um Somador Completo resolve uma coluna, como fazemos para resolver oito colunas seguidas. Agora observe a montagem abaixo:

O que essa imagem mostra, na prática, é a repetição do mesmo bloco oito vezes. Cada um deles resolve uma coluna da soma binária.

Leia da direita para a esquerda, começando pela coluna menos significativa:

• o primeiro somador recebe A0, B0 e Cin = 0
• ele produz S0 e um transporte de saída
• esse transporte se chama $C_1$ e sai como Cout do primeiro bloco
• imediatamente entra como Cin do segundo bloco
• o segundo bloco então soma A1, B1 e o carry $C_1$ que acabou de chegar
• o mesmo processo se repete até a última coluna, gerando $C_2$, $C_3$, $\ldots$, $C_7$

Quando os somadores são ligados desse jeito, com o carry saindo de um bloco e entrando no seguinte, o circuito recebe o nome de ripple-carry adder (somador com propagação em onda). O nome vem do fato de que o carry precisa se propagar por todas as colunas, uma a uma, como uma onda, até atingir a saída final. Quanto maior o número de bits, mais tempo o circuito demora para estabilizar, porque cada estágio depende do resultado do anterior.

A última coluna merece atenção extra. O carry de saída do bloco mais significativo ($C_8$ no diagrama conceitual) não alimenta nenhum bloco seguinte. Ele representa o estouro da operação, a indicação de que o resultado da soma não cabe em 8 bits e precisaria de um nono bit para ser representado corretamente. Se $C_8 = 1$, dizemos que ocorreu overflow.

Subtração Binária na Prática12.6

Assim como na adição, a subtração binária é feita coluna por coluna, da direita para a esquerda. A diferença é o conceito de empréstimo (borrow): quando o minuendo de uma coluna é menor que o subtraendo, precisamos pedir valor emprestado à coluna mais significativa. Em binário, esse empréstimo vale $10_2 = 2$ localmente.

Considere $1101_2 - 0001_2$. Como em decimal, subtraímos coluna a coluna:

$$ \begin{alignedat}{5} & & 1 &\;1 &\;0 &\;1_2 &\;(13_{10}) \\ &-& 0 &\;0 &\;0 &\;1_2 &\;(1_{10}) \\ \hline & & 1 &\;1 &\;0 &\;0_2 &\;(12_{10}) \end{alignedat} $$

Coluna $0$: $1 - 1 = 0$, sem borrow. Coluna $1$: $0 - 0 = 0$, sem borrow. Coluna $2$: $1 - 0 = 1$, sem borrow. Coluna $3$: $1 - 0 = 1$, sem borrow. Cada coluna individualmente consegue fazer a conta, esse é o caso ideal.

O borrow aparece quando o minuendo local é menor que o subtraendo. Por exemplo, $1000_2 - 0001_2$:

$$ \begin{alignedat}{5} & & 1 &\;0 &\;0 &\;0_2 &\;(8_{10}) \\ &-& 0 &\;0 &\;0 &\;1_2 &\;(1_{10}) \\ \hline & & 0 &\;1 &\;1 &\;1_2 &\;(7_{10}) \end{alignedat} $$

Coluna $0$: $0 - 1$ não é possível. A coluna $1$ empresta $1$ (que vale $10_2 = 2$ localmente). Agora coluna $0$ faz $10_2 - 1 = 1$.
Coluna $1$: após o empréstimo, a coluna $1$ passou a valer $0$. $0 - 0 = 0$, sem novo borrow.
Coluna $2$: $0 - 0 = 0$, sem borrow.
Coluna $3$: $1 - 0 = 1$, sem borrow.

Meio Subtrator12.7

Agora vamos para a subtração binária. O raciocínio continua sendo por coluna, mas a pergunta muda. Em vez de saber se surgiu um transporte, precisamos saber se faltou valor na coluna atual e se será necessário pedir um empréstimo à próxima posição mais significativa.

No Meio Subtrator, temos apenas duas entradas:

• $A$, o minuendo
• $B$, o subtraendo

As saídas serão:

• Diferença (Difference)
• Borrow Out, o empréstimo enviado para a próxima coluna

Se na soma a pergunta era “sobrou valor para carregar adiante?”, agora a pergunta é “faltou valor e foi preciso pedir emprestado?”.

Para construir o Meio Subtrator, começamos pelas quatro subtrações possíveis entre dois bits. As contas básicas são:

• $0 - 0 = 0$
• $1 - 0 = 1$
• $1 - 1 = 0$
• $0 - 1$ exige empréstimo

Esse último caso é o mais importante de todo o bloco. A coluna atual não consegue entregar 0 - 1 usando apenas o que tem localmente. Então ela precisa pedir valor emprestado à próxima coluna mais significativa. Em binário, esse empréstimo equivale a receber $10_2$ localmente. Assim, a conta passa a ser:

$$ 0 - 1 \Rightarrow 10_2 - 1 = 1 $$

Portanto, o bloco precisa informar duas coisas ao mesmo tempo:

• a Diferença que fica na coluna atual é $1$
• houve necessidade de empréstimo, então Borrow Out = 1

Escrevendo explicitamente:

$$ Difference = 1, \qquad Borrow\ Out = 1 $$

A tabela-verdade do Meio Subtrator é:

$$ \begin{array}{c|c||c|c} A & B & Difference & Borrow\ Out \\ \hline 0 & 0 & 0 & 0 \\ 0 & 1 & 1 & 1 \\ 1 & 0 & 1 & 0 \\ 1 & 1 & 0 & 0 \end{array} $$

Aqui, Difference responde ao que permanece na coluna. Borrow Out responde se foi preciso pedir ajuda à coluna seguinte. Agora observe a coluna Difference. Ela tem o mesmo padrão da soma local do Meio Somador.

$$ \begin{array}{c|c||c} A & B & Difference \\ \hline 0 & 0 & 0 \\ 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 0 \end{array} $$

Esse padrão é idêntico ao da XOR. A saída vale $1$ quando as entradas são diferentes. Logo:

$$ Difference = A \oplus B $$

Se quisermos a escrita canônica:

$$ Difference = \bar{A}B + A\bar{B} $$

Isso é um ótimo lembrete de que duas operações diferentes podem compartilhar parte de sua lógica interna. A diferença entre soma e subtração não está necessariamente na saída principal da coluna, mas muitas vezes na lógica de transporte ou empréstimo.

Agora olhe para a coluna do empréstimo. Ela mostra diretamente quando o Borrow Out precisa aparecer.

$$ \begin{array}{c|c||c} A & B & Borrow\ Out \\ \hline 0 & 0 & 0 \\ 0 & 1 & 1 \\ 1 & 0 & 0 \\ 1 & 1 & 0 \end{array} $$

O empréstimo só aparece em um único caso: quando o minuendo local vale $0$ e o subtraendo exige $1$. Portanto:

$$ Borrow\ Out = \bar{A} \cdot B $$

Essa função já está minimizada. Ela também tem uma leitura física muito clara: o empréstimo ocorre quando a coluna não tem valor suficiente para atender a subtração pedida por $B$.

Leitura algébrica final

$$ \begin{aligned} Difference &= A \oplus B \\ Borrow\ Out &= \bar{A} \cdot B \end{aligned} $$

Circuito final

Assim como ocorreu na soma, esse bloco ainda não resolve o caso geral. Em uma subtração de vários bits, a segunda coluna em diante pode receber um empréstimo vindo da anterior. Nesse momento, o Meio Subtrator deixa de ser suficiente e precisamos do Subtrator Completo.

Subtrator Completo12.8

O Subtrator Completo subtrai três bits ao mesmo tempo:

$$ A - B - Borrow\ In $$

Aqui, $A$ é o minuendo local, $B$ é o subtraendo local e Borrow In é o empréstimo recebido da coluna anterior. O circuito precisa calcular a nova diferença da coluna e decidir se um novo empréstimo deve ser enviado adiante.

Se o Somador Completo era a versão “com carry de entrada” do somador, o Subtrator Completo é a versão “com borrow de entrada” do subtrator.

Para interpretar a subtração com três entradas, vamos observar alguns exemplos centrais:

• $1 - 0 - 0 = 1 \Rightarrow Difference = 1, Borrow\ Out = 0$
• $1 - 1 - 0 = 0 \Rightarrow Difference = 0, Borrow\ Out = 0$
• $1 - 0 - 1 = 0 \Rightarrow Difference = 0, Borrow\ Out = 0$
• $0 - 0 - 1 \Rightarrow Difference = 1, Borrow\ Out = 1$
• $0 - 1 - 0 \Rightarrow Difference = 1, Borrow\ Out = 1$
• $0 - 1 - 1 \Rightarrow Difference = 0, Borrow\ Out = 1$

O caso mais delicado é $0 - 1 - 1$. A coluna precisa retirar dois valores de um bit que vale zero. Isso não é possível localmente. Então a coluna pede empréstimo da próxima posição mais significativa, ajusta seu valor local e ainda sinaliza que o problema continua existindo em forma de Borrow Out = 1.

Essa leitura mostra que o borrow de entrada não é um detalhe cosmético. Ele altera concretamente a conta local da coluna.

A tabela-verdade completa do Subtrator Completo é:

$$ \begin{array}{c|c|c||c|c} A & B & Borrow\ In & Difference & Borrow\ Out \\ \hline 0 & 0 & 0 & 0 & 0 \\ 0 & 0 & 1 & 1 & 1 \\ 0 & 1 & 0 & 1 & 1 \\ 0 & 1 & 1 & 0 & 1 \\ 1 & 0 & 0 & 1 & 0 \\ 1 & 0 & 1 & 0 & 0 \\ 1 & 1 & 0 & 0 & 0 \\ 1 & 1 & 1 & 1 & 1 \end{array} $$

A saída Difference pode ser lida diretamente pela coluna da diferença. Ela vale $1$ nas combinações:

$$ 001,\ 010,\ 100,\ 111 $$

Mais uma vez aparece a regra da paridade ímpar. Isso significa que a diferença local pode ser implementada como XOR em cascata:

$$ Difference = A \oplus B \oplus Borrow\ In $$

Se quisermos a forma canônica explícita:

$$ Difference = \bar{A}\bar{B}B_{in} + \bar{A}B\bar{B}_{in} + A\bar{B}\bar{B}_{in} + ABB_{in} $$

Mas, assim como no Somador Completo, a leitura via XOR é a que mais revela a estrutura da função.

Para obter o Borrow Out, partimos das linhas em que ele vale $1$. Pela tabela-verdade, isso ocorre nas combinações:

$$ 001,\ 010,\ 011,\ 111 $$

Usando $C$ para representar Borrow In, a forma canônica SOP é:

$$ Borrow\ Out = \bar{A}\bar{B}C + \bar{A}B\bar{C} + \bar{A}BC + ABC $$

Agora organizamos esses 1s no Mapa de Karnaugh.

Vamos ler cada grupo com calma:

• 001-011 mantém $A=0$ e $C=1$, então gera $\bar{A}C$
• 010-011 mantém $A=0$ e $B=1$, então gera $\bar{A}B$
• 011-111 mantém $B=1$ e $C=1$, então gera $BC$

Logo, a forma minimizada fica:

$$ Borrow\ Out = \bar{A}C + \bar{A}B + BC $$

Substituindo $C$ por Borrow In:

$$ Borrow\ Out = (\bar{A} \cdot Borrow\ In) + (\bar{A} \cdot B) + (B \cdot Borrow\ In) $$

Essa expressão mostra muito bem quando a coluna continua em dívida:

• quando o minuendo local é insuficiente e ainda chega um borrow anterior
• quando o minuendo local é insuficiente diante de $B$
• quando $B$ e Borrow In exigem valor ao mesmo tempo

Cada bloco continua resolvendo apenas uma coluna. O que transforma o sistema em um subtrator grande é o encadeamento coerente dos empréstimos, exatamente como o carry encadeava o somador.

Questões12.9

A0, B0 -> HA  -> S0, C1
A1, B1, C1 -> FA1 -> S1, C2
...
A7, B7, C7 -> FA7 -> S7, C8

Próximos passos12.10

Agora que os blocos básicos de soma e subtração já estão claros e já vimos como encadear colunas para montar um somador de 8 bits, o próximo passo é estudar como operações maiores podem ser implementadas por repetição, deslocamento e composição de blocos. No próximo capítulo, Aritmética Digital II, vamos avançar para multiplicação e divisão binárias.