typedlogic 0.1.1__tar.gz

typedlogic-0.1.1/LICENSE

@@ -0,0 +1,22 @@
+
+The MIT License (MIT)
+
+Copyright (c) 2024 Monarch Initiative
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

typedlogic-0.1.1/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.1
+Name: typedlogic
+Version: 0.1.1
+Summary: typedlogic
+License: MIT
+Author: Author 1
+Author-email: author@org.org
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: clingo
+Provides-Extra: clorm
+Provides-Extra: llm
+Provides-Extra: pydantic
+Provides-Extra: pyprover
+Provides-Extra: rdflib
+Provides-Extra: snakelog
+Provides-Extra: sympy
+Provides-Extra: tests
+Provides-Extra: z3
+Requires-Dist: click
+Requires-Dist: clingo ; extra == "clingo"
+Requires-Dist: clorm ; extra == "clorm"
+Requires-Dist: importlib-metadata (>=8.2.0)
+Requires-Dist: llm ; extra == "llm"
+Requires-Dist: pydantic ; extra == "pydantic"
+Requires-Dist: pyprover ; extra == "pyprover"
+Requires-Dist: pytest (>=8.3.2,<9.0.0)
+Requires-Dist: rdflib ; extra == "rdflib"
+Requires-Dist: snakelog ; extra == "snakelog"
+Requires-Dist: sympy ; extra == "sympy"
+Requires-Dist: typer (>=0.12.5,<0.13.0)
+Requires-Dist: z3-solver ; extra == "z3"
+Description-Content-Type: text/markdown
+
+from typedlogic.registry import get_solver
+
+# py-typedlogic: Pythonic logic for your data models.
+
+Define logical predicates directly in Python as Pydantic, dataclasses, SQLModel, or plain python objects:
+
+```python
+# links.py
+from pydantic import BaseModel
+from typedlogic import FactMixin, Term
+
+ID = str
+
+class Link(BaseModel, FactMixin):
+    """A link between two entities"""
+    source: ID
+    target: ID
+
+class Path(BaseModel, FactMixin):
+    """An N-hop path between two entities, consisting of one or more links"""
+    source: ID
+    target: ID
+    hops: int
+```
+
+This data model has two classes, `Link` and `Path`. These also correspond to *predicate signatures*
+in a logical theory.
+
+You can use this to create objects (ground terms, in logic terms) using normal Python code:
+
+```python
+links = []
+for source, target in [('CA', 'OR'), ('OR', 'WA')]:
+   links.append(link)
+```
+
+Define logical *constraints* or *rules* using Python syntax:
+ 
+```python
+from typedlogic.decorators import axiom
+
+@axiom
+def path_from_link(x: ID, y: ID):
+    """If there is a link from x to y, there is a path from x to y"""
+    if Link(source=x, target=y):
+        assert Path(source=x, target=y, hops=1)
+
+@axiom
+def transitivity(x: ID, y: ID, z: ID, d1: int, d2: int):
+    """Transitivity of paths, plus hop counting"""
+    if Path(source=x, target=y, hops=d1) and Path(source=y, target=z, hops=d2):
+        assert Path(source=x, target=z, hops=d1+d2)
+```
+
+Use a solver to infer new facts:
+
+```python
+from typedlogic.registry import get_solver
+from links import Link
+
+solver = get_solver("clingo")
+solver.load(links) 
+links = [Link(source='CA', target='OR'), Link(source='OR', target='WA')]
+for link in links:
+    solver.add(link)
+model = solver.model()
+for fact in model.iter_retrieve("Path"):
+    print(fact)
+```
+
+prints:
+
+```
+Path(source='CA', target='OR')
+Path(source='OR', target='WA')
+Path(source='CA', target='WA')
+```
+
+## Key Features
+
+- Write logical axioms and rules using Python syntax (but can also be used independently of this)
+- Benefit from strong typing and mypy validation
+- Integration with multiple FOL solvers and logic programming engines
+- Interconversion between multiple syntaxes for FOL, Rules, and logical models
+- Integration with OWL-DL
+- Integration with Python libraries like Pydantic
+- Command Line and Python interfaces
+
+## Installation
+
+Install TypedLogic using pip:
+
+```bash
+pip install "typedlogic"
+```
+
+## Next Steps
+
+- Consult the main docs 
+

typedlogic-0.1.1/README.md

@@ -0,0 +1,99 @@
+from typedlogic.registry import get_solver
+
+# py-typedlogic: Pythonic logic for your data models.
+
+Define logical predicates directly in Python as Pydantic, dataclasses, SQLModel, or plain python objects:
+
+```python
+# links.py
+from pydantic import BaseModel
+from typedlogic import FactMixin, Term
+
+ID = str
+
+class Link(BaseModel, FactMixin):
+    """A link between two entities"""
+    source: ID
+    target: ID
+
+class Path(BaseModel, FactMixin):
+    """An N-hop path between two entities, consisting of one or more links"""
+    source: ID
+    target: ID
+    hops: int
+```
+
+This data model has two classes, `Link` and `Path`. These also correspond to *predicate signatures*
+in a logical theory.
+
+You can use this to create objects (ground terms, in logic terms) using normal Python code:
+
+```python
+links = []
+for source, target in [('CA', 'OR'), ('OR', 'WA')]:
+   links.append(link)
+```
+
+Define logical *constraints* or *rules* using Python syntax:
+ 
+```python
+from typedlogic.decorators import axiom
+
+@axiom
+def path_from_link(x: ID, y: ID):
+    """If there is a link from x to y, there is a path from x to y"""
+    if Link(source=x, target=y):
+        assert Path(source=x, target=y, hops=1)
+
+@axiom
+def transitivity(x: ID, y: ID, z: ID, d1: int, d2: int):
+    """Transitivity of paths, plus hop counting"""
+    if Path(source=x, target=y, hops=d1) and Path(source=y, target=z, hops=d2):
+        assert Path(source=x, target=z, hops=d1+d2)
+```
+
+Use a solver to infer new facts:
+
+```python
+from typedlogic.registry import get_solver
+from links import Link
+
+solver = get_solver("clingo")
+solver.load(links) 
+links = [Link(source='CA', target='OR'), Link(source='OR', target='WA')]
+for link in links:
+    solver.add(link)
+model = solver.model()
+for fact in model.iter_retrieve("Path"):
+    print(fact)
+```
+
+prints:
+
+```
+Path(source='CA', target='OR')
+Path(source='OR', target='WA')
+Path(source='CA', target='WA')
+```
+
+## Key Features
+
+- Write logical axioms and rules using Python syntax (but can also be used independently of this)
+- Benefit from strong typing and mypy validation
+- Integration with multiple FOL solvers and logic programming engines
+- Interconversion between multiple syntaxes for FOL, Rules, and logical models
+- Integration with OWL-DL
+- Integration with Python libraries like Pydantic
+- Command Line and Python interfaces
+
+## Installation
+
+Install TypedLogic using pip:
+
+```bash
+pip install "typedlogic"
+```
+
+## Next Steps
+
+- Consult the main docs 

typedlogic-0.1.1/pyproject.toml

@@ -0,0 +1,107 @@
+[tool.poetry]
+name = "typedlogic"
+version = "0.1.1"
+description = "typedlogic"
+authors = ["Author 1 <author@org.org>"]
+license = "MIT"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+click = "*"
+importlib-metadata = ">=8.2.0"
+pydantic = { version="*" }
+clingo = { version="*" }
+z3-solver = { version="*" }
+pyprover = { version="*" }
+snakelog = { version="*" }
+clorm = { version="*" }
+rdflib = { version="*" }
+sympy = { version="*" }
+#py-horned-owldl = { version="*" }
+llm = { version="*" }
+pytest = "^8.3.2"
+typer = "^0.12.5"
+
+[tool.poetry.group.dev.dependencies]
+pytest = {version = ">=8.3.2"}
+tox = {version = ">=4.16.0"}
+mypy = {version = "*"}
+types-PyYAML = {version = "*"}
+jupyter = {version = "*"}
+papermill = {version = "*"}
+nbdime = {version = "*"}
+nbformat = {version = "*"}
+pre-commit = {version = ">=3.3.3"}
+mkdocs = "*"
+mkdocs-mermaid2-plugin = "*"
+mkdocstrings = {extras = ["crystal", "python"], version = "*"}
+mknotebooks = "^0.8.0"
+mkdocs-windmill = "*"
+mkdocs-material = "*"
+
+
+[tool.poetry.extras]
+tests = ["black", "ruff"]
+pydantic = ["pydantic"]
+z3 = ["z3-solver"]
+clingo = ["clingo"]
+pyprover = ["pyprover"]
+snakelog = ["snakelog"]
+clorm = ["clorm"]
+rdflib = ["rdflib"]
+#owldl = ["py-horned-owldl"]
+llm = ["llm"]
+sympy = ["sympy"]
+
+
+[tool.poetry.scripts]
+typedlogic = "typedlogic.cli:app"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+vcs = "git"
+style = "pep440"
+
+[tool.black]
+line-length = 120
+target-version = ["py38", "py39", "py310"]
+
+[tool.ruff]
+lint.extend-ignore = [
+    "D211",  # `no-blank-line-before-class`
+    "D212",  # `multi-line-summary-first-line`
+    "D203",  # `blank-line-before-docstring`
+    ]
+line-length = 120
+
+# Allow autofix for all enabled rules (when `--fix`) is provided.
+lint.fixable = ["ALL"]
+
+# Select or ignore from https://beta.ruff.rs/docs/rules/
+lint.select = [
+    "B",  # bugbear
+    "D",  # pydocstyle
+    "E",  # pycodestyle errors
+    "F",  # Pyflakes
+    "I",  # isort
+    "S",  # flake8-bandit
+    "W",  # Warning
+]
+
+lint.unfixable = []
+target-version = "py310"
+
+[tool.ruff.lint.mccabe]
+# Unlike Flake8, default to a complexity level of 10.
+max-complexity = 10
+
+[tool.codespell]
+skip = "*.po,*.ts,.git,pyproject.toml"
+count = ""
+quiet-level = 3
+# ignore-words-list = ""
+
+[build-system]
+requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning"]
+build-backend = "poetry_dynamic_versioning.backend"

typedlogic-0.1.1/src/typedlogic/__init__.py

@@ -0,0 +1,44 @@
+"""typedlogic package."""
+from typedlogic.datamodel import (
+                                  BooleanSentence, And, Or, Not, Implies,
+                                  Forall, Exists, Term,
+                                  NegationAsFailure, not_provable, Xor, Implied, Iff, ExactlyOne,
+                                  Theory, Sentence,
+                                  PredicateDefinition, SentenceGroup,
+                                  Variable,
+                                  )
+from typedlogic.pybridge import FactMixin, Fact
+from typedlogic.generators import gen, gen1, gen2, gen3
+from typedlogic.decorators import axiom, goal
+
+__all__ = [
+    'BooleanSentence',
+    'And',
+    'Or',
+    'Not',
+    'Implies',
+    'Iff',
+    'Forall',
+    'Exists',
+    'Term',
+    'NegationAsFailure',
+    'not_provable',
+    'Xor',
+    'ExactlyOne',
+    'Implied',
+    'Theory',
+    'Sentence',
+    'Variable',
+    'PredicateDefinition',
+    'SentenceGroup',
+
+    'Fact',
+    'FactMixin',
+
+    'gen',
+    'gen1',
+    'gen2',
+    'gen3',
+
+]
+

typedlogic-0.1.1/src/typedlogic/builtins.py

@@ -0,0 +1,48 @@
+"""
+Mappings for builtin functions and datatypes.
+"""
+import operator as op
+from typing import Mapping, Callable
+
+NUMERIC_BUILTINS: Mapping[str, Callable] = {
+    'ge': op.ge,
+    'gt': op.gt,
+    'le': op.le,
+    'lt': op.lt,
+    'eq': op.eq,
+    'ne': op.ne,
+    'add': op.add,
+    'sub': op.sub,
+    'mul': op.mul,
+    'truediv': op.truediv,
+    'pow': op.pow,
+    'xor': op.xor,
+    'neg': op.neg,
+}
+
+NAME_TO_INFIX_OP: Mapping[str, str] = {
+'add': '+',
+    'sub': '-',
+    'mul': '*',
+    'truediv': '/',
+    'floordiv': '//',
+    'mod': '%',
+    'pow': '**',
+    'lshift': '<<',
+    'rshift': '>>',
+    'or': '|',
+    'xor': '^',
+    'and': '&',
+    'matmul': '@',
+    # Comparison operators
+    'eq': '==',
+    'ne': '!=',
+    'lt': '<',
+    'le': '<=',
+    'gt': '>',
+    'ge': '>=',
+    'is': 'is',
+    'is_not': 'is not',
+    'in': 'in',
+    'not_in': 'not in',
+}

typedlogic-0.1.1/src/typedlogic/cli.py

@@ -0,0 +1,76 @@
+"""
+Command-line interface definitions using typer.
+"""
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+
+from typedlogic.parsers.pyparser.python_parser import PythonParser
+from typedlogic.registry import get_compiler, get_solver
+
+app = typer.Typer()
+
+
+
+@app.command()
+def convert(
+        input_files: List[Path] = typer.Argument(..., exists=True, dir_okay=False, readable=True),
+        output_format: str = typer.Option(None, "--output-format", "-t", help="Output format"),
+        output_file: Optional[Path] = typer.Option(None, "--output-file", "-o", help="Output file path")
+):
+    """
+    Convert from one logic form to another.
+    """
+    parser = PythonParser()
+    theory = parser.parse(input_files[0])
+    if len(input_files) > 1:
+        for input_file in input_files[1:]:
+            facts_theory = parser.parse(input_file)
+            for s in facts_theory.sentences:
+                theory.add(s)
+
+    compiler = get_compiler(output_format or "z3sexpr")
+    result = compiler.compile(theory)
+
+    if output_file:
+        with open(output_file, 'w') as f:
+            f.write(result)
+        typer.echo(f"Conversion result written to {output_file}")
+    else:
+        typer.echo(result)
+
+
+@app.command()
+def solve(
+        input_file: Path = typer.Argument(..., exists=True, dir_okay=False, readable=True),
+        solver: str = typer.Option(None, help="Solver to use"),
+        output_file: Optional[Path] = typer.Option(None, "--output-file", "-o", help="Output file path for the solution")
+):
+    """
+    Solve using the specified solver.
+    """
+    parser = PythonParser()
+    theory = parser.parse(input_file)
+    solver_instance = get_solver(solver or "souffle")
+
+    solver_instance.add(theory)
+    solution = solver_instance.check()
+
+    result = f"Satisfiable: {solution.satisfiable}\n"
+    if solution.satisfiable:
+        model = solver_instance.model()
+        result += "Model:\n"
+        for fact in model.ground_terms:
+            result += f"{fact}\n"
+
+    if output_file:
+        with open(output_file, 'w') as f:
+            f.write(result)
+        typer.echo(f"Solution written to {output_file}")
+    else:
+        typer.echo(result)
+
+
+if __name__ == "__main__":
+    app()

typedlogic-0.1.1/src/typedlogic/compiler.py

@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import ClassVar, Optional, Type, Union
+
+from typedlogic import Sentence, Theory
+from typedlogic.parser import Parser
+
+
+class ModelSyntax(str, Enum):
+    UNKNOWN = "unknown"
+    SEXPR = "sexpr"
+    FUNCTIONAL = "functional"
+
+
+@dataclass
+class Compiler(ABC):
+    """
+    An engine for compiling from the internal logical model representation to an external format.
+
+    Note: one of the main use cases for compiling a theory is to generate an input for a solver.
+    For many use cases, it's possible to just use a Solver directly, and let the system
+    take care of compilation to an intermediate form.
+
+    You can use the registry `get_compiler` method to get a compiler for a particular syntax:
+
+        >>> from typedlogic.registry import get_compiler
+        >>> compiler = get_compiler("fol")
+
+    Next we will transpile from Python to FOL syntax. We will use a `Parser` object:
+
+        >>> from typedlogic.registry import get_parser
+        >>> parser = get_parser("python")
+        >>> theory = parser.parse_file("tests/theorems/animals.py")
+
+    Now we will compile the theory to FOL syntax:
+
+        >>> print(compiler.compile(theory))
+        Person('Fred')
+        Person('Jie')
+        Animal('corky', 'cat')
+        Animal('fido', 'dog')
+        ∀[x:Thing species:Thing]. Animal(x, species) → Likes(x, 'Fred')
+        ∀[x:Thing species:Thing]. Animal(x, 'cat') → Likes(x, 'Jie')
+        ∀[x:Thing species:Thing]. Animal(x, 'dog') → ¬Likes('Fred', x)
+
+    Another useful syntax is TPTP, which is accepted by many theorom provers:
+
+        >>> compiler = get_compiler("tptp")
+        >>> print(compiler.compile(theory))
+        % Problem: animals
+        fof(axiom1, axiom, person('Fred')).
+        fof(axiom2, axiom, person('Jie')).
+        fof(axiom3, axiom, animal('corky', 'cat')).
+        fof(axiom4, axiom, animal('fido', 'dog')).
+        fof(axiom5, axiom, ! [X, Species] : (animal(X, Species) => likes(X, 'Fred'))).
+        fof(axiom6, axiom, ! [X, Species] : (animal(X, 'cat') => likes(X, 'Jie'))).
+        fof(axiom7, axiom, ! [X, Species] : (animal(X, 'dog') => ~likes('Fred', X))).
+
+    Another common syntax is Prolog syntax, and its variants. These are often used by Datalog solvers:
+
+        >>> compiler = get_compiler("prolog")
+        >>> print(compiler.compile(theory))
+        %% Predicate Definitions
+        % Likes(subject: str, object: str)
+        % Person(name: str)
+        % Animal(name: str, species: str)
+        <BLANKLINE>
+        %% persons
+        <BLANKLINE>
+        person('Fred').
+        person('Jie').
+        <BLANKLINE>
+        %% animals
+        <BLANKLINE>
+        animal('corky', 'cat').
+        animal('fido', 'dog').
+        <BLANKLINE>
+        %% animal_preferences
+        <BLANKLINE>
+        likes(X, 'Fred') :- animal(X, Species).
+        likes(X, 'Jie') :- animal(X, 'cat').
+        <BLANKLINE>
+
+
+    """
+
+    default_suffix: ClassVar[str] = "txt"
+    parser_class: ClassVar[Optional[Type[Parser]]] = None
+    strict: Optional[bool] = None
+
+
+    @abstractmethod
+    def compile(self, theory: Theory, syntax: Optional[Union[str, ModelSyntax]] = None, **kwargs) -> str:
+        """
+        Compile a theory into an external representation.
+
+        :param theory:
+        :param syntax:
+        :param kwargs:
+        :return:
+        """
+        pass
+
+    def compile_sentence(self, sentence: Sentence, syntax: Optional[Union[str, ModelSyntax]] = None, **kwargs) -> str:
+        """
+        Compiles an individual sentence
+
+        :param sentence:
+        :param syntax:
+        :param kwargs:
+        :return:
+        """
+        theory = Theory()
+        theory.add(sentence)
+        return self.compile(theory, syntax=syntax, **kwargs)
+
+    @property
+    def suffix(self) -> str:
+        return self.default_suffix
+
+    def _add_untranslatable(self, sentence: Sentence):
+        pass

typedlogic-0.1.1/src/typedlogic/compilers/fol_compiler.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import ClassVar, Optional, Union
+
+from typedlogic import Theory
+from typedlogic.compiler import Compiler, ModelSyntax
+from typedlogic.transformations import as_fol
+
+
+@dataclass
+class FOLCompiler(Compiler):
+
+    default_suffix: ClassVar[str] = "fol"
+
+    def compile(self, theory: Theory, syntax: Optional[Union[str, ModelSyntax]] = None, **kwargs) -> str:
+        lines = []
+        for s in theory.sentences:
+            lines.append(as_fol(s))
+        return "\n".join(lines)