feat: add evaluations for Xor, Nand, and Nor logic functions; enhance tests for logical operations and CNF/DNF conversions

Author: arnog

CHANGELOG.md

@@ -39,6 +39,20 @@
   when simplifying expressions containing exponentials, such as the derivative
   of `erf(x)` which is `(2/√π)·e^(-x²)`.
 
+- **Special Function Derivatives**: Fixed derivative formulas for several special
+  functions and removed incorrect ones:
+  - Fixed `d/dx erfi(x) = (2/√π)·e^(x²)` (imaginary error function)
+  - Fixed `d/dx S(x) = sin(πx²/2)` (Fresnel sine integral)
+  - Fixed `d/dx C(x) = cos(πx²/2)` (Fresnel cosine integral)
+  - Removed incorrect derivative formulas for Zeta, Digamma, PolyGamma, Beta,
+    LambertW, Bessel functions, and Airy functions (these now return symbolic
+    derivatives like `Digamma'(x)` instead of wrong numeric results)
+
+- **Symbolic Derivative Evaluation**: Fixed derivatives of unknown functions
+  returning `0` instead of symbolic derivatives. For example, `D(Digamma(x), x)`
+  now correctly returns `Digamma'(x)` (as `Apply(Derivative(Digamma, 1), x)`)
+  instead of incorrectly returning `0`.
+
 - **([#168](https://github.com/cortex-js/compute-engine/issues/168))
   Absolute Value**: Fixed parsing of nested absolute value expressions that
   start with a double bar (e.g. `||3-5|-4|`), which previously produced an

src/compute-engine/library/calculus.ts

@@ -160,6 +160,13 @@ volumes
         f = f?.canonical;
         // Avoid recursive evaluation
         if (f?.operator === 'D') return f;
+        // Avoid evaluating symbolic derivative applications like Digamma'(x)
+        // which would incorrectly evaluate to 0
+        if (
+          f?.operator === 'Apply' &&
+          f.op1?.operator === 'Derivative'
+        )
+          return f;
         // If the result contains symbolic transcendentals (like ln(2)),
         // return it without full evaluation to preserve the symbolic form
         if (f && hasSymbolicTranscendental(f)) return f;

src/compute-engine/library/logic.ts

@@ -82,6 +82,33 @@ export const LOGIC_LIBRARY: SymbolDefinitions = {
     signature: '(boolean, boolean) -> boolean',
     evaluate: evaluateImplies,
   },
+  Xor: {
+    description: 'Exclusive or: true when exactly one operand is true',
+    wikidata: 'Q498186',
+    broadcastable: true,
+    commutative: true,
+    complexity: 10200,
+    signature: '(boolean, boolean) -> boolean',
+    evaluate: evaluateXor,
+  },
+  Nand: {
+    description: 'Not-and: negation of conjunction',
+    wikidata: 'Q189550',
+    broadcastable: true,
+    commutative: true,
+    complexity: 10200,
+    signature: '(boolean, boolean) -> boolean',
+    evaluate: evaluateNand,
+  },
+  Nor: {
+    description: 'Not-or: negation of disjunction',
+    wikidata: 'Q189561',
+    broadcastable: true,
+    commutative: true,
+    complexity: 10200,
+    signature: '(boolean, boolean) -> boolean',
+    evaluate: evaluateNor,
+  },
   // Quantifiers return boolean values (they are propositions)
   // They support evaluation over finite domains (e.g., ForAll with Element condition)
   // The first argument can be:
@@ -268,6 +295,60 @@ function evaluateImplies(
   return undefined;
 }
 
+function evaluateXor(
+  args: ReadonlyArray<BoxedExpression>,
+  { engine: ce }: { engine: ComputeEngine }
+): BoxedExpression | undefined {
+  const lhs = args[0].symbol;
+  const rhs = args[1].symbol;
+  // XOR is true when exactly one operand is true
+  if (
+    (lhs === 'True' && rhs === 'False') ||
+    (lhs === 'False' && rhs === 'True')
+  )
+    return ce.True;
+  if (
+    (lhs === 'True' && rhs === 'True') ||
+    (lhs === 'False' && rhs === 'False')
+  )
+    return ce.False;
+  return undefined;
+}
+
+function evaluateNand(
+  args: ReadonlyArray<BoxedExpression>,
+  { engine: ce }: { engine: ComputeEngine }
+): BoxedExpression | undefined {
+  // NAND is the negation of AND
+  const lhs = args[0].symbol;
+  const rhs = args[1].symbol;
+  if (lhs === 'True' && rhs === 'True') return ce.False;
+  if (
+    (lhs === 'True' && rhs === 'False') ||
+    (lhs === 'False' && rhs === 'True') ||
+    (lhs === 'False' && rhs === 'False')
+  )
+    return ce.True;
+  return undefined;
+}
+
+function evaluateNor(
+  args: ReadonlyArray<BoxedExpression>,
+  { engine: ce }: { engine: ComputeEngine }
+): BoxedExpression | undefined {
+  // NOR is the negation of OR
+  const lhs = args[0].symbol;
+  const rhs = args[1].symbol;
+  if (lhs === 'False' && rhs === 'False') return ce.True;
+  if (
+    (lhs === 'True' && rhs === 'True') ||
+    (lhs === 'True' && rhs === 'False') ||
+    (lhs === 'False' && rhs === 'True')
+  )
+    return ce.False;
+  return undefined;
+}
+
 export function simplifyLogicFunction(
   x: BoxedExpression
 ): { value: BoxedExpression; because: string } | undefined {
@@ -277,6 +358,9 @@ export function simplifyLogicFunction(
     Not: evaluateNot,
     Equivalent: evaluateEquivalent,
     Implies: evaluateImplies,
+    Xor: evaluateXor,
+    Nand: evaluateNand,
+    Nor: evaluateNor,
   }[x.operator];
 
   if (!fn || !x.ops) return undefined;

test/compute-engine/logic.test.ts

@@ -47,6 +47,27 @@ describe('Logic', () => {
       `"True"`
     );
   });
+
+  it('should evaluate Xor', () => {
+    expect(box(['Xor', 'True', 'True'])).toMatchInlineSnapshot(`"False"`);
+    expect(box(['Xor', 'True', 'False'])).toMatchInlineSnapshot(`"True"`);
+    expect(box(['Xor', 'False', 'True'])).toMatchInlineSnapshot(`"True"`);
+    expect(box(['Xor', 'False', 'False'])).toMatchInlineSnapshot(`"False"`);
+  });
+
+  it('should evaluate Nand', () => {
+    expect(box(['Nand', 'True', 'True'])).toMatchInlineSnapshot(`"False"`);
+    expect(box(['Nand', 'True', 'False'])).toMatchInlineSnapshot(`"True"`);
+    expect(box(['Nand', 'False', 'True'])).toMatchInlineSnapshot(`"True"`);
+    expect(box(['Nand', 'False', 'False'])).toMatchInlineSnapshot(`"True"`);
+  });
+
+  it('should evaluate Nor', () => {
+    expect(box(['Nor', 'True', 'True'])).toMatchInlineSnapshot(`"False"`);
+    expect(box(['Nor', 'True', 'False'])).toMatchInlineSnapshot(`"False"`);
+    expect(box(['Nor', 'False', 'True'])).toMatchInlineSnapshot(`"False"`);
+    expect(box(['Nor', 'False', 'False'])).toMatchInlineSnapshot(`"True"`);
+  });
 });
 
 describe('Kronecker Delta', () => {
@@ -282,6 +303,18 @@ describe('CNF/DNF Conversion', () => {
     );
   });
 
+  it('should handle Xor', () => {
+    // A ⊕ B ≡ (A ∨ B) ∧ (¬A ∨ ¬B) in CNF
+    expect(box(['ToCNF', ['Xor', 'A', 'B']])).toMatchInlineSnapshot(
+      `(A || B) && (!A || !B)`
+    );
+
+    // A ⊕ B ≡ (A ∧ ¬B) ∨ (¬A ∧ B) in DNF
+    expect(box(['ToDNF', ['Xor', 'A', 'B']])).toMatchInlineSnapshot(
+      `A && !B || B && !A`
+    );
+  });
+
   it('should simplify constant expressions', () => {
     expect(box(['ToCNF', 'True'])).toMatchInlineSnapshot(`"True"`);
     expect(box(['ToCNF', 'False'])).toMatchInlineSnapshot(`"False"`);