tiny-datalog 0.1.0__py3-none-any.whl

tiny_datalog/prolog.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""
+prolog.py — a miniature top-down Horn-clause interpreter: the other side
+of the Datalog boundary.
+
+Datalog is Horn-clause logic with function symbols confiscated; that ban
+is what makes bottom-up evaluation terminate.  This module puts the
+function symbols back — `s(N)`, `cons(H, T)` — and pays the price:
+top-down SLD resolution with proper unification and no termination
+guarantee.  Two bounds cut the search off: a depth bound on each proof
+branch and a budget on the total number of resolution steps.  The depth
+bound alone is not enough — with two clauses per goal a depth of 100
+still allows about 2^100 branches — so the step budget is what keeps a
+query from running for longer than anyone will wait.  Either way the
+interpreter tells you when it was cut off, i.e. when the answer set may
+be incomplete.
+
+Differences from real Prolog, on purpose:
+
+* unification includes the occurs check (Prolog omits it for speed, and
+  `X = s(X)` quietly builds an infinite term);
+* no cut, no arithmetic, no I/O — just SLD resolution over Horn clauses;
+* `not` is negation as failure via a depth-bounded sub-proof.
+
+Same syntax and parser as datalog.py, which *parses* compound terms but
+rejects them at validation — run datalog.py on programs/peano.pl to see
+the boundary stated as an error message.
+
+CLI
+---
+    python3 prolog.py programs/peano.pl -q 'add(s(zero), s(s(zero)), X)'
+    python3 prolog.py programs/peano.pl -q 'nat(X)' --max-solutions 5
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from collections import defaultdict
+
+from tiny_datalog.datalog import (
+    Atom, Const, DatalogError, Literal, parse, parse_goal, ParseError,
+    read_program, Rule, Struct, Var)
+
+
+# ---------------------------------------------------------------------------
+# Unification (with occurs check)
+# ---------------------------------------------------------------------------
+
+def _walk(term, subst):
+    while isinstance(term, Var) and term.name in subst:
+        term = subst[term.name]
+    return term
+
+
+def _occurs(name, term, subst):
+    term = _walk(term, subst)
+    if isinstance(term, Var):
+        return term.name == name
+    if isinstance(term, Struct):
+        return any(_occurs(name, a, subst) for a in term.args)
+    return False
+
+
+def unify(a, b, subst):
+    """Return an extended substitution unifying a and b, or None."""
+    a, b = _walk(a, subst), _walk(b, subst)
+    if isinstance(a, Var):
+        if isinstance(b, Var) and b.name == a.name:
+            return subst
+        if _occurs(a.name, b, subst):
+            return None
+        s = dict(subst)
+        s[a.name] = b
+        return s
+    if isinstance(b, Var):
+        return unify(b, a, subst)
+    if isinstance(a, Const) and isinstance(b, Const):
+        return subst if a.value == b.value else None
+    if isinstance(a, Struct) and isinstance(b, Struct):
+        if a.functor != b.functor or len(a.args) != len(b.args):
+            return None
+        for x, y in zip(a.args, b.args):
+            subst = unify(x, y, subst)
+            if subst is None:
+                return None
+        return subst
+    return None
+
+
+def _unify_atoms(goal, head, subst):
+    if goal.pred != head.pred or len(goal.args) != len(head.args):
+        return None
+    for x, y in zip(goal.args, head.args):
+        subst = unify(x, y, subst)
+        if subst is None:
+            return None
+    return subst
+
+
+def resolve(term, subst):
+    """Deep-substitute for printing an answer term."""
+    term = _walk(term, subst)
+    if isinstance(term, Struct):
+        return Struct(term.functor, tuple(resolve(a, subst) for a in term.args))
+    return term
+
+
+def _is_ground(atom, subst):
+    """True iff every argument resolves to a variable-free term."""
+    def ground(t):
+        t = _walk(t, subst)
+        if isinstance(t, Var):
+            return False
+        if isinstance(t, Struct):
+            return all(ground(a) for a in t.args)
+        return True
+    return all(ground(a) for a in atom.args)
+
+
+# ---------------------------------------------------------------------------
+# SLD resolution
+# ---------------------------------------------------------------------------
+
+class PrologEngine:
+    """Bounded SLD resolution over Horn clauses.  After a solve, the
+    `truncated` flag records whether the depth bound or the step budget
+    cut the search off (in which case "no more solutions" is not a proof
+    of absence)."""
+
+    def __init__(self, clauses):
+        self.clauses = list(clauses)
+        # index clauses by (pred, arity) so each resolution step only
+        # scans candidates that could possibly unify; source order is
+        # preserved within a bucket, so SLD semantics are unchanged
+        self.by_pred = defaultdict(list)
+        for c in self.clauses:
+            self.by_pred[(c.head.pred, len(c.head.args))].append(c)
+        self.counter = 0
+        self.truncated = False
+        self.steps, self.max_steps = 0, 100_000
+
+    def _rename(self, rule):
+        """Standardise a clause apart with fresh variable names.  The
+        `#` makes them names the parser can never produce, so a renamed
+        clause variable can never collide with one the user wrote."""
+        self.counter += 1
+        n = self.counter
+
+        def rt(term):
+            if isinstance(term, Var):
+                return Var("%s#%d" % (term.name, n))
+            if isinstance(term, Struct):
+                return Struct(term.functor, tuple(rt(a) for a in term.args))
+            return term
+
+        def ra(atom):
+            return Atom(atom.pred, tuple(rt(a) for a in atom.args))
+
+        return Rule(ra(rule.head),
+                    tuple(Literal(ra(l.atom), l.negated) for l in rule.body))
+
+    def solve(self, goals, subst=None, depth=100):
+        """Yield substitutions proving the goal list, left to right."""
+        if subst is None:
+            subst = {}
+        if not goals:
+            yield subst
+            return
+        if depth <= 0:
+            self.truncated = True
+            return
+        goal, rest = goals[0], goals[1:]
+        if goal.negated:
+            # Negation as failure, with two honesty guards.
+            # (1) The goal must be ground: `not p(X)` with X unbound would
+            # mean "no instance of p is provable at all", whose answer
+            # depends on literal order — the classic "floundering" trap.
+            if not _is_ground(goal.atom, subst):
+                raise DatalogError(
+                    "negation as failure needs a ground goal, but %s has "
+                    "unbound variables — reorder the body so positive "
+                    "literals bind them first" % (goal.atom,))
+            # (2) Failure must be finite: if the sub-proof was cut off by
+            # a bound, "no proof found" means unproven, not disproven —
+            # so the negated goal must fail, not succeed.  (If it *was*
+            # proved, the failure is genuine, whatever else was cut off.)
+            outer = self.truncated
+            self.truncated = False
+            proved = False
+            for _ in self.solve([Literal(goal.atom)], subst, depth - 1):
+                proved = True
+                break
+            truncated = self.truncated and not proved
+            self.truncated = outer or truncated
+            if proved or truncated:
+                return
+            yield from self.solve(rest, subst, depth - 1)
+            return
+        for clause in self.by_pred.get((goal.atom.pred,
+                                        len(goal.atom.args)), ()):
+            if self.steps >= self.max_steps:
+                self.truncated = True
+                return
+            self.steps += 1
+            renamed = self._rename(clause)
+            s2 = _unify_atoms(goal.atom, renamed.head, subst)
+            if s2 is not None:
+                yield from self.solve(list(renamed.body) + rest, s2,
+                                      depth - 1)
+
+    def query(self, atom, depth=100, max_solutions=None, max_steps=100_000):
+        """Solve a single goal; return (answers, incomplete) where answers
+        is a list of {var_name: term} dicts for the query's variables and
+        incomplete is True when the search was truncated — by the depth
+        bound, the step budget or the solution cap — so "no more answers"
+        is not a proof of absence."""
+        if max_solutions is not None and max_solutions < 1:
+            raise DatalogError("max_solutions must be at least 1 (got %s)"
+                               % max_solutions)
+        self.truncated = False
+        self.steps, self.max_steps = 0, max_steps
+        qvars = []
+
+        def collect(term):
+            if (isinstance(term, Var) and not term.anonymous
+                    and term not in qvars):
+                qvars.append(term)
+            elif isinstance(term, Struct):
+                for a in term.args:
+                    collect(a)
+
+        for a in atom.args:
+            collect(a)
+        answers, seen = [], set()
+        capped = False
+        try:
+            for s in self.solve([Literal(atom)], depth=depth):
+                answer = {v.name: resolve(v, s) for v in qvars}
+                # dedupe on the terms themselves, not their printed
+                # form: two different terms can print identically
+                key = tuple(answer[v.name] for v in qvars)
+                if key in seen:
+                    continue
+                seen.add(key)
+                answers.append(answer)
+                if max_solutions is not None and len(answers) >= max_solutions:
+                    capped = True
+                    break
+        except RecursionError:
+            raise DatalogError(
+                "the proof search exceeded Python's recursion capacity; "
+                "lower --depth (currently %d)" % depth)
+        return answers, self.truncated or capped
+
+
+def load(text):
+    return PrologEngine(parse(text))
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def _positive_int(text):
+    n = int(text)
+    if n < 1:
+        raise argparse.ArgumentTypeError("must be at least 1, not %d" % n)
+    return n
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        description="Top-down SLD resolution over Horn clauses with "
+                    "function symbols — what Datalog deliberately isn't.")
+    ap.add_argument("file", help="Horn-clause program (.pl)")
+    ap.add_argument("-q", "--query", action="append", default=[],
+                    metavar="GOAL", help="goal to prove (repeatable)")
+    ap.add_argument("--depth", type=int, default=100,
+                    help="resolution depth bound (default 100)")
+    ap.add_argument("--max-solutions", type=_positive_int, default=10,
+                    help="stop after this many answers (default 10)")
+    ap.add_argument("--max-steps", type=_positive_int, default=100_000,
+                    help="resolution-step budget; the depth bound alone "
+                         "can still allow exponentially many branches "
+                         "(default 100000)")
+    args = ap.parse_args(argv)
+
+    try:
+        engine = load(read_program(args.file))
+    except DatalogError as exc:
+        print("error: %s" % exc, file=sys.stderr)
+        return 1
+    if not args.query:
+        print("loaded %d clauses; pass -q 'goal(...)' to prove something"
+              % len(engine.clauses))
+        return 0
+    for q in args.query:
+        try:
+            atom = parse_goal(q)
+        except ParseError as exc:
+            print("error: %s" % exc, file=sys.stderr)
+            return 1
+        print("?- %s" % atom)
+        try:
+            answers, incomplete = engine.query(
+                atom, depth=args.depth, max_solutions=args.max_solutions,
+                max_steps=args.max_steps)
+        except DatalogError as exc:
+            print("error: %s" % exc, file=sys.stderr)
+            return 1
+        if not answers:
+            bound = ("step budget %d" % args.max_steps
+                     if engine.steps >= args.max_steps
+                     else "depth %d" % args.depth)
+            print("   false." if not incomplete else
+                  "   false (search truncated at %s — unproven, "
+                  "not disproven)." % bound)
+            continue
+        for answer in answers:
+            if answer:
+                print("   " + ",  ".join("%s = %s" % (v, t)
+                                         for v, t in answer.items()))
+            else:
+                print("   true.")
+        note = " (more may exist: search truncated)" if incomplete else ""
+        print("   (%d solution%s%s)" % (len(answers),
+                                        "" if len(answers) == 1 else "s",
+                                        note))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tiny_datalog/semantics.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""
+semantics.py — ground semantics: stable models and the well-founded
+model.  (Lesson 5, which ends with a tour of this module.)
+
+Stratifiability is a *syntactic* test, and rejection by the stratified
+engine is not a semantic verdict: win(X) :- move(X, Y), not win(Y) is
+unstratifiable yet has perfectly sensible stable models.  This module
+computes the two classical semantics that answer the real question —
+"what, if anything, does this program mean?":
+
+* **Stable models** (Gelfond–Lifschitz, 1988).  A set of facts M is
+  stable if it *justifies itself*: assume M is exactly what's true,
+  simplify every `not` under that assumption (the "reduct"), and check
+  that the simplified — now negation-free — program derives exactly M
+  back.  No unsupported beliefs, no dropped conclusions.  A program with
+  no stable model (the café paradox, `p :- not p`) is genuinely
+  paradoxical.
+* **The well-founded model** (Van Gelder–Ross–Schlipf, 1991).  Three
+  valued and always defined: every fact comes out true, false, or
+  *undefined*.  What can be settled is settled; what is genuinely
+  circular is named as such.
+
+Both are computed over the program's grounding, and the stable-model
+search is exhaustive over candidate sets — fine for teaching-sized
+programs, and honest about it.  Industrial ASP solvers (clingo) get the
+same answers by conflict-driven search instead.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+
+from tiny_datalog.datalog import (
+    Const, DatalogError, Program, _aggregate_of, _match, _sort_key, validate)
+
+
+def _instantiate_atom(atom, subst):
+    return (atom.pred, tuple(a.value if isinstance(a, Const) else subst[a.name]
+                             for a in atom.args))
+
+
+def ground_program(clauses):
+    """Ground the program.
+
+    Returns (facts, ground_rules, candidates): facts is the set of ground
+    atoms (pred, args) from unit clauses; ground_rules is a list of
+    (head, pos_atoms, neg_atoms) triples over ground atoms; candidates is
+    the set of rule-derivable ground atoms when every negation is assumed
+    to succeed.
+
+    `candidates` is an upper bound on any stable model: the
+    Gelfond–Lifschitz operator is antimonotone (more assumed facts block
+    more rules), so every stable model M satisfies M = Γ(M) ⊆ Γ(∅) — and
+    Γ(∅) is exactly "derive with all negations granted".  The exhaustive
+    search below therefore only needs subsets of this envelope.
+    """
+    validate(clauses)
+    for r in clauses:
+        if r.retract:
+            # `q~.` is an update, not a fact; let the base engine's
+            # Program reject it with its own explanation
+            Program([r])
+        if r.body and _aggregate_of(r.head):
+            raise DatalogError(
+                "stable-model and well-founded semantics for aggregates "
+                "are beyond this module (and still debated in the "
+                "literature): %s" % r)
+    facts = {(r.head.pred, tuple(a.value for a in r.head.args))
+             for r in clauses if not r.body}
+    rules = [r for r in clauses if r.body]
+
+    # Least model ignoring negation = the envelope of possibly-true atoms.
+    rels = defaultdict(set)
+    for pred, args in facts:
+        rels[pred].add(args)
+
+    def substitutions(rule):
+        # Join the positive body literals against the envelope; negated
+        # literals are skipped (treated as satisfied) at this stage.
+        substs = [{}]
+        for lit in rule.body:
+            if lit.negated:
+                continue
+            new = []
+            for s in substs:
+                for tup in rels.get(lit.atom.pred, ()):
+                    m = _match(lit.atom.args, tup, s)
+                    if m is not None:
+                        new.append(m)
+            substs = new
+        return substs
+
+    changed = True
+    while changed:
+        changed = False
+        for rule in rules:
+            for s in substitutions(rule):
+                pred, args = _instantiate_atom(rule.head, s)
+                if args not in rels[pred]:
+                    rels[pred].add(args)
+                    changed = True
+
+    # Instantiate every rule over the envelope: each grounding whose
+    # positive body lies inside the envelope becomes one ground rule.
+    ground_rules = []
+    seen = set()
+    for rule in rules:
+        for s in substitutions(rule):
+            gr = (_instantiate_atom(rule.head, s),
+                  tuple(_instantiate_atom(l.atom, s)
+                        for l in rule.body if not l.negated),
+                  tuple(_instantiate_atom(l.atom, s)
+                        for l in rule.body if l.negated))
+            if gr not in seen:
+                seen.add(gr)
+                ground_rules.append(gr)
+    candidates = {gr[0] for gr in ground_rules} - facts
+    return facts, ground_rules, candidates
+
+
+def _gamma(S, facts, ground_rules):
+    """The Gelfond–Lifschitz operator: least model of the reduct of the
+    ground program with respect to S.
+
+    The reduct deletes every rule with a negative literal `not a` where
+    a ∈ S, and strips the surviving rules' negative literals.  What's
+    left is negation-free, so it has a unique least model — computed here
+    by plain forward chaining.  M is a stable model iff Γ(M) == M.
+    """
+    derived = set(facts)
+    changed = True
+    while changed:
+        changed = False
+        for head, pos, neg in ground_rules:
+            if head in derived:
+                continue
+            if any(a in S for a in neg):
+                continue  # rule deleted by the reduct
+            if all(a in derived for a in pos):
+                derived.add(head)
+                changed = True
+    return derived
+
+
+def stable_models(clauses, limit_atoms=16, grounding=None):
+    """All stable models of the program, as sets of ground atoms (pred,
+    args), EDB facts included.  Exhaustive search over subsets of the
+    candidate atoms; small programs only, and says so.  Pass a
+    precomputed `grounding` (from ground_program) to avoid regrounding."""
+    facts, ground_rules, candidates = grounding or ground_program(clauses)
+    atoms = sorted(candidates, key=lambda a: (a[0], _sort_key(a[1])))
+    if len(atoms) > limit_atoms:
+        raise DatalogError(
+            "stable-model search is limited to %d candidate atoms; this "
+            "program grounds to %d" % (limit_atoms, len(atoms)))
+    models = []
+    for mask in range(1 << len(atoms)):
+        M = {atoms[i] for i in range(len(atoms)) if mask >> i & 1} | facts
+        if _gamma(M, facts, ground_rules) == M:
+            models.append(M)
+    return models
+
+
+def well_founded(clauses, grounding=None):
+    """The well-founded (three-valued) model, via Van Gelder's alternating
+    fixpoint.  Returns (true_atoms, undefined_atoms); everything else is
+    false.
+
+    The trick: Γ is antimonotone, so Γ∘Γ is monotone and has a least
+    fixpoint T (the surely-true atoms) reachable by plain iteration.
+    Γ(T) is then the upper envelope of the possibly-true; the gap
+    Γ(T) - T is precisely the undefined zone — for the café paradox,
+    exactly Bob's three atoms."""
+    facts, ground_rules, _candidates = grounding or ground_program(clauses)
+    T = set(facts)
+    while True:
+        upper = _gamma(T, facts, ground_rules)
+        T2 = _gamma(upper, facts, ground_rules)
+        if T2 == T:
+            return T, upper - T
+        T = T2