From a75babda47b4e0de71de98c5f8bf09eb1051efc2 Mon Sep 17 00:00:00 2001 From: Allaun Silverfox <28494262+allaunthefox@users.noreply.github.com> Date: Sat, 16 May 2026 18:42:25 -0500 Subject: [PATCH] Add MarkovJunior 16D shim runner --- .../famm/markovjunior_16d_shim.py | 183 ++++++++++++++++++ 1 file changed, 183 insertions(+) create mode 100644 5-Applications/tools-scripts/famm/markovjunior_16d_shim.py diff --git a/5-Applications/tools-scripts/famm/markovjunior_16d_shim.py b/5-Applications/tools-scripts/famm/markovjunior_16d_shim.py new file mode 100644 index 00000000..75cc0b0c --- /dev/null +++ b/5-Applications/tools-scripts/famm/markovjunior_16d_shim.py @@ -0,0 +1,183 @@ +#!/usr/bin/env python3 +"""MarkovJunior 16D PIST Rewrite Shim. + +Projects MarkovJunior-style rewrite rules into 16D FAMM/PIST/NUVMAP anchors. + +This runner does not execute the full MarkovJunior XML language. It is a shim: +rules and optional constraints are mapped into 16D route objects, hashes, and +receipts so later tools can use them as PIST/Delta-DAG inputs. +""" + +from __future__ import annotations + +import argparse +import hashlib +import json +from pathlib import Path +from typing import Any + + +def sha256_json(value: Any) -> str: + payload = json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8") + return hashlib.sha256(payload).hexdigest() + + +def norm_hash(value: Any, scale: float = 1.0) -> float: + h = hashlib.sha256(json.dumps(value, sort_keys=True).encode("utf-8")).digest() + n = int.from_bytes(h[:8], "big") + return (n / float((1 << 64) - 1)) * scale + + +def pattern_mass(pattern: str) -> float: + if not pattern: + return 0.0 + non_wild = sum(1 for ch in pattern if ch != "*") + return non_wild / max(1, len(pattern)) + + +def delta_mass(left: str, right: str) -> float: + n = max(len(left), len(right), 1) + changed = 0 + for i in range(n): + l = left[i] if i < len(left) else "" + r = right[i] if i < len(right) else "" + if r != "*" and l != r: + changed += 1 + return changed / n + + +def chirality_score(value: str) -> float: + mapping = { + "left": 0.25, + "right": 0.75, + "neutral": 0.5, + "clockwise": 0.8, + "counterclockwise": 0.2, + } + return float(mapping.get(str(value).lower(), 0.5)) + + +def rule_anchor(rule: dict[str, Any], constraints: dict[str, Any], index: int, total: int) -> dict[str, Any]: + left = str(rule.get("left", "")) + right = str(rule.get("right", "")) + weight = float(rule.get("weight", 1.0)) + obs = constraints.get("observations", []) + + pm = pattern_mass(left) + dm = delta_mass(left, right) + wc = left.count("*") / max(1, len(left)) + obs_pressure = min(1.0, sum(float(o.get("weight", 1.0)) for o in obs) / max(1, len(obs) or 1)) + rule_order_pressure = 1.0 - (index / max(1, total - 1)) if total > 1 else 1.0 + route_cost = min(1.0, (len(left) + len(right)) / 64.0) + receipt_strength = 1.0 if left and right else 0.25 + scar = 0.0 if left and right and len(left) == len(right) else 0.35 + residual = 0.0 if len(left) == len(right) else abs(len(left) - len(right)) / max(len(left), len(right), 1) + invariant_overlap = 1.0 - min(1.0, dm * 0.5 + scar * 0.5) + + vector = [ + norm_hash({"left": left, "right": right, "id": rule.get("id")}), + min(1.0, float(rule.get("dimensions", 2)) / 16.0), + pm, + dm, + rule_order_pressure, + obs_pressure, + chirality_score(rule.get("chirality", "neutral")), + min(1.0, pm + dm), + norm_hash({"recurrence": left + "->" + right}), + dm, + scar, + residual, + invariant_overlap, + route_cost, + receipt_strength, + wc, + ] + + payload = { + "id": rule.get("id", f"rule_{index}"), + "left": left, + "right": right, + "node": rule.get("node", "exists"), + "weight": weight, + "orientation": rule.get("orientation", "axis_aligned"), + "chirality": rule.get("chirality", "neutral"), + "metrics": { + "pattern_mass": pm, + "delta_mass": dm, + "wildcard_fraction": wc, + "constraint_pressure": obs_pressure, + "scar": scar, + "residual": residual, + "invariant_overlap": invariant_overlap, + "route_cost": route_cost, + "receipt_strength": receipt_strength, + }, + "vector16": vector, + "rule_hash": sha256_json(rule), + } + payload["anchor_hash"] = sha256_json(payload) + return payload + + +def run(config: dict[str, Any]) -> dict[str, Any]: + rules = config.get("rules", []) + constraints = config.get("constraints", {}) + anchors = [rule_anchor(rule, constraints, i, len(rules)) for i, rule in enumerate(rules)] + + source = config.get("source", {}) + grid = config.get("grid", {}) + projection = config.get("projection", {}) + + nuvmap = { + "projection": projection.get("nuvmap_projection", "frontier"), + "grid_hash": sha256_json(grid), + "constraints_hash": sha256_json(constraints), + "rule_anchor_hashes": [a["anchor_hash"] for a in anchors], + "dag_node_seed": sha256_json({ + "grid": grid, + "constraints": constraints, + "anchors": [a["anchor_hash"] for a in anchors], + }), + } + + receipt = { + "receipt_type": "famm_markovjunior_16d_shim_receipt", + "schema_version": "0.1.0", + "source": source, + "grid": grid, + "constraints": constraints, + "projection": projection, + "rules": rules, + "anchors": anchors, + "nuvmap": nuvmap, + "pist_transition_form": "X_{t+1}=Pi_adm[PIST_r(X_t)+Delta_MJ(r_t,m_t)]", + "no_drift_boundary": ( + "This shim projects MarkovJunior-style rewrite rules into 16D FAMM/PIST anchors. " + "It does not execute full MarkovJunior XML semantics or prove generated artifacts correct." + ), + } + receipt["receipt_hash"] = sha256_json(receipt) + return receipt + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--config", required=True) + parser.add_argument("--out", required=True) + args = parser.parse_args() + + config = json.loads(Path(args.config).read_text(encoding="utf-8")) + receipt = run(config) + + out_path = Path(args.out) + out_path.parent.mkdir(parents=True, exist_ok=True) + out_path.write_text(json.dumps(receipt, indent=2, sort_keys=True), encoding="utf-8") + + print(f"Wrote {out_path}") + print(f"Rules projected: {len(receipt['anchors'])}") + print(f"NUVMAP DAG seed: {receipt['nuvmap']['dag_node_seed']}") + print(f"Receipt hash: {receipt['receipt_hash']}") + + +if __name__ == "__main__": + main()