setreplace 0.1.0__tar.gz → 0.2.0__tar.gz

{setreplace-0.1.0 → setreplace-0.2.0}/.gitignore

@@ -4,3 +4,4 @@
 __pycache__/
 *.pyc
 .DS_Store
+/scans/

{setreplace-0.1.0 → setreplace-0.2.0}/Cargo.lock

@@ -436,7 +436,7 @@ version = "0.1.0"
 
 [[package]]
 name = "setreplace-python"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "pyo3",
  "setreplace",

{setreplace-0.1.0 → setreplace-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setreplace
-Version: 0.1.0
+Version: 0.2.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

{setreplace-0.1.0 → setreplace-0.2.0}/README.md

@@ -123,6 +123,7 @@ what lets meshes and fractals unfold instead of freezing into hairballs.
 | `"AllEventsList"` / `"AllExpressions"` | `system.events()` / `system.tokens()` |
 | `"CausalGraph"` / `"LayeredCausalGraph"` | `system.causal_graph_edges()` / `.causal_graph_plot()` |
 | `HypergraphPlot[state, VertexLabels -> Automatic]` | `sr.plot(state, labels=True)` |
+| `EnumerateWolframModelRules[{{2, 2}} -> {{3, 2}}]` | `sr.enumerate_rules([(2, 2)], [(3, 2)])` |
 
 Rules can be strings (as above), structured
 (`sr.Rule([["x", "y"]], [["x", "y"], ["y", "z"]])` — strings are variables,

{setreplace-0.1.0 → setreplace-0.2.0}/docs/python-api.md

@@ -237,3 +237,23 @@ pos = sr.layout(system.final_state, seed=1)
    abi3 keeps it to one wheel per platform.
 3. Later, when multiway lands in the engine, `evolve()` gains kwargs rather
    than new entry points — worth keeping in mind when naming things now.
+
+## Added after v0.1.0: rule enumeration
+
+```python
+def enumerate_rules(inputs, outputs, *, connectivity="Automatic",
+                    max_elements=None) -> list[Rule]: ...
+```
+
+Replicates the Wolfram Physics Project's `EnumerateWolframModelRules`
+exactly — same canonical forms, same order — so indices interoperate with
+the registry and the literature. Signature sides are `(count, arity)` pairs;
+`connectivity` is `"Automatic"` (left side connected and rule connected),
+`"All"`, or `"None"`. Verified against captured ground truth: the complete
+11-rule (1_2 -> 1_2) and 562-rule (2_2 -> 2_2) lists element-by-element, and
+the published 40,405 count for 2_2 -> 4_2.
+
+```python
+rules = sr.enumerate_rules([(2, 2)], [(2, 2)])     # 562 rules, registry order
+sr.evolve(rules[101], [[1, 1], [1, 1]], events=500).plot()
+```

{setreplace-0.1.0 → setreplace-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "setreplace"
-version = "0.1.0"
+version = "0.2.0"
 description = "Wolfram models in Python: SetReplace-exact hypergraph substitution and HypergraphPlot-style rendering, powered by Rust"
 readme = "README.md"
 requires-python = ">=3.9"

{setreplace-0.1.0 → setreplace-0.2.0}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "setreplace-python"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 description = "Python bindings for the setreplace engine and visualization"
 license = "MIT"

{setreplace-0.1.0 → setreplace-0.2.0}/python/setreplace.pyi

@@ -113,6 +113,17 @@ def evolve(
     event_ordering: list[str] | None = None,
     random_seed: int = 0,
 ) -> HypergraphSystem: ...
+def enumerate_rules(
+    inputs: list[tuple[int, int]] | list[list[int]],
+    outputs: list[tuple[int, int]] | list[list[int]],
+    *,
+    connectivity: str = "Automatic",
+    max_elements: int | None = None,
+) -> list[Rule]:
+    """All inequivalent rules of a signature ((count, arity) pairs per side),
+    replicating EnumerateWolframModelRules: same canonical forms, same order.
+    connectivity: "Automatic" (LHS connected, rule connected), "All", "None"."""
+
 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

{setreplace-0.1.0 → setreplace-0.2.0}/python/src/lib.rs

@@ -538,6 +538,57 @@ fn evolve(
     Ok(system)
 }
 
+/// All inequivalent rules of a signature, replicating the Wolfram Physics
+/// Project's EnumerateWolframModelRules (canonical forms, same order).
+/// Signature sides are (count, arity) pairs: 2 binary edges -> 3 binary
+/// edges is `enumerate_rules([(2, 2)], [(3, 2)])`.
+#[pyfunction]
+#[pyo3(signature = (inputs, outputs, *, connectivity="Automatic", max_elements=None))]
+fn enumerate_rules(
+    py: Python<'_>,
+    inputs: Vec<Vec<usize>>,
+    outputs: Vec<Vec<usize>>,
+    connectivity: &str,
+    max_elements: Option<usize>,
+) -> PyResult<Vec<Rule>> {
+    fn groups(side: Vec<Vec<usize>>) -> PyResult<Vec<(usize, usize)>> {
+        side.into_iter()
+            .map(|g| {
+                if g.len() == 2 {
+                    Ok((g[0], g[1]))
+                } else {
+                    Err(PyValueError::new_err(
+                        "signature sides must be lists of (count, arity) pairs, \
+                         e.g. enumerate_rules([(2, 2)], [(3, 2)])",
+                    ))
+                }
+            })
+            .collect()
+    }
+    let connectivity = match connectivity {
+        "Automatic" => engine::Connectivity::LeftConnected,
+        "None" => engine::Connectivity::None,
+        "All" => engine::Connectivity::All,
+        other => {
+            return Err(PyValueError::new_err(format!(
+                "unknown connectivity `{other}`; valid: Automatic, None, All"
+            )))
+        }
+    };
+    let signature = engine::RuleSignature {
+        inputs: groups(inputs)?,
+        outputs: groups(outputs)?,
+    };
+    let options = engine::EnumerationOptions {
+        connectivity,
+        max_elements,
+    };
+    let rules = py
+        .allow_threads(|| engine::enumerate_rules(&signature, &options))
+        .map_err(engine_err)?;
+    Ok(rules.into_iter().map(|inner| Rule { inner }).collect())
+}
+
 /// SetReplace[state, rules, events]: applies up to `events` substitution
 /// events and returns the resulting state.
 #[pyfunction]
@@ -604,6 +655,7 @@ fn setreplace(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(plot, m)?)?;
     m.add_function(wrap_pyfunction!(layout, m)?)?;
     m.add_function(wrap_pyfunction!(evolve, m)?)?;
+    m.add_function(wrap_pyfunction!(enumerate_rules, m)?)?;
     m.add_function(wrap_pyfunction!(set_replace, m)?)?;
     m.add_function(wrap_pyfunction!(set_replace_list, m)?)?;
     m.add_function(wrap_pyfunction!(set_replace_all, m)?)?;

{setreplace-0.1.0 → setreplace-0.2.0}/python/tests/test_api.py

@@ -173,6 +173,23 @@ def test_determinism_and_seeds():
     assert [e.inputs for e in a.events()] == [e.inputs for e in b.events()]
 
 
+def test_enumerate_rules():
+    rules = sr.enumerate_rules([(1, 2)], [(1, 2)])
+    assert len(rules) == 11
+    assert rules[0].inputs == [[-1, -1]] and rules[0].outputs == [[-1, -1]]
+    assert len(sr.enumerate_rules([(1, 2)], [(1, 2)], max_elements=2)) == 7
+    assert len(sr.enumerate_rules([(2, 2)], [(2, 2)])) == 562
+    assert len(sr.enumerate_rules([(1, 2)], [(2, 2)], connectivity="None")) > 73
+    # Enumerated rules plug straight into evolution.
+    system = sr.evolve(rules[10], [[1, 2]], events=5)
+    assert system.events_count == 5
+    try:
+        sr.enumerate_rules([(1, 2)], [(1, 2)], connectivity="Bogus")
+        raise AssertionError("expected ValueError")
+    except ValueError as e:
+        assert "Bogus" in str(e)
+
+
 def main():
     tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
     for t in tests:

setreplace-0.2.0/scripts/scan_growth_rates.py

@@ -0,0 +1,143 @@
+"""Growth-rate scan over an enumerated rule signature.
+
+Replicates the Wolfram Physics Project's triage methodology: every
+inequivalent rule of a signature is evolved from the standard self-loop
+initial condition under the standard event ordering; per-generation state
+sizes are recorded and classified. Results go to scans/ (gitignored).
+
+Usage: python scripts/scan_growth_rates.py [--max-gens 9] [--max-events 10000]
+"""
+
+import argparse
+import json
+import math
+import time
+from pathlib import Path
+
+import setreplace as sr
+
+
+def classify(sizes, reason):
+    """Coarse growth classification from per-generation edge counts."""
+    if reason == "FixedPoint":
+        return "terminated", 0.0
+    # The last generation is incomplete if we stopped on the event cap.
+    if reason == "MaxEvents" and len(sizes) > 2:
+        sizes = sizes[:-1]
+    if len(sizes) < 4:
+        return "indeterminate", 0.0
+    tail = sizes[-5:]
+    ratios = [b / a for a, b in zip(tail, tail[1:]) if a > 0]
+    diffs = [b - a for a, b in zip(tail, tail[1:])]
+    if all(d == 0 for d in diffs):
+        return "static", 0.0
+    mean_r = sum(ratios) / len(ratios)
+    var_r = sum((r - mean_r) ** 2 for r in ratios) / len(ratios)
+    mean_d = sum(diffs) / len(diffs)
+    var_d = sum((d - mean_d) ** 2 for d in diffs) / len(diffs)
+    rel_r = math.sqrt(var_r) / mean_r if mean_r else 1.0
+    rel_d = math.sqrt(var_d) / abs(mean_d) if mean_d else 1.0
+    if mean_r > 1.25 and rel_r < 0.08:
+        return "exponential", round(mean_r, 3)
+    if rel_d < 0.25:
+        return "linear", round(mean_d, 3)
+    # Power-law fit s ~ t^p over the recorded generations.
+    points = [(g, s) for g, s in enumerate(sizes) if g >= 1 and s > 0]
+    if len(points) >= 3:
+        xs = [math.log(g) for g, _ in points]
+        ys = [math.log(s) for _, s in points]
+        n = len(xs)
+        mx, my = sum(xs) / n, sum(ys) / n
+        denom = sum((x - mx) ** 2 for x in xs)
+        if denom > 0:
+            p = sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / denom
+            return "polynomial", round(p, 2)
+    return "irregular", 0.0
+
+
+def connected(state):
+    """Whether the hypergraph's edges form one component."""
+    if len(state) <= 1:
+        return True
+    parent = {}
+
+    def find(x):
+        while parent.setdefault(x, x) != x:
+            parent[x] = parent[parent[x]]
+            x = parent[x]
+        return x
+
+    for i, edge in enumerate(state):
+        for v in edge:
+            parent[find(("v", v))] = find(("e", i))
+    roots = {find(("e", i)) for i in range(len(state))}
+    return len(roots) == 1
+
+
+def hub_fraction(state):
+    """Largest share of edges any single vertex appears in."""
+    if not state:
+        return 0.0
+    counts = {}
+    for edge in state:
+        for v in set(edge):
+            counts[v] = counts.get(v, 0) + 1
+    return round(max(counts.values()) / len(state), 3)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--max-gens", type=int, default=9)
+    ap.add_argument("--max-events", type=int, default=10_000)
+    args = ap.parse_args()
+
+    signature_inputs, signature_outputs = [(2, 2)], [(3, 2)]
+    init = [[1, 1], [1, 1]]  # standard self-loop initial condition
+
+    t0 = time.perf_counter()
+    rules = sr.enumerate_rules(signature_inputs, signature_outputs)
+    t_enum = time.perf_counter() - t0
+    print(f"enumerated {len(rules)} rules in {t_enum:.2f}s")
+
+    out_path = Path("scans/2_2-3_2.jsonl")
+    out_path.parent.mkdir(exist_ok=True)
+    counts = {}
+    total_events = 0
+    t1 = time.perf_counter()
+    with out_path.open("w") as out:
+        for i, rule in enumerate(rules):
+            system = sr.evolve(
+                rule, init, generations=args.max_gens, events=args.max_events
+            )
+            gens = system.generations_count
+            sizes = [len(system.state_at_generation(g)) for g in range(gens + 1)]
+            reason = system.termination_reason
+            cls, rate = classify(sizes, reason)
+            final = system.final_state
+            record = {
+                "i": i,
+                "rule": str(rule),
+                "reason": reason,
+                "events": system.events_count,
+                "gens": gens,
+                "sizes": sizes,
+                "atoms": system.final_atom_count,
+                "connected": connected(final),
+                "hub": hub_fraction(final),
+                "class": cls,
+                "rate": rate,
+            }
+            out.write(json.dumps(record) + "\n")
+            counts[cls] = counts.get(cls, 0) + 1
+            total_events += system.events_count
+    t_scan = time.perf_counter() - t1
+
+    print(f"scanned {len(rules)} rules in {t_scan:.2f}s "
+          f"({total_events} events, {total_events / t_scan:,.0f} events/s)")
+    for cls in sorted(counts, key=counts.get, reverse=True):
+        print(f"  {cls:14} {counts[cls]:5}  ({100 * counts[cls] / len(rules):.1f}%)")
+    print(f"results: {out_path}")
+
+
+if __name__ == "__main__":
+    main()