Remove data artifacts and obsolete doc; harden tensor ops

Author: flengyel

README.md

@@ -24,7 +24,7 @@ $$
 To work with these files on your own machine:
 
 1. Clone or update the repository (`git clone` the first time, otherwise `git pull`).
-2. Change into the `Operations-Tensorielles-Simpliciales` directory.
+2. Change into the `SimplicialTensors` directory.
 3. Install the package in editable mode:
 
    ```bash
@@ -38,7 +38,7 @@ You can then import modules via `import simplicial_tensors.tensor_ops`.
 The interactive demonstrations that used to live inside the library modules now reside in the `examples/` folder. After installing the project in editable mode (`pip install -e .`), run any example like so:
 
 ```bash
-python examples/tensor_ops.py
+python examples/ab_mlp_demo.py
 ```
 
 Each script imports the corresponding module under `simplicial_tensors` and calls its `main()` entry point.

data/MNIST/raw/t10k-labels-idx1-ubyte

@@ -63,7 +63,7 @@ Before BRD computation, `verify_basic_facts()` asserts:
 
 ## Output
 The script prints:
-- graph size data,
+- graph size summary,
 - automorphism-group size,
 - right-coset count,
 - BRD over right-coset representatives,
@@ -91,3 +91,4 @@ From repository root:
 ```bash
 .venv/Scripts/python.exe experiments/petersen_brd_right_cosets.py
 ```
+

data/MNIST/raw/t10k-labels-idx1-ubyte.gz

@@ -1,77 +1,36 @@
-"""Run a tiny A/B experiment comparing boundary penalties."""
+"""Run a tiny A/B experiment comparing horn-filler uniqueness."""
 
-import math
-from typing import Tuple
-
-try:  # pragma: no cover - optional dependency
-    import torch
-    from torch import nn
-    from torch.utils.data import DataLoader, TensorDataset
-except ModuleNotFoundError:  # pragma: no cover - friendly exit when torch missing
-    print("PyTorch is required to run the boundary penalty demo. Please install torch.")
-    raise SystemExit(0)
-
-from simplicial_tensors.nn import BoundaryConfig, train_with_boundary
-
-
-def make_synthetic_dataset(n: int = 1024, noise: float = 0.1) -> Tuple[TensorDataset, TensorDataset]:
-    torch.manual_seed(0)
-    x = torch.randn(n, 2)
-    y = torch.sign(x[:, 0] * x[:, 1]).unsqueeze(-1)
-    y[y == 0] = 1
-    y = (y > 0).float()
-
-    x += noise * torch.randn_like(x)
-    split = n // 5
-    val_x, val_y = x[:split], y[:split]
-    train_x, train_y = x[split:], y[split:]
-    train_ds = TensorDataset(train_x, train_y)
-    val_ds = TensorDataset(val_x, val_y)
-    return train_ds, val_ds
+from __future__ import annotations
 
+from typing import Tuple
 
-def make_model(seed: int = 0) -> nn.Module:
-    torch.manual_seed(seed)
-    return nn.Sequential(
-        nn.Linear(2, 32),
-        nn.ReLU(),
-        nn.Linear(32, 32),
-        nn.ReLU(),
-        nn.Linear(32, 1),
-    )
+import numpy as np
 
+from simplicial_tensors.tensor_ops import (
+    filler,
+    horn,
+    n_hypergroupoid_conjecture,
+    random_tensor,
+)
 
-def run_job(mode: str, coboundary: str = "zero", lambda1: float = 1e-3, epochs: int = 10) -> None:
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    train_ds, val_ds = make_synthetic_dataset()
-    train_loader = DataLoader(train_ds, batch_size=64, shuffle=True)
-    val_loader = DataLoader(val_ds, batch_size=64)
 
-    model = make_model(seed=42)
-    optimizer = torch.optim.Adam(model.parameters(), lr=5e-3)
-    criterion = nn.BCEWithLogitsLoss()
+def run_case(shape: Tuple[int, ...], missing_face: int, seed: int) -> None:
+    tensor = random_tensor(shape, low=-5, high=6, seed=seed)
+    horn_faces = horn(tensor, missing_face)
+    reconstructed = filler(horn_faces, missing_face)
+    unique = np.array_equal(tensor, reconstructed)
+    predicted = n_hypergroupoid_conjecture(shape)
 
-    cfg = BoundaryConfig(mode=mode, coboundary=coboundary, lambda1=lambda1)
-    history = train_with_boundary(
-        model,
-        train_loader,
-        val_loader,
-        optimizer,
-        criterion,
-        device,
-        epochs,
-        cfg,
+    print(
+        f"shape={shape} omitted_face={missing_face} predicted_unique={predicted} "
+        f"observed_unique={unique}"
     )
 
-    final_loss = history["val_loss"][-1]
-    final_boundary = history["val_boundary"][-1]
-    print(f"Mode={mode!r} coboundary={coboundary!r}: val_loss={final_loss:.4f} boundary={final_boundary:.4f}")
-
 
 def main() -> None:
-    print("=== Boundary penalty A/B demo ===")
-    run_job(mode="incidence", lambda1=5e-4, epochs=8)
-    run_job(mode="principal", coboundary="zero", lambda1=5e-4, epochs=8)
+    print("=== Horn filler A/B demo ===")
+    run_case(shape=(3, 3), missing_face=1, seed=123)
+    run_case(shape=(5, 5), missing_face=1, seed=456)
 
 
 if __name__ == "__main__":