Boolesche Algebra: Logik-Gatter, Wahrheitstabellen & Schaltalgebra

Dieser Beitrag ist eine umfassende Einführung in die Boolesche Algebra – inklusive Logik-Gatter, Wahrheitstabellen und Schaltalgebra mit praktischen Beispielen.

In a Nutshell

Boolesche Algebra ist die Mathematik der Logik mit nur zwei Werten: wahr (1) und falsch (0). Sie ist Grundlage aller digitalen Schaltungen und Computer.

Kompakte Fachbeschreibung

Boolesche Algebra ist ein algebraisches System zur Beschreibung logischer Operationen. Sie wurde von George Boole entwickelt und bildet die Grundlage der Digitaltechnik.

Grundlegende Operationen:

AND (Konjunktion)

• Symbol: ∧, ·, AND
• Wahrheit: Nur wahr wenn beide Eingänge wahr
• Schaltung: Serienschaltung
• Anwendung: Sicherheitsfunktionen, Validierung

OR (Disjunktion)

• Symbol: ∨, +, OR
• Wahrheit: Wahr wenn mindestens ein Eingang wahr
• Schaltung: Parallelschaltung
• Anwendung: Alternative Entscheidungen

NOT (Negation)

• Symbol: ¬, ~, NOT, überstrichen
• Wahrheit: Kehrt den Wahrheitswert um
• Schaltung: Inverter
• Anwendung: Signalumkehrung

NAND (Nicht-UND)

• Symbol: ↑, NAND
• Wahrheit: Nur falsch wenn beide Eingänge wahr
• Schaltung: AND mit Inverter
• Anwendung: Universelles Gatter

NOR (Nicht-ODER)

• Symbol: ↓, NOR
• Wahrheit: Nur wahr wenn beide Eingänge falsch
• Schaltung: OR mit Inverter
• Anwendung: Universelles Gatter

XOR (Exklusiv-ODER)

• Symbol: ⊕, XOR
• Wahrheit: Wahr wenn Eingänge unterschiedlich
• Schaltung: Paritätsgatter
• Anwendung: Fehlererkennung, Kryptographie

Prüfungsrelevante Stichpunkte

• Boolesche Algebra: Mathematik mit zwei Werten (0 und 1)
• Logik-Gatter: Elektronische Schaltungen für logische Operationen
• Wahrheitstabellen: Systematische Darstellung aller möglichen Eingangskombinationen
• Schaltalgebra: Anwendung der Booleschen Algebra auf Schaltungen
• Universalgatter: NAND und NOR können alle anderen Gatter ersetzen
• Karnaugh-Diagramm: Vereinfachung logischer Ausdrücke
• IHK-relevant: Grundlage für digitale Schaltungen und Programmierung

Kernkomponenten

1. Boolesche Variablen: Nur 0 oder 1
2. Logische Operationen: AND, OR, NOT, NAND, NOR, XOR
3. Wahrheitstabellen: Vollständige Funktionsbeschreibung
4. Schaltalgebra: Gesetze und Vereinfachungen
5. Logik-Gatter: Elektronische Realisierung
6. Schaltungsdesign: Kombinatorische und sequentielle Schaltungen
7. Minimierung: Karnaugh-Diagramme, Quine-McCluskey
8. Anwendungen: Computerarchitektur, digitale Systeme

Praxisbeispiele

1. Grundlegende Logik-Gatter in Java

public class BoolescheAlgebra {
    
    public static void main(String[] args) {
        // Eingangswerte
        boolean a = true;   // 1
        boolean b = false;  // 0
        
        System.out.println("=== Grundlegende Logik-Operationen ===");
        System.out.println("a = " + a + " (1), b = " + b + " (0)");
        
        // AND (Konjunktion)
        boolean and = a && b;
        System.out.println("a AND b = " + and + " (" + (and ? 1 : 0) + ")");
        
        // OR (Disjunktion)
        boolean or = a || b;
        System.out.println("a OR b = " + or + " (" + (or ? 1 : 0) + ")");
        
        // NOT (Negation)
        boolean notA = !a;
        boolean notB = !b;
        System.out.println("NOT a = " + notA + " (" + (notA ? 1 : 0) + ")");
        System.out.println("NOT b = " + notB + " (" + (notB ? 1 : 0) + ")");
        
        // NAND (Nicht-UND)
        boolean nand = !(a && b);
        System.out.println("a NAND b = " + nand + " (" + (nand ? 1 : 0) + ")");
        
        // NOR (Nicht-ODER)
        boolean nor = !(a || b);
        System.out.println("a NOR b = " + nor + " (" + (nor ? 1 : 0) + ")");
        
        // XOR (Exklusiv-ODER)
        boolean xor = a ^ b;
        System.out.println("a XOR b = " + xor + " (" + (xor ? 1 : 0) + ")");
        
        // Wahrheitstabellen
        wahrheitstabellen();
        
        // Schaltalgebra-Gesetze
        schaltalgebraGesetze();
        
        // Praktische Anwendungen
        praktischeAnwendungen();
    }
    
    private static void wahrheitstabellen() {
        System.out.println("\n=== Wahrheitstabellen ===");
        
        System.out.println("A B | AND | OR | XOR | NAND | NOR");
        System.out.println("---+-----+----+-----+------+----");
        
        for (int a = 0; a <= 1; a++) {
            for (int b = 0; b <= 1; b++) {
                boolean aBool = a == 1;
                boolean bBool = b == 1;
                
                int and = (aBool && bBool) ? 1 : 0;
                int or = (aBool || bBool) ? 1 : 0;
                int xor = (aBool ^ bBool) ? 1 : 0;
                int nand = !(aBool && bBool) ? 1 : 0;
                int nor = !(aBool || bBool) ? 1 : 0;
                
                System.out.printf("%d %d |  %d  | %d  |  %d  |  %d   | %d%n", 
                                a, b, and, or, xor, nand, nor);
            }
        }
    }
    
    private static void schaltalgebraGesetze() {
        System.out.println("\n=== Schaltalgebra-Gesetze ===");
        
        boolean x = true;
        boolean y = false;
        boolean z = true;
        
        // Kommutativgesetze
        System.out.println("Kommutativgesetze:");
        System.out.println("x AND y = y AND x: " + ((x && y) == (y && x)));
        System.out.println("x OR y = y OR x: " + ((x || y) == (y || x)));
        
        // Assoziativgesetze
        System.out.println("\nAssoziativgesetze:");
        System.out.println("(x AND y) AND z = x AND (y AND z): " + 
                          ((x && y) && z == x && (y && z)));
        System.out.println("(x OR y) OR z = x OR (y OR z): " + 
                          ((x || y) || z == x || (y || z)));
        
        // Distributivgesetze
        System.out.println("\nDistributivgesetze:");
        System.out.println("x AND (y OR z) = (x AND y) OR (x AND z): " + 
                          (x && (y || z) == (x && y) || (x && z)));
        System.out.println("x OR (y AND z) = (x OR y) AND (x OR z): " + 
                          (x || (y && z) == (x || y) && (x || z)));
        
        // De Morgansche Gesetze
        System.out.println("\nDe Morgansche Gesetze:");
        System.out.println("NOT (x AND y) = NOT x OR NOT y: " + 
                          (!(x && y) == (!x || !y)));
        System.out.println("NOT (x OR y) = NOT x AND NOT y: " + 
                          (!(x || y) == (!x && !y)));
        
        // Idempotenzgesetze
        System.out.println("\nIdempotenzgesetze:");
        System.out.println("x AND x = x: " + (x && x == x));
        System.out.println("x OR x = x: " + (x || x == x));
        
        // Nullgesetze
        System.out.println("\nNullgesetze:");
        System.out.println("x AND 0 = 0: " + (x && false == false));
        System.out.println("x OR 1 = 1: " + (x || true == true));
        
        // Einsgesetze
        System.out.println("\nEinsgesetze:");
        System.out.println("x AND 1 = x: " + (x && true == x));
        System.out.println("x OR 0 = x: " + (x || false == x));
        
        // Komplementärgesetze
        System.out.println("\nKomplementärgesetze:");
        System.out.println("x AND NOT x = 0: " + (x && !x == false));
        System.out.println("x OR NOT x = 1: " + (x || !x == true));
        System.out.println("NOT (NOT x) = x: " + (!(!x) == x));
    }
    
    private static void praktischeAnwendungen() {
        System.out.println("\n=== Praktische Anwendungen ===");
        
        // Sicherheitssystem: Mehrere Bedingungen müssen erfüllt sein
        boolean passwortKorrekt = true;
        boolean biometrieErfolgreich = true;
        boolean zugriffErlaubt = passwortKorrekt && biometrieErfolgreich;
        System.out.println("Zugriff erlaubt (AND): " + zugriffErlaubt);
        
        // Notausgang: Mindestens eine Bedingung muss erfüllt sein
        boolean feuerMeldung = false;
        boolean notausGedrueckt = true;
        boolean alarmAktiv = feuerMeldung || notausGedrueckt;
        System.out.println("Alarm aktiv (OR): " + alarmAktiv);
        
        // Paritätsprüfung: XOR für Fehlererkennung
        int daten = 0b1011001;  // 7 Bit
        int paritaetsbit = 0;
        for (int i = 0; i < 7; i++) {
            paritaetsbit ^= (daten >> i) & 1;  // XOR für Parität
        }
        System.out.println("Paritätsbit: " + paritaetsbit + " (gerade Parität)");
        
        // Multiplexer-Auswahl
        int auswahl = 2;  // 0, 1, 2, oder 3
        boolean auswahl0 = (auswahl & 1) == 0 && (auswahl & 2) == 0;
        boolean auswahl1 = (auswahl & 1) == 1 && (auswahl & 2) == 0;
        boolean auswahl2 = (auswahl & 1) == 0 && (auswahl & 2) == 2;
        boolean auswahl3 = (auswahl & 1) == 1 && (auswahl & 2) == 2;
        
        System.out.println("Multiplexer-Auswahl " + auswahl + ":");
        System.out.println("  Ausgang 0: " + auswahl0);
        System.out.println("  Ausgang 1: " + auswahl1);
        System.out.println("  Ausgang 2: " + auswahl2);
        System.out.println("  Ausgang 3: " + auswahl3);
    }
}

2. Logik-Gatter als Schaltkreise (Python)

class LogikGatter:
    """Implementierung von Logik-Gattern"""
    
    @staticmethod
    def and_gatter(a, b):
        """AND-Gatter"""
        return a and b
    
    @staticmethod
    def or_gatter(a, b):
        """OR-Gatter"""
        return a or b
    
    @staticmethod
    def not_gatter(a):
        """NOT-Gatter (Inverter)"""
        return not a
    
    @staticmethod
    def nand_gatter(a, b):
        """NAND-Gatter"""
        return not (a and b)
    
    @staticmethod
    def nor_gatter(a, b):
        """NOR-Gatter"""
        return not (a or b)
    
    @staticmethod
    def xor_gatter(a, b):
        """XOR-Gatter"""
        return a != b
    
    @staticmethod
    def xnor_gatter(a, b):
        """XNOR-Gatter (Äquivalenz)"""
        return a == b

class SchaltungsDesign:
    """Design von digitalen Schaltungen"""
    
    @staticmethod
    def halbaddierer(a, b):
        """Halbaddierer: Summe und Übertrag"""
        summe = LogikGatter.xor_gatter(a, b)
        uebertrag = LogikGatter.and_gatter(a, b)
        return summe, uebertrag
    
    @staticmethod
    def volladdierer(a, b, c_in):
        """Volladdierer: Mit Eingangsübertrag"""
        # Erster Halbaddierer
        summe1, uebertrag1 = SchaltungsDesign.halbaddierer(a, b)
        
        # Zweiter Halbaddierer
        summe2, uebertrag2 = SchaltungsDesign.halbaddierer(summe1, c_in)
        
        # Endgültiger Übertrag
        uebertrag = LogikGatter.or_gatter(uebertrag1, uebertrag2)
        
        return summe2, uebertrag
    
    @staticmethod
    def multiplexer(a, b, s):
        """2-zu-1 Multiplexer"""
        # Wenn s=0, Ausgang=a; wenn s=1, Ausgang=b
        not_s = LogikGatter.not_gatter(s)
        ausgang_a = LogikGatter.and_gatter(a, not_s)
        ausgang_b = LogikGatter.and_gatter(b, s)
        return LogikGatter.or_gatter(ausgang_a, ausgang_b)
    
    @staticmethod
    def demultiplexer(d, s):
        """1-zu-2 Demultiplexer"""
        # Wenn s=0, y0=d, y1=0; wenn s=1, y0=0, y1=d
        not_s = LogikGatter.not_gatter(s)
        y0 = LogikGatter.and_gatter(d, not_s)
        y1 = LogikGatter.and_gatter(d, s)
        return y0, y1
    
    @staticmethod
    def rs_flipflop(r, s, q_alt):
        """RS-Flipflop (asynchron)"""
        # Q_neu = (S OR (NOT R AND Q_alt))
        not_r = LogikGatter.not_gatter(r)
        temp = LogikGatter.and_gatter(not_r, q_alt)
        q_neu = LogikGatter.or_gatter(s, temp)
        q_bar_neu = LogikGatter.not_gatter(q_neu)
        return q_neu, q_bar_neu

def wahrheitstabelle_drucken(gatter_name, gatter_funktion):
    """Druckt Wahrheitstabelle für ein Gatter"""
    print(f"\n=== {gatter_name} ===")
    print("A B | Ausgang")
    print("---+--------")
    
    for a in [False, True]:
        for b in [False, True]:
            ergebnis = gatter_funktion(a, b)
            print(f"{int(a)} {int(b)} |   {int(ergebnis)}")

def main():
    """Hauptprogramm mit Demonstrationen"""
    
    # Wahrheitstabellen
    wahrheitstabelle_drucken("AND", LogikGatter.and_gatter)
    wahrheitstabelle_drucken("OR", LogikGatter.or_gatter)
    wahrheitstabelle_drucken("NAND", LogikGatter.nand_gatter)
    wahrheitstabelle_drucken("NOR", LogikGatter.nor_gatter)
    wahrheitstabelle_drucken("XOR", LogikGatter.xor_gatter)
    wahrheitstabelle_drucken("XNOR", LogikGatter.xnor_gatter)
    
    # Schaltungsdesign Demonstrationen
    print("\n=== Halbaddierer ===")
    for a in [False, True]:
        for b in [False, True]:
            summe, uebertrag = SchaltungsDesign.halbaddierer(a, b)
            print(f"{int(a)} + {int(b)} = Summe: {int(summe)}, Übertrag: {int(uebertrag)}")
    
    print("\n=== Volladdierer ===")
    for a in [False, True]:
        for b in [False, True]:
            for c_in in [False, True]:
                summe, uebertrag = SchaltungsDesign.volladdierer(a, b, c_in)
                print(f"{int(c_in)}{int(a)} + {int(b)} = Summe: {int(summe)}, Übertrag: {int(uebertrag)}")
    
    print("\n=== Multiplexer ===")
    for s in [False, True]:
        ausgang = SchaltungsDesign.multiplexer(True, False, s)
        print(f"Select {int(s)}: Ausgang = {int(ausgang)}")
    
    print("\n=== RS-Flipflop ===")
    q_alt = False
    print(f"Q_alt = {int(q_alt)}")
    
    # Setzen
    q_neu, q_bar_neu = SchaltungsDesign.rs_flipflop(False, True, q_alt)
    print(f"S=1, R=0: Q={int(q_neu)}, Q_bar={int(q_bar_neu)}")
    
    # Halten
    q_neu, q_bar_neu = SchaltungsDesign.rs_flipflop(False, False, q_neu)
    print(f"S=0, R=0: Q={int(q_neu)}, Q_bar={int(q_bar_neu)}")
    
    # Zurücksetzen
    q_neu, q_bar_neu = SchaltungsDesign.rs_flipflop(True, False, q_neu)
    print(f"S=0, R=1: Q={int(q_neu)}, Q_bar={int(q_bar_neu)}")

if __name__ == "__main__":
    main()

3. Boolesche Algebra mit Bit-Operationen (C++)

#include <iostream>
#include <bitset>
#include <string>

class BoolescheAlgebraCPP {
public:
    // Bit-Operationen für logische Gatter
    static bool and_gatter(bool a, bool b) {
        return a & b;
    }
    
    static bool or_gatter(bool a, bool b) {
        return a | b;
    }
    
    static bool not_gatter(bool a) {
        return !a;
    }
    
    static bool nand_gatter(bool a, bool b) {
        return !(a & b);
    }
    
    static bool nor_gatter(bool a, bool b) {
        return !(a | b);
    }
    
    static bool xor_gatter(bool a, bool b) {
        return a ^ b;
    }
    
    // Boolesche Funktionen mit mehreren Eingängen
    static bool and_n(bool eingaenge[], int n) {
        bool ergebnis = true;
        for (int i = 0; i < n; i++) {
            ergebnis &= eingaenge[i];
        }
        return ergebnis;
    }
    
    static bool or_n(bool eingaenge[], int n) {
        bool ergebnis = false;
        for (int i = 0; i < n; i++) {
            ergebnis |= eingaenge[i];
        }
        return ergebnis;
    }
    
    // Paritätsprüfung
    static bool gerade_paritat(unsigned int wert) {
        bool paritaet = false;
        while (wert > 0) {
            paritaet ^= (wert & 1);
            wert >>= 1;
        }
        return !paritaet;  // Gerade Parität
    }
    
    // Gray-Code Konvertierung
    static unsigned int dezimal_zu_gray(unsigned int dezimal) {
        return dezimal ^ (dezimal >> 1);
    }
    
    static unsigned int gray_zu_dezimal(unsigned int gray) {
        unsigned int dezimal = 0;
        while (gray > 0) {
            dezimal ^= gray;
            gray >>= 1;
        }
        return dezimal;
    }
    
    // Karnaugh-Diagramm Helfer
    static void karnaugh_diagramm_drucken() {
        std::cout << "\n=== Karnaugh-Diagramm (2 Variablen) ===\n";
        std::cout << "  AB\\CD  00  01  11  10\n";
        std::cout << "  -----------------------\n";
        
        // Beispiel-Funktion: F = A'B + AB'
        for (int a = 0; a <= 1; a++) {
            for (int b = 0; b <= 1; b++) {
                std::string ab = std::to_string(a) + std::to_string(b);
                std::cout << "    " << ab << "   ";
                
                for (int c = 0; c <= 1; c++) {
                    for (int d = 0; d <= 1; d++) {
                        // F = A'B + AB'
                        bool f = (!a && b) || (a && !b);
                        std::cout << " " << f << "  ";
                    }
                }
                std::cout << "\n";
                break;  // Nur eine Zeile für 2 Variablen
            }
        }
    }
};

int main() {
    std::cout << "=== Boolesche Algebra in C++ ===\n";
    
    // Grundlegende Operationen
    bool a = true;
    bool b = false;
    
    std::cout << "a = " << a << ", b = " << b << "\n";
    std::cout << "a AND b = " << BoolescheAlgebraCPP::and_gatter(a, b) << "\n";
    std::cout << "a OR b = " << BoolescheAlgebraCPP::or_gatter(a, b) << "\n";
    std::cout << "NOT a = " << BoolescheAlgebraCPP::not_gatter(a) << "\n";
    std::cout << "a XOR b = " << BoolescheAlgebraCPP::xor_gatter(a, b) << "\n";
    
    // Mehrfacheingänge
    std::cout << "\n=== Mehrfacheingänge ===\n";
    bool eingaenge[4] = {true, false, true, false};
    std::cout << "AND aller Eingänge: " << BoolescheAlgebraCPP::and_n(eingaenge, 4) << "\n";
    std::cout << "OR aller Eingänge: " << BoolescheAlgebraCPP::or_n(eingaenge, 4) << "\n";
    
    // Paritätsprüfung
    std::cout << "\n=== Paritätsprüfung ===\n";
    unsigned int werte[] = {0b1011001, 0b1101101, 0b1110000};
    for (unsigned int wert : werte) {
        std::cout << "Wert: " << std::bitset<7>(wert) 
                  << ", gerade Parität: " << BoolescheAlgebraCPP::gerade_paritat(wert) << "\n";
    }
    
    // Gray-Code
    std::cout << "\n=== Gray-Code Konvertierung ===\n";
    for (unsigned int i = 0; i < 8; i++) {
        unsigned int gray = BoolescheAlgebraCPP::dezimal_zu_gray(i);
        unsigned int zurueck = BoolescheAlgebraCPP::gray_zu_dezimal(gray);
        std::cout << i << " -> " << std::bitset<3>(gray) 
                  << " -> " << zurueck << "\n";
    }
    
    // Bitmanipulation
    std::cout << "\n=== Bitmanipulation ===\n";
    unsigned int register_wert = 0b10101010;
    
    std::cout << "Original: " << std::bitset<8>(register_wert) << "\n";
    
    // Bit setzen
    unsigned int bit_gesetzt = register_wert | (1 << 3);
    std::cout << "Bit 3 setzen: " << std::bitset<8>(bit_gesetzt) << "\n";
    
    // Bit löschen
    unsigned int bit_geloescht = register_wert & ~(1 << 5);
    std::cout << "Bit 5 löschen: " << std::bitset<8>(bit_geloescht) << "\n";
    
    // Bit umschalten
    unsigned int bit_umgeschaltet = register_wert ^ (1 << 1);
    std::cout << "Bit 1 umschalten: " << std::bitset<8>(bit_umgeschaltet) << "\n";
    
    // Bit prüfen
    bool bit_4_gesetzt = (register_wert & (1 << 4)) != 0;
    std::cout << "Bit 4 gesetzt: " << bit_4_gesetzt << "\n";
    
    // Karnaugh-Diagramm
    BoolescheAlgebraCPP::karnaugh_diagramm_drucken();
    
    return 0;
}

4. Schaltalgebra und Vereinfachung

public class Schaltalgebra {
    
    // Boolesche Ausdrücke als Methoden
    public static boolean ausdruck1(boolean a, boolean b, boolean c) {
        // Original: (A AND B) OR (A AND C)
        return (a && b) || (a && c);
    }
    
    public static boolean ausdruck1Vereinfacht(boolean a, boolean b, boolean c) {
        // Vereinfacht: A AND (B OR C)  (Distributivgesetz)
        return a && (b || c);
    }
    
    public static boolean ausdruck2(boolean a, boolean b, boolean c) {
        // Original: (A OR B) AND (A OR C) AND (NOT B OR C)
        return (a || b) && (a || c) && (!b || c);
    }
    
    public static boolean ausdruck2Vereinfacht(boolean a, boolean b, boolean c) {
        // Vereinfacht: A AND (NOT B OR C) OR (B AND C)
        return (a && (!b || c)) || (b && c);
    }
    
    public static boolean ausdruck3(boolean a, boolean b) {
        // Original: (A AND NOT B) OR (NOT A AND B)
        return (a && !b) || (!a && b);
    }
    
    public static boolean ausdruck3Vereinfacht(boolean a, boolean b) {
        // Vereinfacht: A XOR B
        return a ^ b;
    }
    
    // Wahrheitstabellen für Vergleich
    public static void vergleicheAusdruecke() {
        System.out.println("=== Ausdrucksvergleiche ===");
        System.out.println("A B C | Orig1 | Simp1 | Orig2 | Simp2 | Orig3 | Simp3");
        System.out.println("-------+-------+-------+-------+-------+-------+-------");
        
        for (boolean a : new boolean[]{false, true}) {
            for (boolean b : new boolean[]{false, true}) {
                for (boolean c : new boolean[]{false, true}) {
                    boolean orig1 = ausdruck1(a, b, c);
                    boolean simp1 = ausdruck1Vereinfacht(a, b, c);
                    boolean orig2 = ausdruck2(a, b, c);
                    boolean simp2 = ausdruck2Vereinfacht(a, b, c);
                    boolean orig3 = ausdruck3(a, b);
                    boolean simp3 = ausdruck3Vereinfacht(a, b);
                    
                    System.out.printf("%d %d %d |  %d    |  %d    |  %d    |  %d    |  %d    |  %d%n",
                                    a?1:0, b?1:0, c?1:0,
                                    orig1?1:0, simp1?1:0,
                                    orig2?1:0, simp2?1:0,
                                    orig3?1:0, simp3?1:0);
                }
            }
        }
    }
    
    // NAND-NOR Implementierung (universelle Gatter)
    public static boolean andMitNand(boolean a, boolean b) {
        // AND = NOT(NAND(A,B))
        return !(!(a && b));
    }
    
    public static boolean orMitNand(boolean a, boolean b) {
        // OR = NOT(NAND(NOT(A), NOT(B)))
        return !(!a && !b);
    }
    
    public static boolean notMitNand(boolean a) {
        // NOT = NAND(A,A)
        return !(a && a);
    }
    
    public static boolean xorMitNand(boolean a, boolean b) {
        // XOR = NAND(NAND(A,NAND(A,B)), NAND(B,NAND(A,B)))
        boolean nand_ab = !(a && b);
        boolean nand_a_nandab = !(a && nand_ab);
        boolean nand_b_nandab = !(b && nand_ab);
        return !(nand_a_nandab && nand_b_nandab);
    }
    
    // NOR Implementierung
    public static boolean andMitNor(boolean a, boolean b) {
        // AND = NOR(NOR(A,A), NOR(B,B))
        return !(!a || !b);
    }
    
    public static boolean orMitNor(boolean a, boolean b) {
        // OR = NOT(NOR(A,B))
        return !(a || b);
    }
    
    public static boolean notMitNor(boolean a) {
        // NOT = NOR(A,A)
        return !(a || a);
    }
    
    public static void universaleGatterDemo() {
        System.out.println("\n=== Universale Gatter Demonstration ===");
        
        boolean a = true;
        boolean b = false;
        
        System.out.println("a = " + a + ", b = " + b);
        
        // NAND-Implementierungen
        System.out.println("\nNAND-Implementierungen:");
        System.out.println("AND mit NAND: " + andMitNand(a, b));
        System.out.println("OR mit NAND: " + orMitNand(a, b));
        System.out.println("NOT mit NAND: " + notMitNand(a));
        System.out.println("XOR mit NAND: " + xorMitNand(a, b));
        
        // NOR-Implementierungen
        System.out.println("\nNOR-Implementierungen:");
        System.out.println("AND mit NOR: " + andMitNor(a, b));
        System.out.println("OR mit NOR: " + orMitNor(a, b));
        System.out.println("NOT mit NOR: " + notMitNor(a));
    }
    
    public static void main(String[] args) {
        vergleicheAusdruecke();
        universaleGatterDemo();
        
        // Komplexere Schaltung: 4-zu-1 Multiplexer
        multiplexerDemo();
    }
    
    private static void multiplexerDemo() {
        System.out.println("\n=== 4-zu-1 Multiplexer ===");
        
        boolean d0 = true, d1 = false, d2 = true, d3 = false;
        boolean s0 = true, s1 = false;  // Select-Leitungen
        
        // Multiplexer-Logik
        boolean y = (d0 && !s0 && !s1) || 
                   (d1 && s0 && !s1) || 
                   (d2 && !s0 && s1) || 
                   (d3 && s0 && s1);
        
        System.out.println("Daten: D0=" + d0 + ", D1=" + d1 + ", D2=" + d2 + ", D3=" + d3);
        System.out.println("Select: S0=" + s0 + ", S1=" + s1);
        System.out.println("Ausgang Y: " + y);
    }
}

Wahrheitstabellen Übersicht

Grundgatter (2 Eingänge)

A	B	AND	OR	NAND	NOR	XOR	XNOR
0	0	0	0	1	1	0	1
0	1	0	1	1	0	1	0
1	0	0	1	1	0	1	0
1	1	1	1	0	0	0	1

NOT-Gatter (1 Eingang)

A	NOT
0	1
1	0

Schaltalgebra Gesetze

Kommutativgesetze

A ∧ B = B ∧ A
A ∨ B = B ∨ A

Assoziativgesetze

(A ∧ B) ∧ C = A ∧ (B ∧ C)
(A ∨ B) ∨ C = A ∨ (B ∨ C)

Distributivgesetze

A ∧ (B ∨ C) = (A ∧ B) ∨ (A ∧ C)
A ∨ (B ∧ C) = (A ∨ B) ∧ (A ∨ C)

De Morgansche Gesetze

¬(A ∧ B) = ¬A ∨ ¬B
¬(A ∨ B) = ¬A ∧ ¬B

Idempotenzgesetze

A ∧ A = A
A ∨ A = A

Null- und Einsgesetze

A ∧ 0 = 0
A ∨ 1 = 1
A ∧ 1 = A
A ∨ 0 = A

Komplementärgesetze

A ∧ ¬A = 0
A ∨ ¬A = 1
¬(¬A) = A

Logik-Gatter Symbole

ANSI/IEEE-Symbole

• AND: D-förmiges Gatter
• OR: Bogenförmiges Gatter
• NOT: Dreieck mit Kreis
• NAND: AND mit Kreis
• NOR: OR mit Kreis
• XOR: OR mit zusätzlicher Linie

DIN-Symbole (Europäisch)

• AND: Rechteck mit &
• OR: Rechteck mit ≥1
• NOT: Rechteck mit 1
• NAND: Rechteck mit &
• NOR: Rechteck mit ≥1
• XOR: Rechteck mit =1

Kombinatorische Schaltungen

Addierer

• Halbaddierer: 2 Bit → Summe + Übertrag
• Volladdierer: 3 Bit → Summe + Übertrag
• Ripple-Carry Addierer: Mehrere Volladdierer

Multiplexer/Demultiplexer

• Multiplexer: Wähler aus mehreren Eingängen
• Demultiplexer: Verteiler zu mehreren Ausgängen
• Anwendungen: Datenbusse, Adressierung

Encoder/Decoder

• Encoder: Mehrere Eingänge → Binärcode
• Decoder: Binärcode → Mehrere Ausgänge
• Anwendungen: Tastaturen, 7-Segment-Anzeigen

Vorteile und Nachteile

Vorteile der Booleschen Algebra

• Einfachheit: Nur zwei Zustände
• Zuverlässigkeit: Robuste digitale Schaltungen
• Vereinfachung: Komplexe Logik kann minimiert werden
• Automatisierung: Geeignet für Computer-Design

Nachteile

• Abstraktion: Nicht intuitiv für komplexe Probleme
• Einschränkung: Nur binäre Logik
• Komplexität: Große Schaltungen werden unübersichtlich

Häufige Prüfungsfragen

1. Erstellen Sie die Wahrheitstabelle für XOR! XOR ist wahr wenn die Eingänge unterschiedlich sind.

2. Was besagen die De Morganschen Gesetze? ¬(A ∧ B) = ¬A ∨ ¬B und ¬(A ∨ B) = ¬A ∧ ¬B

3. Warum sind NAND und NOR universelle Gatter? Alle anderen logischen Funktionen können nur mit NAND oder NOR realisiert werden.

4. Was ist der Unterschied zwischen Halbaddierer und Volladdierer? Halbaddierer hat 2 Eingänge, Volladdierer hat 3 Eingänge (inkl. Übertrag).

Wichtigste Quellen

1. https://de.wikipedia.org/wiki/Boolesche_Algebra
2. https://de.wikipedia.org/wiki/Logikgatter
3. https://www.tutorialspoint.com/digital_electronics/