Added shit

src/cheatsheets/Digitaltechnik.typ

@@ -180,48 +180,135 @@
   ]
 
   #bgBlock(fill: colorOptimierung)[
-    #subHeading(fill: colorOptimierung)[Hauptsatz der Schaltalgebra]
+    #subHeading(fill: colorOptimierung)[Kannauth Tabelle]
-    Jede $f(x_0, ...,x_n)$ kann als...
+    - Gray-Coding: Ein Kästechen abstand $equiv$ 1 Bit Unterschied
-    - *Minterme $m$:* $ = LNot(x)_0 dot x_1 dot ...$\
-      VerODERungen von VerUNDungen\
-      $f(underline(x)) = m_0 + m_1 + ... + m_n$
 
-    - *Maxterme $M$:* $ = LNot(x)_0 + x_1 ü ...$\
+    #grid(
-      VerUNDungen von VerODERungen\
+      columns: (auto, 1fr),
-      $f(underline(x)) = m_0 dot m_1 dot ... dot m_n$
+      image("../images/digitaltechnik/kan.jpg", height: 2cm),
+      [
+        - Primiplikant: Blöcken aus $1,2,4,8,16...$ Kästechen
+        - Kernprimplikanten: Blöcke die Kästenchen abdecken die sonst keine anderer Block abdecket
+      ]
+    )
 
-    ... dargestellt werden
+    - Don't Cares (#raw("*")) können belibig auf 1/0 gesetzt werden
+    - Große Blöcke sind gute Blöcke
+  ]
+
+  #bgBlock(fill: colorOptimierung)[#text(8pt)[
+    #subHeading(fill: colorOptimierung)[Min/Max Terme Und DNF/KNF]
+
+    *Hauptsatz der Schaltalgebra:* jedes $f(x_0, ...)$ kann als DNF oder KNF dargestellt werden
+    
+    #SeperatorLine
+    
+    *Minimal*: DNF/KNF aus minmalen Anzahl an Literalern
+  
+    *Prim-Implika(#text(red, "n"))t (pi/Pi)*: Keine freisetzbaren Variablen mehr \
+    *Kern-Prim-Implika(#text(red, "n"))t (Kpi/KPi)*: Ein pi/Pi der eine Minterm überdeckt welcher nur von einem pi/Pi überdeckt wird
+    
+
+    DNF $<->$ KNF: Algebrisch (*Distributivgesetz*)
+
+    $A "überdeckt" B : B ==> A$
 
     #SeperatorLine
 
-    *DNF:* Disjunktive Normalform, *Minterme*
-    - Term $tilde.equiv$ $1$-Zeile
-    - $LNot(x)_0 dot x_1 + x_0 dot x_1 +...$\
-    - $1 tilde.equiv x_0$, $0 tilde.equiv overline(x_0)$
-  
-    *KNF:* Konjunktive Normalform, *Maxterme*
-    - Term $tilde.equiv$ $0$-Zeile
-    - $(LNot(x)_0 + LNot(x)_1) dot (x_0 + x_1) dot...$\
-    - $1 tilde.equiv overline(x_0)$, $0 tilde.equiv x_0$
-  
-    Kanonische: In jedem Term müssen alle enthalten sein.
 
-    *KDNF:* Kanonische DNF\
+    #table(columns: (1fr, 1fr),
-    *KKNF:* Kanonische KNF
+      fill: (x, y) => if (calc.rem(x, 2) == 1) { tableFillLow } else { tableFillHigh },
+      [
+        === DNF
 
+        $LNot(x)_0 dot x_1 + x_0 dot x_1 ...$
 
-    *Trick DNF $->$ KDNF:* \
+        Output: Term $tilde.equiv$ $1$-Zeile \
-    $a + 0 = a + (overline(b) dot b) = a overline(b) + a b$
+        Input: $x_0 tilde.equiv 1$, $overline(x_0) tilde.equiv 0$
+      ],
+      [
+        === KNF
 
-    *KNF $->$ KKNF:* \
+        $(LNot(x)_0 + LNot(x)_1) dot (x_0 + x_1) dot...$\
-    $a dot 1 = a dot (overline(b) + b) = (a + overline(b)) dot (a +  b)$\
 
-    *DMF:* Disjunktive #underline("Minimal")-Form: \ 
+        Output: Term $tilde.equiv$ $0$-Zeile
-    $ --> LNot(x_0)x_1 + LNot(x_1)$\
+        Input: $x_0 tilde.equiv 0$, $overline(x_0) tilde.equiv 1$
+      ],
+      [
+        besteht aus \ *Min-Term* / *Implika#text(red, "n")t*
 
-    *KMF:* Konjunktive #underline("Minimal")-Form: \
+        VerODERungen von mehren VerUNDungen
-    $ --> (LNot(x_0) + x_1) dot LNot(x_1)$
+
-  ]
+        Sum of Products (SOP)
+      ],
+      [
+        besteht aus \ *Max-Tern* / *Implikat*
+
+        VerUNDungen von mehren VerODERungen
+
+        Product of Sums (POS)
+      ],
+    )
+
+    *Kannonisch*: Jeder Input Variable muss in jedem Min/Max-Termn enthalten sein
+    
+    #table(columns: (1fr, 1fr),
+      fill: (x, y) => if (calc.rem(x, 2) == 1) { tableFillLow } else { tableFillHigh },
+      [
+        *KDNF:* Kanonische DNF
+
+        besteht NUR aus *Minterme*
+
+        *DNF $->$ KDNF:* \
+        $a + 0 = a + (overline(b) dot b) = a overline(b) + a b$
+      ],
+      [
+        *KKNF:* Kanonische KNF
+
+        besteht NUR aus *Maxterme*
+
+        *KNF $->$ KKNF:* \
+        $a dot 1 = a dot (overline(b) + b) = (a + overline(b)) dot (a +  b)$\
+      ],
+      [
+        *DMF:* Disjunktive #underline("Minimal")-Form: \ 
+        $ --> LNot(x_0)x_1 + LNot(x_1)$\
+      ],
+      [
+        *KMF:* Konjunktive #underline("Minimal")-Form: \
+        $ --> (LNot(x_0) + x_1) dot LNot(x_1)$
+      ]
+    )
+
+    #table(columns: (1fr, 1fr),
+      fill: (x, y) => if (calc.rem(x, 2) == 1) { tableFillLow } else { tableFillHigh },
+      [
+        *Minterme $m$:* \ $ = LNot(x)_0 dot x_1 dot ...$
+
+        $tilde.equiv$ $1$-Zeile
+
+        Enthält JEDE Eingangsvariable
+      ],
+      [
+        *Maxterme $M$:* \ $ = LNot(x)_0 + x_1 ...$\
+
+        $tilde.equiv$ $0$-Zeile
+
+        Enthält JEDE Eingangsvariable
+      ],
+      [
+        *Implika#text(red, weight: "bold", "n")t* \
+        $ = LNot(x)_0 dot x_1 dot ...$ \
+        #text(7pt, $"Mintermen" subset.eq "Implika"#text(red, weight: "bold", "n")"t"$)
+      ],
+      [
+        *Implikat* \
+        $ = LNot(x)_0 + x_1 + ...$ \
+        #text(7pt, $"Maxtermen" subset.eq "Implikat"$)
+      ]
+    )
+  ]]
+  #colbreak()
 
   // Quine McCluskey
   #bgBlock(fill: colorOptimierung)[
@@ -239,69 +326,37 @@
         Eine Literal unterschied, #raw("X") müssen matchen \
       2.3. Abhacken was absorbiert wurde \
 
-    #image("../images/digitaltechnik/qmc6.jpg", height: 3cm)
+    #image("../images/digitaltechnik/qmc6.jpg", height: 2.5cm)
     #SeperatorLine
     
     === McClusky
     1. Überdeckungstabelle aufstellen
-    #image("../images/digitaltechnik/qmc1.jpg", height: 3cm)
+    #image("../images/digitaltechnik/qmc1.jpg", height: 2.5cm)
     #SeperatorLine
 
     2. Kernprimimplikanten  finden \
       (Splaten mit nur einem Eintrag) \
       und vom Kerprimiplaten übdeckte \
       NICHT Kernprimstplaten Streichen
-    #image("../images/digitaltechnik/qmc3.jpg", height: 3cm)
+    #image("../images/digitaltechnik/qmc3.jpg", height: 2.5cm)
     #SeperatorLine
 
     3. Splaten dominazen \
       (Dominierte Spalte streichend)
 
-    #image("../images/digitaltechnik/qmc4.jpg", height: 3cm)
+    #image("../images/digitaltechnik/qmc4.jpg", height: 2.5cm)
     #SeperatorLine
 
     4. Zeilen dominazen \
       (Domenierete Zeile streiche) \
       Kosten: D1 dominierte D2 \
         D1 $<=$ D2 $->$ NUR dann streichen \
-    #image("../images/digitaltechnik/qmc5.jpg", height: 3cm)
+    #image("../images/digitaltechnik/qmc5.jpg", height: 2.5cm)
     #SeperatorLine
 
     5. Wiederhole 3.-5. solange noch was geht
   ]
 
-
-  // Voll adierer
-  #bgBlock(fill: colorBoolscheLogic)[
-    #subHeading(fill: colorBoolscheLogic)[Volladierer/Ripple Carry Adder]
-
-    #grid(
-      columns: (auto, 1fr),
-      column-gutter: 2mm,
-      image("../images/digitaltechnik/va.jpg", height: 1.5cm),
-      text(8pt, [
-        *Generate/Propergated*
-
-        $G = A dot B \
-        P = A xor B \ 
-        = A LNot(B) + LNot(A) B $
-
-      ])
-    )
-
-    $C_"out" = ((A xor B) dot C_"in") + A B $
-
-    $S = A xor B xor C_"in"$
-
-    #SeperatorLine
-
-    *Ripple Carry Adder*
-
-    $t_"pd"$ dominiert von Carry-Übertrag
-  ]
-
-  #colbreak()
-
   // FlipFlops
   #bgBlock(fill: colorState)[
     #subHeading(fill: colorState)[Latches, Flipflops und Register]
@@ -344,7 +399,6 @@
     )
   ]
   
-  #colbreak()
   // Pipelining
   #bgBlock(fill: colorState)[
     #subHeading(fill: colorState)[Pipeline/Parallele Verarbeitungseinheiten]
@@ -361,6 +415,146 @@
         $T_"c2q" + T_"logic,min" > T_"hold" $ \
         Buffer-Gatter einfügen bei Verletzung
 
+    $T = 1/f quad f = 1/T$
+
+    #block(inset: (top: -0.2cm), scale(90%, align(center)[
+      #cetz.canvas({
+        import cetz.draw: *
+
+        let signal-height = 0.45
+        let width = 6
+        let switching-width = 0.3
+        let padding = 0.3
+
+        let setup = 0.8
+        let hold = 1.4
+        let c2q = 0.7
+        let clk = 2
+
+        line((width / 2 - 1.4, 0.6), (width / 2, 0.6), mark: (end: "straight"), name: "T")
+        content("T.centroid", $t$, anchor: "south", padding: 0.1)
+
+        let timing-line(x, depth: 2.7, peak: 0) = {
+          line((x, signal-height / 2 + peak * (signal-height / 2 + padding)), (x, - depth * (signal-height + padding) - signal-height / 2), stroke: (dash: "dashed", paint: gray))
+        }
+
+        timing-line(-clk, depth: 3.3, peak: 1.1)
+        timing-line(clk, depth: 3.3)
+        timing-line(-clk + c2q, peak: 0.3)
+        timing-line(clk - setup)
+        timing-line(-clk + hold, depth: 1.6, peak: 1.1)
+
+        content((-width / 2, 0), [Clock], anchor: "east", padding: 0.1)
+        line(stroke: blue,
+          (-width / 2, -signal-height / 2),
+          (-switching-width/2 - clk, -signal-height / 2),
+          (switching-width/2 - clk, signal-height / 2),
+          (-switching-width/2, signal-height / 2),
+          (switching-width/2, -signal-height / 2),
+          (-switching-width/2 + clk, -signal-height / 2),
+          (switching-width/2 + clk, signal-height / 2),
+          (width/2, signal-height / 2)
+        )
+
+        group({
+          translate(y: -(signal-height + padding))
+          content((-width / 2, 0), [Output], anchor: "east", padding: 0.1)
+
+          line(
+            stroke: blue,
+            (-width / 2, signal-height / 2),
+            (-clk + c2q - switching-width / 2, signal-height / 2),
+            (-clk + c2q, 0),
+            (-clk + c2q - switching-width / 2, -signal-height / 2),
+            (-width / 2, -signal-height / 2),
+          )
+
+          line(
+            close: true,
+            stroke: blue,
+            (-clk + c2q, 0),
+            (-clk + c2q + switching-width / 2, signal-height / 2),
+            (clk + c2q - switching-width / 2, signal-height / 2),
+            (clk + c2q, 0),
+            (clk + c2q - switching-width / 2, -signal-height / 2),
+            (-clk + c2q + switching-width / 2, -signal-height / 2),
+          )
+
+          line(
+            stroke: blue,
+            (width / 2, signal-height / 2),
+            (clk + c2q + switching-width / 2, signal-height / 2),
+            (clk + c2q, 0),
+            (clk + c2q + switching-width / 2, -signal-height / 2),
+            (width / 2, -signal-height / 2),
+          )
+        })
+
+        group({
+          translate(y: - 2 *(signal-height + padding))
+          content((-width / 2, 0), [Data], anchor: "east", padding: 0.1)
+
+          line(
+            stroke: blue,
+            (-width / 2, signal-height / 2),
+            (-clk - setup - switching-width / 2, signal-height / 2),
+            (-clk - setup, 0),
+            (-clk - setup - switching-width / 2, -signal-height / 2),
+            (-width / 2, -signal-height / 2),
+          )
+
+          line(
+            stroke: blue,
+            close: true,
+            (-clk - setup, 0),
+            (-clk - setup + switching-width / 2, signal-height / 2),
+            (-clk + hold - switching-width / 2, signal-height / 2),
+            (-clk + hold, 0),
+            (-clk + hold - switching-width / 2, -signal-height / 2),
+            (-clk - setup + switching-width / 2, -signal-height / 2),
+          )
+
+          line(
+            stroke: blue,
+            fill: blue.transparentize(70%),
+            close: true,
+            (-clk + hold, 0),
+            (-clk + hold + switching-width / 2, signal-height / 2),
+            (clk - setup - switching-width / 2, signal-height / 2),
+            (clk - setup, 0),
+            (clk - setup - switching-width / 2, -signal-height / 2),
+            (-clk + hold + switching-width / 2, -signal-height / 2),
+          )
+
+          line(
+            stroke: blue,
+            (width / 2, -signal-height / 2),
+            (clk - setup + switching-width / 2, -signal-height / 2),
+            (clk - setup, 0),
+            (clk - setup + switching-width / 2, signal-height / 2),
+            (width / 2, signal-height / 2),
+          )
+        })
+
+        let arrow(from, to, height, text) = {
+          let annotation-height = - height * (signal-height + padding)
+
+          line((from, annotation-height), (to, annotation-height), mark: (end: "straight", start: "straight", scale: 0.75), name: "A")
+          content("A", text, anchor: "south", padding: 0.05)
+        }
+
+        arrow(-clk + c2q, -clk + hold, -0.5, $t_"l,min"$)
+        arrow(-clk, -clk + hold, -1.1, $t_"hold"$)
+
+        arrow(-clk, -clk + c2q, 3, $t_"c2q"$)
+        arrow(clk - setup, clk, 3, $t_"setup"$)
+        arrow(-clk, clk, 3.6, $t_"clk"$)
+        arrow(-clk + c2q, clk - setup, 3, $t_"logic,max"$)
+      })
+    ]
+  ))
+
+
     #SeperatorLine
     
     *Parallel Verarbeitung*
@@ -410,20 +604,6 @@
 
       [*NMOS*], [*PMOS*],
 
-      image("../images/digitaltechnik/nmos3.jpg"),
-      image("../images/digitaltechnik/pmos3.jpg"),
-
-      [
-        - Source am *niedrigen* Potenzial (*GND*)
-        - Guter PULL-DOWN
-        - Substrat am GND
-      ],
-      [
-        - Source am *hohes* Potenzial (*$V_"DD"$*)
-        - Guter PULL-UP
-        - Substrat am $V_"DD"$
-      ],
-
       align(center+horizon, scale(
         x: 75%, y: 75%,
         zap.circuit({
@@ -477,6 +657,28 @@
         })
       )),
 
+      image("../images/digitaltechnik/nmos3.jpg", height: 2cm),
+      image("../images/digitaltechnik/pmos3.jpg", height: 2cm),
+
+      grid(columns: (auto, 1fr), 
+        column-gutter: 3mm,
+        image("../images/digitaltechnik/nmosD.jpg", height: 3cm),
+        [
+          - Source am *niedrigen* Potenzial (*GND*)
+          - Guter PULL-DOWN
+          - Substrat am GND
+        ]
+      ),
+      grid(columns: (auto, 1fr),
+        column-gutter: 3mm,
+        image("../images/digitaltechnik/pmosD.jpg", height: 3cm),
+        [
+        - Source am *hohes* Potenzial (*$V_"DD"$*)
+        - Guter PULL-UP
+        - Substrat am $V_"DD"$
+        ]
+      ),
+
       block( inset: (top: 2mm, bottom: 2mm),$ I_"Dn" = cases(
         gap: #0.6em,
         0 & 0 < U_"GS" < U_t,
@@ -500,8 +702,8 @@
         columns: (auto, auto),
         column-gutter: 2mm,
         image("../images/digitaltechnik/pmos4.jpg", height: 2.5cm),
-        image("../images/digitaltechnik/pmos3.jpg", height: 2.5cm),
+        image("../images/digitaltechnik/pmos2.jpg", height: 2.5cm),
-      ),        
+      ),
     )
   ]
 
@@ -909,57 +1111,139 @@
       */
     ]
 
-    #colbreak()
 
     #SIPrefixesTable
 
+
+    #bgBlock(fill: colorBoolscheLogic)[
+      #subHeading(fill: colorBoolscheLogic)[MUX/DEMUX]
+
+      #table(columns: (1fr, 1fr),
+        fill: (x, y) => if (calc.rem(x, 2) == 1) { tableFillLow } else { tableFillHigh },
+        [*MUX*],
+        [*DEMUX*], 
+        [$ D = LNot(S)A + S B $],
+        [$ A = LNot(S)D \ B = S D $],
+        image("../images/digitaltechnik/mux1.jpg", height: 1.5cm),
+        image("../images/digitaltechnik/demux1.jpg", height: 1.5cm),
+        image("../images/digitaltechnik/mux2.jpg", height: 1.5cm),
+        image("../images/digitaltechnik/demux2.jpg", height: 1.5cm),
+      )
+
+    ]
+
+    #colbreak()
+
+    // Voll adierer
+    #bgBlock(fill: colorBoolscheLogic)[
+      #subHeading(fill: colorBoolscheLogic)[HA/VA/Ripple Carry Adder]
+
+        === Halbaddierer
+        #grid(
+        columns: (auto, 1fr),
+        column-gutter: 2mm,
+        image("../images/digitaltechnik/ha.jpg", height: 1.5cm),
+        text(8pt, [
+          $C_"out" = A dot B \
+          S = A xor B \ 
+          = A LNot(B) + LNot(A) B $
+
+        ])
+      )
+
+      #SeperatorLine
+      
+      === Voll Addierer
+      #grid(  
+        columns: (auto, 1fr),
+        column-gutter: 2mm,
+        image("../images/digitaltechnik/va.jpg", height: 1.5cm),
+        text(8pt, [
+          *Generate/Propergated*
+
+          $G = A dot B \
+          P = A xor B \ 
+          = A LNot(B) + LNot(A) B $
+
+        ])
+      )
+
+      #table(columns: (auto, auto, auto, auto),
+        [*$A$*], [*$B$*], [*$C_"out"$*], "",
+        $0$, $0$, $0$, raw("KILL"),
+        $0$, $1$, $C_"in"$, raw("PROPERGATE"),
+        $1$, $0$, $C_"in"$, raw("PROPERGATE"),
+        $1$, $1$, $1$, raw("GENERATE"),
+      )
+
+
+      $C_"out" = ((A xor B) dot C_"in") + A B $
+
+      $S = A xor B xor C_"in"$
+
+      #SeperatorLine
+
+      *Ripple Carry Adder*
+
+      $t_"pd"$ dominiert von Carry-Übertrag
+
+      Timing-Worst-Case: \
+      - erster VA: #raw("GENERATE") \
+        Rest: nur #raw("PROPERGATE")
+
+      Timing-Best-Case: \
+      - Alle: #raw("GENERATE") oder #raw("KILL")
+
+      #image("../images/digitaltechnik/rippleAdder.jpg", height: 2cm)
+    ]
+
     #colbreak()
     #bgBlock(fill: colorBoolscheLogic)[
-      #subHeading(fill: colorBoolscheLogic)[Logik Gatter]
+    #subHeading(fill: colorBoolscheLogic)[Logik Gatter]
 
-      #table(columns: (auto, 1fr),
+    #table(columns: (auto, 1fr),
-        fill: (x, y) => if (calc.rem(y, 2) == 1) { tableFillLow } else { tableFillHigh },
+      fill: (x, y) => if (calc.rem(y, 2) == 1) { tableFillLow } else { tableFillHigh },
-        align(center, box(image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
+      align(center, box(image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
-        align(center+horizon, [*AND* \ $and space dot$]),
+      align(center+horizon, [*AND* \ $and space dot$]),
 
-        align(center, box(inset: (top: -6cm/4), image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
+      align(center, box(inset: (top: -6cm/4), image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
-        align(center+horizon, [*OR* \ $or space +$]),
+      align(center+horizon, [*OR* \ $or space +$]),
 
-        align(center, box(inset: (top: -6cm/4 * 2), image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
+      align(center, box(inset: (top: -6cm/4 * 2), image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
-        align(center+horizon, [*XOR* \ $xor$]),
+      align(center+horizon, [*XOR* \ $xor$]),
 
-        align(center, box(inset: (top: -6cm/4 *3), image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
+      align(center, box(inset: (top: -6cm/4 *3), image("../images/digitaltechnik/logicGates.jpg", height: 6cm, fit: "cover"), clip: true, height: 6cm/4)),
-        align(center+horizon, [*NOT* \ $not space LNot(X)$])
+      align(center+horizon, [*NOT* \ $not space LNot(X)$])
-      )
+    )
 
-      #grid(
+    #grid(
-        columns: (auto, 1fr),
+      columns: (auto, 1fr),
-        column-gutter: 4mm,
+      column-gutter: 4mm,
-        row-gutter: 2.5mm,
+      row-gutter: 2.5mm,
-        [XOR], $A LNot(B) + LNot(A) B = A xor B$,
+      [XOR], $A LNot(B) + LNot(A) B = A xor B$,
-        [XNOR], $A B + LNot(A) LNot(B)$,
+      [XNOR], $A B + LNot(A) LNot(B)$,
-        [NOR], $LNot(A + B) = LNot(A) dot LNot(B)$,
+      [NOR], $LNot(A + B) = LNot(A) dot LNot(B)$,
-        [NAND], $LNot(A dot B) = LNot(A) + LNot(B)$,
+      [NAND], $LNot(A dot B) = LNot(A) + LNot(B)$,
-      
+    
-      )
+    )
 
-      #truth-table(
+    #truth-table(
-        outputs: (
+      outputs: (
-          ("AND",  (0, 0, 0, 1)),
+        ("AND",  (0, 0, 0, 1)),
-          ("OR",   (0, 1, 1, 1)),
+        ("OR",   (0, 1, 1, 1)),
-          ("XOR",  (0, 1, 1, 0)),
+        ("XOR",  (0, 1, 1, 0)),
-        ),
+      ),
-        inputs: ("A", "B")
+      inputs: ("A", "B")
-      )
+    )
 
-      #truth-table(
+    #truth-table(
-        outputs: (
+      outputs: (
-          ("NAND", (1, 1, 1, 0)),
+        ("NAND", (1, 1, 1, 0)),
-          ("NOR",  (1, 0, 0, 0)),
+        ("NOR",  (1, 0, 0, 0)),
-          ("XNOR", (1, 0, 0, 1)),
+        ("XNOR", (1, 0, 0, 1)),
-        ),
+      ),
-        inputs: ("A", "B")
+      inputs: ("A", "B")
-      )
+    )
-    ]
+  ]
   ]
 ]