implica 0.3.0__py3-none-any.whl

implica/__init__.py

@@ -0,0 +1,44 @@
+"""
+Guanciale - Implicational Logic Graph Library
+
+A Python package for working with graphs representing minimal implicational
+logic models. This library provides tools for constructing and manipulating
+type systems based on combinatory logic, with support for transactional
+graph operations.
+
+Import as 'gil' for a clean, concise API:
+    import guanciale as gil
+
+    graph = gil.Graph()
+    A = gil.var("A")
+    B = gil.var("B")
+
+    with graph.connect() as conn:
+        conn.add_node(gil.node(A))
+        conn.add_node(gil.node(B))
+"""
+
+from .core import *
+from .graph import Node, Edge, node, edge, Graph, Connection
+from . import mutations
+
+
+__all__ = [
+    "BaseType",
+    "Variable",
+    "Application",
+    "var",
+    "app",
+    "Combinator",
+    "S",
+    "K",
+    "Node",
+    "Edge",
+    "node",
+    "edge",
+    "Graph",
+    "Connection",
+    "mutations",
+]
+
+__version__ = "0.3.0"

implica/core/__init__.py

@@ -0,0 +1,4 @@
+from .types import BaseType, Variable, Application, var, app
+from .combinator import Combinator, S, K
+
+__all__ = ["BaseType", "Variable", "Application", "var", "app", "Combinator", "S", "K"]

implica/core/combinator.py

@@ -0,0 +1,149 @@
+"""
+Combinator system for minimal implicational logic.
+
+This module defines combinators that represent transformations between types
+in the implicational logic graph.
+"""
+
+import hashlib
+from functools import cached_property
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .types import BaseType, Application, app
+
+
+class Combinator(BaseModel):
+    """
+    A combinator with a specific type.
+
+    In combinatory logic:
+    - S combinator: S x y z = x z (y z) with type (A -> B -> C) -> (A -> B) -> A -> C
+    - K combinator: K x y = x with type A -> B -> A
+
+    Each combinator has a name (e.g., "S", "K") and an application type.
+    """
+
+    name: str = Field(..., min_length=1, description="Name of the combinator")
+    type: BaseType = Field(..., description="Type of the combinator")
+
+    model_config = ConfigDict(frozen=True)  # Make immutable
+
+    @cached_property
+    def uid(self) -> str:
+        """
+        Return a unique identifier for this combinator.
+
+        The uid includes both the name and the type, as combinators with the same
+        name but different types are different combinators.
+
+        Returns:
+            str: SHA256 hash of the combinator name and type
+        """
+        content = f"Comb({self.name},{self.type.uid})"
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def __str__(self) -> str:
+        """Return the combinator name and type."""
+        return f"{self.name}: {self.type}"
+
+    def __repr__(self) -> str:
+        """Return a detailed representation."""
+        return f"Combinator(name='{self.name}', type={self.type})"
+
+    def __hash__(self) -> int:
+        """Make combinator hashable for use in sets and dicts."""
+        return hash((self.name, self.type.uid))
+
+    def __call__(self, other: "Combinator") -> "Combinator":
+        """
+        Apply this combinator to another combinator.
+
+        If this combinator has type A -> B and the input has type A,
+        the result will be a combinator with type B.
+
+        Args:
+            other: The combinator to apply this combinator to
+
+        Returns:
+            Combinator: The result of the application
+
+        Raises:
+            TypeError: If the types are incompatible
+        """
+        if not isinstance(self.type, Application):
+            raise TypeError(
+                f"Cannot apply combinator {self.name} with type {self.type} "
+                f"(not a function type)"
+            )
+
+        # Check if the input type matches
+        if self.type.input_type.uid != other.type.uid:
+            raise TypeError(
+                f"Type mismatch: expected {self.type.input_type}, " f"got {other.type}"
+            )
+
+        # Create the result combinator
+        result_name = f"({self.name} {other.name})"
+        return Combinator(name=result_name, type=self.type.output_type)
+
+
+# Helper functions for creating S and K combinators with specific types
+def S(A: BaseType, B: BaseType, C: BaseType) -> Combinator:
+    """
+    Create the S combinator with specific types.
+
+    Type: (A -> B -> C) -> (A -> B) -> A -> C
+
+    The S combinator implements the following computation:
+    S x y z = x z (y z)
+
+    Args:
+        A: Type variable A
+        B: Type variable B
+        C: Type variable C
+
+    Returns:
+        Combinator: The S combinator with the specified types
+    """
+    s_type = app(
+        app(A, app(B, C)),  # (A -> B -> C)
+        app(app(A, B), app(A, C)),  # (A -> B) -> A -> C
+    )
+    return Combinator(name="S", type=s_type)
+
+
+def K(A: BaseType, B: BaseType) -> Combinator:
+    """
+    Create the K combinator with specific types.
+
+    Type: A -> B -> A
+
+    The K combinator implements the following computation:
+    K x y = x
+
+    Args:
+        A: Type variable A
+        B: Type variable B
+
+    Returns:
+        Combinator: The K combinator with type A -> B -> A
+    """
+    k_type = app(A, app(B, A))  # A -> B -> A
+    return Combinator(name="K", type=k_type)
+
+
+def combinator(name: str, type: BaseType) -> Combinator:
+    """
+    Helper function to create a combinator from a sequence string.
+
+    Args:
+        name: Sequence of 'S' and 'K' characters
+
+    Returns:
+        Combinator: A new Combinator instance
+
+    Raises:
+        ValueError: If the name contains invalid characters
+    """
+    return Combinator(name=name, type=type)

implica/core/types.py

@@ -0,0 +1,140 @@
+"""
+Type system for minimal implicational logic.
+
+This module defines the type hierarchy for the implicational logic graph:
+- BaseType: Abstract base for all types
+- Variable: Simple type variables (e.g., A, B, C)
+- Application: Function application types (e.g., A -> B)
+"""
+
+import hashlib
+from abc import ABC, abstractmethod
+from functools import cached_property
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class BaseType(BaseModel, ABC):
+    """Abstract base class for all types in the implicational logic system."""
+
+    model_config = ConfigDict(frozen=True)  # Make immutable
+
+    @cached_property
+    @abstractmethod
+    def uid(self) -> str:
+        """
+        Unique identifier for this type, computed as a hash.
+
+        This property is cached for performance and should uniquely identify
+        the type based on its structure.
+
+        Returns:
+            str: A unique string identifier for this type
+        """
+        pass
+
+    @abstractmethod
+    def __str__(self) -> str:
+        """String representation of the type."""
+        pass
+
+
+class Variable(BaseType):
+    """
+    A simple type variable (e.g., A, B, C).
+
+    Variables represent atomic types in the type system.
+    """
+
+    name: str = Field(..., min_length=1, description="Name of the type variable")
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        """Validate that the variable name is non-empty and contains valid characters."""
+        if not v or not v.strip():
+            raise ValueError("Variable name cannot be empty or whitespace")
+        return v.strip()
+
+    @cached_property
+    def uid(self) -> str:
+        """Return the variable name hashed as its unique identifier."""
+        content = f"Var({self.name})"
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def __str__(self) -> str:
+        """Return the variable name."""
+        return self.name
+
+    def __repr__(self) -> str:
+        """Return a detailed representation."""
+        return f"Variable(name='{self.name}')"
+
+
+class Application(BaseType):
+    """
+    A function application type (e.g., A -> B).
+
+    Represents the type of a function that takes `input_type` and returns `output_type`.
+    In notation: input_type -> output_type
+    """
+
+    input_type: BaseType = Field(..., description="Input type of the function")
+    output_type: BaseType = Field(..., description="Output type of the function")
+
+    @cached_property
+    def uid(self) -> str:
+        """
+        Compute unique identifier based on input and output types.
+
+        Returns:
+            str: A SHA256 hash of the structure
+        """
+        content = f"App({self.input_type.uid},{self.output_type.uid})"
+        return hashlib.sha256(content.encode("utf-8")).hexdigest()
+
+    def __str__(self) -> str:
+        """
+        Return a human-readable string representation.
+
+        Uses parentheses for nested applications to maintain clarity.
+        """
+        # Add parentheses around input if it's also an Application
+        if isinstance(self.input_type, Application):
+            input_str = f"({self.input_type})"
+        else:
+            input_str = str(self.input_type)
+
+        return f"{input_str} -> {self.output_type}"
+
+    def __repr__(self) -> str:
+        """Return a detailed representation."""
+        return f"Application(input_type={repr(self.input_type)}, output_type={repr(self.output_type)})"
+
+
+# Helper function to create types more easily
+def var(name: str) -> Variable:
+    """
+    Helper function to create a Variable.
+
+    Args:
+        name: Name of the variable
+
+    Returns:
+        Variable: A new Variable instance
+    """
+    return Variable(name=name)
+
+
+def app(input_type: BaseType, output_type: BaseType) -> Application:
+    """
+    Helper function to create an Application.
+
+    Args:
+        input_type: The input type
+        output_type: The output type
+
+    Returns:
+        Application: A new Application instance
+    """
+    return Application(input_type=input_type, output_type=output_type)

implica/graph/__init__.py

@@ -0,0 +1,5 @@
+from .elements import Node, Edge, node, edge
+from .graph import Graph
+from .connection import Connection
+
+__all__ = ["Node", "Edge", "node", "edge", "Graph", "Connection"]