yukigo 0.2.3 → 0.3.2

package/src/interpreter/components/logic/LogicEngine.ts

@@ -1,519 +1,509 @@
-import {
-  Exist,
-  Expression,
-  Findall,
-  Forall,
-  Goal,
-  Pattern,
-  PrimitiveValue,
-  Query,
-  EnvStack,
-  LogicResult,
-  Statement,
-  Not,
-  LogicConstraint,
-  Sequence,
-  SymbolPrimitive,
-  VariablePattern,
-} from "yukigo-ast";
-import {
-  solveFindallCPS,
-  solveGoalCPS,
-  Substitution,
-  unify,
-  instantiate,
-  SuccessCont,
-  FailureCont,
-} from "./LogicResolver.js";
-import { createStream, ExpressionEvaluator } from "../../utils.js";
-import { InterpreterVisitor } from "../Visitor.js";
-import { LogicTranslator } from "./LogicTranslator.js";
-import { trampoline, Continuation, Thunk } from "../../trampoline.js";
-import { RuntimeContext, LogicSearchMode } from "../RuntimeContext.js";
-import { inspect } from "util";
-import { PatternResolver } from "../PatternMatcher.js";
-
-export type LogicExecutable = Expression | Statement | Goal | Exist | Findall;
-
-export class LogicEngine {
-  private translator: LogicTranslator;
-
-  constructor(
-    evaluator: ExpressionEvaluator,
-    private context: RuntimeContext,
-  ) {
-    this.translator = new LogicTranslator(evaluator, this.context);
-  }
-
-  public unifyExpr(
-    left: Expression,
-    right: Expression,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    return this.translator.instantiateExpressionAsPattern(
-      left,
-      new Map(),
-      (p1) => {
-        return () =>
-          this.translator.instantiateExpressionAsPattern(
-            right,
-            new Map(),
-            (p2) => {
-              return k(unify(p1, p2, new Map()) !== null);
-            },
-          );
-      },
-    );
-  }
-
-  public solveQuery(
-    node: Query,
-    k: Continuation<PrimitiveValue>,
-    modeOverride?: LogicSearchMode,
-  ): Thunk<PrimitiveValue> {
-    const mode = modeOverride || this.context.config.outputMode || "first";
-    if (mode === "all") {
-      return this.collectAllResults(node.expressions, new Map(), (results) =>
-        k(results.map((s) => this.formatLogicResult(s))),
-      );
-    } else if (mode === "stream") {
-      return k(this.createLazyStream(node.expressions, new Map()));
-    }
-    // "first" mode
-    return this.solveConjunction(
-      node.expressions,
-      new Map(),
-      (s) => k(this.formatLogicResult(s)),
-      () => k(false),
-    );
-  }
-
-  public solveGoal(
-    node: Goal,
-    k: Continuation<PrimitiveValue>,
-    modeOverride?: LogicSearchMode,
-  ): Thunk<PrimitiveValue> {
-    return this.prepareLogicTargetCPS(node, new Map(), ({ id, patterns }) => {
-      // Goals evaluated as expressions should usually default to "first"
-      // to avoid combinatorial explosion when they are part of a sequence.
-      const mode = modeOverride || this.context.config.outputMode || "first";
-      if (mode === "all") {
-        return this.collectAllResultsForGoal(
-          id,
-          patterns,
-          new Map(),
-          (results) => k(results.map((s) => this.formatLogicResult(s))),
-        );
-      } else if (mode === "stream") {
-        return k(this.createLazyStreamForGoal(id, patterns, new Map()));
-      }
-      return solveGoalCPS(
-        this.context,
-        id,
-        patterns,
-        (body, s, onSucc, onFail) =>
-          this.solveConjunction(body, s, onSucc, onFail),
-        new Map(),
-        (s) => k(this.formatLogicResult(s)),
-        () => k(false),
-      );
-    });
-  }
-
-  public solveNot(
-    node: Not,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    return () =>
-      this.solveConjunction(
-        [node.expression],
-        new Map(),
-        () => k(false),
-        () => k(true),
-      );
-  }
-
-  public solveFindall(
-    node: Findall,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<PrimitiveValue> {
-    return solveFindallCPS(
-      node,
-      new Map(),
-      (body, substs, onSuccess, onFailure) =>
-        this.solveConjunction(body, substs, onSuccess, onFailure),
-      (finalSubsts) => {
-        const pat = finalSubsts.get((node.bag as any).name.value);
-        const val = this.translator.patternToPrimitive(pat!);
-        return k(val!);
-      },
-      () => k([]),
-    );
-  }
-
-  public solveForall(
-    node: Forall,
-    k: Continuation<PrimitiveValue>,
-  ): Thunk<any> {
-    return this.solveConjunction(
-      [node.condition],
-      new Map(),
-      (condSubsts, nextCond) => {
-        return this.solveConjunction(
-          [node.action],
-          condSubsts,
-          () => nextCond,
-          () => k(false),
-        );
-      },
-      () => k(true),
-    );
-  }
-
-  public solveExist(
-    node: Exist,
-    k: Continuation<PrimitiveValue>,
-    modeOverride?: LogicSearchMode,
-  ): Thunk<PrimitiveValue> {
-    return this.prepareLogicTargetCPS(node, new Map(), ({ id, patterns }) => {
-      // Exists evaluated as expressions should usually default to "first"
-      const mode = modeOverride || this.context.config.outputMode || "first";
-      if (mode === "all") {
-        return this.collectAllResultsForGoal(
-          id,
-          patterns,
-          new Map(),
-          (results) => k(results.map((s) => this.formatLogicResult(s))),
-        );
-      } else if (mode === "stream") {
-        return k(this.createLazyStreamForGoal(id, patterns, new Map()));
-      }
-      return solveGoalCPS(
-        this.context,
-        id,
-        patterns,
-        (body, s, onSucc, onFail) =>
-          this.solveConjunction(body, s, onSucc, onFail),
-        new Map(),
-        (s) => k(this.formatLogicResult(s)),
-        () => k(false),
-      );
-    });
-  }
-
-  private solveConjunction(
-    nodes: LogicExecutable[],
-    substs: Substitution,
-    onSuccess: SuccessCont,
-    onFailure: FailureCont,
-  ): Thunk<any> {
-    if (this.context.config.debug)
-      console.log(`[LogicEngine] Solving conjunction.`);
-    if (nodes.length === 0) {
-      if (this.context.config.debug)
-        console.log(`[LogicEngine] Nothing else to solve. Success.`);
-      return onSuccess(substs, onFailure);
-    }
-
-    const [head, ...tail] = nodes;
-
-    return () =>
-      this.solveSingle(
-        head,
-        substs,
-        (newSubsts, next) => {
-          return this.solveConjunction(tail, newSubsts, onSuccess, next);
-        },
-        onFailure,
-      );
-  }
-
-  private solveSingle(
-    node: LogicExecutable,
-    substs: Substitution,
-    onSuccess: SuccessCont,
-    onFailure: FailureCont,
-  ): Thunk<any> {
-    if (this.isLogicGoal(node))
-      return () => this.solveLogicGoal(node, substs, onSuccess, onFailure);
-    return () => this.solveCondition(node, substs, onSuccess, onFailure);
-  }
-
-  private solveLogicGoal(
-    goal: Goal | Exist | Findall | LogicConstraint | Sequence,
-    substs: Substitution,
-    onSuccess: SuccessCont,
-    onFailure: FailureCont,
-  ): Thunk<any> {
-    if (goal instanceof LogicConstraint) {
-      return () =>
-        this.solveConjunction([goal.expression], substs, onSuccess, onFailure);
-    }
-
-    if (goal instanceof Sequence) {
-      return () =>
-        this.solveConjunction(goal.statements, substs, onSuccess, onFailure);
-    }
-
-    if (goal instanceof Findall) {
-      return solveFindallCPS(
-        goal,
-        substs,
-        (body, s, onSucc, onFail) =>
-          this.solveConjunction(body, s, onSucc, onFail),
-        onSuccess,
-        onFailure,
-      );
-    }
-    if (this.context.config.debug) {
-      console.log(
-        `[LogicEngine] Solving logic goal: ${goal.identifier.value}.`,
-      );
-    }
-
-    return this.prepareLogicTargetCPS(goal, substs, ({ id, patterns }) => {
-      return solveGoalCPS(
-        this.context,
-        id,
-        patterns,
-        (body, s, onSucc, onFail) =>
-          this.solveConjunction(body, s, onSucc, onFail),
-        substs,
-        onSuccess,
-        onFailure,
-      );
-    });
-  }
-
-  private solveCondition(
-    expr: Expression | Statement,
-    substs: Substitution,
-    onSuccess: SuccessCont,
-    onFailure: FailureCont,
-  ): Thunk<any> {
-    this.createLocalEnv(substs);
-    const localEvaluator = new InterpreterVisitor(this.context);
-
-    return localEvaluator.evaluate(expr, (result) => {
-      if (result !== undefined && result !== false) {
-        let currentSubsts = new Map(substs);
-        for (const [name, val] of this.context.env.head) {
-          const pat = this.translator.primitiveToPattern(val);
-          const unified = unify(
-            new VariablePattern(new SymbolPrimitive(name)),
-            pat,
-            currentSubsts,
-          );
-          if (unified) {
-            currentSubsts = unified;
-          } else {
-            return onFailure();
-          }
-        }
-        return onSuccess(currentSubsts, onFailure);
-      }
-      return onFailure();
-    });
-  }
-
-  private isLogicGoal(
-    node: LogicExecutable,
-  ): node is Goal | Exist | Findall | LogicConstraint | Sequence {
-    return (
-      node instanceof Goal ||
-      node instanceof Exist ||
-      node instanceof Findall ||
-      node instanceof LogicConstraint ||
-      node instanceof Sequence
-    );
-  }
-
-  private createLocalEnv(substs: Substitution) {
-    this.context.pushEnv(new Map());
-    for (const [name, pattern] of substs) {
-      const resolvedPattern = instantiate(pattern, substs);
-      const value = this.translator.patternToPrimitive(resolvedPattern);
-
-      this.context.define(name, value);
-
-      // map base name if it was standardized apart ("X_1" -> "X")
-      const baseNameMatch = name.match(/^(.*)_\d+$/);
-      if (baseNameMatch) {
-        const baseName = baseNameMatch[1];
-        if (!this.context.env.head.has(baseName)) {
-          this.context.define(baseName, value);
-        }
-      }
-    }
-  }
-
-  private prepareLogicTargetCPS(
-    node: Goal | Exist,
-    substs: Substitution,
-    k: (res: { id: string; patterns: Pattern[] }) => Thunk<any>,
-  ): Thunk<any> {
-    const id = node.identifier.value;
-    if (node instanceof Goal) {
-      const patterns: Pattern[] = [];
-      const next = (index: number): Thunk<any> => {
-        if (index >= node.args.length) return k({ id, patterns });
-        return this.translator.instantiateExpressionAsPattern(
-          node.args[index],
-          substs,
-          (p) => {
-            patterns.push(p);
-            return () => next(index + 1);
-          },
-        );
-      };
-      return () => next(0);
-    } else {
-      const patterns = node.patterns.map((pat) => instantiate(pat, substs));
-      return k({ id, patterns });
-    }
-  }
-
-  private collectAllResults(
-    nodes: LogicExecutable[],
-    substs: Substitution,
-    k: (results: Substitution[]) => Thunk<any>,
-  ): Thunk<any> {
-    const results: Substitution[] = [];
-    return this.solveConjunction(
-      nodes,
-      substs,
-      (s, next) => {
-        if (this.context.config.debug)
-          console.log(
-            `[LogicEngine] Pushing { ${Array.from(s).map(([k, pat]) => `${k} -> ${pat.accept(new PatternResolver())}`)} } to results`,
-          );
-        results.push(s);
-        if (this.context.config.debug)
-          console.log(
-            `[LogicEngine] Collected results: ${results.map((s) => `{ ${Array.from(s).map(([k, pat]) => `${k} -> ${pat.accept(new PatternResolver())}`)} }`)}`,
-          );
-        return next;
-      },
-      () => k(results),
-    );
-  }
-
-  private collectAllResultsForGoal(
-    id: string,
-    patterns: Pattern[],
-    substs: Substitution,
-    k: (results: Substitution[]) => Thunk<any>,
-  ): Thunk<any> {
-    const results: Substitution[] = [];
-    return solveGoalCPS(
-      this.context,
-      id,
-      patterns,
-      (body, s, onSucc, onFail) =>
-        this.solveConjunction(body, s, onSucc, onFail),
-      substs,
-      (s, next) => {
-        results.push(s);
-        return next;
-      },
-      () => k(results),
-    );
-  }
-
-  private createLazyStream(
-    nodes: LogicExecutable[],
-    substs: Substitution,
-  ): any {
-    let currentSubst: Substitution | null = null;
-    let currentNext: (() => Thunk<any>) | null = null;
-
-    let thunk = this.solveConjunction(
-      nodes,
-      substs,
-      (s, next) => {
-        currentSubst = s;
-        currentNext = next;
-        return null;
-      },
-      () => {
-        currentSubst = null;
-        return null;
-      },
-    );
-
-    return createStream(() => {
-      return {
-        next: () => {
-          trampoline(thunk);
-          if (currentSubst) {
-            const res = this.formatLogicResult(currentSubst);
-            thunk = currentNext!();
-            return { value: res, done: false };
-          }
-          return { value: undefined, done: true };
-        },
-      } as any;
-    });
-  }
-
-  private createLazyStreamForGoal(
-    id: string,
-    patterns: Pattern[],
-    substs: Substitution,
-  ): any {
-    let currentSubst: Substitution | null = null;
-    let currentNext: (() => Thunk<any>) | null = null;
-
-    let thunk = solveGoalCPS(
-      this.context,
-      id,
-      patterns,
-      (body, s, onSucc, onFail) =>
-        this.solveConjunction(body, s, onSucc, onFail),
-      substs,
-      (s, next) => {
-        currentSubst = s;
-        currentNext = next;
-        return null;
-      },
-      () => {
-        currentSubst = null;
-        return null;
-      },
-    );
-
-    return createStream(() => {
-      return {
-        next: () => {
-          trampoline(thunk);
-          if (currentSubst) {
-            const res = this.formatLogicResult(currentSubst);
-            thunk = currentNext!();
-            return { value: res, done: false };
-          }
-          return { value: undefined, done: true };
-        },
-      } as any;
-    });
-  }
-
-  private formatLogicResult(substs: Substitution): LogicResult {
-    const solutions = new Map<string, PrimitiveValue>();
-    substs.forEach((pattern, key) => {
-      const val = this.translator.patternToPrimitive(pattern);
-      if (val !== undefined) {
-        solutions.set(key, val);
-
-        // Also map base name if it was standardized apart (e.g., "X_1" -> "X")
-        const baseNameMatch = key.match(/^(.*)_\d+$/);
-        if (baseNameMatch) {
-          const baseName = baseNameMatch[1];
-          if (!solutions.has(baseName)) {
-            solutions.set(baseName, val);
-          }
-        }
-      }
-    });
-    return { success: true, solutions };
-  }
-}
+import {
+  Exist,
+  Expression,
+  Findall,
+  Forall,
+  Goal,
+  Query,
+  Statement,
+  Not,
+  LogicConstraint,
+  Sequence,
+  UnifyOperation,
+  AssignOperation,
+  Assert,
+  Call,
+  If,
+} from "yukigo-ast";
+import { solveGoalKernel } from "./LogicResolver.js";
+import { LogicTranslator } from "./LogicTranslator.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import {
+  ExecutionCommand,
+  StepCommand,
+  BindCommand,
+  ChoiceCommand,
+  NotCommand,
+  FindallCommand,
+  BacktrackCommand,
+} from "../kernel/commands.js";
+import { VariableTerm, CompoundTerm, ConstantTerm } from "./LogicTerm.js";
+import { error, raise } from "../../utils.js";
+import { YuValue } from "../../primitives/YuValue.js";
+import {
+  Substitution,
+  YuArray,
+  LogicTerm,
+  LogicResult,
+  LogicAnswer,
+  isLogicTerm,
+  YuBoolean,
+  isLogicResult,
+  YuNil,
+  YuString,
+} from "../../primitives/index.js";
+import { Evaluator } from "../evaluators/BaseEvaluator.js";
+import { InterpreterVisitor } from "../evaluators/index.js";
+
+export type LogicExecutable =
+  | Expression
+  | Statement
+  | Goal
+  | Exist
+  | Findall
+  | Forall
+  | Not
+  | Assert
+  | Call
+  | If;
+
+export type Scope = Map<string, VariableTerm>;
+
+type NodeSolver = (
+  node: LogicExecutable,
+  substs: Substitution,
+  scope?: Scope,
+) => ExecutionCommand;
+
+export class LogicEngine {
+  private translator: LogicTranslator;
+  private readonly dispatch: Map<string, NodeSolver>;
+
+  constructor(
+    evaluator: Evaluator,
+    private context: RuntimeContext,
+  ) {
+    if (!this.context.logicState) {
+      this.context.logicState = {
+        variableCounter: 0,
+        idToName: new Map<number, string>(),
+      };
+    }
+    this.translator = new LogicTranslator(evaluator, this.context);
+    this.dispatch = this.buildDispatch();
+  }
+
+  private buildDispatch(): Map<string, NodeSolver> {
+    const goalKernel = (
+      node: Goal | Exist,
+      substs: Substitution,
+      scope?: Scope,
+    ) =>
+      new BindCommand(
+        this.resolveTerms(node, substs, scope),
+        (termsRes: YuValue) => {
+          const terms = termsRes.asSequence;
+          if (!terms || !(terms instanceof YuArray))
+            return raise(error("LogicEngine", "Expected array of terms"));
+          return this.runKernel(node, terms.items as LogicTerm[], substs);
+        },
+      );
+
+    return new Map<string, NodeSolver>([
+      [
+        "Sequence",
+        (node, substs, scope) =>
+          this.solveConjunction((node as Sequence).statements, substs, scope),
+      ],
+      [
+        "LogicConstraint",
+        (node, substs, scope) =>
+          this.solveConjunction(
+            [(node as LogicConstraint).expression],
+            substs,
+            scope,
+          ),
+      ],
+      [
+        "UnifyOperation",
+        (node, substs, scope) => {
+          const op = node as UnifyOperation;
+          return new BindCommand(
+            this.unifyExpr(op.left, op.right, substs, scope),
+            (res) => {
+              const isMatch = res instanceof YuBoolean && res.value;
+              if (isMatch)
+                return new StepCommand(
+                  new LogicResult([new LogicAnswer(true, substs)]),
+                );
+              return new BacktrackCommand();
+            },
+          );
+        },
+      ],
+      [
+        "AssignOperation",
+        (node, substs, scope) =>
+          this.solveAssign(node as AssignOperation, substs, scope),
+      ],
+      [
+        "Findall",
+        (node, substs, scope) =>
+          this.solveFindall(node as Findall, substs, scope),
+      ],
+      [
+        "Forall",
+        (node, substs, scope) =>
+          this.solveForall(node as Forall, substs, scope),
+      ],
+      ["Not", (node, substs, scope) => this.solveNot(node as Not, substs, scope)],
+      ["Goal", (node, substs, scope) => goalKernel(node as Goal, substs, scope)],
+      [
+        "Exist",
+        (node, substs, scope) => goalKernel(node as Exist, substs, scope),
+      ],
+      ["If", (node, substs, scope) => this.solveIf(node as If, substs, scope)],
+      [
+        "Call",
+        (node, substs, scope) => {
+          const callNode = node as Call;
+          return new BindCommand(
+            this.translator.expressionToTerm(callNode.callee, scope),
+            (calleeTermVal) => {
+              const calleeTerm = (calleeTermVal as LogicTerm)
+                .instantiate(substs)
+                .resolve(substs);
+              return new BindCommand(
+                this.resolveArgSequentially(callNode.args, substs, scope),
+                (argsRes) => {
+                  const resolvedArgs = (argsRes as YuArray)
+                    .items as LogicTerm[];
+                  let targetPredicate: string;
+                  let targetArgs: LogicTerm[];
+
+                  if (calleeTerm.logicTermType === "Compound") {
+                    const comp = calleeTerm as CompoundTerm;
+                    targetPredicate = comp.functor;
+                    targetArgs = [...comp.args, ...resolvedArgs];
+                  } else if (calleeTerm.logicTermType === "Constant") {
+                    const constTerm = calleeTerm as ConstantTerm;
+                    const val = constTerm.value;
+                    if (val instanceof YuString) {
+                      targetPredicate = val.value;
+                      targetArgs = resolvedArgs;
+                    } else {
+                      return new BacktrackCommand();
+                    }
+                  } else {
+                    return new BacktrackCommand();
+                  }
+
+                  return solveGoalKernel(
+                    this.context,
+                    targetPredicate,
+                    targetArgs,
+                    (body, s, scp) => this.solveConjunction(body, s, scp),
+                    substs,
+                    this.translator,
+                  );
+                },
+              );
+            },
+          );
+        },
+      ],
+    ]);
+  }
+
+  public unifyExpr(
+    left: Expression,
+    right: Expression,
+    substs: Substitution = new Map(),
+    scope?: Scope,
+  ): ExecutionCommand {
+    return new BindCommand(
+      this.translator.expressionToTerm(left, scope),
+      (leftTerm: YuValue) => {
+        if (!isLogicTerm(leftTerm)) return new BacktrackCommand();
+        return new BindCommand(
+          this.translator.expressionToTerm(right, scope),
+          (rightTerm: YuValue) => {
+            if (!isLogicTerm(rightTerm)) return new BacktrackCommand();
+
+            return leftTerm.unify(rightTerm, substs);
+          },
+        );
+      },
+    );
+  }
+
+  public solveQuery(node: Query): ExecutionCommand {
+    const scope: Scope = new Map();
+    const compiled = this.solveConjunction(node.expressions, new Map(), scope);
+    return this.aggregateResults(compiled, scope);
+  }
+
+  public solveGoalLike(
+    node: Goal | Exist,
+    outerSubsts?: Substitution,
+    outerScope?: Scope,
+  ): ExecutionCommand {
+    const scope: Scope = outerScope ?? new Map();
+    const substs: Substitution = outerSubsts ?? new Map();
+    return new BindCommand(
+      this.resolveTerms(node, substs, scope),
+      (termsRes: YuValue) => {
+        const termsSeq = termsRes.asSequence;
+        if (!(termsSeq instanceof YuArray)) return new BacktrackCommand();
+        const terms = termsSeq.items;
+        if (!terms.every(isLogicTerm)) return new BacktrackCommand();
+        return this.runKernel(node, terms, substs);
+      },
+    );
+  }
+
+  public solveNot(
+    node: Not,
+    substs: Substitution = new Map(),
+    scope: Scope = new Map(),
+  ): ExecutionCommand {
+    const clonedSubsts = new Map(substs);
+    const innerGoalCmd = this.solveConjunction(
+      [node.expression],
+      clonedSubsts,
+      scope,
+    );
+    return new NotCommand(innerGoalCmd, substs);
+  }
+
+  public solveFindall(
+    node: Findall,
+    substs: Substitution = new Map(),
+    scope: Scope = new Map(),
+  ): ExecutionCommand {
+    const clonedSubsts = new Map(substs);
+    const innerGoalCmd = this.solveConjunction(
+      [node.goal],
+      clonedSubsts,
+      scope,
+    );
+    return new FindallCommand(
+      node.template,
+      node.bag,
+      innerGoalCmd,
+      substs,
+      scope,
+      this.translator,
+    );
+  }
+
+  private solveAssign(
+    op: AssignOperation,
+    substs: Substitution,
+    scope?: Scope,
+  ): ExecutionCommand {
+    const localEnv = this.createLocalEnv(substs);
+    const isolatedContext = new RuntimeContext(this.context.config);
+    isolatedContext.logicState = this.context.logicState;
+    isolatedContext.setEnv({ head: localEnv, tail: this.context.env });
+    const localEvaluator = new InterpreterVisitor(isolatedContext);
+
+    return new BindCommand(localEvaluator.evaluate(op.right), (val) => {
+      const resultTerm = this.translator.primitiveToTerm(val);
+      return new BindCommand(
+        this.translator.expressionToTerm(op.left, scope),
+        (leftTerm: YuValue) => {
+          if (!isLogicTerm(leftTerm)) return new BacktrackCommand();
+          if (leftTerm.unify(resultTerm, substs)) {
+            return new StepCommand(
+              new LogicResult([new LogicAnswer(true, substs)]),
+            );
+          }
+          return new BacktrackCommand();
+        },
+      );
+    });
+  }
+
+  public solveForall(
+    node: Forall,
+    substs: Substitution = new Map(),
+    scope: Scope = new Map(),
+  ): ExecutionCommand {
+    // a forall(Cond, Action) is equivalent to \+ (Cond, \+ Action)
+    return this.solveNot(
+      new Not(new Sequence([node.condition, new Not(node.action)])),
+      substs,
+      scope,
+    );
+  }
+
+  private aggregateResults(
+    command: ExecutionCommand,
+    scope: Scope,
+  ): ExecutionCommand {
+    return new BindCommand(command, (res: YuValue) => {
+      if (!isLogicResult(res)) return new StepCommand(res);
+      const mappedAnswers = res.allAnswers.map((ans) =>
+        this.finalizeUserResult(ans, scope),
+      );
+      return new StepCommand(new LogicResult(mappedAnswers));
+    });
+  }
+
+  private branchSolutions(
+    solutions: Substitution[],
+    tail: LogicExecutable[],
+    scope?: Scope,
+  ): ExecutionCommand {
+    if (solutions.length === 0) return new BacktrackCommand();
+
+    if (solutions.length === 1) {
+      return this.solveConjunction(tail, solutions[0], scope);
+    }
+    return new ChoiceCommand(
+      solutions.map((s) => this.solveConjunction(tail, s, scope)),
+    );
+  }
+
+  public solveConjunction(
+    nodes: LogicExecutable[],
+    substs: Substitution,
+    scope?: Scope,
+  ): ExecutionCommand {
+    if (nodes.length === 0) {
+      return new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
+    }
+
+    const [head, ...tail] = nodes;
+    const solver: NodeSolver =
+      this.dispatch.get(head.constructor.name) ??
+      ((node, s) => this.solveCondition(node as Expression | Statement, s));
+
+    const currentSubst = new Map(substs);
+
+    return new BindCommand(
+      solver(head, currentSubst, scope),
+      (res: YuValue) => {
+        // fail if result not a LogicResult or if some conditionfail
+        if (!isLogicResult(res) || !res.allSuccessful())
+          return new BacktrackCommand();
+
+        return this.branchSolutions(res.getSuccessfulSolutions(), tail, scope);
+      },
+    );
+  }
+
+  private solveCondition(
+    expr: Expression | Statement | Assert,
+    substs: Substitution,
+  ): ExecutionCommand {
+    const localEnv = this.createLocalEnv(substs);
+    const isolatedContext = new RuntimeContext(this.context.config);
+    isolatedContext.logicState = this.context.logicState;
+    isolatedContext.setEnv({ head: localEnv, tail: this.context.env });
+    const localEvaluator = new InterpreterVisitor(isolatedContext);
+
+    return new BindCommand(localEvaluator.evaluate(expr), (result: YuValue) => {
+      // fail if result is falsy
+      const isTrue =
+        (result instanceof YuBoolean && result.value) ||
+        (result instanceof LogicResult && result.success) ||
+        result instanceof YuNil;
+      if (!isTrue) return new BacktrackCommand();
+
+      return new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
+    });
+  }
+
+  private createLocalEnv(substs: Substitution): Map<string, YuValue> {
+    const env = new Map<string, YuValue>();
+    for (const [id, term] of substs) {
+      const name = typeof id === "string" ? id : this.translator.getName(id);
+      if (name) env.set(name, term.instantiate(substs).toPrimitive(substs));
+    }
+    return env;
+  }
+
+  private finalizeUserResult(ans: LogicAnswer, scope: Scope): LogicAnswer {
+    const solution = ans.getSolution();
+
+    const fromScope: [string, LogicTerm][] = Array.from(scope.entries()).map(
+      ([name, term]) => [name, term.instantiate(solution)],
+    );
+
+    const fromSolution: [string, LogicTerm][] = Array.from(
+      solution.entries(),
+    ).map(([id, term]) => [
+      typeof id === "number" ? this.translator.getName(id)! : (id as string),
+      term.instantiate(solution),
+    ]);
+
+    const userMapped: Substitution = new Map(
+      [fromSolution, fromScope].flatMap((s) => [...s]),
+    );
+
+    return new LogicAnswer(ans.isSuccessful(), userMapped);
+  }
+
+  private resolveTerms(
+    node: Goal | Exist,
+    substs: Substitution,
+    scope?: Scope,
+  ): ExecutionCommand {
+    if (node.is(Goal))
+      return this.resolveArgSequentially(node.args, substs, scope);
+
+    const terms = node.patterns.map((pat) =>
+      this.translator.patternToTerm(pat, scope).instantiate(substs),
+    );
+    return new StepCommand(new YuArray(terms));
+  }
+  private resolveArgSequentially(
+    args: Expression[],
+    substs: Substitution,
+    scope?: Scope,
+  ): ExecutionCommand {
+    const terms: LogicTerm[] = [];
+    const next = (index: number): ExecutionCommand => {
+      if (index >= args.length) {
+        return new StepCommand(new YuArray(terms));
+      }
+      return new BindCommand(
+        this.translator.instantiateExpressionAsTerm(args[index], substs, scope),
+        (t) => {
+          if (isLogicTerm(t)) terms.push(t);
+          return next(index + 1);
+        },
+      );
+    };
+    return next(0);
+  }
+
+  private runKernel(
+    node: Goal | Exist,
+    terms: LogicTerm[],
+    substs: Substitution,
+  ): ExecutionCommand {
+    return solveGoalKernel(
+      this.context,
+      node.identifier.value,
+      terms,
+      (body, s, scp) => this.solveConjunction(body, s, scp),
+      substs,
+      this.translator,
+    );
+  }
+
+  private solveIf(
+    node: If,
+    substs: Substitution,
+    scope?: Scope,
+  ): ExecutionCommand {
+    return new BindCommand(
+      this.solveConjunction([node.condition], substs, scope),
+      (res: YuValue) => {
+        if (isLogicResult(res) && res.allSuccessful()) {
+          const solutions = res.getSuccessfulSolutions();
+          if (solutions.length === 1) {
+            return this.solveConjunction([node.then], solutions[0], scope);
+          }
+          return new ChoiceCommand(
+            solutions.map((s) => this.solveConjunction([node.then], s, scope)),
+          );
+        }
+        return this.solveConjunction([node.elseExpr], substs, scope);
+      },
+    );
+  }
+}