Simplificación

01 · Punto de partida

Cada puerta cuesta

Σm(1,2,3) directo pide 3 AND + 1 OR (+ NOTs): 6 puertas. Simplificado es un OR. Menos chips, menos retardo, menos puntos de falla. La herramienta: adyacencia (minterms que difieren en 1 bit se fusionan).

• ¿Cuándo se fusionan dos minterms?
• ¿Se puede reusar un minterm?
• ¿Cómo queda la mayoría simplificada?
• ¿Cuánto se ahorra en cada caso?

02 · Adyacencia

Difieren en 1, se va 1

A·~B + A·B = A·(~B+B) = A: B se va porque cambia. m1+m3 = ~A·B+A·B = B; m2+m3 = A·~B+A·B = A. Entonces Σm(1,2,3) = A+B (m3 usado dos veces: legal y necesario).

03 · Tres casos

Antes y después

Mayoría mínima: AB+AC+BC (verificar por tabla: el laboratorio lo comprueba en vivo).

04 · Reglas de poda

Lo permitido

Grupos de 1, 2, 4, 8…

Solo potencias de 2: 3 minterms no fusionan de una (se hace de a pares).

Reusar vale

Un minterm en varios grupos: m3 arma B con m1 y A con m2. Sin reuso no hay mínimo.

2 niveles

AND-OR (o NAND-NAND) es lo ideal: cada nivel suma retardo. Simplificar también es aplanar.

XOR no poda

A⊕B no tiene forma AND/OR más corta: es su propio mínimo. No todo se achica.

05 · Poda en código

Vecinos y verificación

Buscar adyacencias y comprobar mínimos por fuerza bruta.

def vecinos(m1, m2, n=2):
    d = m1 ^ m2
    return d != 0 and (d & (d - 1)) == 0


def adyacencias(mins, n=2):
    pares = [(a, b) for i, a in enumerate(mins) for b in mins[i+1:] if vecinos(a, b, n)]
    print(f"{mins} -> vecinos: {pares}")
    return pares


adyacencias([1, 2, 3])
adyacencias([3, 5, 6, 7], n=3)

[1,2,3] → (1,3) y (2,3): m3 con todos. Mayoría → 3 pares: (3,7), (5,7) y (6,7). ¿Por qué (3,5) no aparece?

Verificar mínimos

def check(orig, simp, n=2):
    ok = all(orig(*[(i >> (n-1-k)) & 1 for k in range(n)]) ==
             simp(*[(i >> (n-1-k)) & 1 for k in range(n)]) for i in range(2**n))
    print("minimo valido" if ok else "MAL simplificado")
    return ok


check(lambda a, b: (a, b) in [(0,1),(1,0),(1,1)], lambda a, b: a or b)
check(lambda a, b: (a, b) in [(0,0),(0,1),(1,0)], lambda a, b: (not a) or (not b))

06 · Analogía programador

DRY en silicio

1. 1
   Fusionar = factorizar.

   Código común afuera del if: (a&&!b)||(a&&b) → a. Igualito.

2. 2
   Reusar minterm = reutilizar test.

   Un caso que prueba dos ramas: coverage compartido, menos tests.

3. 3
   2 niveles = flat.

   Código sin anidar de más: legible y rápido. Profundidad = latencia.

07 · Taller

Laboratorio: podar en vivo

Elegí función y mové entradas: el laboratorio evalúa original vs mínimo y cuenta el ahorro.

Preguntas para explorar

1. Recorré las 4 filas en Σm(0,1,2). ¿Original y mínimo coinciden siempre?
2. En mayoría con A=1,B=1,C=0: ¿original? ¿AB+AC+BC? ¿Qué términos dan 1?
3. ¿Por qué el ahorro cuenta NOTs? ¿Qué pasa si los ignorás?

08 · Comprensión

Confusiones frecuentes

09 · Práctica guiada

Ejercicios de poda

Ejercicio 1: Σm(0,1,2) a mano

Fusioná (0,1) y (0,2): ¿qué se va en cada par? Escribí el resultado y verificá con check().

Ejercicio 2: mayoría mínima

Con pares (3,7), (5,7), (6,7): ¿qué producto da cada uno? Sumalos y verificá las 8 filas.

Ejercicio 3: contar de verdad

Mayoría directa vs mínima, contando NOTs (3), ANDs y OR. ¿Puertas? ¿Chips HC?

10 · Síntesis

Ideas para recordar

Poda algebraica dominada. Ahora visual: en el próximo tema, Karnaugh.