Propiedades de programación

boolean activo = true;

// Identidad AND: el true no aporta nada
boolean r1 = activo && true;   // equivale a: activo
boolean r2 = activo && false;  // equivale a: false (siempre)

// Identidad OR: el false no aporta nada
boolean r3 = activo || false;  // equivale a: activo
boolean r4 = activo || true;   // equivale a: true (siempre)

System.out.println(r1 + ", " + r2 + ", " + r3 + ", " + r4);
// true, false, true, true

boolean p = true;
System.out.println(!!p);  // true (doble negación = original)

boolean q = false;
System.out.println(!!q);  // false

// ❌ Código redundante:
if (!!esValido) { ... }
// ✅ Simplificado:
if (esValido) { ... }

// Ejemplo: descuento si es cliente VIP Y (compra > 100 O tiene cupón)
boolean esVIP = true;
boolean compraGrande = false;
boolean tieneCupon = true;

// Forma compacta (distribución sin expandir)
boolean descuento1 = esVIP && (compraGrande || tieneCupon);

// Forma expandida (distribución aplicada)
boolean descuento2 = (esVIP && compraGrande) || (esVIP && tieneCupon);

System.out.println(descuento1 == descuento2);  // true (equivalentes)

boolean esAdmin = true;
boolean tienePermiso = false;

// ❌ Condición con absorción no simplificada
if (esAdmin && (esAdmin || tienePermiso)) {
    System.out.println("Acceso");
}

// ✅ Simplificada por absorción: solo necesitamos esAdmin
if (esAdmin) {
    System.out.println("Acceso");
}

int edad = 15;
boolean tienePermiso = false;

// Condición original: NO (es mayor de edad Y tiene permiso)
boolean original = !(edad >= 18 && tienePermiso);

// Aplicando De Morgan: es menor de edad O no tiene permiso
boolean deMorgan = (edad < 18) || !tienePermiso;

System.out.println("Original: " + original);    // true
System.out.println("De Morgan: " + deMorgan);    // true
System.out.println("¿Iguales? " + (original == deMorgan));  // true

public class VerificadorLeyes {

    static boolean verificar2vars(String nombre,
            java.util.function.BiFunction<Boolean,Boolean,Boolean> f1,
            java.util.function.BiFunction<Boolean,Boolean,Boolean> f2) {
        boolean[] vals = {true, false};
        boolean ok = true;
        for (boolean p : vals) {
            for (boolean q : vals) {
                if (!f1.apply(p, q).equals(f2.apply(p, q))) {
                    ok = false;
                }
            }
        }
        System.out.printf("  %-25s → %s%n", nombre, ok ? "✅ Verificada" : "❌ Falla");
        return ok;
    }

    public static void main(String[] args) {
        System.out.println("=== Verificación de leyes lógicas ===\n");

        // Complemento
        verificar2vars("Complemento AND",
            (p, q) -> p && !p,
            (p, q) -> false);

        verificar2vars("Complemento OR",
            (p, q) -> p || !p,
            (p, q) -> true);

        // Idempotencia
        verificar2vars("Idempotencia AND",
            (p, q) -> p && p,
            (p, q) -> p);

        verificar2vars("Idempotencia OR",
            (p, q) -> p || p,
            (p, q) -> p);

        // Identidad
        verificar2vars("Identidad AND true",
            (p, q) -> p && true,
            (p, q) -> p);

        verificar2vars("Identidad OR false",
            (p, q) -> p || false,
            (p, q) -> p);

        // Doble negación
        verificar2vars("Doble negación",
            (p, q) -> !!p,
            (p, q) -> p);

        // De Morgan
        verificar2vars("De Morgan 1ª ley",
            (p, q) -> !(p && q),
            (p, q) -> !p || !q);

        verificar2vars("De Morgan 2ª ley",
            (p, q) -> !(p || q),
            (p, q) -> !p && !q);

        // Distribución
        verificar2vars("Distribución AND/OR",
            (p, q) -> p && (p || q),  // absorción: resultado = p
            (p, q) -> p);

        // Absorción
        verificar2vars("Absorción OR/AND",
            (p, q) -> p || (p && q),
            (p, q) -> p);
    }
}

// Verificación por tabla de verdad
boolean[] v = {true, false};
System.out.println("  p\t  q\t  ¬(p→q)\t  p∧¬q\t  ¿Iguales?");
for (boolean p : v) {
    for (boolean q : v) {
        boolean f1 = !(!p || q);    // ¬(p → q)
        boolean f2 = p && !q;       // p ∧ ¬q
        System.out.printf("  %s\t  %s\t  %s\t\t  %s\t  %s%n",
            p, q, f1, f2, f1 == f2 ? "✓" : "✗");
    }
}
// Las 4 filas muestran ✓: equivalencia demostrada

// ❌ Error: negar operandos PERO NO cambiar el operador
// !(a && b) NO es igual a (!a && !b)
boolean a = true, b = false;
System.out.println(!(a && b));     // true
System.out.println(!a && !b);      // false ← ¡DIFERENTE!

// ✅ Correcto: negar operandos Y cambiar el operador
System.out.println(!a || !b);      // true ← Ahora sí coincide