@polintpro/proposit-core 0.8.0 → 0.8.3

package/dist/lib/core/argument-engine.js

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import { Value } from "typebox/value";
 import { CoreArgumentSchema, isClaimBound, isPremiseBound, } from "../schemata/index.js";
 import { DEFAULT_GRAMMAR_CONFIG, PERMISSIVE_GRAMMAR_CONFIG, } from "../types/grammar.js";
@@ -7,11 +6,13 @@ import { DEFAULT_CHECKSUM_CONFIG, normalizeChecksumConfig, serializeChecksumConf
 import { getOrCreate, sortedUnique } from "../utils/collections.js";
 import { ChangeCollector } from "./change-collector.js";
 import { canonicalSerialize, computeHash, entityChecksum } from "./checksum.js";
-import { kleeneAnd, kleeneNot } from "./evaluation/kleene.js";
+import { kleeneAnd, kleeneNot, kleeneOr, kleeneImplies, kleeneIff, } from "./evaluation/kleene.js";
 import { makeErrorIssue, makeValidationResult, } from "./evaluation/validation.js";
 import { InvariantViolationError } from "./invariant-violation-error.js";
 import { PremiseEngine } from "./premise-engine.js";
 import { VariableManager } from "./variable-manager.js";
+/** Default ID generator using the Web Crypto API (Node.js 20+, all modern browsers). */
+export const defaultGenerateId = () => globalThis.crypto.randomUUID();
 /**
  * Manages a propositional logic argument composed of premises, variable
  * assignments, and logical roles (supporting premises and a conclusion).
@@ -30,6 +31,7 @@ export class ArgumentEngine {
     checksumConfig;
     positionConfig;
     grammarConfig;
+    generateId;
     restoringFromSnapshot = false;
     checksumDirty = true;
     cachedMetaChecksum;
@@ -56,9 +58,11 @@ export class ArgumentEngine {
         this.checksumConfig = options?.checksumConfig;
         this.positionConfig = options?.positionConfig;
         this.grammarConfig = options?.grammarConfig;
+        this.generateId = options?.generateId ?? defaultGenerateId;
         this.variables = new VariableManager({
             checksumConfig: this.checksumConfig,
             positionConfig: this.positionConfig,
+            generateId: this.generateId,
         });
         this.expressionIndex = new Map();
         this.conclusionPremiseId = undefined;
@@ -320,7 +324,7 @@ export class ArgumentEngine {
         return lines.join("\n");
     }
     createPremise(extras, symbol) {
-        return this.createPremiseWithId(randomUUID(), extras, symbol);
+        return this.createPremiseWithId(this.generateId(), extras, symbol);
     }
     createPremiseWithId(id, extras, symbol) {
         return this.withValidation(() => {
@@ -341,6 +345,7 @@ export class ArgumentEngine {
                 checksumConfig: this.checksumConfig,
                 positionConfig: this.positionConfig,
                 grammarConfig: this.grammarConfig,
+                generateId: this.generateId,
             });
             this.premises.set(id, pm);
             this.wireCircularityCheck(pm);
@@ -363,7 +368,7 @@ export class ArgumentEngine {
             if (!this.restoringFromSnapshot) {
                 const autoSymbol = symbol ?? this.generateUniqueSymbol();
                 const autoVariable = {
-                    id: randomUUID(),
+                    id: this.generateId(),
                     argumentId: this.argument.id,
                     argumentVersion: this.argument.version,
                     symbol: autoSymbol,
@@ -800,17 +805,20 @@ export class ArgumentEngine {
         };
     }
     /** Creates a new ArgumentEngine from a previously captured snapshot. */
-    static fromSnapshot(snapshot, claimLibrary, sourceLibrary, claimSourceLibrary, grammarConfig, checksumVerification) {
+    static fromSnapshot(snapshot, claimLibrary, sourceLibrary, claimSourceLibrary, grammarConfig, checksumVerification, generateId) {
         const engine = new ArgumentEngine(snapshot.argument, claimLibrary, sourceLibrary, claimSourceLibrary, snapshot.config
             ? {
                 ...snapshot.config,
                 checksumConfig: normalizeChecksumConfig(snapshot.config.checksumConfig),
+                generateId: generateId ?? snapshot.config.generateId,
             }
-            : undefined);
+            : generateId
+                ? { generateId }
+                : undefined);
         engine.restoringFromSnapshot = true;
         // Restore premises first (premise-bound variables reference them)
         for (const premiseSnap of snapshot.premises) {
-            const pe = PremiseEngine.fromSnapshot(premiseSnap, snapshot.argument, engine.variables, engine.expressionIndex, grammarConfig);
+            const pe = PremiseEngine.fromSnapshot(premiseSnap, snapshot.argument, engine.variables, engine.expressionIndex, grammarConfig, generateId);
             engine.premises.set(pe.getId(), pe);
             engine.wireCircularityCheck(pe);
             engine.wireEmptyBoundPremiseCheck(pe);
@@ -1488,6 +1496,270 @@ export class ArgumentEngine {
         }
         return makeValidationResult(issues);
     }
+    /**
+     * Run fixed-point constraint propagation over accepted operators.
+     * Fills unknown (null) variable values based on operator semantics.
+     * Never overwrites user-assigned values (true/false).
+     */
+    propagateOperatorConstraints(assignment) {
+        const vars = { ...assignment.variables };
+        const opAssignments = assignment.operatorAssignments;
+        // Collect all expressions across all premises, indexed by id
+        const exprById = new Map();
+        // Children lookup: parentId -> sorted children
+        const childrenOf = new Map();
+        for (const pm of this.listPremises()) {
+            for (const expr of pm.getExpressions()) {
+                exprById.set(expr.id, expr);
+            }
+            // Build children map using getChildExpressions for each operator/formula
+            for (const expr of pm.getExpressions()) {
+                if (expr.type === "operator" || expr.type === "formula") {
+                    childrenOf.set(expr.id, pm.getChildExpressions(expr.id));
+                }
+            }
+        }
+        /**
+         * Resolve the current Kleene value of an expression subtree
+         * given the current variable assignments. Does not force-accept
+         * nested operators — evaluates them normally via Kleene logic.
+         */
+        const resolveValue = (exprId) => {
+            const expr = exprById.get(exprId);
+            if (!expr)
+                return null;
+            if (expr.type === "variable") {
+                return (vars[expr
+                    .variableId] ?? null);
+            }
+            if (expr.type === "formula") {
+                const children = childrenOf.get(expr.id) ?? [];
+                return children.length > 0 ? resolveValue(children[0].id) : null;
+            }
+            // operator
+            const op = expr
+                .operator;
+            const children = childrenOf.get(expr.id) ?? [];
+            switch (op) {
+                case "not":
+                    return kleeneNot(resolveValue(children[0].id));
+                case "and":
+                    return children.reduce((acc, child) => kleeneAnd(acc, resolveValue(child.id)), true);
+                case "or":
+                    return children.reduce((acc, child) => kleeneOr(acc, resolveValue(child.id)), false);
+                case "implies": {
+                    return kleeneImplies(resolveValue(children[0].id), resolveValue(children[1].id));
+                }
+                case "iff": {
+                    return kleeneIff(resolveValue(children[0].id), resolveValue(children[1].id));
+                }
+            }
+        };
+        /**
+         * Unwrap formula wrappers to find the leaf variable expression.
+         * Returns the variableId if the leaf is a variable, otherwise null.
+         */
+        const resolveLeafVariableId = (expr) => {
+            if (expr.type === "variable") {
+                return expr.variableId;
+            }
+            if (expr.type === "formula") {
+                const children = childrenOf.get(expr.id) ?? [];
+                if (children.length > 0) {
+                    return resolveLeafVariableId(children[0]);
+                }
+            }
+            return null;
+        };
+        // Track which variable IDs were explicitly set by the user
+        // (true or false). These are never overwritten by propagation.
+        const userAssigned = new Set();
+        for (const [varId, val] of Object.entries(vars)) {
+            if (val !== null && val !== undefined)
+                userAssigned.add(varId);
+        }
+        /**
+         * Try to set a child expression's variable to a value.
+         * Never overwrites user-assigned values.
+         * False overrides propagated true (rejection wins).
+         * Returns true if a value changed.
+         */
+        const trySetChild = (child, value) => {
+            const varId = resolveLeafVariableId(child);
+            if (varId == null || userAssigned.has(varId))
+                return false;
+            const current = vars[varId] ?? null;
+            if (current === null) {
+                vars[varId] = value;
+                return true;
+            }
+            // False overrides propagated true
+            if (value === false && current === true) {
+                vars[varId] = false;
+                return true;
+            }
+            return false;
+        };
+        // Two-phase propagation: rejections first (to establish false values),
+        // then acceptances (which only fill remaining unknowns).
+        // This prevents acceptance from deriving values through chains that
+        // are later invalidated by rejection.
+        for (const phase of ["rejected", "accepted"]) {
+            let changed = true;
+            while (changed) {
+                changed = false;
+                for (const [exprId, expr] of exprById) {
+                    if (expr.type !== "operator")
+                        continue;
+                    const state = opAssignments[exprId];
+                    if (state !== phase)
+                        continue;
+                    const op = expr.operator;
+                    const children = childrenOf.get(exprId) ?? [];
+                    if (state === "accepted") {
+                        switch (op) {
+                            case "not": {
+                                // ¬A accepted (= true) => child must be false
+                                if (children.length > 0) {
+                                    if (trySetChild(children[0], false))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "and": {
+                                // A ∧ B accepted => all children must be true
+                                for (const child of children) {
+                                    if (trySetChild(child, true))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "or": {
+                                // A ∨ B accepted: if all-but-one are false, remaining must be true
+                                const unknownChildren = [];
+                                let allOthersAreFalse = true;
+                                for (const child of children) {
+                                    const childValue = resolveValue(child.id);
+                                    if (childValue === null) {
+                                        unknownChildren.push(child);
+                                    }
+                                    else if (childValue !== false) {
+                                        allOthersAreFalse = false;
+                                    }
+                                }
+                                if (unknownChildren.length === 1 &&
+                                    allOthersAreFalse) {
+                                    if (trySetChild(unknownChildren[0], true))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "implies": {
+                                // A → B accepted: if A=true => B=true; if B=false => A=false
+                                if (children.length >= 2) {
+                                    const leftValue = resolveValue(children[0].id);
+                                    const rightValue = resolveValue(children[1].id);
+                                    if (leftValue === true) {
+                                        if (trySetChild(children[1], true))
+                                            changed = true;
+                                    }
+                                    if (rightValue === false) {
+                                        if (trySetChild(children[0], false))
+                                            changed = true;
+                                    }
+                                }
+                                break;
+                            }
+                            case "iff": {
+                                // A ↔ B accepted: if A known => B matches; if B known => A matches
+                                if (children.length >= 2) {
+                                    const leftValue = resolveValue(children[0].id);
+                                    const rightValue = resolveValue(children[1].id);
+                                    if (leftValue !== null) {
+                                        if (trySetChild(children[1], leftValue))
+                                            changed = true;
+                                    }
+                                    if (rightValue !== null) {
+                                        if (trySetChild(children[0], rightValue))
+                                            changed = true;
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        // state === "rejected" — expression forced false
+                        switch (op) {
+                            case "not": {
+                                // ¬A rejected (= false) => child must be true
+                                if (children.length > 0) {
+                                    if (trySetChild(children[0], true))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "and": {
+                                // A ∧ B rejected (= false): if all-but-one are true, remaining must be false
+                                const unknownChildren = [];
+                                let allOthersAreTrue = true;
+                                for (const child of children) {
+                                    const childValue = resolveValue(child.id);
+                                    if (childValue === null) {
+                                        unknownChildren.push(child);
+                                    }
+                                    else if (childValue !== true) {
+                                        allOthersAreTrue = false;
+                                    }
+                                }
+                                if (unknownChildren.length === 1 &&
+                                    allOthersAreTrue) {
+                                    if (trySetChild(unknownChildren[0], false))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "or": {
+                                // A ∨ B rejected (= false) => all children must be false
+                                for (const child of children) {
+                                    if (trySetChild(child, false))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "implies": {
+                                // A → B rejected (= false) => A must be true, B must be false
+                                if (children.length >= 2) {
+                                    if (trySetChild(children[0], true))
+                                        changed = true;
+                                    if (trySetChild(children[1], false))
+                                        changed = true;
+                                }
+                                break;
+                            }
+                            case "iff": {
+                                // A ↔ B rejected (= false): if A known => B is opposite; if B known => A is opposite
+                                if (children.length >= 2) {
+                                    const leftValue = resolveValue(children[0].id);
+                                    const rightValue = resolveValue(children[1].id);
+                                    if (leftValue !== null) {
+                                        if (trySetChild(children[1], !leftValue))
+                                            changed = true;
+                                    }
+                                    if (rightValue !== null) {
+                                        if (trySetChild(children[0], !rightValue))
+                                            changed = true;
+                                    }
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return vars;
+    }
     evaluate(assignment, options) {
         const validateFirst = options?.validateFirst ?? true;
         if (validateFirst) {
@@ -1538,6 +1810,12 @@ export class ArgumentEngine {
                 return true;
             return false;
         });
+        // Run operator constraint propagation
+        const propagatedVars = this.propagateOperatorConstraints(assignment);
+        const propagatedAssignment = {
+            variables: propagatedVars,
+            operatorAssignments: assignment.operatorAssignments,
+        };
         try {
             // Build a resolver that lazily evaluates premise-bound variables
             // by evaluating their bound premise's expression tree under the
@@ -1552,7 +1830,7 @@ export class ArgumentEngine {
                     !isPremiseBound(variable) ||
                     variable.boundArgumentId !== this.argument.id) {
                     // Claim-bound or externally-bound: read from assignment
-                    return assignment.variables[variableId] ?? null;
+                    return propagatedAssignment.variables[variableId] ?? null;
                 }
                 // Internal premise-bound: lazy resolution
                 const boundPremiseId = variable.boundPremiseId;
@@ -1561,7 +1839,7 @@ export class ArgumentEngine {
                     resolverCache.set(variableId, null);
                     return null;
                 }
-                const premiseResult = boundPremise.evaluate(assignment, {
+                const premiseResult = boundPremise.evaluate(propagatedAssignment, {
                     resolver,
                 });
                 const value = premiseResult?.rootValue ?? null;
@@ -1572,9 +1850,9 @@ export class ArgumentEngine {
                 strictUnknownKeys: options?.strictUnknownAssignmentKeys ?? false,
                 resolver,
             };
-            const conclusionEvaluation = conclusion.evaluate(assignment, evalOpts);
-            const supportingEvaluations = supportingPremises.map((pm) => pm.evaluate(assignment, evalOpts));
-            const constraintEvaluations = constraintPremises.map((pm) => pm.evaluate(assignment, evalOpts));
+            const conclusionEvaluation = conclusion.evaluate(propagatedAssignment, evalOpts);
+            const supportingEvaluations = supportingPremises.map((pm) => pm.evaluate(propagatedAssignment, evalOpts));
+            const constraintEvaluations = constraintPremises.map((pm) => pm.evaluate(propagatedAssignment, evalOpts));
             const isAdmissibleAssignment = constraintEvaluations.reduce((acc, result) => kleeneAnd(acc, result.rootValue ?? null), true);
             const allSupportingPremisesTrue = supportingEvaluations.reduce((acc, result) => kleeneAnd(acc, result.rootValue ?? null), true);
             const conclusionTrue = conclusionEvaluation.rootValue ?? null;
@@ -1593,10 +1871,10 @@ export class ArgumentEngine {
             return {
                 ok: true,
                 assignment: {
-                    variables: { ...assignment.variables },
-                    rejectedExpressionIds: [
-                        ...assignment.rejectedExpressionIds,
-                    ],
+                    variables: { ...propagatedAssignment.variables },
+                    operatorAssignments: {
+                        ...propagatedAssignment.operatorAssignments,
+                    },
                 },
                 referencedVariableIds,
                 conclusion: strip(conclusionEvaluation),
@@ -1699,7 +1977,7 @@ export class ArgumentEngine {
             }
             const assignment = {
                 variables: {},
-                rejectedExpressionIds: [],
+                operatorAssignments: {},
             };
             for (let i = 0; i < checkedVariableIds.length; i++) {
                 assignment.variables[checkedVariableIds[i]] = Boolean(mask & (1 << i));