{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# DS 21 – Belegungstabellen, Äquivalenz und Disjunktive Normalform (DNF)\n",
    "**Informatik 10 – MINT-Zweig | Informatiksysteme**\n",
    "\n",
    "## Lernziel\n",
    "Ich erstelle Belegungstabellen zu gegebenen aussagenlogischen Termen, erläutere den Begriff der Äquivalenz und erstelle die DNF zu gegebenen Termen bzw. Belegungstabellen."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "sprachhilfe"
    ]
   },
   "source": [
    "## 🗣️ Sprachhilfe\n",
    "- „Für die Eingangswerte … liefert die Schaltung den Ausgangswert …“\n",
    "- „Der Term/die Tabelle repräsentiert die Schaltung, weil …“\n",
    "- „Die Rückkopplung bzw. Gruppierung bewirkt …“"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📌 Merksätze\n",
    "\n",
    "- Zwei aussagenlogische Terme heißen **äquivalent**, wenn sie für **jede** mögliche Belegung denselben Wahrheitswert liefern – also **dieselbe Belegungstabelle** besitzen. (Äquivalenz ist ein Begriff **über** Terme, kein eigener Operator!)\n",
    "- Die **Disjunktive Normalform (DNF)** ist eine standardisierte Darstellung eines Terms:\n",
    "  - Für **jede** Zeile der Belegungstabelle, in der der Ausgang `1` ist, bildet man ein **Minterm**: die Konjunktion aller Variablen, wobei Variablen mit Wert `0` negiert werden.\n",
    "  - Alle Minterme werden anschließend **disjunktiv** (mit `∨`) verknüpft.\n",
    "- Beispiel: Ist der Ausgang bei `A=1,B=0` und bei `A=0,B=1` gleich `1` (sonst `0`), lautet die DNF: `(A ∧ ¬B) ∨ (¬A ∧ B)` — das ist übrigens genau XOR!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💡 Beispiel: DNF aus Belegungstabelle ablesen\n",
    "\n",
    "| A | B | Ausgang |\n",
    "|---|---|---|\n",
    "| 0 | 0 | 0 |\n",
    "| 0 | 1 | 1 |\n",
    "| 1 | 0 | 1 |\n",
    "| 1 | 1 | 0 |\n",
    "\n",
    "Zeilen mit Ausgang `1`: `(A=0,B=1)` und `(A=1,B=0)`\n",
    "→ DNF: `(¬A ∧ B) ∨ (A ∧ ¬B)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "\n",
    "def dnf_beispiel(a, b):\n",
    "    return (not a and b) or (a and not b)\n",
    "\n",
    "for a, b in product([0, 1], repeat=2):\n",
    "    print(f\"A={a} B={b} -> {int(dnf_beispiel(a, b))}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Vorübung – Von einem Term zur Belegungstabelle\n",
    "Bevor ihr DNFs bestimmt: Erstellt **von Hand** die vollständige Belegungstabelle (3 Variablen, 8 Zeilen) zu folgendem Term:\n",
    "\n",
    "`(A ∨ B) ∧ ¬C`\n",
    "\n",
    "Überprüft euer Ergebnis anschließend mit der Python-Zelle unten."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "\n",
    "def vorbuebung_term(a, b, c):\n",
    "    return (a or b) and (not c)\n",
    "\n",
    "for a, b, c in product([0, 1], repeat=3):\n",
    "    print(f\"A={a} B={b} C={c} -> {int(vorbuebung_term(a,b,c))}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übung 1 – DNF ablesen\n",
    "Gegeben ist folgende Belegungstabelle:\n",
    "\n",
    "| A | B | C | Ausgang |\n",
    "|---|---|---|---|\n",
    "| 0 | 0 | 0 | 0 |\n",
    "| 0 | 0 | 1 | 1 |\n",
    "| 0 | 1 | 0 | 0 |\n",
    "| 0 | 1 | 1 | 0 |\n",
    "| 1 | 0 | 0 | 0 |\n",
    "| 1 | 0 | 1 | 0 |\n",
    "| 1 | 1 | 0 | 1 |\n",
    "| 1 | 1 | 1 | 1 |\n",
    "\n",
    "Bestimmt die DNF (auf Papier) und überprüft sie anschließend mit Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Übung 1 - DNF als Python-Funktion eingeben und gegen die Tabelle prüfen\n",
    "def meine_dnf(a, b, c):\n",
    "    pass\n",
    "\n",
    "for a, b, c in product([0, 1], repeat=3):\n",
    "    print(f\"A={a} B={b} C={c} -> {int(meine_dnf(a,b,c)) if meine_dnf(a,b,c) is not None else '?'}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 📝 Übung 2 – Äquivalenz prüfen\n",
    "Prüft **automatisiert mit Python**, ob die beiden folgenden Terme äquivalent sind, indem ihr für **alle** Belegungen vergleicht, ob beide Funktionen stets denselben Wert liefern:\n",
    "\n",
    "`Term A: ¬(A ∧ B)` und `Term B: ¬A ∨ ¬B` (De Morgansches Gesetz)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def term_a(a, b):\n",
    "    return not (a and b)\n",
    "\n",
    "def term_b(a, b):\n",
    "    return (not a) or (not b)\n",
    "\n",
    "# TODO: Übung 2 - prüft für alle Belegungen, ob term_a und term_b immer gleich sind\n",
    "aequivalent = True\n",
    "for a, b in product([0, 1], repeat=2):\n",
    "    # TODO: Vergleich einbauen und ggf. aequivalent = False setzen\n",
    "    pass\n",
    "\n",
    "print(\"Äquivalent:\", aequivalent)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  },
  "v3_revision": {
   "basis": "MINT-Lehrplan Informatik 10 (2026)",
   "didaktik": "fragend-entwickelnder Kern, kurzer Transfer, flexible Reserve",
   "lerngruppe": "11 SuS"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
