El álgebra booleana proporciona leyes algebraicas para transformar y simplificar expresiones lógicas sin construir tablas de verdad completas. Es la herramienta central del diseño lógico, la optimización de condiciones y el razonamiento formal.
En el tema anterior aprendimos a verificar equivalencias mediante tablas de verdad. Ese método es exhaustivo pero repetitivo. El **álgebra booleana** ofrece un atajo: reglas de reescritura que preservan el valor de verdad y permiten simplificar expresiones de forma directa.
Estas leyes son el fundamento del diseño de circuitos digitales, de la optimización de predicados en bases de datos y de la refactorización de condiciones complejas en código.
Un **álgebra de Boole** es una estructura matemática sobre un conjunto con dos operaciones binarias (∧, ∨) y una unaria (¬) que satisfacen un conjunto de axiomas. En nuestro caso, el conjunto es B = {0, 1}.
Las operaciones corresponden a:
Elementos especiales: 0 es el elemento neutro de ∨ y absorbente de ∧; 1 es el neutro de ∧ y absorbente de ∨.
Las leyes más usadas en la manipulación de expresiones booleanas son:
| Ley | Forma |
|---|---|
| Conmutativa | p ∧ q = q ∧ p · p ∨ q = q ∨ p |
| Asociativa | (p ∧ q) ∧ r = p ∧ (q ∧ r) · (p ∨ q) ∨ r = p ∨ (q ∨ r) |
| Distributiva | p ∧ (q ∨ r) = (p ∧ q) ∨ (p ∧ r) · p ∨ (q ∧ r) = (p ∨ q) ∧ (p ∨ r) |
| Identidad | p ∧ 1 = p · p ∨ 0 = p |
| Complemento | p ∧ ¬p = 0 · p ∨ ¬p = 1 |
| Idempotencia | p ∧ p = p · p ∨ p = p |
| Absorción | p ∨ (p ∧ q) = p · p ∧ (p ∨ q) = p |
| Doble negación | ¬(¬p) = p |
Las leyes de **De Morgan** describen cómo distribuir la negación sobre AND y OR. Son esenciales para simplificar expresiones negadas y convertir entre formas normales:
Ejemplo aplicado: la condición de programación !(a && b) puede reescribirse como !a || !b sin cambiar su comportamiento, gracias a la primera ley de De Morgan.
Selecciona una ley del álgebra booleana y observa la transformación de la expresión. El simulador verifica la equivalencia comparando las salidas en las cuatro combinaciones de p y q. Pulsa **Aplicar Ley** para revelar la expresión simplificada y la tabla de verificación.
Las leyes booleanas permiten refactorizar condiciones para mejorar legibilidad o reducir evaluaciones, siempre preservando la semántica.
// De Morgan en condiciones compuestas
function alertaOriginal(a, b) {
return !(a && b);
}
function alertaSimplificada(a, b) {
return !a || !b; // ¬(a ∧ b) = ¬a ∨ ¬b
}
// Absorción: p ∨ (p ∧ q) = p
function permisoOriginal(esAdmin, tieneRol, activo) {
return esAdmin || (esAdmin && tieneRol && activo);
}
function permisoSimplificado(esAdmin, tieneRol, activo) {
return esAdmin || (tieneRol && activo);
// Si esAdmin es true, la expresión original ya era true
}
// Implicación como OR: p → q ≡ ¬p ∨ q
const implica = (p, q) => !p || q;
function verificarLey(fn1, fn2) {
const casos = [[false,false],[false,true],[true,false],[true,true]];
return casos.every(([p, q]) => Boolean(fn1(p,q)) === Boolean(fn2(p,q)));
}
console.log("De Morgan OK:", verificarLey(
(a, b) => !(a && b),
(a, b) => !a || !b
));
// De Morgan OK: trueEl álgebra booleana cierra el estudio formal de la lógica proposicional desde el punto de vista algebraico. Dominar sus leyes evita depender siempre de tablas de verdad y prepara el terreno para el diseño de hardware y software basado en compuertas lógicas.
En el próximo tema veremos las **funciones discretas en circuitos digitales**, conectando estas leyes algebraicas con compuertas físicas AND, OR y NOT que implementan funciones booleanas en electrónica.