poussins 0.0.1__tar.gz

poussins-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: poussins
+Version: 0.0.1
+Summary: Add your description here
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# poussins
+
+## Develop
+
+```bash
+    # Run
+    uv run -m poussins
+
+    # Unit Test
+    uv run pytest
+
+    # Lint
+    uv run ruff check .
+```

poussins-0.0.1/README.md

@@ -0,0 +1,14 @@
+# poussins
+
+## Develop
+
+```bash
+    # Run
+    uv run -m poussins
+
+    # Unit Test
+    uv run pytest
+
+    # Lint
+    uv run ruff check .
+```

poussins-0.0.1/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "poussins"
+version = "0.0.1"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[build-system]
+requires = ["uv_build>=0.11.9,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "build>=1.5.0",
+    "pytest>=9.0.3",
+    "pytest-cov>=7.1.0",
+    "ruff>=0.15.12",
+    "twine>=6.2.0",
+]

poussins-0.0.1/src/poussins/__init__.py

@@ -0,0 +1,5 @@
+"""Public package exports for poussins."""
+
+from .ast import *
+
+__all__ = []

poussins-0.0.1/src/poussins/__main__.py

@@ -0,0 +1,6 @@
+# Entrypoint for `python -m poussins`.
+# Sets up logger and global error handler.
+from .cli.main import main
+
+if __name__ == "__main__":
+    main()

poussins-0.0.1/src/poussins/ast/__init__.py

@@ -0,0 +1,57 @@
+"""Formula kernel: AST nodes and proof terms for propositional logic."""
+
+from .formulas import (
+    Formula,
+    FVar,
+    FImpl,
+    FAnd,
+    FOr,
+    FTrue,
+    FFalse,
+    FExists,
+)
+from .proof_terms import (
+    ProofTerm,
+    PMetaVar,
+    PVar,
+    PLam,
+    PApp,
+    PAndI,
+    PAndE1,
+    PAndE2,
+    POrIL,
+    POrIR,
+    POrE,
+    PTrueI,
+    PFalseE,
+    PExI,
+    PExE,
+)
+
+__all__ = [
+    # Formula AST
+    "Formula",
+    "FVar",
+    "FImpl",
+    "FAnd",
+    "FOr",
+    "FTrue",
+    "FFalse",
+    "FExists",
+    # ProofTerm AST
+    "ProofTerm",
+    "PMetaVar",
+    "PVar",
+    "PLam",
+    "PApp",
+    "PAndI",
+    "PAndE1",
+    "PAndE2",
+    "POrIL",
+    "POrIR",
+    "POrE",
+    "PTrueI",
+    "PFalseE",
+    "PExI",
+    "PExE",
+]

poussins-0.0.1/src/poussins/ast/formulas.py

@@ -0,0 +1,79 @@
+"""Formula AST nodes for propositional logic.
+
+Defined in this module:
+- FVar, FImpl, FAnd, FOr, FTrue, FFalse, FExists
+
+Not defined here (by design):
+- FNot is syntax sugar and is expanded during formula parsing
+  from formula text to Formula AST:
+  ~A = FImpl(A, FFalse)
+- FIff is syntax sugar and is expanded during formula parsing
+  from formula text to Formula AST:
+  A <-> B = FAnd(FImpl(A, B), FImpl(B, A))
+
+TODO:
+- Add FAll/FExists over a proper term language (arithmetic milestone).
+  The current FExists is second-order (quantifies over propositional variables).
+- Add FEq with a dedicated Term AST (arithmetic milestone).
+"""
+
+from __future__ import annotations
+from abc import ABC
+from dataclasses import dataclass
+
+
+class Formula(ABC):
+    pass
+
+
+@dataclass(frozen=True)
+class FVar(Formula):
+    """Propositional variable, e.g. P, Q."""
+
+    name: str
+
+
+@dataclass(frozen=True)
+class FImpl(Formula):
+    """Implication: antecedent -> consequent."""
+
+    antecedent: Formula
+    consequent: Formula
+
+
+@dataclass(frozen=True)
+class FAnd(Formula):
+    """Conjunction: left /\\ right."""
+
+    left: Formula
+    right: Formula
+
+
+@dataclass(frozen=True)
+class FOr(Formula):
+    """Disjunction: left \\/ right."""
+
+    left: Formula
+    right: Formula
+
+
+@dataclass(frozen=True)
+class FTrue(Formula):
+    """Logical true (top)."""
+
+
+@dataclass(frozen=True)
+class FFalse(Formula):
+    """Logical false (bottom)."""
+
+
+@dataclass(frozen=True)
+class FExists(Formula):
+    """Existential quantification over a propositional variable: ∃var. body.
+
+    ``var`` is the name of a bound propositional variable (an FVar name).
+    ``body`` is the formula with ``var`` potentially free.
+    """
+
+    var: str
+    body: Formula

poussins-0.0.1/src/poussins/ast/proof_terms.py

@@ -0,0 +1,242 @@
+"""ProofTerm AST nodes for propositional logic (natural deduction).
+
+Each node corresponds to one natural deduction inference rule.
+
+Inference rules covered:
+    PVar      Var     h : A in ctx  =>  ctx |- A
+    PLam      ->-I    ctx, x:A |- B  =>  ctx |- A -> B
+    PApp      ->-E    ctx |- A -> B,  ctx |- A  =>  ctx |- B
+    PAndI     /\\-I   ctx |- A,  ctx |- B  =>  ctx |- A /\\ B
+    PAndE1    /\\-E1  ctx |- A /\\ B  =>  ctx |- A
+    PAndE2    /\\-E2  ctx |- A /\\ B  =>  ctx |- B
+    POrIL     \\/-I1  ctx |- A  =>  ctx |- A \\/ B
+    POrIR     \\/-I2  ctx |- B  =>  ctx |- A \\/ B
+    POrE      \\/-E   ctx |- A \\/ B, ctx,h:A |- C, ctx,h:B |- C  =>  ctx |- C
+    PTrueI    T-I     ctx |- True
+    PFalseE   F-E     ctx |- False  =>  ctx |- A  (ex falso)
+    PExI      ∃-I     ctx |- P[A/x]  =>  ctx |- ∃x. P
+    PExE      ∃-E     ctx |- ∃x. P,  ctx, h:P[α/x] |- C  =>  ctx |- C
+
+Note on negation: FNot is not a primitive node.
+    ~A is sugar for FImpl(A, FFalse), expanded during formula parsing
+    from formula text to Formula AST.
+    PNotI = PLam,  PNotE = PApp  (no extra nodes needed).
+
+TODO:
+- Add PRefl once FEq and a Term AST are introduced.
+- Add oracle proof terms (PRing, PSimp, POmega) via reflection.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from .formulas import Formula
+
+
+class ProofTerm(ABC):
+    @property
+    @abstractmethod
+    def has_meta_var(self) -> bool:
+        pass
+
+
+@dataclass()
+class PMetaVar(ProofTerm):
+    """Meta-variable (proof hole): represents an unresolved subgoal in the proof tree."""
+
+    goal_id: str
+
+    @property
+    def has_meta_var(self) -> bool:
+        return True
+
+
+@dataclass()
+class PVar(ProofTerm):
+    """Hypothesis variable: proves A when h : A is in context."""
+
+    name: str
+
+    @property
+    def has_meta_var(self) -> bool:
+        return False
+
+
+@dataclass()
+class PLam(ProofTerm):
+    """Implication introduction: abstracts over a hypothesis.
+
+    Proves antecedent -> consequent when body proves consequent
+    under the assumption var : dom (= antecedent).
+    """
+
+    var: str
+    dom: Formula
+    body: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.body.has_meta_var
+
+
+@dataclass()
+class PApp(ProofTerm):
+    """Implication elimination (modus ponens)."""
+
+    fn: ProofTerm
+    arg: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.fn.has_meta_var or self.arg.has_meta_var
+
+
+@dataclass()
+class PAndI(ProofTerm):
+    """Conjunction introduction."""
+
+    left: ProofTerm
+    right: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.left.has_meta_var or self.right.has_meta_var
+
+
+@dataclass()
+class PAndE1(ProofTerm):
+    """Conjunction elimination, left projection."""
+
+    inner: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.inner.has_meta_var
+
+
+@dataclass()
+class PAndE2(ProofTerm):
+    """Conjunction elimination, right projection."""
+
+    inner: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.inner.has_meta_var
+
+
+@dataclass()
+class POrIL(ProofTerm):
+    """Disjunction introduction, left.
+
+    right_type must be provided explicitly because type_check cannot
+    infer the right disjunct from the proof term alone.
+    """
+
+    pf: ProofTerm
+    right_type: Formula
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.pf.has_meta_var
+
+@dataclass()
+class POrIR(ProofTerm):
+    """Disjunction introduction, right."""
+
+    left_type: Formula
+    pf: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.pf.has_meta_var
+
+
+@dataclass()
+class PTrueI(ProofTerm):
+    """True introduction: proves FTrue unconditionally."""
+
+    @property
+    def has_meta_var(self) -> bool:
+        return False
+
+
+@dataclass()
+class POrE(ProofTerm):
+    """Disjunction elimination (case split).
+
+    Given a proof of A \\/ B, and a proof of C assuming A (left branch),
+    and a proof of C assuming B (right branch), concludes C.
+
+    left_var  : name bound in left_branch  (h : A)
+    right_var : name bound in right_branch (h : B)
+    """
+
+    disj: ProofTerm
+    left_var: str
+    left_branch: ProofTerm
+    right_var: str
+    right_branch: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return (
+            self.disj.has_meta_var or
+            self.left_branch.has_meta_var or
+            self.right_branch.has_meta_var
+        )
+
+
+@dataclass()
+class PFalseE(ProofTerm):
+    """False elimination (ex falso quodlibet): proves any formula from FFalse."""
+
+    inner: ProofTerm
+    conclusion: Formula
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.inner.has_meta_var
+
+
+@dataclass()
+class PExI(ProofTerm):
+    """Existential introduction (∃-I).
+
+    Proves FExists(exists_var, body) when pf proves body[witness/exists_var].
+    Both exists_var and body must be provided because the type checker cannot
+    infer them from the proof term alone.
+    """
+
+    exists_var: str
+    body: Formula
+    witness: Formula
+    pf: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.pf.has_meta_var
+
+
+@dataclass()
+class PExE(ProofTerm):
+    """Existential elimination (∃-E).
+
+    Given pf : ∃x. P(x), introduces a fresh propositional variable prop_var
+    and a hypothesis hyp_var : P[prop_var/x], then proves the conclusion C
+    (which must not mention prop_var).
+
+    prop_var  : name of the fresh propositional variable (appears in hyp type)
+    hyp_var   : proof-context name bound to P[prop_var/x]
+    """
+
+    pf: ProofTerm
+    prop_var: str
+    hyp_var: str
+    body: ProofTerm
+
+    @property
+    def has_meta_var(self) -> bool:
+        return self.pf.has_meta_var or self.body.has_meta_var

poussins-0.0.1/src/poussins/cli/__init__.py

@@ -0,0 +1,14 @@
+"""Public CLIs."""
+
+
+from .batch import run_batch
+from .step import run_step
+from .lean import run_lean2py, run_py2lean
+
+
+__all__ = [
+    "run_batch",
+    "run_step",
+    "run_lean2py",
+    "run_py2lean",
+]

poussins-0.0.1/src/poussins/cli/batch.py

@@ -0,0 +1,24 @@
+
+"""Batch proof execution subcommand for poussins CLI."""
+
+
+def run_batch(filepath: str):
+    """
+    Run batch proof execution: import the file, collect all theorems/lemmas, and log their status.
+    """
+    import importlib.util
+    import sys
+    import os
+
+    file_abspath = os.path.abspath(filepath)
+    file_dir = os.path.dirname(file_abspath)
+    sys.path.insert(0, file_dir)
+    sys.path.insert(0, os.getcwd())
+    module_name = os.path.splitext(os.path.basename(filepath))[0]
+    spec = importlib.util.spec_from_file_location(module_name, file_abspath)
+    module = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(module)
+    except Exception as e:
+        print(f"[poussins] Error executing {filepath}: {e}")
+        return

poussins-0.0.1/src/poussins/cli/lean.py

@@ -0,0 +1,13 @@
+"""Lean conversion subcommand."""
+
+def run_lean2py(filepath: str, output: str | None = None):
+    """
+    Convert Lean file to Python DSL.
+    """
+    print(f"[poussins] Lean to Python conversion (stub): {filepath} -> {output}")
+
+def run_py2lean(filepath: str, output: str | None = None):
+    """
+    Convert Python DSL file to Lean format.
+    """
+    print(f"[poussins] Python to Lean conversion (stub): {filepath} -> {output}")

poussins-0.0.1/src/poussins/cli/main.py

@@ -0,0 +1,42 @@
+"""Command-line entrypoint wiring for poussins."""
+
+
+import argparse
+from .batch import run_batch
+from .step import run_step
+from .lean import run_lean2py, run_py2lean
+
+def main():
+    parser = argparse.ArgumentParser(description="poussins command line")
+    subparsers = parser.add_subparsers(dest="subcmd", required=True)
+
+
+    # batch
+    p_batch = subparsers.add_parser("batch", help="Batch proof execution (.py)")
+    p_batch.add_argument("filepath", help=".py file with theorems/lemmas")
+
+    # step
+    p_step = subparsers.add_parser("step", help="Step-by-step proof execution")
+    p_step.add_argument("filepath", help=".py file with theorems/lemmas")
+    p_step.add_argument("--theorem", help="Theorem name to step through", default=None)
+
+    # lean2py
+    p_lean2py = subparsers.add_parser("lean2py", help="Convert Lean file to Python DSL")
+    p_lean2py.add_argument("filepath", help=".lean file to convert")
+    p_lean2py.add_argument("--output", help="Output file path", default=None)
+
+    # py2lean
+    p_py2lean = subparsers.add_parser("py2lean", help="Convert Python DSL to Lean format")
+    p_py2lean.add_argument("filepath", help=".py file to convert")
+    p_py2lean.add_argument("--output", help="Output file path", default=None)
+
+    args = parser.parse_args()
+
+    if args.subcmd == "batch":
+        run_batch(args.filepath)
+    elif args.subcmd == "step":
+        run_step(args.filepath, args.theorem)
+    elif args.subcmd == "lean2py":
+        run_lean2py(args.filepath, args.output)
+    elif args.subcmd == "py2lean":
+        run_py2lean(args.filepath, args.output)

poussins-0.0.1/src/poussins/cli/step.py

@@ -0,0 +1,8 @@
+
+"""Step-by-step proof execution subcommand for poussins CLI."""
+
+def run_step(filepath: str, theorem: str | None = None):
+    """
+    Run step-by-step proof execution for a given file and theorem (stub).
+    """
+    print(f"[poussins] Step-by-step execution (stub): {filepath}, theorem={theorem}")

poussins-0.0.1/src/poussins/dsl/__init__.py

@@ -0,0 +1,27 @@
+"""Public DSL layer: Prop, Axiom, Theorem, Example, and aliases."""
+
+from .prop import Prop
+from .axiom import Axiom
+from .theorem import (
+    Theorem,
+    Lemma,
+    Proposition,
+    Corollary,
+    Fact,
+    Remark,
+    Property,
+    Example,
+)
+
+__all__ = [
+    "Prop",
+    "Axiom",
+    "Theorem",
+    "Lemma",
+    "Proposition",
+    "Corollary",
+    "Fact",
+    "Remark",
+    "Property",
+    "Example",
+]

poussins-0.0.1/src/poussins/dsl/axiom.py

@@ -0,0 +1,23 @@
+"""Axiom: a named proposition accepted without proof."""
+
+from __future__ import annotations
+
+class Axiom:
+    """A named proposition accepted without proof.
+
+    Axioms always have assurance TRUSTED.
+
+    If *env* is provided the axiom is registered immediately, mirroring
+    Coq's ``Axiom foo : T.`` which registers into the global environment
+    on the same line.
+
+    Usage::
+
+        # declare and register in one step (Coq-style)
+        ax = Axiom("excluded_middle", p | ~p, env)
+
+        # declare only — useful for tests or composing declarations
+        ax = Axiom("excluded_middle", p | ~p)
+        env.register(ax.to_declaration())
+    """
+    pass

poussins-0.0.1/src/poussins/dsl/proof_base.py

@@ -0,0 +1,66 @@
+"""ProofBase: tactic methods for proof-carrying DSL objects (Theorem, Example).
+
+This abstract base class provides method-style tactic access on top of the underlying
+ProofEngine. The logic of each tactic lives in ``tactics/primitive.py``
+and ``tactics/derived.py``; this module only delegates to those functions.
+
+Classes that inherit ProofBase must implement the ``engine`` property.
+
+Usage::
+
+    th = Theorem("identity", p >> p)
+    th.intro("h")
+    th.exact("h")
+    th.qed(env)
+
+Alternatively, the same tactics are still available as standalone
+functions for use in combinators or batch execution::
+
+    from poussins import intro, exact
+    intro(th.engine, "h")
+    exact(th.engine, "h")
+"""
+
+from __future__ import annotations
+from abc import ABC
+
+from ..ast.formulas import Formula
+from ..ast.proof_terms import ProofTerm
+from ..kernel.proof_engine import ProofEngine
+from .prop import Prop
+
+
+class ProofBase(ABC):
+    def __init__(self, statement: Prop | Formula):
+        self.__setattr__("engine", ProofEngine(Prop.to_formula(statement)))
+
+    def is_closed(self) -> bool:
+        return self.engine.is_closed()
+
+    def qed(self):
+        # TODO: Add to Envirnonment and closed status should be checked in engine.
+        if not self.is_closed():
+            raise ValueError("Not proofed.")
+        print(f"Assignment: {self.engine.goal.assignment}")
+
+    # ------------------------------------------------------------------
+    # Primitive tactics
+    # ------------------------------------------------------------------
+
+    def intro(self, name: str) -> None:
+        from ..tactics.primitive import intro
+        intro(self.engine, name)
+
+    def exact(self, term_or_hyp: ProofTerm | str) -> None:
+        from ..tactics.primitive import exact
+        exact(self.engine, term_or_hyp)
+
+    def apply(self, term_or_hyp: ProofTerm | str) -> None:
+        from ..tactics.primitive import apply
+        apply(self.engine, term_or_hyp)
+
+    # ------------------------------------------------------------------
+    # Derived tactics
+    # ------------------------------------------------------------------
+
+    # TODO: add derived tactics here

poussins-0.0.1/src/poussins/dsl/prop.py

@@ -0,0 +1,104 @@
+"""Prop: public-facing propositional formula DSL.
+
+Wraps the internal Formula AST with Python operator overloads so that
+propositions can be written naturally in Python code:
+
+    p, q = Prop("P"), Prop("Q")
+    p >> q        # P → Q  (implication)
+    p & q         # P ∧ Q  (conjunction)
+    p | q         # P ∨ Q  (disjunction)
+    ~p            # ¬P     (negation, sugar for P → ⊥)
+    Prop.top()    # ⊤
+    Prop.bot()    # ⊥
+    Prop.exists("x", p)  # ∃x. P
+
+Prop is immutable.  The underlying Formula is accessible via .formula.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass
+
+from ..ast.formulas import (
+    Formula,
+    FVar,
+    FTrue,
+    FFalse,
+    FExists,
+    FAnd, FImpl, FOr)
+
+
+@dataclass(frozen=True)
+class Prop:
+    def __init__(self, formula: Formula | str) -> None:
+        if isinstance(formula, Formula):
+            object.__setattr__(self, "formula", formula)
+        else:
+            object.__setattr__(self, "formula", FVar(formula))
+
+    # ------------------------------------------------------------------
+    # Factory helpers
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def top(cls) -> Prop:
+        """⊤ (True)."""
+        return cls(FTrue())
+
+    @classmethod
+    def bot(cls) -> Prop:
+        """⊥ (False)."""
+        return cls(FFalse())
+
+    @classmethod
+    def exists(cls, var: str, body: Formula) -> Prop:
+        """∃var. body."""
+        return cls(FExists(var, body))
+
+    # ------------------------------------------------------------------
+    # Coercion
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def to_formula(prop_or_formula: Prop | Formula) -> Formula:
+        return prop_or_formula.formula if isinstance(prop_or_formula, Prop) else prop_or_formula
+
+    @staticmethod
+    def to_prop(prop_or_formula: Prop | Formula) -> Prop:
+        return prop_or_formula if isinstance(prop_or_formula, Prop) else Prop(prop_or_formula)
+
+    # ------------------------------------------------------------------
+    # Operator overloads
+    # ------------------------------------------------------------------
+
+    def __rshift__(self, other: Prop | Formula) -> Prop:
+        """P >> Q  →  P → Q  (implication)."""
+        return Prop(FImpl(self.to_formula(self), self.to_formula(other)))
+
+    def __and__(self, other: Prop | Formula) -> Prop:
+        """P & Q  →  P ∧ Q  (conjunction)."""
+        return Prop(FAnd(self.to_formula(self), self.to_formula(other)))
+
+    def __or__(self, other: Prop | Formula) -> Prop:
+        """P | Q  →  P ∨ Q  (disjunction)."""
+        return Prop(FOr(self.to_formula(self), self.to_formula(other)))
+
+    def __invert__(self) -> Prop:
+        """~P  →  P → ⊥  (negation)."""
+        return Prop(FImpl(self.to_formula(self), FFalse()))
+
+    # ------------------------------------------------------------------
+    # Equality / hashing — delegate to Formula
+    # ------------------------------------------------------------------
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Prop):
+            return self.formula == other.formula
+        elif isinstance(other, Formula):
+            return self.formula == other
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.formula)
+
+    def __repr__(self) -> str:
+        return f"Prop({self.formula!r})"

poussins-0.0.1/src/poussins/dsl/theorem.py

@@ -0,0 +1,102 @@
+"""Theorem, Lemma, Example: proof-carrying DSL objects.
+
+Usage pattern::
+
+    from poussins import Prop, Theorem, Lemma, Axiom, Example, Environment
+    from poussins import intro, exact
+
+    p, q = Prop("P"), Prop("Q")
+    env = Environment()
+
+    # Theorem: named, registered in Environment
+    th = Theorem("identity", p >> p)
+    th.intro("h")       # method-style via ProofBase
+    th.exact("h")
+    th.qed(env)
+
+    # Standalone functions are also available (useful in combinators)
+    intro(th.engine, "h")
+    exact(th.engine, "h")
+
+    # Lemma: alias for Theorem (stylistic distinction only)
+    lem = Lemma("and_comm", (p & q) >> (q & p))
+    ...
+
+    # Example: anonymous proof, never registered
+    ex = Example(p >> p)
+    intro(ex, "h")
+    exact(ex, "h")
+    assert ex.closed
+
+Design:
+    Theorem  wraps ProofSession and produces a Declaration on success.
+             Inherits ProofBase for method-style tactic access.
+    Example  is like Theorem but anonymous and does not produce a Declaration.
+
+    None of the above hold a reference to an Environment; that is the
+    caller's concern.
+
+See also:
+    dsl/proof_base.py  for ProofBase (method delegation layer).
+    dsl/axiom.py       for Axiom (no-proof declarations).
+"""
+
+from __future__ import annotations
+
+from ..ast.formulas import Formula
+from .prop import Prop
+from .proof_base import ProofBase
+
+
+class Theorem(ProofBase):
+    """A named proposition together with an interactive proof session.
+
+    Tactics can be applied as methods (via ProofBase) or as standalone
+    functions — both styles are equivalent::
+
+        th = Theorem("mp", (p >> q) >> p >> q)
+        th.intro("hpq")          # method style
+        intro(th.engine, "hpq")         # function style — also valid
+
+        th.intro("hp")
+        th.apply("hpq")
+        th.exact("hp")
+        th.qed(env)              # seals the proof and registers into env
+    """
+
+
+    def __init__(
+        self,
+        name: str,
+        statement: Prop
+    ) -> None:
+        self.name = name
+        super().__init__(statement)
+
+
+# Alias for Theorem.
+Lemma = Theorem
+Proposition = Theorem
+Corollary = Theorem
+Fact = Theorem
+Remark = Theorem
+Property = Theorem
+
+
+class Example(ProofBase):
+    """An anonymous proof for exploration or testing.
+
+    Like Theorem but without a name and without to_declaration().
+    Tactics can be applied as methods (via ProofBase) or as standalone
+    functions — both styles are equivalent::
+
+        ex = Example(p >> p)
+        ex.intro("h")    # method style
+        ex.exact("h")
+        assert ex.closed
+    """
+    def __init__(
+        self,
+        statement: Prop | Formula,
+    ) -> None:
+        super().__init__(statement)

poussins-0.0.1/src/poussins/environment/__init__.py

@@ -0,0 +1 @@
+# TODO: implementation

poussins-0.0.1/src/poussins/kernel/__init__.py

@@ -0,0 +1,7 @@
+"""Internal kernel package (non-public).
+
+Do not import from this package in user code.
+Public APIs are re-exported from top-level packages only.
+"""
+
+__all__: list[str] = []

poussins-0.0.1/src/poussins/kernel/goal.py

@@ -0,0 +1,54 @@
+"""
+"""
+
+from __future__ import annotations
+from enum import Enum
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+from uuid import uuid4
+
+from ..ast.proof_terms import ProofTerm, Formula
+
+
+class ProofAssurance(str, Enum):
+    """Verification assurance axis."""
+
+    UNKNOWN = "unknown"
+    VERIFIED = "verified"
+    TRUSTED = "trusted"
+    ADMITTED = "admitted"
+    INVALID = "invalid"
+
+
+@dataclass(frozen=True)
+class Context:
+    hyps: Dict[str, Formula]
+
+    def get(self, name: str) -> Optional[Formula]:
+        return self.hyps.get(name)
+
+    def add(self, additional_hyps: Dict[str, Formula]) -> Context:
+        new_hyps = dict(self.hyps)
+        new_hyps.update(additional_hyps)
+        return Context(hyps=new_hyps)
+
+
+@dataclass
+class Goal:
+    id: str = field(init=False)
+    formula: Formula
+    context: Context
+    assignment: Optional[ProofTerm] = None
+    assurance: ProofAssurance = ProofAssurance.UNKNOWN
+
+    def __post_init__(self):
+        self.id = str(uuid4())
+
+    def is_closed(self) -> bool:
+        if self.assignment is None:
+            return False
+        else:
+            return not self.assignment.has_meta_var
+
+    def __eq__(self, other: Goal) -> bool:
+        return self.id == other.id

poussins-0.0.1/src/poussins/kernel/proof_engine.py

@@ -0,0 +1,98 @@
+"""
+"""
+
+from collections import deque
+from copy import deepcopy
+from typing import Optional
+
+from poussins.ast import *
+
+from .proof_state import ProofState
+from .goal import Goal, Context, ProofAssurance
+from ..ast import Formula, ProofTerm, PMetaVar
+
+
+class ProofEngine:
+    """Proof engine: manages the proof state and applies inference rules to manipulate goals."""
+
+    def __init__(self, root_formula: Formula):
+        self.goal = Goal(formula=root_formula, context=Context(hyps={}))
+        self.state = ProofState(goals=deque([self.goal]))
+
+    @staticmethod
+    def _substitute_meta_var(closed_goal: Goal, term: ProofTerm) -> ProofTerm:
+        if not closed_goal.is_closed():
+            return term
+        elif isinstance(term, PMetaVar) and term.goal_id == closed_goal.id:
+            return deepcopy(closed_goal.assignment)
+        else:
+            match term:
+                case PLam():
+                    term.body = ProofEngine._substitute_meta_var(closed_goal, term.body)
+                case PApp():
+                    term.fn = ProofEngine._substitute_meta_var(closed_goal, term.fn)
+                    term.arg = ProofEngine._substitute_meta_var(closed_goal, term.arg)
+                case PAndI():
+                    term.left = ProofEngine._substitute_meta_var(closed_goal, term.left)
+                    term.right = ProofEngine._substitute_meta_var(closed_goal, term.right)
+                case PAndE1():
+                    term.inner = ProofEngine._substitute_meta_var(closed_goal, term.inner)
+                case PAndE2():
+                    term.inner = ProofEngine._substitute_meta_var(closed_goal, term.inner)
+                case POrIL():
+                    term.pf = ProofEngine._substitute_meta_var(closed_goal, term.pf)
+                case POrIR():
+                    term.pf = ProofEngine._substitute_meta_var(closed_goal, term.pf)
+                case POrE():
+                    term.disj = ProofEngine._substitute_meta_var(closed_goal, term.disj)
+                    term.left_branch = ProofEngine._substitute_meta_var(closed_goal, term.left_branch)
+                    term.right_branch = ProofEngine._substitute_meta_var(closed_goal, term.right_branch)
+                case PFalseE():
+                    term.inner = ProofEngine._substitute_meta_var(closed_goal, term.inner)
+                case PExE():
+                    term.pf = ProofEngine._substitute_meta_var(closed_goal, term.pf)
+                    term.body = ProofEngine._substitute_meta_var(closed_goal, term.body)
+
+            return term
+
+    
+    def _close_sub_goals(self, closed_goal: Goal):
+        if not closed_goal.is_closed():
+            raise ValueError("Cannot close sub-goals of an open goal.")
+        else:
+            self.state.goals.remove(closed_goal)
+
+        closed_goals: list[Goal] = []
+        for goal in list(self.state.goals):
+            goal.assignment = ProofEngine._substitute_meta_var(closed_goal, goal.assignment)
+            if goal.is_closed() and goal not in closed_goals:
+                closed_goals.append(goal)
+
+        for closed_goal in closed_goals:
+            self._close_sub_goals(closed_goal)
+
+    def close_goal(self, assignment: ProofTerm):
+        current_goal = self.state.current_goal()
+        if current_goal is None:
+            raise ValueError("No active goal to close.")
+        elif current_goal.assignment is not None:
+            raise ValueError("Current goal is already assigned a proof term.")
+        elif assignment.has_meta_var:
+            raise ValueError("Cannot close goal with a proof term containing meta-variables.")
+        else:
+            current_goal.assignment = assignment
+            self._close_sub_goals(current_goal)
+
+    def refine_goal(self, sub_goals: list[Goal], assignment: Optional[ProofTerm] = None):
+        if assignment is not None:
+            self.state.current_goal().assignment = assignment
+        self.state.goals.extendleft(sub_goals[::-1])
+
+    def rotate_left(self):
+        self.state.goals.rotate(-1)
+
+    def rotate_right(self):
+        self.state.goals.rotate(1)
+
+    def is_closed(self) -> bool:
+        return self.state.is_closed() and self.goal.is_closed()

poussins-0.0.1/src/poussins/kernel/proof_state.py

@@ -0,0 +1,20 @@
+""" 
+"""
+
+from __future__ import annotations
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Optional
+
+from .goal import Goal
+
+
+@dataclass
+class ProofState:
+    goals: deque[Goal] = field(default_factory=deque)
+    
+    def current_goal(self) -> Optional[Goal]:
+        return self.goals[0] if self.goals else None
+    
+    def is_closed(self) -> bool:
+        return not self.goals

poussins-0.0.1/src/poussins/tactics/__init__.py

@@ -0,0 +1,11 @@
+"""Public tactic API."""
+
+
+from .primitive import intro, exact, apply
+
+
+__all__ = [
+    "intro",
+    "exact",
+    "apply"
+]

poussins-0.0.1/src/poussins/tactics/derived.py

@@ -0,0 +1,2 @@
+"""
+"""

poussins-0.0.1/src/poussins/tactics/primitive.py

@@ -0,0 +1,90 @@
+"""
+"""
+
+from copy import deepcopy
+
+from poussins.ast.proof_terms import PLam, ProofTerm
+
+from ..kernel.proof_engine import ProofEngine
+from ..kernel.goal import Goal
+from ..ast import Formula, FImpl, PMetaVar, PVar, PApp
+
+
+def intro(proof_engine: ProofEngine, hyp_name: str):
+    """Introduce a new hypothesis."""
+    current_goal = proof_engine.state.current_goal()
+    if current_goal is None:
+        raise ValueError("No active goal to apply intro tactic.")
+    elif not isinstance(current_goal.formula, FImpl):
+        raise ValueError("Intro tactic can only be applied to implications.")
+
+    sub_goal = Goal(
+        formula=deepcopy(current_goal.formula.consequent),
+        context=current_goal.context.add(
+            { hyp_name: deepcopy(current_goal.formula.antecedent) }
+        ),
+        assignment=PMetaVar(goal_id=current_goal.id)
+    )
+    proof_engine.refine_goal(
+        [sub_goal],
+        assignment=PLam(
+            var=hyp_name,
+            dom=deepcopy(current_goal.formula.antecedent),
+            body=PMetaVar(goal_id=sub_goal.id)
+        )
+    )
+
+
+def exact(proof_engine: ProofEngine, hyp_name: str):
+    """Close the current goal with a hypothesis."""
+    current_goal = proof_engine.state.current_goal()
+    if current_goal is None:
+        raise ValueError("No active goal to apply exact tactic.")
+
+    hyp = current_goal.context.get(hyp_name)
+    if hyp is None:
+        raise ValueError(f"Hypothesis '{hyp_name}' not found in the current context.")
+    elif hyp != current_goal.formula:
+        raise ValueError(f"Hypothesis '{hyp_name}' does not match the current goal formula.")
+
+    proof_engine.close_goal(PVar(name=hyp_name))
+
+
+def apply(proof_engine: ProofEngine, hyp_name: str):
+    current_goal = proof_engine.state.current_goal()
+    if current_goal is None:
+        raise ValueError("No active goal to apply apply tactic.")
+
+    hyp = current_goal.context.get(hyp_name)
+    if hyp is None:
+        raise ValueError(f"Hypothesis '{hyp_name}' not found in the current context.")
+    elif hyp == current_goal.formula:
+        exact(proof_engine, hyp_name)
+    elif not isinstance(hyp, FImpl):
+        raise ValueError(f"Hypothesis '{hyp_name}' is not an implication and cannot be applied.")
+
+    sub_goals, assignment = _apply(current_goal, hyp_name, hyp)
+    proof_engine.refine_goal(sub_goals=sub_goals, assignment=assignment)
+
+
+def _apply(
+        current_goal: Goal,
+        hyp_name: str,
+        hyp: Formula,
+        goals: list[Goal] = None,
+        idx: int = 0
+    ) -> tuple[list[Goal], ProofTerm]:
+    if goals is None:
+        goals = []
+
+    if current_goal.formula == hyp:
+        return goals, PVar(name=hyp_name)
+    elif isinstance(hyp, FImpl):
+        sub_goal = Goal(
+            formula=deepcopy(hyp.antecedent),
+            context=current_goal.context
+        )
+        sub_goals, assignment = _apply(current_goal, hyp_name, hyp.consequent, goals, idx + 1)
+        return [sub_goal] + sub_goals, PApp(fn=assignment, arg=PMetaVar(goal_id=sub_goal.id))
+    else:
+        raise ValueError(f"Hypothesis '{hyp}' cannot be applied to the current goal '{current_goal.formula}'.")