setreplace 0.1.0__cp39-abi3-win_amd64.whl

setreplace/__init__.py

@@ -0,0 +1,5 @@
+from .setreplace import *
+
+__doc__ = setreplace.__doc__
+if hasattr(setreplace, "__all__"):
+    __all__ = setreplace.__all__

setreplace/__init__.pyi

@@ -0,0 +1,123 @@
+"""Wolfram model (SetReplace) hypergraph substitution and visualization."""
+
+from typing import Union
+
+__version__: str
+
+Rules = Union["Rule", str, list[Union["Rule", str]]]
+
+class SetReplaceError(Exception):
+    """Evolution-time failure (e.g. disconnected rule inputs)."""
+
+class Rule:
+    def __init__(
+        self,
+        inputs: list[list[int | str]],
+        outputs: list[list[int | str]],
+    ) -> None:
+        """Structured form: strings are pattern variables, ints are concrete atoms."""
+
+    @staticmethod
+    def parse(s: str) -> Rule:
+        """Wolfram-ish text: '{{x, y}} -> {{x, y}, {y, z}}' or '{{a_, b_}} :> ...'."""
+
+    @property
+    def inputs(self) -> list[list[int]]: ...
+    @property
+    def outputs(self) -> list[list[int]]: ...
+
+class Token:
+    atoms: list[int]
+    creator_event: int
+    destroyer_event: int | None
+    generation: int
+
+class Event:
+    rule: int | None
+    inputs: list[int]
+    outputs: list[int]
+    generation: int
+
+class Plot:
+    @property
+    def svg(self) -> str: ...
+    def save(self, path: str) -> None:
+        """Writes .svg or .png by extension (PNG rasterized in-process)."""
+    def _repr_svg_(self) -> str: ...
+
+class HypergraphSystem:
+    def __init__(
+        self,
+        rules: Rules,
+        initial_state: list[list[int]],
+        *,
+        event_ordering: list[str] | None = None,
+        random_seed: int = 0,
+    ) -> None: ...
+    def evolve(
+        self,
+        *,
+        max_events: int | None = None,
+        max_generations: int | None = None,
+        max_vertices: int | None = None,
+        max_vertex_degree: int | None = None,
+        max_edges: int | None = None,
+    ) -> int: ...
+    def replace_once(self) -> bool: ...
+    @property
+    def final_state(self) -> list[list[int]]: ...
+    @property
+    def termination_reason(self) -> str: ...
+    @property
+    def events_count(self) -> int: ...
+    @property
+    def generations_count(self) -> int: ...
+    @property
+    def final_atom_count(self) -> int: ...
+    def state_after_event(self, k: int) -> list[list[int]]: ...
+    def states_by_event(self) -> list[list[list[int]]]: ...
+    def state_at_generation(self, g: int) -> list[list[int]]: ...
+    def max_complete_generation(self) -> int: ...
+    def tokens(self) -> list[Token]: ...
+    def events(self) -> list[Event]: ...
+    def causal_graph_edges(self, include_initial: bool = False) -> list[tuple[int, int]]: ...
+    def causal_graph_dot(self, include_initial: bool = False) -> str: ...
+    def plot(
+        self,
+        *,
+        labels: bool | dict[int, str] | None = None,
+        seed: int = 0,
+        width: float = 478.0,
+    ) -> Plot: ...
+    def causal_graph_plot(
+        self, *, include_initial: bool = False, width: float = 478.0
+    ) -> Plot: ...
+
+def plot(
+    edges: list[list[int]],
+    *,
+    labels: bool | dict[int, str] | None = None,
+    seed: int = 0,
+    width: float = 478.0,
+) -> Plot: ...
+def layout(edges: list[list[int]], *, seed: int = 0) -> dict[int, tuple[float, float]]: ...
+def evolve(
+    rules: Rules,
+    initial_state: list[list[int]],
+    *,
+    generations: int | None = None,
+    events: int | None = None,
+    max_vertices: int | None = None,
+    max_vertex_degree: int | None = None,
+    max_edges: int | None = None,
+    event_ordering: list[str] | None = None,
+    random_seed: int = 0,
+) -> HypergraphSystem: ...
+def set_replace(state: list[list[int]], rules: Rules, events: int = 1) -> list[list[int]]: ...
+def set_replace_list(
+    state: list[list[int]], rules: Rules, events: int
+) -> list[list[list[int]]]: ...
+def set_replace_all(
+    state: list[list[int]], rules: Rules, generations: int = 1
+) -> list[list[int]]: ...
+def set_replace_fixed_point(state: list[list[int]], rules: Rules) -> list[list[int]]: ...

setreplace-0.1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: setreplace
+Version: 0.1.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Summary: Wolfram models in Python: SetReplace-exact hypergraph substitution and HypergraphPlot-style rendering, powered by Rust
+Keywords: wolfram-model,hypergraph,rewriting,setreplace,graph-layout
+Author: Kovas Boguta
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://github.com/kovasb/setreplace-py/blob/main/docs/python-api.md
+Project-URL: Repository, https://github.com/kovasb/setreplace-py
+
+# setreplace
+
+**Wolfram models in Python** — hypergraph substitution systems with the exact
+semantics of Wolfram's [SetReplace](https://github.com/maxitg/SetReplace),
+plus `HypergraphPlot`-style rendering, powered by a Rust engine. No Wolfram
+Language license, no graphviz, no native dependencies to install.
+
+<img src="https://raw.githubusercontent.com/kovasb/setreplace-py/main/docs/images/showcase/announcement_web.png" width="500"
+     alt="1500 events of the Wolfram Physics Project announcement's rule">
+
+```python
+import setreplace as sr
+
+# The rule from the Wolfram Physics Project announcement
+system = sr.evolve("{{x, y}, {x, z}} -> {{x, z}, {x, w}, {y, w}, {z, w}}",
+                   [[1, 2], [2, 3], [3, 4], [2, 4]], events=1500)
+system.plot()        # ↑ renders inline in Jupyter
+```
+
+States are plain `list[list[int]]`; rules are the same strings the
+SetReplace docs use. Evolution is incremental and fully deterministic
+(seeded), and every token and event keeps its causal history:
+
+```python
+rule = "{{v1, v2, v3}, {v2, v4, v5}} -> {{v5, v6, v1}, {v6, v4, v2}, {v4, v5, v3}}"
+system = sr.evolve(rule, [[1, 2, 3], [2, 4, 5], [4, 6, 7]], events=10)
+
+system                       # <HypergraphSystem: 10 events, 5 generations, 13 edges, MaxEvents>
+system.final_state           # [[7, 2, 9], [7, 14, 6], ...]
+system.evolve(max_events=100)
+system.termination_reason    # "MaxEvents" | "FixedPoint" | "MaxGenerations" | ...
+system.tokens()[0]           # Token(atoms=[1, 2, 3], creator_event=0, ...)
+system.causal_graph_plot()   # layered causal graph, inline
+system.plot().save("state.png")
+
+sr.set_replace([[1, 2], [2, 3]], "{{a_, b_}, {b_, c_}} :> {{a, c}}")   # [[1, 3]]
+pos = sr.layout(system.final_state)   # {atom: (x, y)} for matplotlib & friends
+```
+
+| Wolfram Language | Python |
+|---|---|
+| `WolframModel[rules, init, g]` | `sr.evolve(rules, init, generations=g)` |
+| `SetReplace[set, rules, n]` | `sr.set_replace(set, rules, n)` |
+| `<\|"MaxEvents" -> n, "MaxVertices" -> v\|>` | `system.evolve(max_events=n, max_vertices=v)` |
+| `"EventOrderingFunction" -> {"OldestEdge", ...}` | `event_ordering=["OldestEdge", ...]` |
+| `"CausalGraph"` / `"LayeredCausalGraph"` | `system.causal_graph_edges()` / `.causal_graph_plot()` |
+| `HypergraphPlot[state, VertexLabels -> Automatic]` | `sr.plot(state, labels=True)` |
+
+The engine is a verified port of SetReplace's C++ core: test vectors lifted
+from SetReplace's own suite, plus live cross-checks against SetReplace under
+wolframscript — final states, event traces, causal graphs, and every event
+ordering agree exactly. The renderer's palette and arrowhead geometry are
+transcribed from SetReplace's style sources, and large states lay out in
+seconds via a multilevel spring-electrical embedding.
+
+Docs, gallery, and the Rust crates:
+[github.com/kovasb/setreplace-py](https://github.com/kovasb/setreplace-py).
+
+Independent reimplementation of [SetReplace](https://github.com/maxitg/SetReplace)
+(MIT) by Max Piskunov and contributors; not affiliated with the SetReplace
+project, the Wolfram Physics Project, or Wolfram Research. MIT licensed.
+

setreplace-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+setreplace/__init__.py,sha256=LscnJ1XqXVpnolL4ncZLpCLKN1PKabeJDv5bOMTpF9g,123
+setreplace/__init__.pyi,sha256=7kHE07eP5wnNuOUtZO_Tm-aNaXLbIGS09weeCNy63Wk,3896
+setreplace/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setreplace/setreplace.pyd,sha256=bQu_7dFLsgdopbC41uyJBDiF3CLOegOx-txia4NWEy0,3559936
+setreplace-0.1.0.dist-info/METADATA,sha256=__5nIAudYuHUMy3shiW2I9HcxQKyEHtaHBDZ5zoYwTc,4068
+setreplace-0.1.0.dist-info/WHEEL,sha256=dB50znGoqD95tHNeV5UBZvlfLNwgEh0iQcswp5YahQ4,95
+setreplace-0.1.0.dist-info/sboms/setreplace-python.cyclonedx.json,sha256=pyco4UGLaz4h5a_wyTMzErL2x52AfRTTcWb4FPjXj4s,87717
+setreplace-0.1.0.dist-info/RECORD,,

setreplace-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.13.3)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64