XOR y XNOR

01 · Punto de partida

¿Son iguales o no?

Hay dos preguntas que se repiten en todo sistema: «¿lo que leí es igual a lo que esperaba?» y «¿cambió algo desde la última vez?». Las dos son la misma pregunta: comparar dos bits. La puerta que responde «difieren» es la XOR (OR exclusivo); la que responde «coinciden» es la XNOR.

• ¿Qué filas dan 1 en cada una, y qué reglas cumple el XOR?
• ¿Cómo se usa un XOR como inversor que se puede encender y apagar?
• ¿Cómo se comparan dos números de N bits y cuántos bits difieren?
• ¿Qué relación hay entre XOR, la suma binaria y la paridad?
• ¿Qué trampa trae el chip de XNOR?

02 · XOR

Detector de diferencias

La salida del XOR vale 1 cuando las entradas son distintas. Se escribe Y = A⊕B. El símbolo es una OR con una curva extra en la entrada, y el chip estándar es el 74HC86, con cuatro puertas.

El XOR tiene cuatro lecturas equivalentes, y conviene saltar de una a otra según el problema:

«Difieren»

Es el a != b del software. Compara dos bits y marca la discrepancia.

«Uno solo está en 1» (OR exclusivo)

«Uno u otro, pero no los dos». Distinto del OR común, que incluye el caso 11.

«Cantidad impar de unos»

Con dos entradas, la salida es 1 cuando hay exactamente un uno. Con N entradas encadenadas, es 1 cuando hay una cantidad impar: la paridad (Tema 26).

«Suma sin acarreo»

0+0 = 0, 0+1 = 1, 1+0 = 1 y 1+1 = 0 (el 1 que se pierde es el acarreo, que calcula un AND aparte). Es el bit de suma del sumador (Tema 23).

Reglas del XOR

03 · XNOR

Verificador de igualdad

La XNOR es la negación del XOR: su salida vale 1 cuando las entradas son iguales. Se escribe Y = A⊙B (o ~(A⊕B)). Es una XOR con la bolita en la salida.

El drenador abierto no es solo un defecto: permite unir las salidas de varias XNOR y obtener un AND cableado de todas las igualdades. Así, cuatro XNOR de salida abierta y un pull-up comparan dos nibbles sin ninguna puerta AND extra.

04 · Aplicaciones

Seis usos que ya conocés sin saberlo

Interruptores conmutados

La luz de pasillo del Tema 6 con dos interruptores (cada uno la invierte) es un XOR; con tres, la paridad de tres. Por eso la autoinversa importa: cada interruptor «deshace» al otro.

Código Gray

La conversión del Tema 5 a Gray es g = n ⊕ (n >> 1): cada bit se compara con su vecino y solo cambia un bit por paso.

Cifrado con clave

texto ⊕ clave lo ofusca; aplicar ⊕ clave otra vez lo recupera (autoinversa). Es la base de los cifrados de flujo, pero con una clave corta y repetida es trivial de romper: sirve para entender, no para proteger datos.

Recuperación de datos (RAID 5)

La paridad de un bloque es el XOR de los demás. Si un disco se pierde, su contenido es el XOR de los que quedan más la paridad: A⊕B⊕P = C.

05 · N bits

De un bit a muchos

Dos números de N bits son iguales si y solo si todos sus bits coinciden. Eso se traduce directamente en puertas: un XNOR por cada par de bits y un AND que junta los resultados.

Hay una versión equivalente que se lee mejor en software: A ^ B da un número cuyos bits en 1 marcan las posiciones donde difieren. Si ese número es cero, los dos son iguales. Y cuántos unos tiene es la distancia de Hamming: la cantidad de bits distintos.

Paridad: una cadena de XOR

Para saber si una palabra tiene cantidad par o impar de unos se encadenan XOR. Para N bits hacen falta N − 1 puertas y la señal atraviesa ⌈log₂ N⌉ niveles si se dispone en árbol, igual que en el AND del Tema 8. Si al enviar un byte agregás un noveno bit que hace que la cantidad total de unos sea par, el receptor hace el mismo XOR y detecta cualquier error de un solo bit.

06 · Chips reales

74HC86 y compañía

Pines del 74HC86

Es idéntico al 74HC00 y al 74HC08 (Tema 8 y 9): entradas 1A, 1B y salida 1Y en los pines 1, 2, 3; 2A, 2B, 2Y en 4, 5, 6; GND en el 7; 3Y, 3A, 3B en 8, 9, 10; 4Y, 4A, 4B en 11, 12, 13; VCC en el 14. Aun así, confirmalo en la hoja de datos del fabricante.

Entradas sobrantes

Una entrada de XOR sin usar se ata a un valor que convierta la puerta en lo que querés: a 0 es un buffer (A⊕0 = A); a 1 es un inversor (A⊕1 = ~A). Una puerta entera sin usar lleva las dos entradas atadas a GND.

XOR con NAND

Con puertas universales (Tema 9) un XOR cuesta 4 NAND, es decir, un chip 74HC00 entero. Cuatro XOR dedicados caben en un solo 74HC86: otro caso de universal que no es óptimo.

07 · Simulador

Laboratorio: ¿coinciden?

El simulador compara dos números A y B bit a bit con una columna de puertas XOR (o XNOR). Cada columna es una puerta independiente; las posiciones donde los bits difieren se marcan en naranja, sin importar qué puerta elijas. Abajo ves el veredicto y cuántos bits distintos hay (la distancia de Hamming).

• Arriba y en el medio: los bits de A y de B (amarillo = 1, turquesa = 0).
• Cuadros intermedios: una puerta por columna; el cable que baja lleva el resultado.
• Fila inferior: el resultado por bit. En naranja, las posiciones que difieren.

Recorrido guiado (6 minutos)

1. 1
   Mirá el estado inicial: 0xA5 contra 0xA1.

   Siete columnas dan 0 (coinciden) y una da 1: el bit 2, en naranja. El XOR bit a bit es 0x04: un solo bit distinto, distancia de Hamming 1.

2. 2
   Apretá «B = A».

   Todas las columnas se ponen en 0 y el veredicto dice IGUALES. Es la prueba de igualdad: A⊕B = 0.

3. 3
   Apretá «B = ~A (invertir)».

   Todas las columnas difieren: el resultado es 0xFF y la distancia es 8 de 8. XOR con 0xFF es el complemento a uno.

4. 4
   Pasá a XNOR sin tocar A ni B.

   Todos los bits del resultado se invierten, pero las posiciones naranja no cambian: siguen siendo las que difieren. El veredicto es el mismo; lo que cambia es qué valor significa «difiere» (0 en XNOR).

5. 5
   Con XOR, apretá varias veces «Cambiar un bit de B».

   Cada clic agrega o quita una diferencia. La distancia de Hamming sube y baja de a uno. Fijate que la paridad de A⊕B (par o impar) alterna con cada cambio.

6. 6
   Probá el ancho de 4 bits y armá A = 0xA y B = 0x9.

   1010 contra 1001: difieren en 2 posiciones (bits 1 y 0). Con dos errores la paridad vuelve a ser par: un bit de paridad no los detectaría, como advierte el Tema 26.

Preguntas para pensar

1. Con A = 1010 0101 y B = 1010 0101, ¿qué da XOR bit a bit? ¿Y XNOR?
2. ¿Qué B hace que A⊕B = 0xFF para cualquier A? ¿Y qué B hace que A⊕B = A?
3. Si cambiás dos bits de B respecto de A, ¿cuál es la paridad de A⊕B?
4. ¿Cuántas puertas XOR y cuántas AND/NOR hacen falta para comparar dos bytes?

08 · Diferencia en código

Comparar, cambiar, verificar

Estos bloques demuestran las reglas del XOR, lo usan como inversor controlado y como alternador de bits, comparan números con la distancia de Hamming, detectan cambios y flancos en un puerto, calculan paridad y checksum (incluida la recuperación de un bloque perdido) y muestran el sumador medio, el código Gray y un cifrado XOR.

Paso 1: las dos puertas y sus reglas

from itertools import product


def xor_(a, b):
    return a ^ b


def xnor_(a, b):
    return 1 - (a ^ b)


filas = [(a, b) for a in (0, 1) for b in (0, 1)]
print("XOR: ", "".join(str(xor_(a, b)) for a, b in filas))
print("XNOR:", "".join(str(xnor_(a, b)) for a, b in filas))

REGLAS = {
    "neutro      A^0 = A":        lambda a, b, c: (a ^ 0) == a,
    "inversion   A^1 = ~A":       lambda a, b, c: (a ^ 1) == 1 - a,
    "anulacion   A^A = 0":        lambda a, b, c: (a ^ a) == 0,
    "complemento A^~A = 1":       lambda a, b, c: (a ^ (1 - a)) == 1,
    "asociativa  (A^B)^C":        lambda a, b, c: ((a ^ b) ^ c) == (a ^ (b ^ c)),
    "autoinversa (A^B)^B = A":    lambda a, b, c: ((a ^ b) ^ b) == a,
    "distributiva A&(B^C)":       lambda a, b, c: (a & (b ^ c)) == ((a & b) ^ (a & c)),
    "falsa:      A^B = A|B":      lambda a, b, c: (a ^ b) == (a | b),
}
for nombre, regla in REGLAS.items():
    ok = all(regla(*f) for f in product((0, 1), repeat=3))
    print(f"{'vale' if ok else 'FALLA'}  {nombre}")

XOR: 0110 y XNOR: 1001. Las siete reglas valen en las 8 filas; la última (XOR no es OR) falla en la fila 11.

Paso 2: inversor controlado y alternar bits

def invertir_si(x, c, bits=8):
    return x ^ (((1 << bits) - 1) if c else 0)


x = 0b01100110
print(f"x               = {x:08b}")
print(f"invertir_si c=0 = {invertir_si(x, 0):08b}   (pasa igual)")
print(f"invertir_si c=1 = {invertir_si(x, 1):08b}   (complemento a uno)")

flags = 0b0000
LED1, LED2, LED3 = 0b001, 0b010, 0b100
for nombre, mascara in (("LED1", LED1), ("LED3", LED3), ("LED1", LED1)):
    flags ^= mascara
    print(f"alternar {nombre}: {flags:03b}")

a, b = 0x3C, 0xA5                    # intercambio sin variable temporal
a ^= b
b ^= a
a ^= b
print(f"swap con XOR: a=0x{a:02X} b=0x{b:02X}")

Con c = 1 se invierte el byte entero, con c = 0 queda igual. Alternar el mismo LED dos veces lo deja como estaba (autoinversa). El intercambio con XOR funciona justamente por esa propiedad.

Paso 3: igualdad de N bits y distancia de Hamming

def comparar(a, b, bits=8):
    mascara = (1 << bits) - 1
    d = a ^ b                            # 1 en cada posición donde difieren
    xnor = ~d & mascara                  # 1 en cada posición donde coinciden
    iguales = xnor == mascara            # el AND de todos los XNOR
    hamming = bin(d).count("1")
    print(f"{a:08b} vs {b:08b}  XOR={d:08b}  "
          f"{'IGUALES' if iguales else 'difieren'}  Hamming={hamming}")
    return hamming


comparar(0xA5, 0xA5)
comparar(0xA5, 0xA1)
comparar(0xA5, 0x5A)
comparar(0xA5, 0xAA)

Distancias 0, 1, 8 y 4. Igualdad es «todos los XNOR en 1» o, equivalente, «A ^ B == 0».

Paso 4: detector de cambios y flancos de un puerto

lecturas = [0b0001, 0b0011, 0b0010, 0b0010, 0b1010]

previo = lecturas[0]
print("   lectura  cambio  subió  bajó")
for nuevo in lecturas[1:]:
    cambio = previo ^ nuevo
    subio = cambio & nuevo          # cambió y ahora vale 1
    bajo = cambio & previo          # cambió y antes valía 1
    print(f"   {nuevo:04b}     {cambio:04b}    {subio:04b}   {bajo:04b}")
    previo = nuevo

En cada paso, XOR marca qué pines cambiaron; AND con el valor nuevo separa los flancos de subida y AND con el anterior, los de bajada. Es lo que hace en hardware la «interrupción por cambio de pin».

Paso 5: paridad, checksum y recuperación

from functools import reduce


def paridad_par(byte):
    # bit que, agregado al byte, deja una cantidad par de unos
    return reduce(lambda p, i: p ^ ((byte >> i) & 1), range(8), 0)


for c in "ACb":
    v = ord(c)
    print(f"{c!r} = {v:08b}  bit de paridad par = {paridad_par(v)}")

recibido = 0b01000001 ^ 0b00000100          # 'A' con un bit dañado
print("¿error detectado?", paridad_par(recibido) != paridad_par(0b01000001))


def checksum_nmea(cuerpo):
    return f"{reduce(lambda x, c: x ^ ord(c), cuerpo, 0):02X}"


print("checksum de 'GPGLL':", checksum_nmea("GPGLL"))

d1, d2, d3 = 0x3C, 0xA5, 0x0F
p = d1 ^ d2 ^ d3                              # bloque de paridad (RAID 5)
print(f"paridad = 0x{p:02X}; si se pierde d2, d2 = 0x{p ^ d1 ^ d3:02X}")

Con 'A' (dos unos) la paridad par es 0; con 'C' (tres unos), 1. Un bit dañado cambia la paridad y se detecta. El checksum de «GPGLL» es 50. Con la paridad de los demás bloques se reconstruye el perdido: 0xA5.

Paso 6: sumador medio, código Gray y cifrado

print("A B | suma acarreo")
for a in (0, 1):
    for b in (0, 1):
        print(a, b, "|", a ^ b, "   ", a & b)

print()
for n in range(8):
    g = n ^ (n >> 1)
    print(f"{n} {n:03b} -> Gray {g:03b}")

clave = 0x5A
texto = "HOLA"
cifrado = bytes(ord(c) ^ clave for c in texto)
descifrado = "".join(chr(b ^ clave) for b in cifrado)
print(cifrado.hex(" "), "->", descifrado)

XOR da la suma y AND el acarreo (1+1 = «10»). En Gray cada fila difiere de la anterior en un solo bit. «HOLA» pasa a 12 15 16 1B y vuelve igual: aplicar el mismo XOR dos veces es la identidad.

09 · Analogía de programador

!= y == con silicio

1. 1
   XOR = !=.

   Verdadero cuando difieren. Es la comparación elemental, hecha puerta.

2. 2
   XNOR = ==.

   Verdadero cuando coinciden: una cerradura que abre con el código exacto.

3. 3
   Cascada = comparar strings.

   La igualdad total es el AND de las igualdades por posición, como comparar char por char. La diferencia es que en el hardware se comparan todas a la vez.

Una advertencia sobre el lenguaje: en C, ^ es el XOR bit a bit y no la potencia; y != sobre enteros compara el valor completo, no bit por bit. El primero devuelve «dónde» difieren; el segundo, solo «si».

10 · Comprensión

Confusiones frecuentes

11 · Práctica guiada

Ejercicios de coincidencia

Ejercicio 1: alarma de discrepancia

Dos sensores redundantes deben coincidir; si difieren, hay alarma. ¿Qué puerta y qué chip? Si en lugar de dos fueran tres sensores, ¿sirve un XOR de tres entradas?

Ejercicio 2: igualdad de dos números de 2 bits

Compará A = A₁A₀ con B = B₁B₀. ¿Cuántas puertas y qué chips usás con XNOR + AND? ¿Y con XOR + NOR?

Ejercicio 3: inversor controlado

Un nibble x = 0110 pasa por cuatro XOR con un control común C. ¿Cuánto vale la salida con C = 0 y con C = 1? ¿Para qué sirve ese circuito en una resta?

Ejercicio 4: bit de paridad

El byte 0x6B se envía con un noveno bit de paridad par. ¿Cuánto vale ese bit? ¿Cuántas puertas XOR hacen falta para calcularlo y cuántos niveles tiene un árbol? Verificá con paridad_par().

Ejercicio 5: montar el comparador

Armá un 74HC86 con dos pulsadores con pull-down y un LED. Medí las cuatro filas. ¿Qué hacés con las otras tres puertas del chip?

Ejercicio 6: detector de cambios

Un puerto de 4 bits entrega las lecturas 0001, 0011, 0010, 0010. En cada paso, ¿qué pines cambiaron y cuáles subieron o bajaron? Verificá con el Paso 4.

12 · Síntesis

Ideas para recordar

¿Listo para el Tema 11?

Podés avanzar si sos capaz de responder esto sin mirar:

• Escribir de memoria las firmas de XOR y XNOR.
• Explicar qué le hace un XOR a un bit cuando el otro vale 0 y cuando vale 1.
• Armar un comparador de dos números de 4 bits con puertas.
• Decir qué indica A ^ B y cómo se obtiene la cantidad de bits distintos.
• Calcular el bit de paridad par de un byte y decir qué errores no detecta.
• Explicar por qué el XOR de tres sensores no sirve para detectar discrepancia.

Con las puertas lógicas completas, pasamos de los símbolos a los cables: el mundo real no es limpio. En el próximo tema, botones y rebotes, lo que pasa cuando un contacto mecánico se cruza con tu lógica perfecta.