EPICProver 0.1.0__py3-none-any.whl

epiclogic/__init__.py

@@ -0,0 +1,61 @@
+"""Modal logic symbolic library."""
+import os
+import importlib
+
+from .kernel import operators
+from .kernel.opertree import (
+    opertree, str_tree
+)
+from .kernel.proofTree import (
+    proofTree,
+    isDerived
+)
+from .utils.derivedFormula import (
+    derivedFormula
+)
+from .utils.inferenceRule import (
+    inferenceRule
+)
+from .utils.provenTheorem import (
+    provenTheorem,
+    proven_theorems
+)
+
+current_dir = os.path.dirname(__file__)
+strategy_dir = os.path.join(current_dir, 'strategy')
+
+strategy = []
+if os.path.exists(strategy_dir):
+    strategy = [
+        (x[:-3] if x.endswith('.py') else x)
+        for x in os.listdir(strategy_dir)
+        if not x.startswith('__') and not x.startswith('.')
+    ]
+
+__all__ = [
+    #operators
+    'operators',
+    
+    #opertree
+    'opertree',
+    'str_tree',
+
+    #proofTree
+    'proofTree',
+    'isDerived',
+
+    #derivedFormula
+    'derivedFormula',
+
+    #inferenceRule
+    'inferenceRule',
+
+    #provenTheorem
+    'provenTheorem',
+    'proven_theorems'
+]
+
+for st in strategy:
+    module = importlib.import_module(f".strategy.{st}", package=__name__)
+    globals()[st] = module
+    __all__.append(st)

epiclogic/kernel/deque.py

@@ -0,0 +1,153 @@
+class dequenode:
+    """A node in a doubly linked list (deque) with manual link management.
+
+    This class represents a node that stores a value and references to its
+    left and right neighbors. Unlike collections.deque, this implementation
+    gives the user full control over node links, allowing O(1) insertion and
+    removal at arbitrary positions (not just at ends).
+
+    Links are managed via the `left` and `right` properties, which
+    automatically update the corresponding neighbor's opposite link.
+
+    Attributes:
+        value (object): The payload stored in the node.
+        _left (dequenode | None): Internal reference to the left neighbor.
+        _right (dequenode | None): Internal reference to the right neighbor.
+
+    Properties:
+        left (dequenode | None): Left neighbor (get/set). Setting updates the
+            neighbor's right link.
+        right (dequenode | None): Right neighbor (get/set). Setting updates the
+            neighbor's left link.
+
+    Examples:
+        >>> a = dequenode('a')
+        >>> b = dequenode('b', a)  # b.left = a, a.right = b
+        >>> c = dequenode('c', b)  # c.left = b, b.right = c
+        >>> d = dequenode('d')
+        >>> c.right = d            # c.right = d, d.left = c"""
+
+    __slots__ = ('value', '_left', '_right')
+
+    def __init__(self, value: object, left: 'dequenode|None' = None, right: 'dequenode|None' = None):
+        self.value = value
+        self._left = self._right = None
+        self.left = left
+        self.right = right
+
+    def of(elems: 'iterable', index: int = 0, cycle: bool = False) -> 'deque':
+        res = cur = None
+        for elem in elems:
+            if res is None:
+                res = cur = dequenode(elem)
+            elif cur.right is None:
+                cur.right = dequenode(elem)
+                cur = cur.right
+        if cycle:
+            cur.right = res
+        for _ in range(index):
+            if not res.right is None:
+                res = res.right
+            else:
+                raise IndexError('deque index out of range')
+        return res
+
+    @property
+    def left(self):
+        return self._left
+
+    @left.setter
+    def left(self, value: 'dequenode|None'):
+        if value is None:
+            if not self._left is None:
+                self._left._right = None
+            self._left = None
+        elif isinstance(value, dequenode):
+            if not self._left is None:
+                self._left._right = None
+            self._left = value
+            if not value._right is None:
+                value._right._left = None
+            value._right = self
+        else:
+            raise TypeError(f'must be "dequenode", not a "{type(value).__name__}"')
+
+    @property
+    def right(self):
+        return self._right
+
+    @right.setter
+    def right(self, value: 'dequenode|None'):
+        if value is None:
+            if not self._right is None:
+                self._right._left = None
+            self._right = None
+        elif isinstance(value, dequenode):
+            if not self._right is None:
+                self._right._left = None
+            self._right = value
+            if not value._left is None:
+                value._left._right = None
+            value._left = self
+        else:
+            raise TypeError(f'must be "dequenode", not a "{type(value).__name__}"')
+
+    def __str__(self):
+        res = f'<->[{self.value}]<->'
+        cur = self
+        while not (
+            (cur := cur.left) is None or
+            cur is self
+        ):
+            res = f'<->({cur.value})' + res
+        if cur is None:
+            res = 'None' + res
+        else:
+            res = f'...<->[{cur.value}]' + res
+        cur = self
+        while not (
+            (cur := cur.right) is None or
+            cur is self
+        ):
+            res += f'({cur.value})<->'
+        if cur is None:
+            res += 'None'
+        else:
+            res += f'[{cur.value}]<->...'
+        return res
+
+    def __repr__(self):
+        prev = cur = self
+        index = 0
+        while not (
+            (cur := cur.left) is None or
+            cur is self
+        ):
+            prev = cur
+            index += 1
+        if cur is self:
+            res = [cur.value]
+            while not (cur := cur.right) is self:
+                res.append(cur.value)
+            return f'dequenode.of({res!r}, 0, True)'
+        else:
+            cur = prev
+            res = [cur.value]
+            while not (cur := cur.right) is None:
+                res.append(cur.value)
+            return f'dequenode.of({res!r}, {index})'
+
+if __name__ == '__main__':
+    a = dequenode('a')
+    b = dequenode('b', a)
+    c = dequenode('c', b)
+    d = c.right = dequenode('d')
+    print(a, b, c, d, sep = '\n')
+    print(f'{a!r}\n{b!r}\n{c!r}\n{d!r}')
+    d.right = a
+    print(a, b, c, d, sep = '\n')
+    print(f'{a!r}\n{b!r}\n{c!r}\n{d!r}')
+    b.left = b.left.left
+    b.right = b.right.right
+    print(a, b, c, d, sep = '\n')
+    print(f'{a!r}\n{b!r}\n{c!r}\n{d!r}')