proact-py 0.1.0__tar.gz

proact_py-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include src/*.c src/*.h
+include Makefile

proact_py-0.1.0/Makefile

@@ -0,0 +1,32 @@
+CC ?= gcc
+CFLAGS = -Wall -Wextra -O2 -std=c11
+SRCDIR = src
+SOURCES = $(SRCDIR)/term.c $(SRCDIR)/parse.c $(SRCDIR)/unify.c $(SRCDIR)/eval.c $(SRCDIR)/main.c
+LIB_SOURCES = $(SRCDIR)/term.c $(SRCDIR)/parse.c $(SRCDIR)/unify.c $(SRCDIR)/eval.c
+BUILDDIR = build
+TARGET = $(BUILDDIR)/proact
+
+all: $(TARGET)
+
+$(BUILDDIR):
+	mkdir -p $(BUILDDIR)
+
+$(TARGET): $(SOURCES) $(SRCDIR)/proact.h | $(BUILDDIR)
+	$(CC) $(CFLAGS) -I$(SRCDIR) $(SOURCES) -o $(TARGET)
+
+test: test/test_proact.c $(LIB_SOURCES) $(SRCDIR)/proact.h | $(BUILDDIR)
+	$(CC) $(CFLAGS) -I$(SRCDIR) $(LIB_SOURCES) test/test_proact.c -o $(BUILDDIR)/test_proact
+	./$(BUILDDIR)/test_proact
+
+coverage: test/test_proact.c $(LIB_SOURCES) $(SRCDIR)/proact.h | $(BUILDDIR)
+	$(CC) -Wall -Wextra -std=c11 -O0 --coverage -I$(SRCDIR) $(LIB_SOURCES) test/test_proact.c -o $(BUILDDIR)/test_proact_cov
+	ulimit -s unlimited && ./$(BUILDDIR)/test_proact_cov
+	lcov --capture --directory . --output-file $(BUILDDIR)/coverage.info --ignore-errors inconsistent
+	lcov --remove $(BUILDDIR)/coverage.info '*/test/*' --output-file $(BUILDDIR)/coverage.info --ignore-errors unused
+	lcov --list $(BUILDDIR)/coverage.info
+
+clean:
+	rm -rf $(BUILDDIR)
+	rm -f $(SRCDIR)/*.gcda $(SRCDIR)/*.gcno
+
+.PHONY: all test coverage clean

proact_py-0.1.0/PKG-INFO

@@ -0,0 +1,207 @@
+Metadata-Version: 2.4
+Name: proact-py
+Version: 0.1.0
+Summary: Active logic meets Prolog — three-valued reasoning engine
+License-Expression: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+# Proact
+
+Prolog has two truth values: succeed and fail. Proact adds a third: **cont** — *work/reasoning in progress*.
+
+Every goal returns a status. Conjunction is a sequence. Disjunction is a selector. Backtracking only triggers on failure — `cont` and `done` cut the search. Between ticks, queries returning `cont` are automatically re-evaluated while the database persists, giving you a stateless tick loop for free.
+
+Applications:
+
+- **Reasoning under uncertainty.** The three values map onto epistemic states: *verified*, *undetermined*, *refuted*. A conjunction of checks naturally implements iterative deepening — work focuses on the earliest unresolved premise. Unary operators give you cognitive control: `demote` means "don't commit yet" (done→cont); `promote` means "don't give up yet" (fail→cont). This is relevant to validation layers for LLM reasoning, where forcing every check into true/false is lossy compression of the actual epistemic state.
+
+- **Behavior modeling.** Reactive agents, planners, robot controllers — anything where logic meets time. Prolog gives you unification, backtracking, and pattern matching. Active logic adds temporal flow. You get behavior trees with the expressiveness of logic programming, without the trees.
+
+## Install
+
+```
+pip install git+https://github.com/eelstork/proact.git
+```
+
+Requires a C compiler (`gcc`, `clang`, or MSVC).
+
+```python
+from proact import Proact
+
+p = Proact()
+p.add("mortal(X) :- human(X). human(socrates).")
+print(p.query("mortal(socrates)"))  # Result(status='done')
+```
+
+## Tutorials
+
+- [Reasoning under uncertainty](tutorial/reasoning.md) — from predicate logic to three-valued epistemics
+- [Behavior modeling](tutorial/behavior.md) — behavior trees via logic programming
+
+## Build
+
+```
+make
+```
+
+## Usage
+
+```
+./proact                          # REPL
+./proact file.pa                  # consult file, then REPL
+./proact file.pa -e "goal."      # evaluate goal and exit
+./proact --max-ticks 100 -e "g." # limit tick count
+```
+
+## The Transform
+
+### Conjunction (`,`) — Active logic AND / Sequence
+
+```
+         fail  cont  done
+  fail   fail  fail  fail
+  cont   cont  cont  cont
+  done   fail  cont  done
+```
+
+If the left goal is `cont`, the whole conjunction is `cont` — don't evaluate the right side yet.
+
+### Disjunction (`;`) — Active logic OR / Selector
+
+```
+         fail  cont  done
+  fail   fail  cont  done
+  cont   cont  cont  cont
+  done   done  done  done
+```
+
+If the left goal is `done` or `cont`, don't try alternatives.
+
+### Clause resolution
+
+Multiple clauses for the same predicate provide choice points. Backtracking occurs **only on fail** — if a clause body returns `cont` or `done`, stop searching.
+
+### Tick loop
+
+Queries returning `cont` are automatically re-evaluated on the next tick with a fresh environment. The database (asserted facts) persists between ticks.
+
+## Built-ins
+
+| Predicate | Status | Description |
+|---|---|---|
+| `done` / `true` | done | Always succeeds |
+| `fail` / `false` | fail | Always fails |
+| `cont` | cont | Always continues |
+| `inv(G)` / `\+ G` | swap done/fail, keep cont | Inverter |
+| `condone(G)` | fail→done | Forgive failure |
+| `promote(G)` | fail→cont, cont→done | Optimistic |
+| `demote(G)` | done→cont, cont→fail | Pessimistic |
+| `par_any(A,B)` | max(A,B) | Lenient parallel |
+| `par_all(A,B)` | min(A,B) | Strict parallel |
+| `tick(N)` | done | Unify N with current tick |
+
+Plus standard Prolog: `write/1`, `writeln/1`, `nl`, `assert/1`, `retract/1`, `is/2`, `=/2`, `\=/2`, `</2`, `>/2`, `>=/2`, `=</2`, `call/1`, `consult/1`.
+
+## Examples
+
+### Wait N ticks, then succeed
+
+```prolog
+wait(N) :- tick(T), T >= N.
+wait(N) :- tick(T), T < N, cont.
+```
+
+```
+?- wait(3), writeln(hello).
+[tick 0] cont
+[tick 1] cont
+[tick 2] cont
+hello
+done.
+```
+
+### Counter (stateful, using assert/retract)
+
+```prolog
+:- assert(count(0)).
+
+count_to(Target) :- count(N), N >= Target.
+count_to(Target) :-
+    count(N), N < Target,
+    retract(count(N)), N1 is N + 1, assert(count(N1)),
+    cont.
+```
+
+### Reactive behavior (condition-gated sequence)
+
+```prolog
+:- assert(agent_pos(0)).
+
+move_to(X) :- agent_pos(P), P =:= X.
+move_to(X) :- agent_pos(P), P < X,
+    retract(agent_pos(P)), P1 is P + 1, assert(agent_pos(P1)), cont.
+
+patrol :-
+    agent_pos(P), P < 3, move_to(3), cont.
+patrol :-
+    agent_pos(P), P >= 3, P < 5, move_to(5), cont.
+patrol :-
+    agent_pos(P), P >= 5.
+```
+
+### Reasoning under uncertainty
+
+```prolog
+% reason.pa — three-valued validation for multi-step arguments
+
+:- assert(known(premise_a)).
+:- assert(investigation(premise_b, 2)).
+:- assert(investigation(premise_c, 1)).
+
+check(P) :- known(P).
+check(P) :- known_false(P), fail.
+check(P) :-
+    investigation(P, N), N > 0,
+    retract(investigation(P, N)), N1 is N - 1,
+    (N1 > 0 -> assert(investigation(P, N1)) ; assert(known(P))),
+    cont.
+
+argument :- check(premise_a), check(premise_b), check(premise_c).
+```
+
+The conjunction *is* the search strategy — it focuses work on the earliest unresolved premise and doesn't waste computation on steps whose preconditions haven't been met:
+
+```
+[tick 0] a=done, b=cont          → cont  (c never reached)
+[tick 1] a=done, b=done, c=cont  → cont  (work shifts to c)
+[tick 2] a=done, b=done, c=done  → done
+```
+
+The epistemic operators give cognitive control over the validation:
+
+```prolog
+cautious(X)       :- demote(check(X)).    % "verified but needs review"  (done→cont)
+keep_exploring(X) :- promote(check(X)).   % "refuted but try harder"     (fail→cont)
+viable_theory     :- par_any(hyp_a, hyp_b). % first hypothesis verified wins
+```
+
+## Relation to active-logic
+
+This prototype implements the core operators from [activelogic-cs](https://github.com/active-logic/activelogic-cs) in a logic programming context:
+
+| C# (activelogic-cs) | Proact | BT equivalent |
+|---|---|---|
+| `status && status` | `Goal, Goal` | Sequence |
+| `status \|\| status` | `Goal ; Goal` | Selector |
+| `+` (lenient) | `par_any(A, B)` | Parallel (any) |
+| `*` (strict) | `par_all(A, B)` | Parallel (all) |
+| `!status` | `inv(G)` | Inverter |
+| `~status` | `condone(G)` | Condone |
+| `+status` (unary) | `promote(G)` | Promoter |
+| `-status` (unary) | `demote(G)` | Demoter |
+| `cont` | `cont` | Running |
+
+The key addition over Prolog is `cont` — a single built-in that bridges logic programming with reactive, tick-based behavior.

proact_py-0.1.0/README.md

@@ -0,0 +1,197 @@
+# Proact
+
+Prolog has two truth values: succeed and fail. Proact adds a third: **cont** — *work/reasoning in progress*.
+
+Every goal returns a status. Conjunction is a sequence. Disjunction is a selector. Backtracking only triggers on failure — `cont` and `done` cut the search. Between ticks, queries returning `cont` are automatically re-evaluated while the database persists, giving you a stateless tick loop for free.
+
+Applications:
+
+- **Reasoning under uncertainty.** The three values map onto epistemic states: *verified*, *undetermined*, *refuted*. A conjunction of checks naturally implements iterative deepening — work focuses on the earliest unresolved premise. Unary operators give you cognitive control: `demote` means "don't commit yet" (done→cont); `promote` means "don't give up yet" (fail→cont). This is relevant to validation layers for LLM reasoning, where forcing every check into true/false is lossy compression of the actual epistemic state.
+
+- **Behavior modeling.** Reactive agents, planners, robot controllers — anything where logic meets time. Prolog gives you unification, backtracking, and pattern matching. Active logic adds temporal flow. You get behavior trees with the expressiveness of logic programming, without the trees.
+
+## Install
+
+```
+pip install git+https://github.com/eelstork/proact.git
+```
+
+Requires a C compiler (`gcc`, `clang`, or MSVC).
+
+```python
+from proact import Proact
+
+p = Proact()
+p.add("mortal(X) :- human(X). human(socrates).")
+print(p.query("mortal(socrates)"))  # Result(status='done')
+```
+
+## Tutorials
+
+- [Reasoning under uncertainty](tutorial/reasoning.md) — from predicate logic to three-valued epistemics
+- [Behavior modeling](tutorial/behavior.md) — behavior trees via logic programming
+
+## Build
+
+```
+make
+```
+
+## Usage
+
+```
+./proact                          # REPL
+./proact file.pa                  # consult file, then REPL
+./proact file.pa -e "goal."      # evaluate goal and exit
+./proact --max-ticks 100 -e "g." # limit tick count
+```
+
+## The Transform
+
+### Conjunction (`,`) — Active logic AND / Sequence
+
+```
+         fail  cont  done
+  fail   fail  fail  fail
+  cont   cont  cont  cont
+  done   fail  cont  done
+```
+
+If the left goal is `cont`, the whole conjunction is `cont` — don't evaluate the right side yet.
+
+### Disjunction (`;`) — Active logic OR / Selector
+
+```
+         fail  cont  done
+  fail   fail  cont  done
+  cont   cont  cont  cont
+  done   done  done  done
+```
+
+If the left goal is `done` or `cont`, don't try alternatives.
+
+### Clause resolution
+
+Multiple clauses for the same predicate provide choice points. Backtracking occurs **only on fail** — if a clause body returns `cont` or `done`, stop searching.
+
+### Tick loop
+
+Queries returning `cont` are automatically re-evaluated on the next tick with a fresh environment. The database (asserted facts) persists between ticks.
+
+## Built-ins
+
+| Predicate | Status | Description |
+|---|---|---|
+| `done` / `true` | done | Always succeeds |
+| `fail` / `false` | fail | Always fails |
+| `cont` | cont | Always continues |
+| `inv(G)` / `\+ G` | swap done/fail, keep cont | Inverter |
+| `condone(G)` | fail→done | Forgive failure |
+| `promote(G)` | fail→cont, cont→done | Optimistic |
+| `demote(G)` | done→cont, cont→fail | Pessimistic |
+| `par_any(A,B)` | max(A,B) | Lenient parallel |
+| `par_all(A,B)` | min(A,B) | Strict parallel |
+| `tick(N)` | done | Unify N with current tick |
+
+Plus standard Prolog: `write/1`, `writeln/1`, `nl`, `assert/1`, `retract/1`, `is/2`, `=/2`, `\=/2`, `</2`, `>/2`, `>=/2`, `=</2`, `call/1`, `consult/1`.
+
+## Examples
+
+### Wait N ticks, then succeed
+
+```prolog
+wait(N) :- tick(T), T >= N.
+wait(N) :- tick(T), T < N, cont.
+```
+
+```
+?- wait(3), writeln(hello).
+[tick 0] cont
+[tick 1] cont
+[tick 2] cont
+hello
+done.
+```
+
+### Counter (stateful, using assert/retract)
+
+```prolog
+:- assert(count(0)).
+
+count_to(Target) :- count(N), N >= Target.
+count_to(Target) :-
+    count(N), N < Target,
+    retract(count(N)), N1 is N + 1, assert(count(N1)),
+    cont.
+```
+
+### Reactive behavior (condition-gated sequence)
+
+```prolog
+:- assert(agent_pos(0)).
+
+move_to(X) :- agent_pos(P), P =:= X.
+move_to(X) :- agent_pos(P), P < X,
+    retract(agent_pos(P)), P1 is P + 1, assert(agent_pos(P1)), cont.
+
+patrol :-
+    agent_pos(P), P < 3, move_to(3), cont.
+patrol :-
+    agent_pos(P), P >= 3, P < 5, move_to(5), cont.
+patrol :-
+    agent_pos(P), P >= 5.
+```
+
+### Reasoning under uncertainty
+
+```prolog
+% reason.pa — three-valued validation for multi-step arguments
+
+:- assert(known(premise_a)).
+:- assert(investigation(premise_b, 2)).
+:- assert(investigation(premise_c, 1)).
+
+check(P) :- known(P).
+check(P) :- known_false(P), fail.
+check(P) :-
+    investigation(P, N), N > 0,
+    retract(investigation(P, N)), N1 is N - 1,
+    (N1 > 0 -> assert(investigation(P, N1)) ; assert(known(P))),
+    cont.
+
+argument :- check(premise_a), check(premise_b), check(premise_c).
+```
+
+The conjunction *is* the search strategy — it focuses work on the earliest unresolved premise and doesn't waste computation on steps whose preconditions haven't been met:
+
+```
+[tick 0] a=done, b=cont          → cont  (c never reached)
+[tick 1] a=done, b=done, c=cont  → cont  (work shifts to c)
+[tick 2] a=done, b=done, c=done  → done
+```
+
+The epistemic operators give cognitive control over the validation:
+
+```prolog
+cautious(X)       :- demote(check(X)).    % "verified but needs review"  (done→cont)
+keep_exploring(X) :- promote(check(X)).   % "refuted but try harder"     (fail→cont)
+viable_theory     :- par_any(hyp_a, hyp_b). % first hypothesis verified wins
+```
+
+## Relation to active-logic
+
+This prototype implements the core operators from [activelogic-cs](https://github.com/active-logic/activelogic-cs) in a logic programming context:
+
+| C# (activelogic-cs) | Proact | BT equivalent |
+|---|---|---|
+| `status && status` | `Goal, Goal` | Sequence |
+| `status \|\| status` | `Goal ; Goal` | Selector |
+| `+` (lenient) | `par_any(A, B)` | Parallel (any) |
+| `*` (strict) | `par_all(A, B)` | Parallel (all) |
+| `!status` | `inv(G)` | Inverter |
+| `~status` | `condone(G)` | Condone |
+| `+status` (unary) | `promote(G)` | Promoter |
+| `-status` (unary) | `demote(G)` | Demoter |
+| `cont` | `cont` | Running |
+
+The key addition over Prolog is `cont` — a single built-in that bridges logic programming with reactive, tick-based behavior.

proact_py-0.1.0/proact/__init__.py

@@ -0,0 +1,5 @@
+"""Proact — active logic meets Prolog."""
+
+from proact.engine import Proact, ProactError
+
+__all__ = ["Proact", "ProactError"]

proact_py-0.1.0/proact/engine.py

@@ -0,0 +1,158 @@
+"""Subprocess wrapper for the proact binary."""
+
+import os
+import re
+import subprocess
+import tempfile
+
+
+class ProactError(Exception):
+    pass
+
+
+def _find_binary():
+    """Find the proact binary — packaged, local build, or PATH."""
+    # 1. Bundled with pip install
+    pkg_dir = os.path.dirname(__file__)
+    for name in ("proact", "proact.exe"):
+        path = os.path.join(pkg_dir, name)
+        if os.path.isfile(path):
+            return path
+
+    # 2. Built locally (repo root/build/)
+    repo = os.path.dirname(pkg_dir)
+    for subdir in ("build", ""):
+        for name in ("proact", "proact.exe"):
+            path = os.path.join(repo, subdir, name)
+            if os.path.isfile(path):
+                return path
+
+    # 3. On PATH
+    from shutil import which
+    path = which("proact")
+    if path:
+        return path
+
+    raise ProactError(
+        "proact binary not found. "
+        "Run 'make' to build it or 'pip install .' to install the package."
+    )
+
+
+class Proact:
+    """Three-valued reasoning engine.
+
+    Example::
+
+        p = Proact()
+        p.consult("rules.pa")
+        result = p.query("mortal(socrates)")
+        print(result.status)  # 'done'
+
+        # Multi-tick evaluation
+        p.add("wait(3) :- tick(T), T >= 3.")
+        p.add("wait(3) :- tick(T), T < 3, cont.")
+        result = p.query("wait(3)", max_ticks=10)
+        print(result.ticks)  # 4
+    """
+
+    def __init__(self, binary=None, max_ticks=1000, max_depth=512, trace=False):
+        self._binary = binary or _find_binary()
+        self._files = []
+        self._inline = []
+        self.max_ticks = max_ticks
+        self.max_depth = max_depth
+        self.trace = trace
+
+    def consult(self, path):
+        """Load a .pa file."""
+        if not os.path.isfile(path):
+            raise FileNotFoundError(f"No such file: {path}")
+        self._files.append(os.path.abspath(path))
+        return self
+
+    def add(self, source):
+        """Add clauses/directives from a string."""
+        self._inline.append(source)
+        return self
+
+    def query(self, goal, max_ticks=None):
+        """Evaluate a goal. Returns a Result."""
+        if not goal.endswith("."):
+            goal += "."
+
+        ticks = max_ticks or self.max_ticks
+
+        # Build a combined source file if we have inline clauses
+        tmp = None
+        files = list(self._files)
+
+        if self._inline:
+            tmp = tempfile.NamedTemporaryFile(
+                mode="w", suffix=".pa", delete=False
+            )
+            tmp.write("\n".join(self._inline) + "\n")
+            tmp.close()
+            files.append(tmp.name)
+
+        try:
+            cmd = [self._binary] + files + [
+                "--max-ticks", str(ticks),
+                "-q",  # quiet — we parse output ourselves
+                "-e", goal,
+            ]
+            if self.trace:
+                cmd.append("--trace")
+
+            proc = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=30,
+            )
+            return Result._parse(proc)
+        finally:
+            if tmp:
+                os.unlink(tmp.name)
+
+    def run(self, goal="main", max_ticks=None):
+        """Shorthand for query(goal, max_ticks)."""
+        return self.query(goal, max_ticks)
+
+    def reset(self):
+        """Clear all loaded files and inline clauses."""
+        self._files.clear()
+        self._inline.clear()
+        return self
+
+
+class Result:
+    """Result of a proact query."""
+
+    __slots__ = ("status", "output", "returncode")
+
+    def __init__(self, status, output, returncode):
+        self.status = status
+        self.output = output
+        self.returncode = returncode
+
+    def _parse(proc):
+        stdout = proc.stdout or ""
+        stderr = proc.stderr or ""
+        output = (stdout + stderr).strip()
+
+        if proc.returncode == 0:
+            status = "done"
+        elif proc.returncode == 1:
+            status = "fail"
+        else:
+            status = "error"
+
+        return Result(status=status, output=output, returncode=proc.returncode)
+
+    @property
+    def ok(self):
+        return self.status == "done"
+
+    def __repr__(self):
+        return f"Result(status={self.status!r})"
+
+    def __bool__(self):
+        return self.ok