@proposit/proposit-core 3.4.2 → 4.0.1

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

@@ -1,8 +1,12 @@
 import { isClaimBound, isPremiseBound, } from "../../schemata/index.js";
-import { kleeneAnd, kleeneNot, kleeneOr, kleeneImplies, kleeneIff, } from "./kleene.js";
+import { CONTESTED, } from "../../types/evaluation.js";
+import { belnapAnd, belnapNot, belnapOr, belnapImplies, belnapIff, hasFalseComponent, hasTrueComponent, joinKnowledge, } from "./belnap.js";
+import { createPremiseBoundResolver } from "./premise-resolver.js";
+import { isPremiseSetSatisfiable } from "./satisfiability.js";
 import { makeErrorIssue, makeValidationResult } from "./validation.js";
 /**
- * Kleene-evaluate an expression subtree under a fixed variable assignment.
+ * Evaluate an expression subtree under a fixed variable assignment, using the
+ * four-valued Belnap connectives.
  *
  * Total and side-effect free: unknown/missing variables and empty operators
  * yield `null`, and `formula` wrappers pass through to their single child.
@@ -13,79 +17,122 @@ import { makeErrorIssue, makeValidationResult } from "./validation.js";
  * The operator base cases (`and` seeds `true`, `or` seeds `false`) match
  * `propagateOperatorConstraints`' internal resolver so the two agree.
  */
-export function evaluateSubtreeKleene(rootExpressionId, getExpression, getChildren, variables) {
+export function evaluateSubtree(rootExpressionId, getExpression, getChildren, variables) {
     const expr = getExpression(rootExpressionId);
     if (!expr)
         return null;
     if (expr.type === "variable") {
         return variables[expr.variableId] ?? null;
     }
-    const recurse = (child) => evaluateSubtreeKleene(child.id, getExpression, getChildren, variables);
+    const recurse = (child) => evaluateSubtree(child.id, getExpression, getChildren, variables);
     const children = getChildren(expr.id);
     if (expr.type === "formula") {
         return children.length > 0 ? recurse(children[0]) : null;
     }
     switch (expr.operator) {
         case "not":
-            return children.length > 0 ? kleeneNot(recurse(children[0])) : null;
+            return children.length > 0 ? belnapNot(recurse(children[0])) : null;
         case "and":
-            return children.reduce((acc, child) => kleeneAnd(acc, recurse(child)), true);
+            return children.reduce((acc, child) => belnapAnd(acc, recurse(child)), true);
         case "or":
-            return children.reduce((acc, child) => kleeneOr(acc, recurse(child)), false);
+            return children.reduce((acc, child) => belnapOr(acc, recurse(child)), false);
         case "implies":
             return children.length >= 2
-                ? kleeneImplies(recurse(children[0]), recurse(children[1]))
+                ? belnapImplies(recurse(children[0]), recurse(children[1]))
                 : null;
         case "iff":
             return children.length >= 2
-                ? kleeneIff(recurse(children[0]), recurse(children[1]))
+                ? belnapIff(recurse(children[0]), recurse(children[1]))
                 : null;
         default:
             return null;
     }
 }
 /**
- * Run fixed-point constraint propagation over accepted/rejected operators.
- * Fills unknown (null) variable values based on operator semantics.
- * Never overwrites user-assigned values (true/false).
+ * Run constraint propagation to a fixed point over the operators the reader
+ * accepted, filling in variable values the granted steps force.
+ *
+ * Only acceptances propagate. A rejection is not a truth value: it strikes the
+ * premise it lives in, and the caller excludes that premise here via
+ * `options.excludedPremiseIds` — so nothing inside a struck premise
+ * contributes, and no value is ever forced `false` by a refusal.
+ *
+ * Each step **merges** what it forces into the variable's current value rather
+ * than overwriting it or declining to write, so two steps that force opposite
+ * values leave the variable `CONTESTED` instead of letting whichever step ran
+ * first decide. That merge is the join of the knowledge order, every rule's
+ * trigger is monotone in that same order, and the state space is finite — so
+ * the sweep converges to the least fixed point above the reader's assignment
+ * and reaches it whatever order premises, expressions and rules are visited
+ * in.
+ *
+ * Each rule moves **one truth component in one direction**, and that is not
+ * decoration: an accepted `A → B` fires forward on `A` being told true and
+ * merges told-true into `B`, and backward on `B` being told false merging
+ * told-false into `A`. Transferring both components at once would read the
+ * conditional as a biconditional and derive `B` false from `A` false. The
+ * one-directional pairing is what a material implication licenses; only `iff`
+ * carries both components both ways.
+ *
+ * Because only the told-true component travels forward, a contested variable
+ * can produce an uncontested `true` downstream and leave every aggregate fact
+ * reading clean. `evaluateArgument` reports `contestedVariableIds` so a
+ * conflict is never inferred from the aggregates. Attribution's counterfactual depends on that: withholding an assertion
+ * and re-closing must give one answer, and must not let mutually supporting
+ * premises certify each other.
+ *
+ * A reader's own assertion takes part in the merge like any other source. If
+ * the reader asserts a value that a granted step contradicts, the result is
+ * `CONTESTED` — the conflict is reported, not silently resolved in either
+ * direction.
  *
  * Axiomatic-bound variables are forced to `true` by `ArgumentEngine`'s
- * pre-pass before this function runs; they land in the propagator's
- * `userAssigned` set and are immune to overwrite. Rejecting an operator
- * whose only unknown child is axiom-bound is therefore a propagation no-op
- * on that branch — the axiom stays true and the rejection's downstream
- * propagation halts gracefully.
+ * pre-pass before this function runs, and are merged on the same footing.
  */
-export function propagateOperatorConstraints(ctx, assignment) {
+export function propagateOperatorConstraints(ctx, assignment, options) {
+    return closeUnderAcceptedOperators(ctx, assignment, options).variables;
+}
+/**
+ * `propagateOperatorConstraints` plus the provenance of every value it saw or
+ * produced. The two share one closure, so a tag is recorded where the value is
+ * actually set rather than reconstructed afterwards.
+ */
+export function closeUnderAcceptedOperators(ctx, assignment, options) {
     const vars = { ...assignment.variables };
+    for (const variableId of options?.withheldVariableIds ?? []) {
+        delete vars[variableId];
+    }
     const opAssignments = assignment.operatorAssignments;
+    const excludedPremiseIds = options?.excludedPremiseIds;
     // Collect all expressions across all premises, indexed by id
     const exprById = new Map();
+    // Expression id -> the premise it belongs to
+    const premiseIdOf = new Map();
     // Children lookup: parentId -> sorted children
     const childrenOf = new Map();
     for (const pm of ctx.listPremises()) {
+        if (excludedPremiseIds?.has(pm.getId()))
+            continue;
         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()) {
+            premiseIdOf.set(expr.id, pm.getId());
+            // Build children map using getChildExpressions for each operator/formula
             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.
+     * Resolve the current four-valued value of an expression subtree given the
+     * current variable assignments. Does not force-accept nested operators —
+     * evaluates them normally.
      */
     const resolveValue = (exprId) => {
         const expr = exprById.get(exprId);
         if (!expr)
             return null;
         if (expr.type === "variable") {
-            return (vars[expr
-                .variableId] ?? null);
+            return vars[expr.variableId] ?? null;
         }
         if (expr.type === "formula") {
             const children = childrenOf.get(expr.id) ?? [];
@@ -94,18 +141,27 @@ export function propagateOperatorConstraints(ctx, assignment) {
         // operator
         const op = expr.operator;
         const children = childrenOf.get(expr.id) ?? [];
+        // Arity is guarded rather than assumed: this function is reachable
+        // from the exported closure, which a caller may hand a tree that
+        // never passed `validateEvaluability()`.
         switch (op) {
             case "not":
-                return kleeneNot(resolveValue(children[0].id));
+                return children.length > 0
+                    ? belnapNot(resolveValue(children[0].id))
+                    : null;
             case "and":
-                return children.reduce((acc, child) => kleeneAnd(acc, resolveValue(child.id)), true);
+                return children.reduce((acc, child) => belnapAnd(acc, resolveValue(child.id)), true);
             case "or":
-                return children.reduce((acc, child) => kleeneOr(acc, resolveValue(child.id)), false);
+                return children.reduce((acc, child) => belnapOr(acc, resolveValue(child.id)), false);
             case "implies": {
-                return kleeneImplies(resolveValue(children[0].id), resolveValue(children[1].id));
+                return children.length >= 2
+                    ? belnapImplies(resolveValue(children[0].id), resolveValue(children[1].id))
+                    : null;
             }
             case "iff": {
-                return kleeneIff(resolveValue(children[0].id), resolveValue(children[1].id));
+                return children.length >= 2
+                    ? belnapIff(resolveValue(children[0].id), resolveValue(children[1].id))
+                    : null;
             }
         }
     };
@@ -125,195 +181,185 @@ export function propagateOperatorConstraints(ctx, assignment) {
         }
         return null;
     };
-    // Track which variable IDs were explicitly set by the user
-    // (true or false). These are never overwritten by propagation.
+    /** Variable IDs in an expression subtree that currently hold a value. */
+    const collectValuedVariableIds = (exprId) => {
+        const expr = exprById.get(exprId);
+        if (!expr)
+            return [];
+        if (expr.type === "variable") {
+            return (vars[expr.variableId] ?? null) === null
+                ? []
+                : [expr.variableId];
+        }
+        return (childrenOf.get(expr.id) ?? []).flatMap((child) => collectValuedVariableIds(child.id));
+    };
+    // Variable IDs the reader supplied a value for. Propagation merges into
+    // them like any other source; the set only tags provenance.
     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.
+     * Every granted step that contributed a component to a variable, keyed by
+     * the step's expression and the value it forced. A step is recorded each
+     * time its rule fires, whether or not the merge changed anything, and the
+     * record is overwritten — so at the fixed point every entry carries
+     * `fromVariableIds` read off the converged state rather than off whatever
+     * was known the first time the rule happened to run.
      */
-    const trySetChild = (child, value) => {
+    const contributions = new Map();
+    /**
+     * Merge a value into a child expression's leaf variable and record the
+     * step that forced it. Returns true iff the variable gained a component
+     * it did not already have.
+     */
+    const mergeIntoChild = (child, value, step) => {
         const varId = resolveLeafVariableId(child);
-        if (varId == null || userAssigned.has(varId))
+        if (varId == null)
             return false;
-        const current = vars[varId] ?? null;
-        if (current === null) {
-            vars[varId] = value;
-            return true;
+        let byStep = contributions.get(varId);
+        if (!byStep) {
+            byStep = new Map();
+            contributions.set(varId, byStep);
         }
-        // False overrides propagated true
-        if (value === false && current === true) {
-            vars[varId] = false;
-            return true;
-        }
-        return false;
+        byStep.set(`${step.expressionId}|${String(value)}`, { step, value });
+        const current = vars[varId] ?? null;
+        const merged = joinKnowledge(current, value);
+        if (merged === current)
+            return false;
+        vars[varId] = merged;
+        return true;
     };
-    // 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;
-                        }
+    // One pass over accepted operators; a rejection propagates nothing. Every
+    // trigger below reads a truth *component* rather than an exact value, so
+    // it can only start holding as the closure learns more, never stop.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [exprId, expr] of exprById) {
+            if (expr.type !== "operator")
+                continue;
+            if (opAssignments[exprId] !== "accepted")
+                continue;
+            const op = expr.operator;
+            const children = childrenOf.get(exprId) ?? [];
+            const stepFrom = (consumedExpressionIds) => ({
+                expressionId: exprId,
+                premiseId: premiseIdOf.get(exprId),
+                fromVariableIds: [
+                    ...new Set(consumedExpressionIds.flatMap(collectValuedVariableIds)),
+                ],
+            });
+            switch (op) {
+                case "not": {
+                    // ¬A accepted (= true) => child must be false
+                    if (children.length > 0) {
+                        if (mergeIntoChild(children[0], false, stepFrom([])))
+                            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 accepted => all children must be true
+                    for (const child of children) {
+                        if (mergeIntoChild(child, true, stepFrom([])))
+                            changed = true;
+                    }
+                    break;
+                }
+                case "or": {
+                    // A ∨ B accepted: a child whose every sibling is known
+                    // false must itself be true.
+                    const isFalse = children.map((child) => hasFalseComponent(resolveValue(child.id)));
+                    for (const [index, child] of children.entries()) {
+                        const siblingsAllFalse = isFalse.every((value, other) => other === index || value);
+                        if (!siblingsAllFalse)
+                            continue;
+                        const consumed = children
+                            .filter((_, other) => other !== index)
+                            .map((sibling) => sibling.id);
+                        if (mergeIntoChild(child, true, stepFrom(consumed)))
+                            changed = true;
+                    }
+                    break;
+                }
+                case "implies": {
+                    // A → B accepted: A true => B true; B false => A false
+                    if (children.length >= 2) {
+                        const leftValue = resolveValue(children[0].id);
+                        const rightValue = resolveValue(children[1].id);
+                        if (hasTrueComponent(leftValue)) {
+                            if (mergeIntoChild(children[1], true, stepFrom([children[0].id])))
+                                changed = true;
                         }
-                        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;
+                        if (hasFalseComponent(rightValue)) {
+                            if (mergeIntoChild(children[0], false, stepFrom([children[1].id])))
+                                changed = true;
                         }
-                        case "or": {
-                            // A ∨ B rejected (= false) => all children must be false
-                            for (const child of children) {
-                                if (trySetChild(child, false))
+                    }
+                    break;
+                }
+                case "iff": {
+                    // A ↔ B accepted: each side carries its components across
+                    if (children.length >= 2) {
+                        const sides = [
+                            [children[0], children[1]],
+                            [children[1], children[0]],
+                        ];
+                        for (const [source, target] of sides) {
+                            const sourceValue = resolveValue(source.id);
+                            const step = stepFrom([source.id]);
+                            if (hasTrueComponent(sourceValue)) {
+                                if (mergeIntoChild(target, true, step))
                                     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))
+                            if (hasFalseComponent(sourceValue)) {
+                                if (mergeIntoChild(target, false, step))
                                     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;
                         }
                     }
+                    break;
                 }
             }
         }
     }
-    return vars;
+    /** Stable step order, so provenance never depends on visitation order. */
+    const sortSteps = (entries) => [...entries]
+        .sort((a, b) => a.step.premiseId.localeCompare(b.step.premiseId) ||
+        a.step.expressionId.localeCompare(b.step.expressionId) ||
+        String(a.value).localeCompare(String(b.value)))
+        .map((entry) => entry.step);
+    const provenance = {};
+    for (const varId of new Set([
+        ...Object.keys(vars),
+        ...contributions.keys(),
+    ])) {
+        const value = vars[varId] ?? null;
+        const steps = sortSteps([...(contributions.get(varId)?.values() ?? [])]);
+        if (value === CONTESTED) {
+            provenance[varId] = {
+                value,
+                origin: "contested",
+                contestedBy: steps,
+            };
+        }
+        else if (userAssigned.has(varId)) {
+            provenance[varId] = { value, origin: "asserted" };
+        }
+        else if (value !== null && steps.length > 0) {
+            provenance[varId] = {
+                value,
+                origin: "derived",
+                derivedBy: steps[0],
+            };
+        }
+        else {
+            provenance[varId] = { value, origin: "unassigned" };
+        }
+    }
+    return { variables: vars, provenance };
 }
 /**
  * Evaluates an argument under a three-valued expression assignment.
@@ -370,42 +416,49 @@ export function evaluateArgument(ctx, assignment, options) {
             return true;
         return false;
     });
-    // Run operator constraint propagation
-    const propagatedVars = propagateOperatorConstraints(ctx, assignment);
-    const propagatedAssignment = {
-        variables: propagatedVars,
-        operatorAssignments: assignment.operatorAssignments,
-    };
+    // A rejection strikes the premise it lives in: that premise stops
+    // constraining the evaluation and asserts nothing. The conclusion premise
+    // and derivation premises are exempt — a rejection recorded against
+    // either is ignored, and observably so, because the struck set is
+    // reported.
+    const struckPremiseIds = allRelevantPremises
+        .filter((pm) => pm.getId() !== ctx.conclusionPremiseId &&
+        pm.getPremiseType?.() !== "derivation" &&
+        pm
+            .getExpressions()
+            .some((expr) => assignment.operatorAssignments[expr.id] ===
+            "rejected"))
+        .map((pm) => pm.getId());
+    const struckIds = new Set(struckPremiseIds);
     try {
-        // Build a resolver that lazily evaluates premise-bound variables
-        // by evaluating their bound premise's expression tree under the
-        // same assignment. Results are cached per-variable per-evaluate call.
-        const resolverCache = new Map();
-        const resolver = (variableId) => {
-            if (resolverCache.has(variableId)) {
-                return resolverCache.get(variableId);
-            }
-            const variable = ctx.getVariable(variableId);
-            if (!variable ||
-                !isPremiseBound(variable) ||
-                variable.boundArgumentId !== ctx.argumentId) {
-                // Claim-bound or externally-bound: read from assignment
-                return propagatedAssignment.variables[variableId] ?? null;
-            }
-            // Internal premise-bound: lazy resolution
-            const boundPremiseId = variable.boundPremiseId;
-            const boundPremise = ctx.getPremise(boundPremiseId);
-            if (!boundPremise) {
-                resolverCache.set(variableId, null);
-                return null;
-            }
-            const premiseResult = boundPremise.evaluate(propagatedAssignment, {
-                resolver,
+        const premiseSetSatisfiable = options?.premiseSetSatisfiable !== undefined
+            ? options.premiseSetSatisfiable
+            : isPremiseSetSatisfiable(ctx, {
+                premises: [
+                    ...supportingPremises,
+                    ...constraintPremises,
+                ].filter((pm) => !struckIds.has(pm.getId())),
+                freeVariableIds: referencedVariableIds,
+                // Deliberately not `forcedTrueVariableIds`. That set
+                // also decides what counts as a reader's assertion, and
+                // a citation belongs in this question but not that one.
+                forcedTrueVariableIds: options?.satisfiabilityForcedTrueVariableIds ??
+                    options?.forcedTrueVariableIds,
             });
-            const value = premiseResult?.rootValue ?? null;
-            resolverCache.set(variableId, value);
-            return value;
+        // Contradicting premises license nothing: exclude every premise from
+        // the closure so the reader is shown only what they asserted.
+        const derivationSuppressed = premiseSetSatisfiable === false;
+        const closureExclusions = derivationSuppressed
+            ? new Set(ctx.listPremises().map((pm) => pm.getId()))
+            : struckIds;
+        const propagation = closeUnderAcceptedOperators(ctx, assignment, {
+            excludedPremiseIds: closureExclusions,
+        });
+        const propagatedAssignment = {
+            variables: propagation.variables,
+            operatorAssignments: assignment.operatorAssignments,
         };
+        const resolver = createPremiseBoundResolver(ctx, propagatedAssignment);
         const evalOpts = {
             strictUnknownKeys: options?.strictUnknownAssignmentKeys ?? false,
             resolver,
@@ -413,12 +466,100 @@ export function evaluateArgument(ctx, assignment, options) {
         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 surviving = (results) => results.filter((result) => !struckIds.has(result.premiseId));
+        const isAdmissibleAssignment = surviving(constraintEvaluations).reduce((acc, result) => belnapAnd(acc, result.rootValue ?? null), true);
+        const survivingSupport = surviving(supportingEvaluations);
+        const survivingSupportingPremisesTrue = survivingSupport.reduce((acc, result) => belnapAnd(acc, result.rootValue ?? null), true);
         const conclusionTrue = conclusionEvaluation.rootValue ?? null;
-        const isCounterexample = kleeneAnd(isAdmissibleAssignment, kleeneAnd(allSupportingPremisesTrue, kleeneNot(conclusionTrue)));
+        // `survivingSupportingPremisesTrue` folds an empty list to `true`, so
+        // when the reader struck every supporting premise there is no case left
+        // to weigh — say so rather than reporting that the premises held and
+        // the conclusion failed. An argument authored with no supporting
+        // premises is the entailment-from-nothing case and keeps its answer.
+        const allSupportStruck = supportingEvaluations.length > 0 && survivingSupport.length === 0;
+        const premisesHoldConclusionFalse = allSupportStruck
+            ? null
+            : belnapAnd(isAdmissibleAssignment, belnapAnd(survivingSupportingPremisesTrue, belnapNot(conclusionTrue)));
+        // Reported unconditionally, not behind `includeDiagnostics`: a
+        // contested value can leave every aggregate above reading clean, so
+        // this is the only fact that always records one.
+        const contestedVariableIds = Object.entries(propagation.provenance)
+            .filter(([, entry]) => entry.value === CONTESTED)
+            .map(([variableId]) => variableId)
+            .sort();
         const includeExpressionValues = options?.includeExpressionValues ?? true;
         const includeDiagnostics = options?.includeDiagnostics ?? true;
+        // Attribution: withhold an assertion, recompute closure from what is
+        // left, and ask again. Never delete a tag from an already-derived
+        // value — the intervention has to be re-derived, not un-derived.
+        const forcedTrueVariableIds = options?.forcedTrueVariableIds;
+        const isReaderAsserted = (variableId) => forcedTrueVariableIds?.has(variableId) !== true &&
+            (assignment.variables[variableId] ?? null) !== null;
+        const canDerive = !derivationSuppressed &&
+            Object.values(assignment.operatorAssignments).includes("accepted");
+        const withhold = (withheldVariableIds) => {
+            if (!canDerive) {
+                // Nothing can be derived, so closure is the seed minus what
+                // was withheld.
+                const reduced = { ...assignment.variables };
+                for (const variableId of withheldVariableIds)
+                    delete reduced[variableId];
+                return reduced;
+            }
+            return closeUnderAcceptedOperators(ctx, assignment, {
+                excludedPremiseIds: closureExclusions,
+                withheldVariableIds,
+            }).variables;
+        };
+        const conclusionClaimVariableIds = [
+            ...new Set(conclusion
+                .getExpressions()
+                .filter((expr) => expr.type === "variable")
+                .map((expr) => expr.variableId)),
+        ].filter((vid) => {
+            if (forcedTrueVariableIds?.has(vid) === true)
+                return false;
+            const variable = ctx.getVariable(vid);
+            return variable != null && isClaimBound(variable);
+        });
+        let reachedWithoutAssertion = conclusionTrue === true;
+        if (conclusionClaimVariableIds.length > 0) {
+            const counterfactual = {
+                variables: withhold(new Set(conclusionClaimVariableIds)),
+                operatorAssignments: assignment.operatorAssignments,
+            };
+            const rootValue = conclusion.evaluate(counterfactual, {
+                strictUnknownKeys: false,
+                resolver: createPremiseBoundResolver(ctx, counterfactual),
+            }).rootValue;
+            reachedWithoutAssertion = (rootValue ?? null) === true;
+        }
+        const conclusionAttribution = {
+            assertedByReader: conclusionClaimVariableIds.some(isReaderAsserted),
+            reachedWithoutAssertion,
+        };
+        // One closure per reader-asserted claim, and only when something could
+        // have been derived at all.
+        const claimAttribution = includeDiagnostics && canDerive
+            ? Object.fromEntries(referencedVariableIds
+                .filter((vid) => {
+                const variable = ctx.getVariable(vid);
+                return (variable != null &&
+                    isClaimBound(variable) &&
+                    isReaderAsserted(vid));
+            })
+                .map((vid) => {
+                const asserted = assignment.variables[vid];
+                const reclosed = withhold(new Set([vid]));
+                return [
+                    vid,
+                    {
+                        assertedByReader: true,
+                        reachedWithoutAssertion: (reclosed[vid] ?? null) === asserted,
+                    },
+                ];
+            }))
+            : undefined;
         const strip = (result) => ({
             ...result,
             expressionValues: includeExpressionValues
@@ -434,6 +575,15 @@ export function evaluateArgument(ctx, assignment, options) {
                 propagatedAssignment.variables[vid] ?? null,
             ]))
             : undefined;
+        const variableProvenance = includeDiagnostics
+            ? Object.fromEntries(referencedVariableIds.map((vid) => [
+                vid,
+                propagation.provenance[vid] ?? {
+                    value: null,
+                    origin: "unassigned",
+                },
+            ]))
+            : undefined;
         return {
             ok: true,
             assignment: {
@@ -446,12 +596,18 @@ export function evaluateArgument(ctx, assignment, options) {
             conclusion: strip(conclusionEvaluation),
             supportingPremises: supportingEvaluations.map(strip),
             constraintPremises: constraintEvaluations.map(strip),
+            struckPremiseIds,
+            survivingSupportingPremiseCount: survivingSupport.length,
             isAdmissibleAssignment,
-            allSupportingPremisesTrue,
+            survivingSupportingPremisesTrue,
             conclusionTrue,
-            isCounterexample,
-            preservesTruthUnderAssignment: kleeneNot(isCounterexample),
+            premisesHoldConclusionFalse,
+            contestedVariableIds,
+            conclusionAttribution,
+            claimAttribution,
+            premiseSetSatisfiable,
             propagatedVariableValues,
+            variableProvenance,
         };
     }
     catch (error) {
@@ -542,6 +698,15 @@ export function checkArgumentValidity(ctx, options) {
             ]),
         };
     }
+    // The generated assignments carry no operator decisions, so nothing is
+    // ever struck and the premise set is the same on every row. Computing it
+    // once here and threading it through keeps the search 2^n rather than
+    // 2^n × 2^n.
+    const premiseSetSatisfiable = isPremiseSetSatisfiable(ctx, {
+        premises: [...supportingPremises, ...constraintPremises],
+        freeVariableIds: checkedVariableIds,
+        forcedTrueVariableIds,
+    });
     const mode = options?.mode ?? "firstCounterexample";
     const maxAssignmentsChecked = options?.maxAssignmentsChecked;
     const counterexamples = [];
@@ -571,6 +736,8 @@ export function checkArgumentValidity(ctx, options) {
             validateFirst: false,
             includeExpressionValues: options?.includeCounterexampleEvaluations ?? false,
             includeDiagnostics: options?.includeCounterexampleEvaluations ?? false,
+            forcedTrueVariableIds,
+            premiseSetSatisfiable,
         });
         if (!result.ok) {
             return {
@@ -582,7 +749,7 @@ export function checkArgumentValidity(ctx, options) {
         if (result.isAdmissibleAssignment === true) {
             numAdmissibleAssignments += 1;
         }
-        if (result.isCounterexample === true) {
+        if (result.premisesHoldConclusionFalse === true) {
             counterexamples.push({
                 assignment: result.assignment,
                 result,