factbag 0.0.0-alpha.0 → 0.0.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # factbag
 
+## 0.0.0-alpha.1
+
+### Patch Changes
+
+- ebc4a8a: A `letIn` or aggregate whose variable is already bound now constrains that variable instead of rebinding it. Before, a rule such as `tax(P, R) iff letIn(R, ...)` concluded `tax(alice, 99)` as true when its body computed 98, and an `or` branch evaluated under another branch's bindings reported those bindings as true. Proofs for such queries now carry a temporary variable and an `eq` comparison.
+- eca65c2: An `or` is now judged per binding environment, so a branch that fails without binding a variable can no longer borrow the truth of a sibling branch whose bindings were discarded. Before, `and(or(p(X), r()), s(X))` could be judged true when `p(x1)` and `s(x3)` held but nothing satisfied both: the false `r()` branch produced an environment without `X`, the `or` was judged true there via `p(x1)`, and `s(X)` then ranged over every candidate. The recursion validator's edge collector also now carries variables bound in every `or` branch forward, matching the variable-use checker, so a comparison after such an `or` is no longer reported as unconstructive recursion.
+
 ## 0.0.0-alpha.0
 
 Initial experimental distribution of core, corpus, guards, and Jev functionality.

package/README.md

@@ -7,8 +7,8 @@ sources and rules behind a conclusion.
 Factbag includes a document corpus, permission controls, and an integration with
 TypeSafe AI’s Jev model.
 
-Read [Introducing Factbag](https://blog.du-pless.is/introducing-factbag) for how and
-why to use it, or [Jev and the Art of Truth Maintenance](https://blog.du-pless.is/jev-and-the-art-of-truth-maintenance)
+Read [Introducing Factbag](https://daniel.du-pless.is/introducing-factbag) for how and
+why to use it, or [Jev and the Art of Truth Maintenance](https://daniel.du-pless.is/jev-and-the-art-of-truth-maintenance)
 for the thinking behind it.
 
 ## Install

package/dist/core/query/index.js

@@ -79,6 +79,15 @@ function uniqueVariables(variables) {
   }
   return unique;
 }
+function bindingsAfterOr(branchBindings, bound) {
+  const next = new Set(bound);
+  for (const candidate of uniqueVariables(branchBindings.flatMap((branch) => [...branch]))) {
+    if (branchBindings.every((branch) => branch.has(candidate))) {
+      next.add(candidate);
+    }
+  }
+  return next;
+}
 function variablesIn(value) {
   if (isVar(value)) {
     return [value];
@@ -95,7 +104,7 @@ function collectBodyEdges(body, headPredicate, bound, edges) {
   if (isAtomLike(body)) {
     edges.push({ from: headPredicate, to: body.predicate, kind: "positive" });
     bindVariables(body, bound);
-    return;
+    return bound;
   }
   if (isNegativeLiteral(body)) {
     edges.push({
@@ -103,20 +112,26 @@ function collectBodyEdges(body, headPredicate, bound, edges) {
       to: body.atom.predicate,
       kind: body.atom.predicate.world === "closed" ? "closed-world-not" : "explicit-not"
     });
-    bindVariables(body.atom, bound);
-    return;
+    return bound;
   }
   if (isFormula(body, "and")) {
+    let nextBound = bound;
     for (const arg of body.args) {
-      collectBodyEdges(arg, headPredicate, bound, edges);
+      nextBound = collectBodyEdges(arg, headPredicate, nextBound, edges);
     }
-    return;
+    return nextBound;
+  }
+  if (isFormula(body, "or")) {
+    const branchBindings = body.args.map(
+      (arg) => collectBodyEdges(arg, headPredicate, new Set(bound), edges)
+    );
+    return bindingsAfterOr(branchBindings, bound);
   }
-  if (isFormula(body, "or") || isFormula(body, "exists")) {
+  if (isFormula(body, "exists")) {
     for (const arg of body.args) {
       collectBodyEdges(arg, headPredicate, new Set(bound), edges);
     }
-    return;
+    return bound;
   }
   if (isFormula(body, "letIn")) {
     const [variable, value, nextBody] = body.args;
@@ -128,12 +143,12 @@ function collectBodyEdges(body, headPredicate, bound, edges) {
     if (isVar(variable)) {
       bound.add(variable);
     }
-    collectBodyEdges(nextBody, headPredicate, bound, edges);
-    return;
+    return collectBodyEdges(nextBody, headPredicate, bound, edges);
   }
   if (isPrimitiveFormula(body) && hasUnboundVariable(body, bound)) {
     edges.push({ from: headPredicate, to: headPredicate, kind: "primitive-ungrounded" });
   }
+  return bound;
 }
 function collectAggregateEdges(aggregate, headPredicate, bound, edges) {
   for (const arg of aggregate.args.slice(1)) {
@@ -252,7 +267,10 @@ function assertSafeBody(body, bound) {
     return nextBound;
   }
   if (isFormula(body, "or")) {
-    return bindingsAvailableAfterOr(body.args, bound);
+    return bindingsAfterOr(
+      body.args.map((arg) => assertSafeBody(arg, new Set(bound))),
+      bound
+    );
   }
   if (isFormula(body, "exists")) {
     const nextBody = body.args.at(-1);
@@ -288,16 +306,6 @@ function assertSafeAggregate(aggregate, bound) {
     assertSafeBody(options.completeWhen, new Set(bound));
   }
 }
-function bindingsAvailableAfterOr(args, bound) {
-  const branchBindings = args.map((arg) => assertSafeBody(arg, new Set(bound)));
-  const next = new Set(bound);
-  for (const candidate of uniqueVariables(branchBindings.flatMap((branch) => [...branch]))) {
-    if (branchBindings.length > 0 && branchBindings.every((branch) => branch.has(candidate))) {
-      next.add(candidate);
-    }
-  }
-  return next;
-}
 function assertVariablesBound(variables, bound) {
   const unbound = uniqueVariables(variables).filter((variable) => !bound.has(variable));
   if (unbound.length > 0) {
@@ -727,7 +735,15 @@ function assertNever(value, message) {
 }
 function evaluateRuleBodyMany(literals, rules, body, bindings, active, context, pathCanHaveUnavailableBindings = false) {
   if (isAtomLike(body)) {
-    return evaluateAtomBody(literals, rules, erasedAtom(body), bindings, active, context);
+    return evaluateAtomBody(
+      literals,
+      rules,
+      erasedAtom(body),
+      bindings,
+      active,
+      context,
+      pathCanHaveUnavailableBindings
+    );
   }
   if (isLiteralLike(body) && body.sign === "-") {
     const bodyAtom = erasedAtom(body.atom);
@@ -907,9 +923,13 @@ function evaluateOrBody(literals, rules, args, bindings, active, context, pathCa
     )
   );
   const environments = candidateBindings.length === 0 ? [bindings] : candidateBindings;
-  return environments.map((environment) => {
-    const judgments = args.map((arg) => {
-      const results = evaluateRuleBodyMany(
+  const queue = [...environments];
+  const seen = new Set(queue.map(bindingsKey));
+  const results = [];
+  for (let next = queue.shift(); next !== void 0; next = queue.shift()) {
+    const environment = next;
+    const judgments = args.flatMap((arg) => {
+      const branch = evaluateRuleBodyMany(
         literals,
         rules,
         arg,
@@ -918,15 +938,27 @@ function evaluateOrBody(literals, rules, args, bindings, active, context, pathCa
         context,
         pathCanHaveUnavailableBindings
       );
-      assert(results.length > 0, "Or branch evaluation produced no results");
-      const result = bestResult(results);
-      assert(result !== void 0, "Or branch evaluation produced no best result");
-      return result.judgment;
+      for (const result2 of branch) {
+        if (bindsBeyond(result2.bindings, environment)) {
+          const key = bindingsKey(result2.bindings);
+          if (!seen.has(key)) {
+            seen.add(key);
+            queue.push(result2.bindings);
+          }
+        }
+      }
+      const result = bestResult(
+        branch.filter((candidate) => !bindsBeyond(candidate.bindings, environment))
+      );
+      return result === void 0 ? [] : [result.judgment];
     });
+    if (judgments.length === 0) {
+      continue;
+    }
     const judgmentBindings = bindingsArray(environment);
     const reboundJudgments = judgments.map((judgment) => withBindings(judgment, judgmentBindings));
     const goal = { kind: "or", goals: reboundJudgments.map((judgment) => judgment.goal) };
-    return {
+    results.push({
       judgment: compoundJudgment(
         goal,
         maxGoalValue(...reboundJudgments.map((judgment) => judgment.value)),
@@ -934,8 +966,9 @@ function evaluateOrBody(literals, rules, args, bindings, active, context, pathCa
         reboundJudgments
       ),
       bindings: environment
-    };
-  });
+    });
+  }
+  return results;
 }
 function evaluateAndBody(literals, rules, args, bindings, active, context, pathCanHaveUnavailableBindings) {
   let partials = [{ bindings, judgments: [] }];
@@ -976,7 +1009,7 @@ function evaluateAndBody(literals, rules, args, bindings, active, context, pathC
     };
   });
 }
-function evaluateAtomBody(literals, rules, atom, bindings, active, context) {
+function evaluateAtomBody(literals, rules, atom, bindings, active, context, pathCanHaveUnavailableBindings = false) {
   const evaluateGrounded = (environment) => {
     const grounded = groundAtom(atom, environment);
     const judgmentBindings = bindingsArray(environment);
@@ -998,7 +1031,14 @@ function evaluateAtomBody(literals, rules, atom, bindings, active, context) {
       ])
     )
   };
-  const candidateBindings = candidateGroundAtoms(literals, rules, pattern, active, context.search).map((candidate) => extendBindings(atom, candidate, bindings)).filter((candidate) => candidate !== void 0);
+  const candidateBindings = candidateGroundAtoms(
+    literals,
+    rules,
+    pattern,
+    active,
+    context.search,
+    pathCanHaveUnavailableBindings
+  ).map((candidate) => extendBindings(atom, candidate, bindings)).filter((candidate) => candidate !== void 0);
   if (candidateBindings.length === 0) {
     if (atom.predicate.world === "closed") {
       assert(!canGroundAtom(atom, bindings), "Ground closed-world absence must use ground solving");
@@ -1181,7 +1221,7 @@ function evaluateExpression(expression, bindings, context) {
     const right = evaluateExpression(expression.args[1], left.bindings, context);
     assert(isScalarGoalExpression(left.expression), "Left arithmetic operand must be scalar");
     assert(isScalarGoalExpression(right.expression), "Right arithmetic operand must be scalar");
-    const variable = new Var(`$tmp${context.nextTemp++}`);
+    const variable = new Var(`${TEMPORARY_PREFIX}${context.nextTemp++}`);
     const goal = {
       kind: expression.kind,
       bind: variable,
@@ -1220,6 +1260,10 @@ function evaluateExpression(expression, bindings, context) {
   };
 }
 function evaluateExpressionInto(variable, expression, bindings, context) {
+  const existing = valueForVariable(bindings, variable);
+  if (existing !== UNBOUND) {
+    return constrainBoundVariable(variable, existing, expression, bindings, context);
+  }
   if (isArithmeticFormula(expression)) {
     const left = evaluateExpression(expression.args[0], bindings, context);
     const right = evaluateExpression(expression.args[1], left.bindings, context);
@@ -1256,9 +1300,35 @@ function evaluateExpressionInto(variable, expression, bindings, context) {
   }
   const value = isVar(expression) ? valueForVariable(bindings, expression) : definedValue(expression, "Expression values must be defined");
   const nextBindings = new Map(bindings);
-  nextBindings.set(variable, value);
+  if (value !== UNBOUND) {
+    nextBindings.set(variable, value);
+  }
   return { value, expression: variable, bindings: nextBindings, judgments: [] };
 }
+function constrainBoundVariable(variable, existing, expression, bindings, context) {
+  const computed = evaluateExpression(expression, bindings, context);
+  assert(
+    isScalarGoalExpression(computed.expression),
+    "A let binding of a bound variable must compare scalar values"
+  );
+  const goal = { kind: "eq", left: variable, right: computed.expression };
+  const value = computed.value === UNBOUND ? "unknown" : compareValues("eq", existing, computed.value);
+  const comparison = primitiveComparisonJudgment(
+    goal,
+    value,
+    bindingsArray(computed.bindings),
+    existing,
+    variable,
+    computed.value,
+    computed.expression
+  );
+  return {
+    value: existing,
+    expression: variable,
+    bindings: computed.bindings,
+    judgments: [...computed.judgments, comparison]
+  };
+}
 function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, active, context) {
   const [valueExpression, whereBody, options] = aggregate.args;
   const completeWhen = options?.completeWhen;
@@ -1282,11 +1352,11 @@ function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, a
     assert(completeness !== void 0, "Aggregate completeness evaluation produced no best result");
     if (completeness.judgment.value !== "true") {
       const judgmentBindings = bindingsArray(bindings);
-      let goal;
+      let goal2;
       switch (aggregate.kind) {
         case "sum":
           assert(isNumericGoalExpression(valueExpression), "Sum value must be numeric");
-          goal = {
+          goal2 = {
             kind: "sum",
             bind: variable,
             value: valueExpression,
@@ -1295,7 +1365,7 @@ function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, a
           };
           break;
         case "count":
-          goal = {
+          goal2 = {
             kind: "count",
             bind: variable,
             where: whereGoal,
@@ -1308,12 +1378,14 @@ function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, a
       return {
         kind: "incomplete",
         result: {
-          judgment: { value: "unknown", goal, bindings: judgmentBindings },
+          judgment: { value: "unknown", goal: goal2, bindings: judgmentBindings },
           bindings
         }
       };
     }
   }
+  const existing = valueForVariable(bindings, variable);
+  const target = existing === UNBOUND ? variable : new Var(`$tmp${context.nextTemp++}`);
   const nextBindings = new Map(bindings);
   const values = rows.map((row) => resolveAggregateValue(valueExpression, row.bindings));
   let value;
@@ -1322,29 +1394,29 @@ function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, a
     case "sum":
       assert(isNumericGoalExpression(valueExpression), "Sum value must be numeric");
       value = sumValues(values);
-      nextBindings.set(variable, value);
+      nextBindings.set(target, value);
       judgment = primitiveSumJudgment(
         {
           kind: "sum",
-          bind: variable,
+          bind: target,
           value: valueExpression,
           where: whereGoal
         },
         bindingsArray(nextBindings),
         values,
-        variable,
+        target,
         value
       );
       break;
     case "count": {
       const range = countRange(possibleRows, isOpenAggregate(whereBody));
       value = exactCountValue(range);
-      nextBindings.set(variable, value);
+      nextBindings.set(target, value);
       judgment = primitiveCountJudgment(
-        { kind: "count", bind: variable, where: whereGoal },
+        { kind: "count", bind: target, where: whereGoal },
         bindingsArray(nextBindings),
         range,
-        variable,
+        target,
         value
       );
       break;
@@ -1352,9 +1424,30 @@ function evaluateAggregateInto(literals, rules, variable, aggregate, bindings, a
     default:
       return assertNever(aggregate.kind, "Unhandled aggregate kind");
   }
+  if (existing === UNBOUND) {
+    return {
+      kind: "complete",
+      expression: { value, expression: variable, bindings: nextBindings, judgments: [judgment] }
+    };
+  }
+  const goal = { kind: "eq", left: variable, right: target };
+  const comparison = primitiveComparisonJudgment(
+    goal,
+    compareValues("eq", existing, value),
+    bindingsArray(nextBindings),
+    existing,
+    variable,
+    value,
+    target
+  );
   return {
     kind: "complete",
-    expression: { value, expression: variable, bindings: nextBindings, judgments: [judgment] }
+    expression: {
+      value: existing,
+      expression: variable,
+      bindings: nextBindings,
+      judgments: [judgment, comparison]
+    }
   };
 }
 function resolveAggregateValue(expression, bindings) {
@@ -1810,13 +1903,28 @@ function ruleContribution(kind, value) {
 function bindingsArray(bindings) {
   return [...bindings.entries()];
 }
+var TEMPORARY_PREFIX = "$tmp";
+function isTemporary(variable) {
+  return variable.name.startsWith(TEMPORARY_PREFIX);
+}
+function bindsBeyond(result, environment) {
+  for (const variable of result.keys()) {
+    if (!isTemporary(variable) && !environment.has(variable)) {
+      return true;
+    }
+  }
+  return false;
+}
+function bindingsKey(binding) {
+  return JSON.stringify(
+    bindingsArray(binding).filter(([variable]) => !isTemporary(variable)).map(([variable, value]) => [variable.name, fieldIdentityToken(value)])
+  );
+}
 function uniqueBindings(bindings) {
   const seen = /* @__PURE__ */ new Set();
   const unique = [];
   for (const binding of bindings) {
-    const key = JSON.stringify(
-      bindingsArray(binding).map(([variable, value]) => [variable.name, fieldIdentityToken(value)])
-    );
+    const key = bindingsKey(binding);
     if (!seen.has(key)) {
       seen.add(key);
       unique.push(binding);
@@ -1831,16 +1939,16 @@ function groundAtomKey(atom) {
   const fields = atom.predicate.paramNames.map((name) => fieldIdentityToken(atom.fields[name]));
   return `${atom.predicate.name}:${JSON.stringify(fields)}`;
 }
-function candidateGroundAtoms(literals, rules, atom, active, search) {
+function candidateGroundAtoms(literals, rules, atom, active, search, pathCanHaveUnavailableBindings = false) {
   return search.candidates.candidates(
     atom,
     matchingGroundAtoms(literals, atom),
-    () => deriveCandidateAtoms(literals, rules, atom, active, search)
+    () => deriveCandidateAtoms(literals, rules, atom, active, search, pathCanHaveUnavailableBindings)
   ).filter(
     (candidate) => isAtomForPredicate(candidate, atom.predicate)
   );
 }
-function deriveCandidateAtoms(literals, rules, atom, active, search) {
+function deriveCandidateAtoms(literals, rules, atom, active, search, pathCanHaveUnavailableBindings = false) {
   const atoms = [];
   for (const rule of rules) {
     const ruleHead = atomForPredicate(rule.head.atom, atom.predicate);
@@ -1852,9 +1960,17 @@ function deriveCandidateAtoms(literals, rules, atom, active, search) {
       continue;
     }
     const context = { nextTemp: 0, search, candidatePredicate: atom.predicate };
-    const bodies = evaluateRuleBodyMany(literals, rules, rule.body, bindings, active, context);
+    const bodies = evaluateRuleBodyMany(
+      literals,
+      rules,
+      rule.body,
+      bindings,
+      active,
+      context,
+      pathCanHaveUnavailableBindings
+    );
     for (const body of bodies) {
-      if (!canGroundAtom(ruleHead, body.bindings)) {
+      if (body.judgment.value === "false" || !canGroundAtom(ruleHead, body.bindings)) {
         continue;
       }
       const candidate = groundAtom(ruleHead, body.bindings);

package/dist/core/solver/query-validation/utils.d.ts

@@ -23,5 +23,7 @@ export declare function isCompleteWhenOption(value: unknown): value is Readonly<
 export declare function isPrimitiveFormula(value: unknown): boolean;
 export declare function bindVariables(value: unknown, bound: Set<Var>): void;
 export declare function uniqueVariables(variables: readonly Var[]): Var[];
+/** Bindings available after an `or`: those held before it plus those every branch makes. */
+export declare function bindingsAfterOr(branchBindings: readonly ReadonlySet<Var>[], bound: ReadonlySet<Var>): Set<Var>;
 export declare function variablesIn(value: unknown): Var[];
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factbag",
-  "version": "0.0.0-alpha.0",
+  "version": "0.0.0-alpha.1",
   "keywords": [
     "logic",
     "rules-engine",