Булева алгебра: логические вентили, таблицы истинности и алгебра переключений

Это полное введение в булеву алгебру - логические вентили, таблицы истинности и алгебру переключений с практическими примерами.

In a Nutshell

Булева алгебра - это математика логики с двумя значениями: истина (1) и ложь (0). Она лежит в основе всех цифровых схем и компьютеров.

Определение

Булева алгебра - это алгебраическая система для описания логических операций. Она была разработана Джорджем Булем и является основой цифровой техники.

Основные операции:

AND (конъюнкция)

Символ: ∧, ·, AND
Условие истинности: Истинно только когда оба входа истинны
Схема: Последовательное соединение
Применение: Функции безопасности, валидация

OR (дизъюнкция)

Символ: ∨, +, OR
Условие истинности: Истинно, если хотя бы один вход истинен
Схема: Параллельное соединение
Применение: Альтернативные решения

NOT (отрицание)

Символ: ¬, ~, NOT, с чертой
Условие истинности: Инвертирует логическое значение
Схема: Инвертор
Применение: Инверсия сигнала

NAND (НЕ-И)

Символ: ↑, NAND
Условие истинности: Ложно только когда оба входа истинны
Схема: AND с инвертором
Применение: Универсальный вентиль

NOR (НЕ-ИЛИ)

Символ: ↓, NOR
Условие истинности: Истинно только когда оба входа ложны
Схема: OR с инвертором
Применение: Универсальный вентиль

XOR (исключающее ИЛИ)

Символ: ⊕, XOR
Условие истинности: Истинно, когда входы различаются
Схема: Вентиль четности
Применение: Обнаружение ошибок, криптография

Ключевые понятия

Булева алгебра: Математика с двумя значениями (0 и 1)
Логические вентили: Электронные схемы для логических операций
Таблицы истинности: Систематическое представление всех возможных входных комбинаций
Алгебра переключений: Применение булевой алгебры к схемам
Универсальные вентили: NAND и NOR могут заменить все остальные вентили
Диаграмма Карно: Упрощение логических выражений
Практическое значение: Основа для цифровых схем и программирования

Основные компоненты

Булевы переменные: Только 0 или 1
Логические операции: AND, OR, NOT, NAND, NOR, XOR
Таблицы истинности: Полное описание функции
Алгебра переключений: Законы и упрощения
Логические вентили: Электронная реализация
Проектирование схем: Комбинационные и последовательные схемы
Минимизация: Диаграммы Карно, метод Куайна-Мак-Класки
Применение: Компьютерная архитектура, цифровые системы

Практические примеры

1. Основные логические вентили на Java

public class BoolescheAlgebra {
    
    public static void main(String[] args) {
        // Входные значения
        boolean a = true;   // 1
        boolean b = false;  // 0
        
        System.out.println("=== Основные логические операции ===");
        System.out.println("a = " + a + " (1), b = " + b + " (0)");
        
        // AND (конъюнкция)
        boolean and = a && b;
        System.out.println("a AND b = " + and + " (" + (and ? 1 : 0) + ")");
        
        // OR (дизъюнкция)
        boolean or = a || b;
        System.out.println("a OR b = " + or + " (" + (or ? 1 : 0) + ")");
        
        // NOT (отрицание)
        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 (НЕ-И)
        boolean nand = !(a && b);
        System.out.println("a NAND b = " + nand + " (" + (nand ? 1 : 0) + ")");
        
        // NOR (НЕ-ИЛИ)
        boolean nor = !(a || b);
        System.out.println("a NOR b = " + nor + " (" + (nor ? 1 : 0) + ")");
        
        // XOR (исключающее ИЛИ)
        boolean xor = a ^ b;
        System.out.println("a XOR b = " + xor + " (" + (xor ? 1 : 0) + ")");
        
        // Таблицы истинности
        wahrheitstabellen();
        
        // Законы алгебры переключений
        schaltalgebraGesetze();
        
        // Практические применения
        praktischeAnwendungen();
    }
    
    private static void wahrheitstabellen() {
        System.out.println("\n=== Таблицы истинности ===");
        
        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=== Законы алгебры переключений ===");
        
        boolean x = true;
        boolean y = false;
        boolean z = true;
        
        // Коммутативные законы
        System.out.println("Коммутативные законы:");
        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)));
        
        // Ассоциативные законы
        System.out.println("\nАссоциативные законы:");
        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)));
        
        // Дистрибутивные законы
        System.out.println("\nДистрибутивные законы:");
        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)));
        
        // Законы де Моргана
        System.out.println("\nЗаконы де Моргана:");
        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)));
        
        // Законы идемпотентности
        System.out.println("\nЗаконы идемпотентности:");
        System.out.println("x AND x = x: " + (x && x == x));
        System.out.println("x OR x = x: " + (x || x == x));
        
        // Нулевые законы
        System.out.println("\nНулевые законы:");
        System.out.println("x AND 0 = 0: " + (x && false == false));
        System.out.println("x OR 1 = 1: " + (x || true == true));
        
        // Единичные законы
        System.out.println("\nЕдиничные законы:");
        System.out.println("x AND 1 = x: " + (x && true == x));
        System.out.println("x OR 0 = x: " + (x || false == x));
        
        // Законы дополнения
        System.out.println("\nЗаконы дополнения:");
        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=== Практические применения ===");
        
        // Система безопасности: несколько условий должны быть выполнены
        boolean passwortKorrekt = true;
        boolean biometrieErfolgreich = true;
        boolean zugriffErlaubt = passwortKorrekt && biometrieErfolgreich;
        System.out.println("Доступ разрешен (AND): " + zugriffErlaubt);
        
        // Аварийный выход: хотя бы одно условие должно быть выполнено
        boolean feuerMeldung = false;
        boolean notausGedrueckt = true;
        boolean alarmAktiv = feuerMeldung || notausGedrueckt;
        System.out.println("Тревога активна (OR): " + alarmAktiv);
        
        // Проверка четности: XOR для обнаружения ошибок
        int daten = 0b1011001;  // 7 бит
        int paritaetsbit = 0;
        for (int i = 0; i < 7; i++) {
            paritaetsbit ^= (daten >> i) & 1;  // XOR для четности
        }
        System.out.println("Бит четности: " + paritaetsbit + " (четная четность)");
        
        // Выбор мультиплексера
        int auswahl = 2;  // 0, 1, 2 или 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("Выбор мультиплексера " + auswahl + ":");
        System.out.println("  Выход 0: " + auswahl0);
        System.out.println("  Выход 1: " + auswahl1);
        System.out.println("  Выход 2: " + auswahl2);
        System.out.println("  Выход 3: " + auswahl3);
    }
}

2. Логические вентили как схемы (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. Булева алгебра с битовыми операциями (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. Булева алгебра и упрощение выражений

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);
    }
}

Обзор таблиц истинности

Базовые логические элементы (2 входа)

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

Инвертор (1 вход)

A	NOT
0	1
1	0

Законы булевой алгебры

Коммутативные законы

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

Ассоциативные законы

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

Дистрибутивные законы

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

Законы де Моргана

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

Законы идемпотентности

A ∧ A = A
A ∨ A = A

Законы нуля и единицы

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

Законы дополнения

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

Условные обозначения логических элементов

Символы ANSI/IEEE

AND: элемент в форме буквы D
OR: элемент в форме арки
NOT: треугольник с кружком
NAND: AND с кружком
NOR: OR с кружком
XOR: OR с дополнительной линией

Европейские символы (DIN)

AND: прямоугольник с символом &
OR: прямоугольник с символом ≥1
NOT: прямоугольник с символом 1
NAND: прямоугольник с символом &
NOR: прямоугольник с символом ≥1
XOR: прямоугольник с символом =1

Комбинационные схемы

Сумматоры

Полусумматор: 2 бита на входе, сумма и перенос на выходе
Полный сумматор: 3 бита на входе, сумма и перенос на выходе
Каскадный сумматор: несколько полных сумматоров, соединенных в цепь

Мультиплексер и демультиплексер

Мультиплексер: селектор, выбирающий один из нескольких входов
Демультиплексер: распределитель, направляющий сигнал на один из нескольких выходов
Применение: шины данных, адресация

Шифратор и дешифратор

Шифратор: несколько входов преобразуются в двоичный код
Дешифратор: двоичный код преобразуется в сигналы на нескольких выходах
Применение: клавиатуры, семисегментные индикаторы

Преимущества и недостатки

Преимущества булевой алгебры

Простота: всего два состояния
Надёжность: устойчивые цифровые схемы
Упрощение: сложную логику можно минимизировать
Автоматизация: подходит для проектирования компьютеров

Недостатки

Абстрактность: интуитивно непонятна при работе со сложными задачами
Ограничение: только бинарная логика
Сложность: большие схемы становятся запутанными

Часто встречающиеся вопросы на экзаменах

Постройте таблицу истинности для XOR! XOR истинен, когда входные значения различаются.
Что гласят законы де Моргана? ¬(A ∧ B) = ¬A ∨ ¬B и ¬(A ∨ B) = ¬A ∧ ¬B
Почему вентили NAND и NOR являются универсальными? Все остальные логические функции можно реализовать, используя только NAND или только NOR.
В чём разница между полусумматором и полным сумматором? Полусумматор имеет 2 входа, полный сумматор имеет 3 входа (включая вход переноса).

Täglicher Artikel