logic-asts 0.2.0__tar.gz → 0.3.2__tar.gz

logic_asts-0.3.2/.github/workflows/ci.yml

@@ -0,0 +1,38 @@
+name: "CI for Python package"
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test package
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+      # checkout@v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      # setup-uv@v6.0.1
+      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca
+        with:
+          version: "latest"
+          python-version: ${{ matrix.python-version }}
+      - name: Test with Python ${{ matrix.python-version }}
+        run: uv run --frozen --dev pytest
+      - name: Run type checker with Python
+        run: uv run --frozen --dev mypy src tests
+      - name: Run basedpyright
+        run: uvx basedpyright
+      - name: lint
+        run: uv run ruff check .
+      - name: format
+        run: uv run ruff format --check .
+

logic_asts-0.3.2/.github/workflows/pypi.yml

@@ -0,0 +1,69 @@
+name: "Test, build, and deploy Python package"
+
+on:
+  pull_request:
+    branches: [main]
+  push:
+    tags:
+      - v*
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Test package
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+      # checkout@v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      # setup-uv@v6.0.1
+      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca
+        with:
+          version: "latest"
+          python-version: ${{ matrix.python-version }}
+      - name: Test with Python ${{ matrix.python-version }}
+        run: uv run --frozen --dev pytest
+      - name: Run type checker with Python
+        run: uv run --frozen --dev mypy src tests
+
+  release-build:
+    name: Build and release package
+    runs-on: ubuntu-latest
+    needs:
+      - test
+    permissions:
+      # IMPORTANT: this permission is mandatory for trusted publishing
+      id-token: write
+
+    # Dedicated environments with protections for publishing are strongly recommended.
+    environment:
+      name: pypi
+      # OPTIONAL: uncomment and update to include your PyPI project URL in the deployment status:
+      url: https://pypi.org/p/logic-asts
+
+    if: "startsWith(github.ref, 'refs/tags/')"
+
+    steps:
+      # checkout@v4.2.2
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683
+      # setup-uv@v6.0.1
+      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca
+        with:
+          version: "latest"
+      - name: Install dependencies
+        run: uv sync
+      - name: Build wheels and sdist
+        run: uv build
+      - name: Upload wheels and sdist
+        # upload-artifact@v4.6.2
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02
+        with:
+          name: release-dists
+          path: dist/
+      - name: Publish release distributions to PyPI
+        run: uv publish

{logic_asts-0.2.0 → logic_asts-0.3.2}/Makefile

@@ -10,19 +10,19 @@ dev: uv.lock | .venv
 .PHONY: dev
 
 fmt:
-	uv run ruff format 
-	uv run ruff check --fix .
+	uv run --frozen ruff format 
+	uv run --frozen ruff check --fix .
 .PHONY: fmt
 
 typing:
-	uv run mypy src
+	uv run --frozen mypy src
 .PHONY: typing
 
 lint: fmt typing
 .PHONY: lint
 
 test:
-	uv run --dev pytest
+	uv run --dev --frozen pytest
 .PHONY: test
 
 uv.lock .venv &: pyproject.toml

{logic_asts-0.2.0 → logic_asts-0.3.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: logic-asts
-Version: 0.2.0
+Version: 0.3.2
 Summary: Grammars and parsers for various logic
 Author-email: Anand Balakrishnan <anandbala1597@gmail.com>
-Requires-Python: >=3.12
+Requires-Python: >=3.11
 Requires-Dist: attrs>=25.3.0
 Requires-Dist: lark>=1.2.2
 Requires-Dist: typing-extensions>=4.13.0

{logic_asts-0.2.0 → logic_asts-0.3.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "logic-asts"
-version = "0.2.0"
+version = "0.3.2"
 description = "Grammars and parsers for various logic"
 readme = "README.md"
 authors = [{ name = "Anand Balakrishnan", email = "anandbala1597@gmail.com" }]
-requires-python = ">=3.12"
+requires-python = ">=3.11"
 dependencies = ["attrs>=25.3.0", "lark>=1.2.2", "typing-extensions>=4.13.0"]
 
 [dependency-groups]
@@ -44,7 +44,7 @@ extend-ignore = ["F722", "PYI041"]
 "*.pyi" = ["B", "E501", "E701"]
 
 [tool.pyright]
-pythonVersion = "3.12"
+pythonVersion = "3.11"
 pythonPlatform = "All"
 reportUnknownMemberType = false
 reportUnknownParameterType = false

{logic_asts-0.2.0 → logic_asts-0.3.2}/src/logic_asts/__init__.py

@@ -43,7 +43,7 @@ class SupportedGrammars(enum.StrEnum):
         return transformer
 
 
-type SupportedGrammarsStr = typing.Literal["base", "ltl", "strel"]
+SupportedGrammarsStr: typing.TypeAlias = typing.Literal["base", "ltl", "strel"]
 
 
 def parse_expr(

logic_asts-0.3.2/src/logic_asts/base.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections import deque
+from collections.abc import Iterator
+from typing import Generic, Self, TypeVar, final
+
+from attrs import frozen
+from typing_extensions import override
+
+
+class Expr(ABC):
+    """Abstract expression"""
+
+    @abstractmethod
+    def expand(self) -> Expr: ...
+
+    @abstractmethod
+    def to_nnf(self) -> Expr: ...
+
+    @abstractmethod
+    def children(self) -> Iterator[Expr]: ...
+
+    def iter_subtree(self) -> Iterator[Expr]:
+        """Post-order traversal of the expression.
+
+        Iterates over all the sub-expressions of the formula, never returning to
+        the same sub-expression twice.
+        """
+        stack: deque[Expr] = deque([self])
+        visited: set[Expr] = set()
+
+        while stack:
+            subexpr = stack[-1]
+            need_to_visit_children = {
+                child
+                for child in subexpr.children()  # We need to visit `child`
+                if (child) not in visited  # if it hasn't already been visited
+            }
+
+            if visited.issuperset(need_to_visit_children):
+                # subexpr is a leaf (the set is empty) or it's children have been
+                # yielded get rid of it from the stack
+                _ = stack.pop()
+                # Add subexpr to visited
+                visited.add(subexpr)
+                # post-order return it
+                yield subexpr
+            else:
+                # mid-level node or an empty set
+                # Add relevant children to stack
+                stack.extend(need_to_visit_children)
+        # Yield the remaining nodes in the stack in reverse order
+        yield from reversed(stack)
+
+    @abstractmethod
+    def horizon(self) -> int | float:
+        """Compute the horizon of the formula. Returns `math.inf` if the formula is unbounded."""
+
+    def __invert__(self) -> Expr:
+        return Not(self)
+
+    def __and__(self, other: Expr) -> Expr:
+        return And(self, other)
+
+    def __or__(self, other: Expr) -> Expr:
+        return Or(self, other)
+
+
+@final
+@frozen
+class Implies(Expr):
+    lhs: Expr
+    rhs: Expr
+
+    @override
+    def __str__(self) -> str:
+        return f"{self.lhs} -> {self.rhs}"
+
+    @override
+    def expand(self) -> Expr:
+        return ~self.lhs | self.rhs
+
+    @override
+    def to_nnf(self) -> Expr:
+        return self.expand().to_nnf()
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.lhs
+        yield self.rhs
+
+    @override
+    def horizon(self) -> int | float:
+        return max(self.lhs.horizon(), self.rhs.horizon())
+
+
+@final
+@frozen
+class Equiv(Expr):
+    lhs: Expr
+    rhs: Expr
+
+    @override
+    def __str__(self) -> str:
+        return f"{self.lhs} <-> {self.rhs}"
+
+    @override
+    def expand(self) -> Expr:
+        x = self.lhs
+        y = self.rhs
+        return (x | ~y) & (~x | y)
+
+    @override
+    def to_nnf(self) -> Expr:
+        return self.expand().to_nnf()
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.lhs
+        yield self.rhs
+
+    @override
+    def horizon(self) -> int | float:
+        return max(self.lhs.horizon(), self.rhs.horizon())
+
+
+@final
+@frozen
+class Xor(Expr):
+    lhs: Expr
+    rhs: Expr
+
+    @override
+    def __str__(self) -> str:
+        return f"{self.lhs} ^ {self.rhs}"
+
+    @override
+    def expand(self) -> Expr:
+        x = self.lhs
+        y = self.rhs
+        return (x & ~y) | (~x & y)
+
+    @override
+    def to_nnf(self) -> Expr:
+        return self.expand().to_nnf()
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.lhs
+        yield self.rhs
+
+    @override
+    def horizon(self) -> int | float:
+        return max(self.lhs.horizon(), self.rhs.horizon())
+
+
+@final
+@frozen
+class And(Expr):
+    lhs: Expr
+    rhs: Expr
+
+    @override
+    def __str__(self) -> str:
+        return f"({self.lhs} & {self.rhs})"
+
+    @override
+    def to_nnf(self) -> Expr:
+        return self.lhs.to_nnf() & self.rhs.to_nnf()
+
+    @override
+    def expand(self) -> Expr:
+        return self.lhs.expand() & self.rhs.expand()
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.lhs
+        yield self.rhs
+
+    @override
+    def horizon(self) -> int | float:
+        return max(self.lhs.horizon(), self.rhs.horizon())
+
+
+@final
+@frozen
+class Or(Expr):
+    lhs: Expr
+    rhs: Expr
+
+    @override
+    def __str__(self) -> str:
+        return f"({self.lhs} | {self.rhs})"
+
+    @override
+    def to_nnf(self) -> Expr:
+        return self.lhs.to_nnf() | self.rhs.to_nnf()
+
+    @override
+    def expand(self) -> Expr:
+        return self.lhs.expand() | self.rhs.expand()
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.lhs
+        yield self.rhs
+
+    @override
+    def horizon(self) -> int | float:
+        return max(self.lhs.horizon(), self.rhs.horizon())
+
+
+@final
+@frozen
+class Not(Expr):
+    arg: Expr
+
+    @override
+    def __str__(self) -> str:
+        return f"!{str(self.arg)}"
+
+    @override
+    def __invert__(self) -> Expr:
+        return self.arg
+
+    @override
+    def to_nnf(self) -> Expr:
+        arg = self.arg
+        match arg:
+            case Literal():
+                return ~arg
+            case Variable():
+                return self
+            case Not(expr):
+                return expr.to_nnf()
+            case And(a, b):
+                return (~a).to_nnf() | (~b).to_nnf()
+            case Or(a, b):
+                return (~a).to_nnf() & (~b).to_nnf()
+            case _:
+                return arg.to_nnf()
+
+    @override
+    def expand(self) -> Expr:
+        return ~(self.arg.expand())
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.arg
+
+    @override
+    def horizon(self) -> int | float:
+        return self.arg.horizon()
+
+
+Var = TypeVar("Var")
+
+
+@final
+@frozen
+class Variable(Expr, Generic[Var]):
+    name: Var
+
+    @override
+    def __str__(self) -> str:
+        return str(self.name)
+
+    @override
+    def to_nnf(self) -> Expr:
+        return self
+
+    @override
+    def expand(self) -> Expr:
+        return self
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield from iter(())
+
+    @override
+    def horizon(self) -> int | float:
+        return 0
+
+
+@final
+@frozen
+class Literal(Expr):
+    value: bool
+
+    @override
+    def __str__(self) -> str:
+        return "t" if self.value else "f"
+
+    @override
+    def __invert__(self) -> Literal:
+        return Literal(not self.value)
+
+    @override
+    def __and__(self, other: Expr) -> Expr:
+        if self.value is False:
+            return self
+        elif isinstance(other, Literal):
+            return Literal(self.value and other.value)
+        else:
+            # True & x = x
+            return other
+
+    @override
+    def __or__(self, other: Expr) -> Expr:
+        if self.value is True:
+            return self
+        elif isinstance(other, Literal):
+            return Literal(self.value or other.value)
+        else:
+            # False | x = x
+            return other
+
+    @override
+    def to_nnf(self) -> Self:
+        return self
+
+    @override
+    def expand(self) -> Self:
+        return self
+
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield from iter(())
+
+    @override
+    def horizon(self) -> int | float:
+        return 0
+
+
+__all__ = [
+    "Expr",
+    "Implies",
+    "Equiv",
+    "Xor",
+    "And",
+    "Or",
+    "Not",
+    "Variable",
+    "Literal",
+]

{logic_asts-0.2.0 → logic_asts-0.3.2}/src/logic_asts/grammars/__init__.py

@@ -62,12 +62,15 @@ class LtlTransform(Transformer[Token, Expr]):
         return lhs & rhs
 
     def until(self, lhs: Expr, interval: TimeInterval | None, rhs: Expr) -> Expr:
+        interval = interval or TimeInterval()
         return Until(lhs, rhs, interval)
 
     def always(self, interval: TimeInterval | None, arg: Expr) -> Expr:
+        interval = interval or TimeInterval()
         return Always(arg, interval)
 
     def eventually(self, interval: TimeInterval | None, arg: Expr) -> Expr:
+        interval = interval or TimeInterval()
         return Eventually(arg, interval)
 
     def next(self, steps: int | None, arg: Expr) -> Expr:

{logic_asts-0.2.0 → logic_asts-0.3.2}/src/logic_asts/ltl.py

@@ -3,10 +3,11 @@ from __future__ import annotations
 import itertools
 import math
 from collections.abc import Iterator
+from typing import final
 
 import attrs
 from attrs import frozen
-from typing_extensions import final, override
+from typing_extensions import override
 
 from logic_asts.base import And, Equiv, Expr, Implies, Literal, Not, Or, Variable, Xor
 from logic_asts.utils import check_positive, check_start
@@ -15,7 +16,7 @@ from logic_asts.utils import check_positive, check_start
 @final
 @frozen
 class TimeInterval:
-    start: None | int = attrs.field(default=None, validator=[check_positive, check_start])
+    start: int | None = attrs.field(default=None, validator=[check_positive, check_start])
     end: int | None = attrs.field(default=None, validator=[check_positive])
 
     @override
@@ -26,6 +27,12 @@ class TimeInterval:
             case _:
                 return f"[{self.start or ''}, {self.end or ''}]"
 
+    def duration(self) -> int | float:
+        start = self.start or 0
+        end = self.end or math.inf
+
+        return end - start
+
     def is_unbounded(self) -> bool:
         return self.end is None or math.isinf(self.end)
 
@@ -90,12 +97,24 @@ class Next(Expr):
     def to_nnf(self) -> Expr:
         return Next(self.arg.to_nnf(), steps=self.steps)
 
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.arg
+
+    @override
+    def horizon(self) -> int | float:
+        arg_hrz = self.arg.horizon()
+        assert isinstance(arg_hrz, int) or math.isinf(arg_hrz), (
+            "`Next` cannot be used for continuous-time specifications, horizon cannot be computed"
+        )
+        return 1 + arg_hrz
+
 
 @final
 @frozen
 class Always(Expr):
     arg: Expr
-    interval: TimeInterval | None = None
+    interval: TimeInterval = attrs.field(factory=lambda: TimeInterval(None, None))
 
     @override
     def __str__(self) -> str:
@@ -109,12 +128,20 @@ class Always(Expr):
     def to_nnf(self) -> Expr:
         return self.expand().to_nnf()
 
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.arg
+
+    @override
+    def horizon(self) -> int | float:
+        return (self.interval.end or math.inf) + self.arg.horizon()
+
 
 @final
 @frozen
 class Eventually(Expr):
     arg: Expr
-    interval: TimeInterval | None = None
+    interval: TimeInterval = attrs.field(factory=lambda: TimeInterval(None, None))
 
     @override
     def __str__(self) -> str:
@@ -123,7 +150,7 @@ class Eventually(Expr):
     @override
     def expand(self) -> Expr:
         match self.interval:
-            case None | TimeInterval(None, None) | TimeInterval(0, None):
+            case TimeInterval(None, None) | TimeInterval(0, None):
                 # Unbounded F
                 return Eventually(self.arg.expand())
             case TimeInterval(0, int(t2)) | TimeInterval(None, int(t2)):
@@ -134,7 +161,7 @@ class Eventually(Expr):
                     expr = expr & Next(arg)
                 return expr
             case TimeInterval(int(t1), None):
-                # F[t1,inf]
+                # F[t1, inf]
                 assert t1 > 0
                 return Next(Eventually(self.arg), t1).expand()
             case TimeInterval(int(t1), int(t2)):
@@ -150,13 +177,21 @@ class Eventually(Expr):
     def to_nnf(self) -> Expr:
         return Eventually(self.arg.to_nnf(), self.interval)
 
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.arg
+
+    @override
+    def horizon(self) -> int | float:
+        return (self.interval.end or math.inf) + self.arg.horizon()
+
 
 @final
 @frozen
 class Until(Expr):
     lhs: Expr
     rhs: Expr
-    interval: TimeInterval | None = None
+    interval: TimeInterval = attrs.field(factory=lambda: TimeInterval(None, None))
 
     @override
     def __str__(self) -> str:
@@ -171,12 +206,12 @@ class Until(Expr):
         new_lhs = self.lhs.expand()
         new_rhs = self.rhs.expand()
         match self.interval:
-            case None | TimeInterval(None | 0, None):
+            case TimeInterval(None | 0, None):
                 # Just make an unbounded one here
                 return Until(new_lhs, new_rhs)
             case TimeInterval(t1, None):  # Unbounded end
                 return Always(
-                    arg=Until(interval=None, lhs=new_lhs, rhs=new_rhs),
+                    arg=Until(lhs=new_lhs, rhs=new_rhs),
                     interval=TimeInterval(0, t1),
                 ).expand()
             case TimeInterval(t1, _):
@@ -185,6 +220,16 @@ class Until(Expr):
                 z2 = Until(interval=until_interval, lhs=new_lhs, rhs=new_rhs).expand()
                 return z1 & z2
 
+    @override
+    def children(self) -> Iterator[Expr]:
+        yield self.lhs
+        yield self.rhs
+
+    @override
+    def horizon(self) -> int | float:
+        end = self.interval.end or math.inf
+        return max(self.lhs.horizon() + end - 1, self.rhs.horizon() + end)
+
 
 __all__ = [
     "Expr",