Add cyclic integration patterns for e^x with trigonometric functions (#276)

* feat: add cyclic e^x*trig integration patterns

Add support for integrating e^x*sin(x), e^x*cos(x), and their
linear argument variants e^x*sin(ax), e^x*cos(ax), e^x*sin(ax+b),
e^x*cos(ax+b). These patterns require the "solve for the integral"
technique as standard integration by parts leads to infinite recursion.

- Add tryCyclicExpTrigIntegral() function for direct detection
- Add INTEGRATION_RULES patterns for matching various forms
- Add tests for e^x*sin(x), e^x*cos(x), e^x*sin(2x), e^x*cos(2x)
- Add tests for x^2*e^x, x*ln(x), sec(x), csc(x)

https://claude.ai/code/session_01PpXCWRd3awYVikU5ErVA68

* build: update generated files

https://claude.ai/code/session_01PpXCWRd3awYVikU5ErVA68

* Delete src/api.md

* feat(logic): implement comprehensive boolean simplification rules

- Added absorption rules for conjunction and disjunction:
  - A ∧ (A ∨ B) → A
  - A ∨ (A ∧ B) → A
- Implemented idempotence, complementation, identity, domination, and double negation simplifications.
- Updated logic-utils.ts with new functions for absorption.
- Enhanced logic.test.ts with extensive tests for all new simplification rules.

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

* chore

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: arnog

CHANGELOG.md

@@ -312,6 +312,47 @@
   This uses u-substitution: since `1/x = d/dx(ln(x))`, the integral becomes
   `∫ h'(x)/h(x) dx = ln|h(x)|`.
 
+#### Logic
+
+- **Boolean Simplification Rules**: Added absorption laws and improved boolean
+  expression simplification:
+  - **Absorption**: `A ∧ (A ∨ B) → A` and `A ∨ (A ∧ B) → A`
+  - **Idempotence**: `A ∧ A → A` and `A ∨ A → A`
+  - **Complementation**: `A ∧ ¬A → False` and `A ∨ ¬A → True`
+  - **Identity**: `A ∧ True → A` and `A ∨ False → A`
+  - **Domination**: `A ∧ False → False` and `A ∨ True → True`
+  - **Double negation**: `¬¬A → A`
+
+  These rules are applied automatically during simplification:
+  ```javascript
+  ce.box(['And', 'A', ['Or', 'A', 'B']]).simplify();  // → A
+  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

@@ -435,6 +435,108 @@ ce.box(['Eigen', ['List', ['List', 4, 2], ['List', 1, 3]]]).evaluate();
 
 ---
 
+## Logic Enhancements (Completed)
+
+### L-1. Logic Simplification Rules ✅
+
+**IMPLEMENTED:** Added comprehensive boolean simplification rules:
+
+1. **Absorption** (NEW):
+   - `A ∧ (A ∨ B) → A`
+   - `A ∨ (A ∧ B) → A`
+
+2. **Idempotence** (already implemented):
+   - `A ∧ A → A`
+   - `A ∨ A → A`
+
+3. **Complementation** (already implemented):
+   - `A ∧ ¬A → False`
+   - `A ∨ ¬A → True`
+
+4. **Identity** (already implemented):
+   - `A ∧ True → A`
+   - `A ∨ False → A`
+
+5. **Domination** (already implemented):
+   - `A ∧ False → False`
+   - `A ∨ True → True`
+
+6. **Double negation** (already implemented via involution):
+   - `¬¬A → A`
+
+**Examples:**
+```typescript
+ce.box(['And', 'A', ['Or', 'A', 'B']]).simplify();  // → A
+ce.box(['Or', 'A', ['And', 'A', 'B']]).simplify();  // → A
+ce.box(['And', 'A', 'A']).simplify();              // → A
+ce.box(['And', 'A', ['Not', 'A']]).simplify();     // → False
+ce.box(['Or', 'A', ['Not', 'A']]).simplify();      // → True
+ce.box(['Not', ['Not', 'A']]).simplify();          // → A
+```
+
+**Files modified:**
+- `src/compute-engine/library/logic-utils.ts` - Added `applyAbsorptionAnd` and `applyAbsorptionOr` functions
+- `test/compute-engine/logic.test.ts` - Added "Logic Simplification Rules" describe block with 18 new tests
+
+---
+
+### 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 ✅