@cogitator-ai/neuro-symbolic 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cogitator Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,494 @@
+# @cogitator-ai/neuro-symbolic
+
+Neuro-symbolic AI package for hybrid neural-symbolic reasoning. Combines LLM-based understanding with formal methods for verifiable, explainable AI.
+
+## Installation
+
+```bash
+pnpm add @cogitator-ai/neuro-symbolic
+```
+
+For Z3 constraint solving support:
+
+```bash
+pnpm add z3-solver
+```
+
+## Features
+
+- **Logic Programming** - Prolog-style rules with unification and SLD resolution
+- **Knowledge Graph Queries** - SPARQL-like query language with natural language interface
+- **Constraint Solving** - SAT/SMT solving with Z3 WASM or pure-TS fallback
+- **Plan Verification** - PDDL-like action schemas with invariant checking and repair
+
+---
+
+## Quick Start
+
+```typescript
+import {
+  createNeuroSymbolic,
+  ConstraintBuilder,
+  variable,
+  constant,
+} from '@cogitator-ai/neuro-symbolic';
+
+const ns = createNeuroSymbolic();
+
+// Logic Programming
+ns.loadLogicProgram(`
+  parent(tom, mary).
+  parent(mary, ann).
+  grandparent(X, Z) :- parent(X, Y), parent(Y, Z).
+`);
+
+const result = ns.queryLogic('grandparent(tom, X)?');
+console.log(result.solutions); // X = ann
+
+// Constraint Solving
+const problem = ConstraintBuilder.create()
+  .int('x', 1, 10)
+  .int('y', 1, 10)
+  .assert(variable('x').add(variable('y')).eq(constant(15)))
+  .build();
+
+const solution = await ns.solve(problem);
+console.log(solution); // { x: 5, y: 10 } or similar
+```
+
+---
+
+## Logic Programming
+
+Prolog-style logic programming with backward chaining and unification.
+
+### Loading Programs
+
+```typescript
+import { createNeuroSymbolic } from '@cogitator-ai/neuro-symbolic';
+
+const ns = createNeuroSymbolic();
+
+// Load facts and rules
+ns.loadLogicProgram(`
+  % Facts
+  human(socrates).
+  human(plato).
+
+  % Rules
+  mortal(X) :- human(X).
+
+  % Lists
+  append([], L, L).
+  append([H|T], L, [H|R]) :- append(T, L, R).
+`);
+```
+
+### Querying
+
+```typescript
+// Simple query
+const result = ns.queryLogic('mortal(socrates)?');
+console.log(result.success); // true
+
+// Query with variables
+const result = ns.queryLogic('mortal(X)?');
+for (const solution of result.solutions) {
+  console.log(solution.get('X')); // socrates, plato
+}
+
+// Multiple solutions
+const result = ns.queryLogic('append(X, Y, [1,2,3])?');
+// X=[], Y=[1,2,3]
+// X=[1], Y=[2,3]
+// X=[1,2], Y=[3]
+// X=[1,2,3], Y=[]
+```
+
+### Proof Trees
+
+```typescript
+import { formatProofTree, proofTreeToMermaid } from '@cogitator-ai/neuro-symbolic';
+
+const result = ns.queryLogic('grandparent(tom, X)?');
+console.log(formatProofTree(result.proofTree));
+console.log(proofTreeToMermaid(result.proofTree)); // Mermaid diagram
+```
+
+### Built-in Predicates
+
+| Predicate                    | Description           |
+| ---------------------------- | --------------------- |
+| `is/2`                       | Arithmetic evaluation |
+| `=/2`                        | Unification           |
+| `\+/1`                       | Negation as failure   |
+| `>/2`, `</2`, `>=/2`, `=</2` | Comparisons           |
+| `member/2`                   | List membership       |
+| `append/3`                   | List concatenation    |
+| `length/2`                   | List length           |
+| `reverse/2`                  | List reversal         |
+| `findall/3`                  | Collect all solutions |
+| `!/0`                        | Cut                   |
+
+---
+
+## Knowledge Graph Queries
+
+SPARQL-like query language with natural language interface.
+
+### Query Builder
+
+```typescript
+import { GraphQueryBuilder, variable, executeQuery } from '@cogitator-ai/neuro-symbolic';
+
+const query = new GraphQueryBuilder()
+  .select()
+  .pattern(variable('person'), 'worksAt', 'Google')
+  .pattern(variable('person'), 'hasSkill', variable('skill'))
+  .filter('skill', 'contains', 'Python')
+  .orderBy('person', 'asc')
+  .limit(10)
+  .build();
+
+const result = await executeQuery(query, { adapter: graphAdapter, agentId: 'agent-1' });
+```
+
+### Natural Language Queries
+
+```typescript
+const result = await ns.askGraph('Who works at Google and knows Python?');
+console.log(result.naturalLanguageResponse);
+```
+
+### Reasoning Engine
+
+```typescript
+import { createReasoningEngine, findPath, multiHopQuery } from '@cogitator-ai/neuro-symbolic';
+
+const engine = createReasoningEngine(graphAdapter);
+
+// Find path between entities
+const path = await findPath(graphAdapter, 'Alice', 'CompanyX', { maxHops: 3 });
+
+// Multi-hop query
+const results = await multiHopQuery(graphAdapter, 'Alice', ['worksAt', 'locatedIn'], {
+  maxHops: 2,
+});
+
+// Inference
+const inferred = await engine.infer({
+  enableTransitivity: true,
+  enableInverse: true,
+  enableComposition: true,
+});
+```
+
+---
+
+## Constraint Solving
+
+SAT/SMT solving with fluent DSL.
+
+### Building Constraints
+
+```typescript
+import {
+  ConstraintBuilder,
+  variable,
+  constant,
+  and,
+  or,
+  not,
+  allDifferent,
+} from '@cogitator-ai/neuro-symbolic';
+
+const problem = ConstraintBuilder.create()
+  // Define variables
+  .bool('a')
+  .bool('b')
+  .int('x', 0, 100)
+  .int('y', 0, 100)
+  .real('z', 0.0, 1.0)
+
+  // Add constraints
+  .assert(variable('a').or(variable('b')))
+  .assert(variable('x').add(variable('y')).lte(constant(50)))
+  .assert(variable('z').mul(constant(2)).gt(constant(0.5)))
+  .assert(allDifferent(variable('x'), variable('y')))
+
+  // Optimization objective
+  .maximize(variable('x').add(variable('y')))
+
+  .build();
+
+const result = await solve(problem);
+if (result.status === 'sat') {
+  console.log(result.model.assignments);
+}
+```
+
+### Solver Selection
+
+```typescript
+import { isZ3Available, createZ3Solver, createSimpleSATSolver } from '@cogitator-ai/neuro-symbolic';
+
+// Check Z3 availability
+if (await isZ3Available()) {
+  const solver = await createZ3Solver();
+  const result = await solver.solve(problem);
+} else {
+  // Fallback to pure-TS solver
+  const solver = createSimpleSATSolver();
+  const result = solver.solve(problem);
+}
+```
+
+### Expression Types
+
+```typescript
+// Arithmetic
+variable('x').add(variable('y'));
+variable('x').sub(constant(5));
+variable('x').mul(constant(2));
+variable('x').div(constant(3));
+
+// Boolean
+variable('a').and(variable('b'));
+variable('a').or(variable('b'));
+not(variable('a'));
+variable('a').implies(variable('b'));
+variable('a').iff(variable('b'));
+
+// Comparisons
+variable('x').eq(constant(10));
+variable('x').neq(variable('y'));
+variable('x').gt(constant(0));
+variable('x').gte(constant(0));
+variable('x').lt(constant(100));
+variable('x').lte(constant(100));
+
+// Global constraints
+allDifferent(variable('x'), variable('y'), variable('z'));
+atMost(2, variable('a'), variable('b'), variable('c'));
+atLeast(1, variable('a'), variable('b'), variable('c'));
+exactly(1, variable('a'), variable('b'), variable('c'));
+```
+
+---
+
+## Plan Verification
+
+PDDL-like planning with verification and repair.
+
+### Action Schemas
+
+```typescript
+import { ActionSchemaBuilder, ActionRegistry } from '@cogitator-ai/neuro-symbolic';
+
+const moveAction = new ActionSchemaBuilder('move')
+  .description('Move robot from one location to another')
+  .parameter('from', 'string', true)
+  .parameter('to', 'string', true)
+  .precondition({ type: 'simple', variable: 'robotAt', value: '${from}' })
+  .precondition({ type: 'comparison', variable: 'battery', operator: 'gt', value: 10 })
+  .effect({ type: 'assign', variable: 'robotAt', value: '${to}' })
+  .effect({ type: 'decrement', variable: 'battery', amount: 5 })
+  .cost(5)
+  .build();
+
+const registry = new ActionRegistry();
+registry.register(moveAction);
+```
+
+### Plan Validation
+
+```typescript
+import { validatePlan, formatValidationResult } from '@cogitator-ai/neuro-symbolic';
+
+const plan = {
+  id: 'plan-1',
+  actions: [
+    { id: 'a1', schemaName: 'move', parameters: { from: 'A', to: 'B' } },
+    { id: 'a2', schemaName: 'move', parameters: { from: 'B', to: 'C' } },
+  ],
+  initialState: { id: 's0', variables: { robotAt: 'A', battery: 100 } },
+  goalConditions: [{ type: 'simple', variable: 'robotAt', value: 'C' }],
+};
+
+const result = validatePlan(registry, plan);
+console.log(formatValidationResult(result));
+```
+
+### Invariant Checking
+
+```typescript
+import { createInvariantChecker, formatInvariantResults } from '@cogitator-ai/neuro-symbolic';
+
+const checker = createInvariantChecker(registry);
+
+// Add safety properties
+checker.addInvariant('battery-non-negative', {
+  type: 'comparison',
+  variable: 'battery',
+  operator: 'gte',
+  value: 0,
+});
+
+checker.addNever('collision', {
+  type: 'and',
+  conditions: [
+    { type: 'simple', variable: 'robotAt', value: 'danger-zone' },
+    { type: 'simple', variable: 'alarmActive', value: false },
+  ],
+});
+
+checker.addEventually('goal-reached', {
+  type: 'simple',
+  variable: 'goalAchieved',
+  value: true,
+});
+
+const results = checker.checkPlan(plan);
+console.log(formatInvariantResults(results));
+```
+
+### Plan Repair
+
+```typescript
+import { createPlanRepairer, formatRepairResult } from '@cogitator-ai/neuro-symbolic';
+
+const repairer = createPlanRepairer(registry, {
+  maxInsertions: 3,
+  maxRemovals: 2,
+  maxIterations: 10,
+});
+
+const repairResult = repairer.repair(plan, validationResult);
+if (repairResult.success) {
+  console.log('Repaired plan:', repairResult.repairedPlan);
+} else {
+  console.log('Suggestions:', repairResult.suggestions);
+}
+```
+
+---
+
+## Main Orchestrator
+
+The `NeuroSymbolic` class integrates all modules.
+
+```typescript
+import { createNeuroSymbolic } from '@cogitator-ai/neuro-symbolic';
+
+const ns = createNeuroSymbolic({
+  graphAdapter: myGraphAdapter, // Optional: for knowledge graph queries
+  config: {
+    knowledgeGraph: {
+      enableNaturalLanguage: true,
+      defaultQueryLimit: 100,
+    },
+    logic: {
+      maxDepth: 50,
+      maxSolutions: 10,
+      timeout: 5000,
+    },
+    constraints: {
+      timeout: 10000,
+      solver: 'z3', // or 'simple-sat'
+    },
+    planning: {
+      maxPlanLength: 100,
+      enableRepair: true,
+      verifyInvariants: true,
+    },
+  },
+});
+
+// Logic
+ns.loadLogicProgram('...');
+const logicResult = ns.queryLogic('...');
+
+// Constraints
+const solverResult = await ns.solve(problem);
+
+// Knowledge Graph
+const graphResult = await ns.queryGraph(query);
+const nlResult = await ns.askGraph('natural language question');
+
+// Planning
+ns.registerAction(actionSchema);
+const validationResult = await ns.validatePlan(plan);
+const repairResult = await ns.repairPlan(plan, validationResult);
+```
+
+---
+
+## Module Imports
+
+Each module can be imported separately:
+
+```typescript
+// Logic Programming
+import {
+  KnowledgeBase,
+  SLDResolver,
+  parseQuery,
+  formatSolutions,
+} from '@cogitator-ai/neuro-symbolic/logic';
+
+// Knowledge Graph
+import {
+  GraphQueryBuilder,
+  executeQuery,
+  ReasoningEngine,
+} from '@cogitator-ai/neuro-symbolic/knowledge-graph';
+
+// Constraints
+import { ConstraintBuilder, solve, Z3WASMSolver } from '@cogitator-ai/neuro-symbolic/constraints';
+
+// Planning
+import {
+  ActionSchemaBuilder,
+  PlanValidator,
+  InvariantChecker,
+} from '@cogitator-ai/neuro-symbolic/planning';
+```
+
+---
+
+## Type Reference
+
+```typescript
+import type {
+  // Logic
+  Term,
+  Clause,
+  Substitution,
+  ProofTree,
+  LogicQueryResult,
+
+  // Knowledge Graph
+  GraphQuery,
+  GraphQueryResult,
+  NaturalLanguageQueryResult,
+
+  // Constraints
+  ConstraintProblem,
+  ConstraintVariable,
+  SolverResult,
+
+  // Planning
+  ActionSchema,
+  Plan,
+  PlanState,
+  PlanValidationResult,
+  SafetyProperty,
+  InvariantCheckResult,
+} from '@cogitator-ai/types';
+```
+
+---
+
+## License
+
+MIT

package/dist/constraints/dsl.d.ts

@@ -0,0 +1,68 @@
+import type { Constraint, ConstraintExpression, ConstraintProblem } from '@cogitator-ai/types';
+export declare class Expr {
+    readonly expression: ConstraintExpression;
+    constructor(expression: ConstraintExpression);
+    static variable(name: string): Expr;
+    static constant(value: boolean | number): Expr;
+    private binaryOp;
+    private unaryOp;
+    add(other: Expr | number): Expr;
+    sub(other: Expr | number): Expr;
+    mul(other: Expr | number): Expr;
+    div(other: Expr | number): Expr;
+    mod(other: Expr | number): Expr;
+    pow(other: Expr | number): Expr;
+    abs(): Expr;
+    eq(other: Expr | number | boolean): Expr;
+    neq(other: Expr | number | boolean): Expr;
+    gt(other: Expr | number): Expr;
+    gte(other: Expr | number): Expr;
+    lt(other: Expr | number): Expr;
+    lte(other: Expr | number): Expr;
+    and(other: Expr | boolean): Expr;
+    or(other: Expr | boolean): Expr;
+    not(): Expr;
+    implies(other: Expr | boolean): Expr;
+    iff(other: Expr | boolean): Expr;
+    min(other: Expr | number): Expr;
+    max(other: Expr | number): Expr;
+}
+export declare function variable(name: string): Expr;
+export declare function constant(value: boolean | number): Expr;
+export declare function and(...exprs: (Expr | boolean)[]): Expr;
+export declare function or(...exprs: (Expr | boolean)[]): Expr;
+export declare function not(expr: Expr | boolean): Expr;
+export declare function implies(a: Expr | boolean, b: Expr | boolean): Expr;
+export declare function iff(a: Expr | boolean, b: Expr | boolean): Expr;
+export declare function ite(condition: Expr, thenExpr: Expr | number, elseExpr: Expr | number): Expr;
+export declare function sum(...exprs: (Expr | number)[]): Expr;
+export declare function product(...exprs: (Expr | number)[]): Expr;
+export declare function allDifferent(...exprs: Expr[]): Expr;
+export declare function atMost(k: number, ...exprs: Expr[]): Expr;
+export declare function atLeast(k: number, ...exprs: Expr[]): Expr;
+export declare function exactly(k: number, ...exprs: Expr[]): Expr;
+export declare class ConstraintBuilder {
+    private variables;
+    private constraints;
+    private objective?;
+    private problemName?;
+    constructor(name?: string);
+    static create(name?: string): ConstraintBuilder;
+    bool(name: string): Expr;
+    int(name: string, min?: number, max?: number): Expr;
+    real(name: string, min?: number, max?: number): Expr;
+    bitvec(name: string, bitWidth: number): Expr;
+    boolArray(prefix: string, count: number): Expr[];
+    intArray(prefix: string, count: number, min?: number, max?: number): Expr[];
+    assert(expr: Expr, name?: string): this;
+    soft(expr: Expr, weight?: number, name?: string): this;
+    minimize(expr: Expr): this;
+    maximize(expr: Expr): this;
+    build(): ConstraintProblem;
+    clear(): this;
+    clone(): ConstraintBuilder;
+}
+export declare function expressionToString(expr: ConstraintExpression): string;
+export declare function constraintToString(constraint: Constraint): string;
+export declare function problemToString(problem: ConstraintProblem): string;
+//# sourceMappingURL=dsl.d.ts.map

package/dist/constraints/dsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl.d.ts","sourceRoot":"","sources":["../../src/constraints/dsl.ts"],"names":[],"mappings":"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"}