feat(logic): implement Quine-McCluskey algorithm for prime implicants and implicates with minimal DNF/CNF conversion

Author: arnog

CHANGELOG.md

@@ -298,6 +298,30 @@
   ce.box(['Or', 'A', ['And', 'A', 'B']]).simplify();  // → A
   ```
 
+- **Prime Implicants and Minimal Normal Forms**: Added Quine-McCluskey algorithm
+  for finding prime implicants/implicates and computing minimal CNF/DNF:
+  - `PrimeImplicants(expr)` - Find all prime implicants (minimal product terms)
+  - `PrimeImplicates(expr)` - Find all prime implicates (minimal sum clauses)
+  - `MinimalDNF(expr)` - Convert to minimal DNF using prime implicant cover
+  - `MinimalCNF(expr)` - Convert to minimal CNF using prime implicate cover
+
+  ```javascript
+  // Find prime implicants (terms that can't be further simplified)
+  ce.box(['PrimeImplicants', ['Or', ['And', 'A', 'B'], ['And', 'A', ['Not', 'B']]]]).evaluate();
+  // → [A] (AB and A¬B combine to just A)
+
+  // Compute minimal DNF
+  ce.box(['MinimalDNF', ['Or',
+    ['And', 'A', 'B'],
+    ['And', 'A', ['Not', 'B']],
+    ['And', ['Not', 'A'], 'B']
+  ]]).evaluate();
+  // → A ∨ B (simplified from 3 terms to 2)
+  ```
+
+  Limited to 12 variables to prevent exponential blowup; larger expressions
+  return unevaluated.
+
 #### Linear Algebra
 
 - **Matrix Decompositions**: Added four matrix decomposition functions for

requirements/DONE.md

@@ -480,6 +480,63 @@ ce.box(['Not', ['Not', 'A']]).simplify();          // → A
 
 ---
 
+### L-2. Prime Implicants/Implicates (Quine-McCluskey) ✅
+
+**IMPLEMENTED:** Added functions for finding prime implicants/implicates and
+computing minimal normal forms using the Quine-McCluskey algorithm:
+
+1. **`PrimeImplicants(expr)`** - Find all prime implicants (minimal product terms):
+   ```typescript
+   ce.box(['PrimeImplicants', ['Or', ['And', 'A', 'B'], ['And', 'A', ['Not', 'B']]]]).evaluate();
+   // → [A] (AB and A¬B combine to just A)
+
+   ce.box(['PrimeImplicants', ['Or', 'A', 'B']]).evaluate();
+   // → [A, B] (two prime implicants)
+   ```
+
+2. **`PrimeImplicates(expr)`** - Find all prime implicates (minimal sum clauses):
+   ```typescript
+   ce.box(['PrimeImplicates', ['And', 'A', 'B']]).evaluate();
+   // → [A, B] (the expression implies both A and B)
+
+   ce.box(['PrimeImplicates', ['Or', 'A', 'B']]).evaluate();
+   // → [A ∨ B] (single prime implicate)
+   ```
+
+3. **`MinimalDNF(expr)`** - Convert to minimal Disjunctive Normal Form:
+   ```typescript
+   ce.box(['MinimalDNF', ['Or',
+     ['And', 'A', 'B'],
+     ['And', 'A', ['Not', 'B']],
+     ['And', ['Not', 'A'], 'B']
+   ]]).evaluate();
+   // → A ∨ B (simplified from 3 terms to 2 prime implicants)
+   ```
+
+4. **`MinimalCNF(expr)`** - Convert to minimal Conjunctive Normal Form:
+   ```typescript
+   ce.box(['MinimalCNF', ['And', ['Or', 'A', 'B'], ['Or', 'A', ['Not', 'B']]]]).evaluate();
+   // → A (simplified to single literal)
+   ```
+
+**Algorithm:** Quine-McCluskey with greedy covering:
+1. Generate minterms (for DNF) or maxterms (for CNF) from truth table
+2. Iteratively combine terms differing in exactly one variable
+3. Identify essential prime implicants
+4. Use greedy algorithm to find minimal cover
+
+**Performance:**
+- O(3^n) worst case complexity
+- Limited to 12 variables to prevent exponential blowup
+- Expressions with more variables return unevaluated
+
+**Files modified:**
+- `src/compute-engine/library/logic-analysis.ts` - Implemented Quine-McCluskey algorithm
+- `src/compute-engine/library/logic.ts` - Added 4 new function definitions
+- `test/compute-engine/logic.test.ts` - Added 17 new tests in "Prime Implicants and Minimal Forms" describe block
+
+---
+
 ## Medium Priority (Completed)
 
 ### 9. Implicit Multiplication Between `\exp` Function Calls ✅

requirements/TODO.md

@@ -123,30 +123,9 @@ ce.box(['IsEquivalent',
 
 ---
 
-### 6. Prime Implicants/Implicates
+### ~~6. Prime Implicants/Implicates~~ ✅ COMPLETED
 
-**Problem:** For circuit minimization and optimal CNF/DNF, we need minimal
-representations.
-
-**Solution:** Add functions:
-
-- `PrimeImplicants(expr)` - Find all prime implicants (minimal terms in DNF)
-- `PrimeImplicates(expr)` - Find all prime implicates (minimal clauses in CNF)
-- `MinimalDNF(expr)` - DNF with only prime implicants (Quine-McCluskey)
-- `MinimalCNF(expr)` - CNF with only prime implicates
-
-```typescript
-ce.box(['MinimalDNF', ['Or',
-  ['And', 'A', 'B'],
-  ['And', 'A', ['Not', 'B']],
-  ['And', ['Not', 'A'], 'B']
-]]).evaluate()
-// → A ∨ B (simplified from 3 terms to 1)
-```
-
-**Algorithm:** Quine-McCluskey or Espresso for larger formulas.
-
-**File:** `src/compute-engine/library/logic.ts`
+See `requirements/DONE.md` for implementation details.
 
 ---