implica 0.3.2__tar.gz → 0.3.4__tar.gz

{implica-0.3.2 → implica-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: implica
-Version: 0.3.2
+Version: 0.3.4
 Summary: A package for working with graphs representing minimal implicational logic models
 Author: Carlos Fernandez
 Author-email: carlos.ferlo@outlook.com
@@ -24,6 +24,7 @@ A Python package for working with graphs representing minimal implicational logi
 ## Features
 
 - 🎯 **Type System**: Build complex type expressions using variables and applications (function types)
+- 🔍 **Variable Extraction**: Recursively extract all variables from any type expression
 - 🧩 **Combinators**: Work with S and K combinators from combinatory logic
 - 📊 **Graph Structure**: Represent type transformations as nodes and edges in a directed graph
 - 🔄 **Transactional Operations**: Safely modify graphs with automatic rollback on failure
@@ -106,6 +107,43 @@ print(complex_function)   # Output: (A -> B) -> C
 print(nested_function)    # Output: A -> B -> C
 ```
 
+#### Extracting Variables from Types
+
+Every type has a `variables` property that returns a list of all variables contained in that type. This is computed recursively and may include duplicate variables if they appear multiple times:
+
+```python
+import implica as imp
+
+# Simple variable returns itself
+A = imp.var("A")
+print(A.variables)  # Output: [Variable(name='A')]
+
+# Application returns all variables from both input and output
+B = imp.var("B")
+func = imp.app(A, B)
+print([v.name for v in func.variables])  # Output: ['A', 'B']
+
+# Nested types return all variables recursively
+C = imp.var("C")
+nested = imp.app(imp.app(A, B), C)  # (A -> B) -> C
+print([v.name for v in nested.variables])  # Output: ['A', 'B', 'C']
+
+# Duplicates are included
+same_var = imp.app(A, A)  # A -> A
+print([v.name for v in same_var.variables])  # Output: ['A', 'A']
+
+# Complex example with duplicates
+complex = imp.app(imp.app(A, B), A)  # (A -> B) -> A
+print([v.name for v in complex.variables])  # Output: ['A', 'B', 'A']
+```
+
+**Use cases:**
+
+- Analyze which variables are used in a complex type expression
+- Count occurrences of specific variables in a type
+- Validate that certain variables are present or absent
+- Generate variable lists for quantification or substitution operations
+
 ### Combinators
 
 Combinators represent transformations between types. The library includes the S and K combinators from combinatory logic:
@@ -800,6 +838,96 @@ ensure_graph_state(
 print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 ```
 
+### Example 10: Analyzing Type Variables
+
+Extract and analyze variables from complex type expressions:
+
+```python
+import implica as imp
+
+# Create a complex type expression
+A = imp.var("A")
+B = imp.var("B")
+C = imp.var("C")
+
+# ((A -> B) -> C) -> (A -> B)
+inner = imp.app(A, B)
+middle = imp.app(inner, C)
+complex_type = imp.app(middle, inner)
+
+print(f"Type: {complex_type}")
+# Output: ((A -> B) -> C) -> A -> B
+
+# Get all variables (including duplicates)
+variables = complex_type.variables
+print(f"All variables: {[v.name for v in variables]}")
+# Output: ['A', 'B', 'C', 'A', 'B']
+
+# Count unique variables
+unique_vars = {v.name for v in variables}
+print(f"Unique variables: {unique_vars}")
+# Output: {'A', 'B', 'C'}
+
+# Count occurrences
+from collections import Counter
+var_counts = Counter(v.name for v in variables)
+print(f"Variable counts: {dict(var_counts)}")
+# Output: {'A': 2, 'B': 2, 'C': 1}
+
+# Check if a specific variable is used
+def uses_variable(type_expr, var_name):
+    """Check if a type expression uses a specific variable."""
+    return any(v.name == var_name for v in type_expr.variables)
+
+print(f"Uses A: {uses_variable(complex_type, 'A')}")  # Output: True
+print(f"Uses D: {uses_variable(complex_type, 'D')}")  # Output: False
+
+# Find all types in a graph that use a specific variable
+graph = imp.Graph()
+
+# Create various types
+types_to_add = [
+    imp.var("X"),
+    imp.var("Y"),
+    imp.app(A, B),
+    imp.app(B, C),
+    imp.app(A, imp.app(B, C)),
+]
+
+with graph.connect() as conn:
+    for t in types_to_add:
+        conn.add_node(imp.node(t))
+
+# Find all nodes containing variable "B"
+nodes_with_B = [
+    n for n in graph.nodes()
+    if any(v.name == "B" for v in n.type.variables)
+]
+
+print(f"\nNodes containing variable B:")
+for n in nodes_with_B:
+    print(f"  - {n.type}")
+# Output:
+#   - A -> B
+#   - B -> C
+#   - A -> B -> C
+
+# Calculate the "complexity" of a type by counting its variables
+def type_complexity(type_expr):
+    """Calculate complexity as the total number of variables."""
+    return len(type_expr.variables)
+
+print(f"\nType complexities:")
+for n in graph.nodes():
+    print(f"  {n.type}: {type_complexity(n.type)}")
+# Output:
+#   X: 1
+#   Y: 1
+#   A -> B: 2
+#   B -> C: 2
+#   A -> B -> C: 3
+```
+
 ## API Reference
 
 ### Core Module (`implica.core`)
@@ -809,7 +937,14 @@ print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 - `var(name: str) -> Variable`: Create a type variable
 - `app(input_type: BaseType, output_type: BaseType) -> Application`: Create a function type
 - `Variable`: Atomic type variable
+  - `name: str`: The name of the variable
+  - `uid: str`: Unique identifier (SHA256 hash)
+  - `variables: list[Variable]`: Returns `[self]`
 - `Application`: Function application type
+  - `input_type: BaseType`: Input type of the function
+  - `output_type: BaseType`: Output type of the function
+  - `uid: str`: Unique identifier (SHA256 hash)
+  - `variables: list[Variable]`: Returns all variables from input and output types (may include duplicates)
 
 **Combinators:**
 

{implica-0.3.2 → implica-0.3.4}/README.md

@@ -10,6 +10,7 @@ A Python package for working with graphs representing minimal implicational logi
 ## Features
 
 - 🎯 **Type System**: Build complex type expressions using variables and applications (function types)
+- 🔍 **Variable Extraction**: Recursively extract all variables from any type expression
 - 🧩 **Combinators**: Work with S and K combinators from combinatory logic
 - 📊 **Graph Structure**: Represent type transformations as nodes and edges in a directed graph
 - 🔄 **Transactional Operations**: Safely modify graphs with automatic rollback on failure
@@ -92,6 +93,43 @@ print(complex_function)   # Output: (A -> B) -> C
 print(nested_function)    # Output: A -> B -> C
 ```
 
+#### Extracting Variables from Types
+
+Every type has a `variables` property that returns a list of all variables contained in that type. This is computed recursively and may include duplicate variables if they appear multiple times:
+
+```python
+import implica as imp
+
+# Simple variable returns itself
+A = imp.var("A")
+print(A.variables)  # Output: [Variable(name='A')]
+
+# Application returns all variables from both input and output
+B = imp.var("B")
+func = imp.app(A, B)
+print([v.name for v in func.variables])  # Output: ['A', 'B']
+
+# Nested types return all variables recursively
+C = imp.var("C")
+nested = imp.app(imp.app(A, B), C)  # (A -> B) -> C
+print([v.name for v in nested.variables])  # Output: ['A', 'B', 'C']
+
+# Duplicates are included
+same_var = imp.app(A, A)  # A -> A
+print([v.name for v in same_var.variables])  # Output: ['A', 'A']
+
+# Complex example with duplicates
+complex = imp.app(imp.app(A, B), A)  # (A -> B) -> A
+print([v.name for v in complex.variables])  # Output: ['A', 'B', 'A']
+```
+
+**Use cases:**
+
+- Analyze which variables are used in a complex type expression
+- Count occurrences of specific variables in a type
+- Validate that certain variables are present or absent
+- Generate variable lists for quantification or substitution operations
+
 ### Combinators
 
 Combinators represent transformations between types. The library includes the S and K combinators from combinatory logic:
@@ -786,6 +824,96 @@ ensure_graph_state(
 print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 ```
 
+### Example 10: Analyzing Type Variables
+
+Extract and analyze variables from complex type expressions:
+
+```python
+import implica as imp
+
+# Create a complex type expression
+A = imp.var("A")
+B = imp.var("B")
+C = imp.var("C")
+
+# ((A -> B) -> C) -> (A -> B)
+inner = imp.app(A, B)
+middle = imp.app(inner, C)
+complex_type = imp.app(middle, inner)
+
+print(f"Type: {complex_type}")
+# Output: ((A -> B) -> C) -> A -> B
+
+# Get all variables (including duplicates)
+variables = complex_type.variables
+print(f"All variables: {[v.name for v in variables]}")
+# Output: ['A', 'B', 'C', 'A', 'B']
+
+# Count unique variables
+unique_vars = {v.name for v in variables}
+print(f"Unique variables: {unique_vars}")
+# Output: {'A', 'B', 'C'}
+
+# Count occurrences
+from collections import Counter
+var_counts = Counter(v.name for v in variables)
+print(f"Variable counts: {dict(var_counts)}")
+# Output: {'A': 2, 'B': 2, 'C': 1}
+
+# Check if a specific variable is used
+def uses_variable(type_expr, var_name):
+    """Check if a type expression uses a specific variable."""
+    return any(v.name == var_name for v in type_expr.variables)
+
+print(f"Uses A: {uses_variable(complex_type, 'A')}")  # Output: True
+print(f"Uses D: {uses_variable(complex_type, 'D')}")  # Output: False
+
+# Find all types in a graph that use a specific variable
+graph = imp.Graph()
+
+# Create various types
+types_to_add = [
+    imp.var("X"),
+    imp.var("Y"),
+    imp.app(A, B),
+    imp.app(B, C),
+    imp.app(A, imp.app(B, C)),
+]
+
+with graph.connect() as conn:
+    for t in types_to_add:
+        conn.add_node(imp.node(t))
+
+# Find all nodes containing variable "B"
+nodes_with_B = [
+    n for n in graph.nodes()
+    if any(v.name == "B" for v in n.type.variables)
+]
+
+print(f"\nNodes containing variable B:")
+for n in nodes_with_B:
+    print(f"  - {n.type}")
+# Output:
+#   - A -> B
+#   - B -> C
+#   - A -> B -> C
+
+# Calculate the "complexity" of a type by counting its variables
+def type_complexity(type_expr):
+    """Calculate complexity as the total number of variables."""
+    return len(type_expr.variables)
+
+print(f"\nType complexities:")
+for n in graph.nodes():
+    print(f"  {n.type}: {type_complexity(n.type)}")
+# Output:
+#   X: 1
+#   Y: 1
+#   A -> B: 2
+#   B -> C: 2
+#   A -> B -> C: 3
+```
+
 ## API Reference
 
 ### Core Module (`implica.core`)
@@ -795,7 +923,14 @@ print(f"Final state: {graph.node_count()} nodes")  # Output: 2 (X and Y)
 - `var(name: str) -> Variable`: Create a type variable
 - `app(input_type: BaseType, output_type: BaseType) -> Application`: Create a function type
 - `Variable`: Atomic type variable
+  - `name: str`: The name of the variable
+  - `uid: str`: Unique identifier (SHA256 hash)
+  - `variables: list[Variable]`: Returns `[self]`
 - `Application`: Function application type
+  - `input_type: BaseType`: Input type of the function
+  - `output_type: BaseType`: Output type of the function
+  - `uid: str`: Unique identifier (SHA256 hash)
+  - `variables: list[Variable]`: Returns all variables from input and output types (may include duplicates)
 
 **Combinators:**
 

{implica-0.3.2 → implica-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "implica"
-version = "0.3.2"
+version = "0.3.4"
 description = "A package for working with graphs representing minimal implicational logic models"
 authors = ["Carlos Fernandez <carlos.ferlo@outlook.com>"]
 readme = "README.md"

{implica-0.3.2 → implica-0.3.4}/src/implica/__init__.py

@@ -41,4 +41,4 @@ __all__ = [
     "mutations",
 ]
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"

{implica-0.3.2 → implica-0.3.4}/src/implica/core/types.py

@@ -10,6 +10,7 @@ This module defines the type hierarchy for the implicational logic graph:
 import hashlib
 from abc import ABC, abstractmethod
 from functools import cached_property
+from typing import List
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
@@ -33,6 +34,20 @@ class BaseType(BaseModel, ABC):
         """
         pass
 
+    @property
+    @abstractmethod
+    def variables(self) -> List["Variable"]:
+        """
+        Return the list of all variables in this type.
+
+        This property is computed recursively on each access.
+        The list may contain duplicate variables if they appear multiple times.
+
+        Returns:
+            List[Variable]: A list of all Variable instances in this type
+        """
+        pass
+
     @abstractmethod
     def __str__(self) -> str:
         """String representation of the type."""
@@ -62,6 +77,18 @@ class Variable(BaseType):
         content = f"Var({self.name})"
         return hashlib.sha256(content.encode("utf-8")).hexdigest()
 
+    @property
+    def variables(self) -> List["Variable"]:
+        """
+        Return the list of variables in this type.
+
+        For a Variable, this returns a list containing only itself.
+
+        Returns:
+            List[Variable]: A list containing only this variable
+        """
+        return [self]
+
     def __str__(self) -> str:
         """Return the variable name."""
         return self.name
@@ -93,6 +120,19 @@ class Application(BaseType):
         content = f"App({self.input_type.uid},{self.output_type.uid})"
         return hashlib.sha256(content.encode("utf-8")).hexdigest()
 
+    @property
+    def variables(self) -> List[Variable]:
+        """
+        Return the list of variables in this type.
+
+        For an Application, this recursively collects all variables from
+        both the input_type and output_type.
+
+        Returns:
+            List[Variable]: A list of all variables in this application type
+        """
+        return self.input_type.variables + self.output_type.variables
+
     def __str__(self) -> str:
         """
         Return a human-readable string representation.