yukigo 0.2.2 → 0.3.1

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

@@ -1,858 +1,209 @@
-import {
-  EnvStack,
-  Fact,
-  FunctorPattern,
-  ListPattern,
-  LiteralPattern,
-  Pattern,
-  Rule,
-  VariablePattern,
-  WildcardPattern,
-  isRuntimePredicate,
-  UnguardedBody,
-  Findall,
-  ConsPattern,
-  Equation,
-  SymbolPrimitive,
-  Goal,
-  Exist,
-  LogicConstraint,
-  Sequence,
-  Not,
-  ComparisonOperation,
-  UnifyOperation,
-  ApplicationPattern,
-  TuplePattern,
-  ConstructorPattern,
-  UnionPattern,
-  AsPattern,
-  PatternVisitor,
-  TypePattern,
-  AssignOperation,
-  ArithmeticBinaryOperation,
-  ArithmeticUnaryOperation,
-  ConsExpression,
-  ListPrimitive,
-  TupleExpression,
-  If,
-  Forall,
-  Call,
-  ListBinaryOperation,
-  ListUnaryOperation,
-  LogicalBinaryOperation,
-  LogicalUnaryOperation,
-  BitwiseBinaryOperation,
-  BitwiseUnaryOperation,
-  StringOperation,
-  NumberPrimitive,
-  StringPrimitive,
-  BooleanPrimitive,
-  NilPrimitive,
-  CharPrimitive,
-  Visitor,
-  isUnguardedBody,
-  GuardedBody,
-} from "yukigo-ast";
-import { Thunk } from "../../trampoline.js";
-import { LogicExecutable } from "./LogicEngine.js";
-import { RuntimeContext } from "../RuntimeContext.js";
-
-/**
- * A Substitution maps variable names to their bound patterns.
- */
-export type Substitution = Map<string, Pattern>;
-
-/**
- * Internal result of a logic operation.
- */
-export type InternalLogicResult = { success: true; substs: Substitution };
-
-/**
- * Backtracking continuations.
- */
-export type SuccessCont = (
-  substs: Substitution,
-  next: () => Thunk<any>,
-) => Thunk<any>;
-export type FailureCont = () => Thunk<any>;
-
-/**
- * A function that can solve a sequence of logic goals/expressions in CPS.
- */
-export type BodySolverCPS = (
-  expressions: LogicExecutable[],
-  env: Substitution,
-  onSuccess: SuccessCont,
-  onFailure: FailureCont,
-) => Thunk<any>;
-
-/**
- * Creates a successful logic result.
- */
-export function success(substs: Substitution): InternalLogicResult {
-  return { success: true, substs };
-}
-
-/**
- * Unifies two patterns given an existing set of substitutions.
- * Returns the updated substitution map or null if unification fails.
- */
-export function unify(
-  t1: Pattern,
-  t2: Pattern,
-  argEnv?: Substitution,
-): Substitution | null {
-  const env: Substitution = argEnv ? new Map(argEnv) : new Map();
-  return unifyInPlace(t1, t2, env) ? env : null;
-}
-
-/**
- * Internal unification that modifies the environment in place for efficiency during recursion.
- */
-function unifyInPlace(t1: Pattern, t2: Pattern, env: Substitution): boolean {
-  const r1 = resolve(t1, env);
-  const r2 = resolve(t2, env);
-
-  if (r1 === r2) return true;
-
-  if (r1 instanceof WildcardPattern || r2 instanceof WildcardPattern) {
-    return true;
-  }
-
-  if (r1 instanceof VariablePattern) {
-    env.set(r1.name.value, r2);
-    return true;
-  }
-  if (r2 instanceof VariablePattern) {
-    env.set(r2.name.value, r1);
-    return true;
-  }
-
-  if (r1 instanceof LiteralPattern && r2 instanceof LiteralPattern) {
-    return r1.name.equals(r2.name);
-  }
-
-  if (r1 instanceof FunctorPattern && r2 instanceof FunctorPattern) {
-    if (r1.identifier.value !== r2.identifier.value) return false;
-    if (r1.args.length !== r2.args.length) return false;
-
-    for (let i = 0; i < r1.args.length; i++) {
-      if (!unifyInPlace(r1.args[i], r2.args[i], env)) return false;
-    }
-    return true;
-  }
-
-  if (r1 instanceof ListPattern && r2 instanceof ListPattern) {
-    if (r1.elements.length !== r2.elements.length) return false;
-    for (let i = 0; i < r1.elements.length; i++) {
-      if (!unifyInPlace(r1.elements[i], r2.elements[i], env)) return false;
-    }
-    return true;
-  }
-
-  if (r1 instanceof ConsPattern && r2 instanceof ConsPattern) {
-    let curr1: Pattern = r1;
-    let curr2: Pattern = r2;
-
-    while (curr1 instanceof ConsPattern && curr2 instanceof ConsPattern) {
-      if (!unifyInPlace(curr1.left, curr2.left, env)) return false;
-      curr1 = resolve(curr1.right, env);
-      curr2 = resolve(curr2.right, env);
-    }
-    return unifyInPlace(curr1, curr2, env);
-  }
-
-  if (r1 instanceof ConsPattern && r2 instanceof ListPattern) {
-    if (r2.elements.length === 0) return false;
-    const [head, ...tail] = r2.elements;
-    return (
-      unifyInPlace(r1.left, head, env) &&
-      unifyInPlace(r1.right, new ListPattern(tail), env)
-    );
-  }
-
-  if (r1 instanceof ListPattern && r2 instanceof ConsPattern) {
-    if (r1.elements.length === 0) return false;
-    const [head, ...tail] = r1.elements;
-    return (
-      unifyInPlace(head, r2.left, env) &&
-      unifyInPlace(new ListPattern(tail), r2.right, env)
-    );
-  }
-
-  return false;
-}
-
-/**
- * Follows variable bindings in the substitution map until a non-variable or unbound variable is found.
- */
-export function resolve(node: Pattern, env: Substitution): Pattern {
-  let current = node;
-  const seen = new Set<string>();
-  while (current instanceof VariablePattern) {
-    const name = current.name.value;
-    if (seen.has(name)) break;
-    seen.add(name);
-    const bound = env.get(name);
-    if (!bound) break;
-    current = bound;
-  }
-  return current;
-}
-
-class Instantiator implements PatternVisitor<Pattern> {
-  constructor(
-    private substs: Substitution,
-    private seen: Set<string> = new Set(),
-  ) {}
-
-  visitVariablePattern(node: VariablePattern): Pattern {
-    const name = node.name.value;
-    if (this.seen.has(name)) return node;
-    const val = this.substs.get(name);
-    if (val) {
-      const nextSeen = new Set(this.seen);
-      nextSeen.add(name);
-      return new Instantiator(this.substs, nextSeen).instantiate(val);
-    }
-    return node;
-  }
-
-  visitLiteralPattern(node: LiteralPattern): Pattern {
-    return node;
-  }
-
-  visitApplicationPattern(node: ApplicationPattern): Pattern {
-    return new ApplicationPattern(
-      node.identifier,
-      node.args.map((arg) => this.instantiate(arg)),
-      node.loc,
-    );
-  }
-
-  visitTuplePattern(node: TuplePattern): Pattern {
-    return new TuplePattern(
-      node.elements.map((el) => this.instantiate(el)),
-      node.loc,
-    );
-  }
-
-  visitListPattern(node: ListPattern): Pattern {
-    return new ListPattern(
-      node.elements.map((el) => this.instantiate(el)),
-      node.loc,
-    );
-  }
-
-  visitFunctorPattern(node: FunctorPattern): Pattern {
-    return new FunctorPattern(
-      node.identifier,
-      node.args.map((arg) => this.instantiate(arg)),
-      node.loc,
-    );
-  }
-
-  visitAsPattern(node: AsPattern): Pattern {
-    return new AsPattern(
-      this.instantiate(node.left) as any,
-      this.instantiate(node.right),
-      node.loc,
-    );
-  }
-
-  visitWildcardPattern(node: WildcardPattern): Pattern {
-    return node;
-  }
-
-  visitUnionPattern(node: UnionPattern): Pattern {
-    return new UnionPattern(
-      node.elements.map((el) => this.instantiate(el)),
-      node.loc,
-    );
-  }
-
-  visitConstructorPattern(node: ConstructorPattern): Pattern {
-    return new ConstructorPattern(
-      node.identifier,
-      node.args.map((arg) => this.instantiate(arg)),
-      node.loc,
-    );
-  }
-
-  visitConsPattern(node: ConsPattern): Pattern {
-    return new ConsPattern(
-      this.instantiate(node.left),
-      this.instantiate(node.right),
-      node.loc,
-    );
-  }
-
-  visitTypePattern(node: TypePattern): Pattern {
-    return new TypePattern(
-      node.targetType,
-      node.innerPattern ? this.instantiate(node.innerPattern) : undefined,
-      node.loc,
-    );
-  }
-
-  instantiate(pattern: Pattern): Pattern {
-    return pattern.accept(this);
-  }
-}
-
-/**
- * Fully instantiates a pattern by replacing all bound variables with their values.
- */
-export function instantiate(
-  pattern: Pattern,
-  substs: Substitution,
-  seen: Set<string> = new Set(),
-): Pattern {
-  return new Instantiator(substs, seen).instantiate(pattern);
-}
-
-let variableCounter = 0;
-
-class LogicVariableRenamer implements PatternVisitor<Pattern> {
-  constructor(
-    private renames: Map<string, string>,
-    private freshId: number,
-  ) {}
-
-  public rename(node: any): any {
-    if (!node || typeof node !== "object") return node;
-    if (typeof node.accept === "function") {
-      return node.accept(this);
-    }
-    return node;
-  }
-
-  visitFact(node: Fact): Fact {
-    return new Fact(
-      node.identifier,
-      node.patterns.map((p) => this.rename(p)),
-      node.loc,
-    );
-  }
-  visitRule(node: Rule): Rule {
-    const renamedEquations = node.equations.map((eq) => {
-      const body = eq.body;
-      if (!isUnguardedBody(body))
-        throw new Error("GuardedBody renaming not implemented");
-      return new Equation(
-        eq.patterns.map((p) => this.rename(p)),
-        body.accept(this),
-        eq.returnExpr,
-        eq.loc,
-      );
-    });
-    return new Rule(node.identifier, renamedEquations, node.loc);
-  }
-  visitUnguardedBody(node: UnguardedBody): UnguardedBody {
-    return new UnguardedBody(
-      new Sequence(
-        node.sequence.statements.map((stmt) => this.rename(stmt)),
-        node.sequence.loc,
-      ),
-      node.loc,
-    );
-  }
-
-  // PatternVisitor
-  visitVariablePattern(node: VariablePattern): Pattern {
-    const name = node.name.value;
-    let newName = this.renames.get(name);
-    if (!newName) {
-      newName = `${name}_${this.freshId}`;
-      this.renames.set(name, newName);
-    }
-    return new VariablePattern(new SymbolPrimitive(newName), node.loc);
-  }
-
-  visitLiteralPattern(node: LiteralPattern): Pattern {
-    return node;
-  }
-
-  visitApplicationPattern(node: ApplicationPattern): Pattern {
-    return new ApplicationPattern(
-      node.identifier,
-      node.args.map((arg) => this.rename(arg)),
-      node.loc,
-    );
-  }
-
-  visitTuplePattern(node: TuplePattern): Pattern {
-    return new TuplePattern(
-      node.elements.map((el) => this.rename(el)),
-      node.loc,
-    );
-  }
-
-  visitListPattern(node: ListPattern): Pattern {
-    return new ListPattern(
-      node.elements.map((el) => this.rename(el)),
-      node.loc,
-    );
-  }
-
-  visitFunctorPattern(node: FunctorPattern): Pattern {
-    return new FunctorPattern(
-      node.identifier,
-      node.args.map((arg) => this.rename(arg)),
-      node.loc,
-    );
-  }
-
-  visitAsPattern(node: AsPattern): Pattern {
-    return new AsPattern(
-      this.rename(node.left) as any,
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitWildcardPattern(node: WildcardPattern): Pattern {
-    return node;
-  }
-
-  visitUnionPattern(node: UnionPattern): Pattern {
-    return new UnionPattern(
-      node.elements.map((el) => this.rename(el)),
-      node.loc,
-    );
-  }
-
-  visitConstructorPattern(node: ConstructorPattern): Pattern {
-    return new ConstructorPattern(
-      node.identifier,
-      node.args.map((arg) => this.rename(arg)),
-      node.loc,
-    );
-  }
-
-  visitConsPattern(node: ConsPattern): Pattern {
-    return new ConsPattern(
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitTypePattern(node: TypePattern): Pattern {
-    return new TypePattern(
-      node.targetType,
-      node.innerPattern ? this.rename(node.innerPattern) : undefined,
-      node.loc,
-    );
-  }
-
-  // Expression/Statement Visitor
-  visitSymbolPrimitive(node: SymbolPrimitive): any {
-    const name = node.value;
-    if (/^[A-Z_]/.test(name) && name !== "_") {
-      let newName = this.renames.get(name);
-      if (!newName) {
-        newName = `${name}_${this.freshId}`;
-        this.renames.set(name, newName);
-      }
-      return new SymbolPrimitive(newName, node.loc);
-    }
-    return node;
-  }
-
-  visitNumberPrimitive(node: NumberPrimitive): any {
-    return node;
-  }
-  visitStringPrimitive(node: StringPrimitive): any {
-    return node;
-  }
-  visitBooleanPrimitive(node: BooleanPrimitive): any {
-    return node;
-  }
-  visitNilPrimitive(node: NilPrimitive): any {
-    return node;
-  }
-  visitCharPrimitive(node: CharPrimitive): any {
-    return node;
-  }
-
-  visitGoal(node: Goal): any {
-    return new Goal(
-      node.identifier,
-      node.args.map((arg) => this.rename(arg)),
-      node.loc,
-    );
-  }
-
-  visitExist(node: Exist): any {
-    return new Exist(
-      node.identifier,
-      node.patterns.map((pat) => this.rename(pat)),
-      node.loc,
-    );
-  }
-
-  visitFindall(node: Findall): any {
-    return new Findall(
-      this.rename(node.template),
-      this.rename(node.goal),
-      this.rename(node.bag),
-      node.loc,
-    );
-  }
-
-  visitForall(node: Forall): any {
-    return new Forall(this.rename(node.condition), this.rename(node.action), node.loc);
-  }
-
-  visitCall(node: Call): any {
-    return new Call(
-      this.rename(node.callee),
-      node.args.map((arg) => this.rename(arg)),
-      node.loc,
-    );
-  }
-
-  visitNot(node: Not): any {
-    return new Not(this.rename(node.expression), node.loc);
-  }
-
-  visitLogicConstraint(node: LogicConstraint): any {
-    return new LogicConstraint(this.rename(node.expression), node.loc);
-  }
-
-  visitSequence(node: Sequence): any {
-    return new Sequence(
-      node.statements.map((stmt) => this.rename(stmt)),
-      node.loc,
-    );
-  }
-
-  visitIf(node: If): any {
-    return new If(
-      this.rename(node.condition),
-      this.rename(node.then),
-      this.rename(node.elseExpr),
-      node.loc,
-    );
-  }
-
-  visitComparisonOperation(node: ComparisonOperation): any {
-    return new ComparisonOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitUnifyOperation(node: UnifyOperation): any {
-    return new UnifyOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitAssignOperation(node: AssignOperation): any {
-    return new AssignOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): any {
-    return new ArithmeticBinaryOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): any {
-    return new ArithmeticUnaryOperation(
-      node.operator,
-      this.rename(node.operand),
-      node.loc,
-    );
-  }
-
-  visitListBinaryOperation(node: ListBinaryOperation): any {
-    return new ListBinaryOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitListUnaryOperation(node: ListUnaryOperation): any {
-    return new ListUnaryOperation(
-      node.operator,
-      this.rename(node.operand),
-      node.loc,
-    );
-  }
-
-  visitLogicalBinaryOperation(node: LogicalBinaryOperation): any {
-    return new LogicalBinaryOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitLogicalUnaryOperation(node: LogicalUnaryOperation): any {
-    return new LogicalUnaryOperation(
-      node.operator,
-      this.rename(node.operand),
-      node.loc,
-    );
-  }
-
-  visitBitwiseBinaryOperation(node: BitwiseBinaryOperation): any {
-    return new BitwiseBinaryOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitBitwiseUnaryOperation(node: BitwiseUnaryOperation): any {
-    return new BitwiseUnaryOperation(
-      node.operator,
-      this.rename(node.operand),
-      node.loc,
-    );
-  }
-
-  visitStringOperation(node: StringOperation): any {
-    return new StringOperation(
-      node.operator,
-      this.rename(node.left),
-      this.rename(node.right),
-      node.loc,
-    );
-  }
-
-  visitConsExpression(node: ConsExpression): any {
-    return new ConsExpression(
-      this.rename(node.head),
-      this.rename(node.tail),
-      node.loc,
-    );
-  }
-
-  visitListPrimitive(node: ListPrimitive): any {
-    return new ListPrimitive(
-      node.value.map((el) => this.rename(el)),
-      node.loc,
-    );
-  }
-
-  visitTupleExpr(node: TupleExpression): any {
-    return new TupleExpression(
-      node.elements.map((el) => this.rename(el)),
-      node.loc,
-    );
-  }
-}
-
-/**
- * Renames all variables in a Rule or Fact to fresh names to avoid name clashes during unification.
- */
-export function renameVariables<T extends Rule | Fact>(clause: T): T {
-  const renames = new Map<string, string>();
-  const freshId = ++variableCounter;
-  const renamer = new LogicVariableRenamer(renames, freshId);
-  const renamedClause = clause.accept(renamer)
-  return renamedClause;
-}
-
-class CPSBodyVisitor implements Visitor<Thunk<any>> {
-  constructor(
-    private readonly solveBody: BodySolverCPS,
-    private readonly substs: Substitution,
-    private readonly onSuccess: SuccessCont,
-    private readonly onNextEq: Thunk<any>,
-  ) {}
-
-  public visitUnguardedBody(body: UnguardedBody): Thunk<any> {
-    return this.solveBody(
-      body.sequence.statements,
-      this.substs,
-      this.onSuccess,
-      this.onNextEq,
-    );
-  }
-
-  public visitGuardedBody(body: GuardedBody): Thunk<any> {
-    return this.solveBody(
-      [body.condition],
-      this.substs,
-      (guardSubsts: Substitution, _nextGuardChoice: Thunk<any>) => {
-        return this.solveBody(
-          [body.body],
-          guardSubsts,
-          this.onSuccess,
-          this.onNextEq,
-        );
-      },
-      this.onNextEq,
-    );
-  }
-}
-
-class GoalSolverVisitor implements Visitor<Thunk<any>> {
-  constructor(
-    private readonly args: Pattern[],
-    private readonly baseSubst: Substitution,
-    private readonly solveBody: BodySolverCPS,
-    private readonly onSuccess: SuccessCont,
-    private readonly onNextClause: Thunk<any>,
-  ) {}
-
-  public visitFact(fact: Fact): Thunk<any> {
-    if (fact.patterns.length !== this.args.length) return this.onNextClause;
-
-    const renamedFact = renameVariables(fact);
-    const substs = unifyParameters(
-      renamedFact.patterns,
-      this.args,
-      this.baseSubst,
-    );
-
-    if (substs) return this.onSuccess(substs, this.onNextClause);
-    return this.onNextClause;
-  }
-
-  public visitRule(rule: Rule): Thunk<any> {
-    if (rule.equations.length === 0) return this.onNextClause;
-
-    const arity = rule.equations[0].patterns.length;
-    if (arity !== this.args.length) return this.onNextClause;
-
-    const renamedRule = renameVariables(rule);
-
-    const tryRuleEq = (eqIndex: number): Thunk<any> => {
-      if (eqIndex >= renamedRule.equations.length) return this.onNextClause;
-
-      const eq = renamedRule.equations[eqIndex];
-      const substs = unifyParameters(eq.patterns, this.args, this.baseSubst);
-      const onNextEq = () => tryRuleEq(eqIndex + 1);
-
-      if (!substs) return onNextEq;
-
-      const bodyVisitor = new CPSBodyVisitor(
-        this.solveBody,
-        substs,
-        this.onSuccess,
-        onNextEq,
-      );
-
-      if (isUnguardedBody(eq.body)) return eq.body.accept(bodyVisitor);
-      return eq.body.forEach((branch) => branch.accept(bodyVisitor));
-    };
-
-    return () => tryRuleEq(0);
-  }
-}
-
-/**
- * Solves a single logic goal (predicate call) using CPS.
- */
-export function solveGoalCPS(
-  ctx: RuntimeContext,
-  predicateName: string,
-  args: Pattern[],
-  solveBody: BodySolverCPS,
-  baseSubst: Substitution,
-  onSuccess: SuccessCont,
-  onFailure: FailureCont,
-): Thunk<any> {
-  const tryClause = (index: number): Thunk<any> => {
-    let equations: (Rule | Fact)[];
-
-    try {
-      const pred = ctx.lookup(predicateName);
-      if (!pred || !isRuntimePredicate(pred)) return () => onFailure();
-      equations = pred.equations;
-    } catch (error) {
-      return () => onFailure();
-    }
-
-    if (index >= equations.length) return () => onFailure();
-
-    const clause = equations[index];
-    const onNextClause = () => tryClause(index + 1);
-
-    const clauseVisitor = new GoalSolverVisitor(
-      args,
-      baseSubst,
-      solveBody,
-      onSuccess,
-      onNextClause,
-    );
-
-    return clause.accept(clauseVisitor);
-  };
-
-  return () => tryClause(0);
-}
-
-/**
- * Unifies two lists of parameters. Returns the resulting Substitution or null.
- */
-function unifyParameters(
-  patterns: Pattern[],
-  args: Pattern[],
-  baseSubst: Substitution,
-): Substitution | null {
-  let subst: Substitution = new Map(baseSubst);
-  for (let i = 0; i < patterns.length; i++) {
-    const nextSubst = unify(patterns[i], args[i], subst);
-    if (!nextSubst) return null;
-    subst = nextSubst;
-  }
-  return subst;
-}
-
-/**
- * Solves a findall/3 goal using CPS.
- */
-export function solveFindallCPS(
-  node: Findall,
-  currentSubsts: Substitution,
-  solveBody: BodySolverCPS,
-  onSuccess: SuccessCont,
-  onFailure: FailureCont,
-): Thunk<any> {
-  const gathered: Pattern[] = [];
-
-  const collectResults = (): Thunk<any> => {
-    return solveBody(
-      [node.goal],
-      currentSubsts,
-      (resultSubsts, next) => {
-        gathered.push(instantiate(node.template, resultSubsts));
-        return () => next();
-      },
-      () => {
-        const resultList = new ListPattern(gathered);
-        const finalSubsts = unify(node.bag, resultList, currentSubsts);
-        if (finalSubsts) {
-          return onSuccess(finalSubsts, onFailure);
-        }
-        return () => onFailure();
-      },
-    );
-  };
-
-  return collectResults();
-}
+import {
+  Fact,
+  Rule,
+  UnguardedBody,
+  Visitor,
+  ASTNode,
+  Pattern,
+  NativeBody,
+  Guard,
+} from "yukigo-ast";
+import { LogicExecutable } from "./LogicEngine.js";
+import { RuntimeContext } from "../RuntimeContext.js";
+import { InterpreterError } from "../../errors.js";
+import {
+  ExecutionCommand,
+  StepCommand,
+  BindCommand,
+  FailCommand,
+  ChoiceCommand,
+  BacktrackCommand,
+} from "../kernel/commands.js";
+import { LogicTranslator } from "./LogicTranslator.js";
+import { VariableTerm } from "./LogicTerm.js";
+import {
+  LogicTerm,
+  Substitution,
+  isLogicResult,
+  LogicResult,
+  LogicAnswer,
+  isRuntimePredicate,
+  YuBoolean,
+  YuNil,
+} from "../../primitives/index.js";
+
+/**
+ * Unified parameter list unification.
+ */
+function unifyParameters(
+  patterns: Pattern[],
+  args: LogicTerm[],
+  baseSubst: Substitution,
+  translator: LogicTranslator,
+  scope: Map<string, VariableTerm>,
+  onSuccess: (subst: Substitution) => ExecutionCommand,
+  onFailure: () => ExecutionCommand,
+): ExecutionCommand {
+  const next = (
+    index: number,
+    currentSubst: Substitution,
+  ): ExecutionCommand => {
+    if (index >= patterns.length) {
+      return onSuccess(currentSubst);
+    }
+    const term = translator.patternToTerm(patterns[index], scope);
+    return new BindCommand(term.unify(args[index], currentSubst), (res) => {
+      if (res instanceof YuBoolean && res.value) {
+        return next(index + 1, currentSubst);
+      }
+      return onFailure();
+    });
+  };
+  return next(0, new Map(baseSubst));
+}
+
+class KernelBodyVisitor implements Visitor<ExecutionCommand> {
+  constructor(
+    private readonly solveBody: Solver,
+    private readonly substs: Substitution,
+    private readonly scope: Map<string, VariableTerm>,
+  ) {}
+
+  public visitNativeBody(body: NativeBody): ExecutionCommand {
+    return new StepCommand(YuNil.getInstance());
+  }
+
+  public visitUnguardedBody(body: UnguardedBody): ExecutionCommand {
+    return this.solveBody(body.sequence.statements, this.substs, this.scope);
+  }
+
+  public visitGuard(guard: Guard): ExecutionCommand {
+    return new BindCommand(
+      this.solveBody([guard.condition], this.substs, this.scope),
+      (res) => {
+        if (!isLogicResult(res) || !res.allSuccessful())
+          return new BacktrackCommand();
+
+        const solutions = res.getSuccessfulSolutions();
+        if (solutions.length === 1)
+          return this.solveBody([guard.body], solutions[0], this.scope);
+
+        return new ChoiceCommand(
+          solutions.map((s) => this.solveBody([guard.body], s, this.scope)),
+        );
+      },
+    );
+  }
+
+  public fallback(node: ASTNode): ExecutionCommand {
+    return new FailCommand(
+      new InterpreterError(
+        "Logic",
+        `Unexpected node ${node.constructor.name} in equation body`,
+      ),
+    );
+  }
+}
+
+type Solver = (
+  expressions: LogicExecutable[],
+  env: Substitution,
+  scope?: Map<string, VariableTerm>,
+) => ExecutionCommand;
+
+export class GoalKernelVisitor implements Visitor<ExecutionCommand> {
+  constructor(
+    private readonly args: LogicTerm[],
+    private readonly baseSubst: Substitution,
+    private readonly solveBody: Solver,
+    private readonly translator: LogicTranslator,
+  ) {}
+
+  public visitFact(fact: Fact): ExecutionCommand {
+    const scope = new Map<string, VariableTerm>();
+    const onSuccess = (substs: Substitution) =>
+      new StepCommand(new LogicResult([new LogicAnswer(true, substs)]));
+
+    return unifyParameters(
+      fact.patterns,
+      this.args,
+      this.baseSubst,
+      this.translator,
+      scope,
+      onSuccess,
+      () => new BacktrackCommand(),
+    );
+  }
+
+  public visitRule(rule: Rule): ExecutionCommand {
+    const tryEquation = (eqIndex: number): ExecutionCommand => {
+      if (eqIndex >= rule.equations.length) {
+        return new BacktrackCommand();
+      }
+
+      const eq = rule.equations[eqIndex];
+      const scope = new Map<string, VariableTerm>();
+
+      const onFailure = () => tryEquation(eqIndex + 1);
+      const onSuccess = (substs: Substitution) => {
+        const bodyVisitor = new KernelBodyVisitor(
+          this.solveBody,
+          substs,
+          scope,
+        );
+        const currentCmd = eq.body.accept(bodyVisitor);
+        return new ChoiceCommand([currentCmd, tryEquation(eqIndex + 1)]);
+      };
+
+      return unifyParameters(
+        eq.patterns,
+        this.args,
+        this.baseSubst,
+        this.translator,
+        scope,
+        onSuccess,
+        onFailure,
+      );
+    };
+
+    return tryEquation(0);
+  }
+
+  public fallback(node: ASTNode): ExecutionCommand {
+    return new FailCommand(
+      new InterpreterError(
+        "Logic",
+        `Unexpected node ${node.constructor.name} in predicate definition`,
+      ),
+    );
+  }
+}
+
+/**
+ * Solves a single logic goal (predicate call) using the Kernel.
+ * Returns a non-deterministic command. Aggregation should happen at top-level.
+ */
+export function solveGoalKernel(
+  ctx: RuntimeContext,
+  predicateName: string,
+  args: LogicTerm[],
+  solveBody: Solver,
+  baseSubst: Substitution,
+  translator: LogicTranslator,
+): ExecutionCommand {
+  const pred = ctx.isDefined(predicateName) ? ctx.lookup(predicateName) : null;
+
+  const validPredicate =
+    isRuntimePredicate(pred) && pred.validateArity(args.length);
+
+  if (!validPredicate) return new BacktrackCommand();
+
+  const visitor = new GoalKernelVisitor(args, baseSubst, solveBody, translator);
+
+  const choices = pred
+    .apply(visitor)
+    .filter((c) => !(c instanceof FailCommand));
+
+  if (choices.length === 0) return new BacktrackCommand();
+  return choices.length === 1 ? choices[0] : new ChoiceCommand(choices);
+}