update repository

.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+trained/dim_sweeps/dim20_v2/cofiber_threshold_dim20_coco_8ep_22k_coco_results.json filter=lfs diff=lfs merge=lfs -text

CofiberDecomposition.v

@@ -0,0 +1,263 @@
+(** * Cofiber scale decomposition in semi-additive categories
+
+    Given a semi-additive category with an adjunction Sigma -| Omega
+    (suspension/loop, upsample/pool), the counit epsilon : Sigma Omega -> 1
+    gives a "low-frequency projection" at each object.  When the connecting
+    morphism in the cofiber of epsilon vanishes, X splits as a biproduct of
+    its low-frequency part and its high-frequency residual.
+
+    The splitting is natural in X: classification on cofibers is equivalent
+    to multi-scale classification on the original features.
+
+    The second section formalizes detection as pi0 of a presheaf colimit:
+    connected components of locally-constant sections over a patch site.
+*)
+
+From HoTT Require Import Basics.Overture.
+From HoTT.Categories Require Import
+  Category.Core
+  Functor.Core Functor.Composition.Core Functor.Identity
+  NaturalTransformation.Core.
+From HoTT.Categories.Additive Require Import ZeroObjects Biproducts SemiAdditive.
+
+Set Universe Polymorphism.
+Set Implicit Arguments.
+Generalizable All Variables.
+
+Local Open Scope category_scope.
+Local Open Scope morphism_scope.
+
+(** * Pre-stable structure on a semi-additive category *)
+
+Record PreStableData := {
+  ps_cat : SemiAdditiveCategory;
+  ps_Susp : Functor ps_cat ps_cat;
+  ps_Loop : Functor ps_cat ps_cat;
+  ps_epsilon : NaturalTransformation (ps_Susp o ps_Loop)%functor
+                                     (Functor.Identity.identity ps_cat)
+}.
+
+Coercion ps_cat : PreStableData >-> SemiAdditiveCategory.
+
+Section CofiberSplitting.
+
+  Context (PS : PreStableData).
+
+  Let C := ps_cat PS.
+  Let Sig := ps_Susp PS.
+  Let L := ps_Loop PS.
+  Let eps := ps_epsilon PS.
+
+  Definition low_freq (X : object C) : object C := Sig (L X).
+
+  Definition eps_at (X : object C) : morphism C (low_freq X) X := eps X.
+
+  (** A cofiber splitting of X along epsilon is a biproduct decomposition
+      of X into low_freq X and some high-frequency complement H, mediated
+      by an isomorphism between the biproduct object and X. *)
+
+  Record CofiberSplitting (X : object C) := {
+    cs_high : object C;
+    cs_biprod : @Biproduct C _ (low_freq X) cs_high;
+    cs_iso : morphism C (biproduct_obj (biproduct_data cs_biprod)) X;
+    cs_iso_inv : morphism C X (biproduct_obj (biproduct_data cs_biprod));
+    cs_sect : (cs_iso o cs_iso_inv = 1)%morphism;
+    cs_retr : (cs_iso_inv o cs_iso = 1)%morphism;
+    cs_eps_compat :
+      (cs_iso o inl (biproduct_data cs_biprod) = eps_at X)%morphism
+  }.
+
+  Arguments cs_high {X} _.
+  Arguments cs_biprod {X} _.
+  Arguments cs_iso {X} _.
+  Arguments cs_iso_inv {X} _.
+
+  (** Naturality of epsilon. *)
+  Lemma eps_natural {X Y : object C} (f : morphism C X Y)
+    : (eps_at Y o (Sig _1 (L _1 f)) = f o eps_at X)%morphism.
+  Proof.
+    exact (commutes eps X Y f).
+  Qed.
+
+  (** The low-frequency component of a morphism. *)
+  Definition low_component {X Y : object C} (f : morphism C X Y)
+    : morphism C (low_freq X) (low_freq Y)
+    := Sig _1 (L _1 f).
+
+  (** The iso inverse composed with epsilon gives the left injection.
+      Derivable from cs_eps_compat and cs_retr. *)
+  Lemma iso_inv_eps (X : object C) (sp : CofiberSplitting X)
+    : (cs_iso_inv sp o eps_at X
+       = inl (biproduct_data (cs_biprod sp)))%morphism.
+  Proof.
+    rewrite <- (cs_eps_compat sp).
+    rewrite <- associativity.
+    rewrite (cs_retr sp).
+    apply left_identity.
+  Qed.
+
+  (** ** Provable block structure
+
+      Given a family of splittings and a morphism f : X -> Y, the
+      conjugated morphism psi_Y o f o phi_X : BX -> BY has the
+      following block structure with respect to the biproducts:
+
+        - (low, low):  low_component f       [low_low_block]
+        - (high, low): 0                      [cross_term_high_low_zero]
+        - (low, high): requires cofiber       [cross_term_low_high_zero]
+        - (high, high): requires cofiber
+
+      The first two are provable from naturality of epsilon alone.
+      The latter two require the splitting to be functorial. *)
+
+  (** The conjugated morphism maps the low injection through epsilon's
+      naturality to the low injection at the target. This is the key
+      intermediate result used in both block theorems. *)
+  Lemma conjugated_inl
+    (split : forall X : object C, CofiberSplitting X)
+    {X Y : object C} (f : morphism C X Y)
+    : (cs_iso_inv (split Y) o f o cs_iso (split X)
+        o inl (biproduct_data (cs_biprod (split X)))
+       = inl (biproduct_data (cs_biprod (split Y)))
+        o low_component f)%morphism.
+  Proof.
+    repeat rewrite Category.Core.associativity.
+    rewrite (cs_eps_compat (split X)).
+    rewrite <- (eps_natural f).
+    assert (H : (cs_iso_inv (split Y) o (eps_at Y o low_component f)
+                 = (cs_iso_inv (split Y) o eps_at Y) o low_component f)%morphism).
+    { symmetry. apply Category.Core.associativity. }
+    rewrite H.
+    rewrite (iso_inv_eps (split Y)).
+    reflexivity.
+  Qed.
+
+  (** The low-low block equals the functorial low-frequency component. *)
+  Theorem low_low_block
+    (split : forall X : object C, CofiberSplitting X)
+    {X Y : object C} (f : morphism C X Y)
+    : let BX := biproduct_data (cs_biprod (split X)) in
+      let BY := biproduct_data (cs_biprod (split Y)) in
+      (outl BY o cs_iso_inv (split Y) o f o cs_iso (split X) o inl BX
+       = low_component f)%morphism.
+  Proof.
+    intros BX BY.
+    repeat rewrite Category.Core.associativity.
+    assert (H := conjugated_inl split f).
+    repeat rewrite Category.Core.associativity in H.
+    rewrite H.
+    rewrite <- Category.Core.associativity.
+    rewrite (beta_l (biproduct_is (cs_biprod (split Y)))).
+    apply left_identity.
+  Qed.
+
+  (** The high-low cross term vanishes: injecting from the low-frequency
+      part of X and projecting onto the high-frequency part of Y gives
+      zero. Follows from naturality of epsilon and the biproduct axioms. *)
+  Theorem cross_term_high_low_zero
+    (split : forall X : object C, CofiberSplitting X)
+    {X Y : object C} (f : morphism C X Y)
+    : let BX := biproduct_data (cs_biprod (split X)) in
+      let BY := biproduct_data (cs_biprod (split Y)) in
+      (outr BY o cs_iso_inv (split Y) o f o cs_iso (split X) o inl BX
+       = @zero_morphism C _ (low_freq X) (cs_high (split Y)))%morphism.
+  Proof.
+    intros BX BY.
+    repeat rewrite Category.Core.associativity.
+    assert (H := conjugated_inl split f).
+    repeat rewrite Category.Core.associativity in H.
+    rewrite H.
+    rewrite <- Category.Core.associativity.
+    rewrite (mixed_r (biproduct_is (cs_biprod (split Y)))).
+    apply zero_morphism_left.
+  Qed.
+
+  (** The low-high cross term vanishes when the splitting is functorial:
+      the conjugated morphism maps the high-frequency injection at X
+      into the high-frequency injection at Y.
+
+      This condition is derivable when the splitting comes from a
+      cofiber construction (distinguished triangles + vanishing
+      connecting morphism), which requires the stable category
+      machinery from PR 2288. Here we take it as a hypothesis. *)
+  Theorem cross_term_low_high_zero
+    (split : forall X : object C, CofiberSplitting X)
+    {X Y : object C} (f : morphism C X Y)
+    (f_high : morphism C (cs_high (split X)) (cs_high (split Y)))
+    (H_func :
+      (cs_iso_inv (split Y) o f o cs_iso (split X)
+        o inr (biproduct_data (cs_biprod (split X)))
+       = inr (biproduct_data (cs_biprod (split Y))) o f_high)%morphism)
+    : let BX := biproduct_data (cs_biprod (split X)) in
+      let BY := biproduct_data (cs_biprod (split Y)) in
+      (outl BY o cs_iso_inv (split Y) o f o cs_iso (split X) o inr BX
+       = @zero_morphism C _ (cs_high (split X)) (low_freq Y))%morphism.
+  Proof.
+    intros BX BY.
+    repeat rewrite associativity.
+    repeat rewrite associativity in H_func.
+    rewrite H_func.
+    rewrite <- associativity.
+    rewrite (mixed_l (biproduct_is (cs_biprod (split Y)))).
+    apply zero_morphism_left.
+  Qed.
+
+  (** ** Iterated decomposition *)
+
+  Fixpoint iterated_low (n : nat) (X : object C) : object C :=
+    match n with
+    | O => X
+    | S m => low_freq (iterated_low m X)
+    end.
+
+  Definition scale_band
+    (split : forall X, CofiberSplitting X) (k : nat) (X : object C)
+    : object C :=
+    cs_high (split (iterated_low k X)).
+
+  Definition iterated_splitting
+    (split : forall X, CofiberSplitting X) (k : nat) (X : object C)
+    : CofiberSplitting (iterated_low k X) :=
+    split (iterated_low k X).
+
+End CofiberSplitting.
+
+(** * Detection as pi0 of a presheaf colimit *)
+
+From HoTT Require Import Basics.Trunc Truncations.Core.
+From HoTT Require Import Diagrams.Graph Diagrams.Diagram.
+From HoTT Require Import Colimits.Colimit.
+
+Section SheafPi0.
+
+  Context (Site : Graph).
+  Context (F : Diagram Site).
+
+  Definition presheaf_colimit : Type := Colimit F.
+
+  Definition pi0 : Type := Trunc 0 presheaf_colimit.
+
+  Global Instance ishset_pi0 : IsHSet pi0 := _.
+
+  Definition pi0_in (i : Site) (x : obj F i) : pi0 := tr (colim i x).
+
+  Definition same_component (i j : Site) (x : obj F i) (y : obj F j)
+    : Type :=
+    pi0_in i x = pi0_in j y.
+
+  Record FinitePresentation := {
+    fp_graph : Graph;
+    fp_diagram : Diagram fp_graph;
+    fp_n_gen : nat;
+    fp_n_rel : nat;
+    fp_equiv : Colimit fp_diagram <~> Colimit F
+  }.
+
+  Theorem finite_presentation_pi0 (P : FinitePresentation)
+    : Trunc 0 (Colimit (fp_diagram P)) <~> pi0.
+  Proof.
+    apply Trunc_functor_equiv.
+    exact (fp_equiv P).
+  Defined.
+
+End SheafPi0.

README.md

@@ -0,0 +1,145 @@
+---
+license: other
+license_name: fair-research-license
+base_model: facebook/EUPE-ViT-B
+tags:
+  - object-detection
+  - vision-transformer
+  - cofiber-decomposition
+library_name: pytorch
+---
+
+# Cofiber Detection
+
+Object detection heads built on cofiber decomposition of frozen [EUPE-ViT-B](https://huggingface.co/facebook/EUPE-ViT-B) features. The cofiber decomposition produces multi-scale representations with zero learned parameters, replacing the 11M-parameter FPN typically used in FCOS-style detectors. Heads range from 70-parameter analytical constructions to 3.85M-parameter trained networks, evaluated on COCO val2017.
+
+## The Cofiber Decomposition
+
+Given spatial backbone features `f : [768, H, W]`, the cofiber decomposition produces `n` scale bands via iterated subtraction of downsampled-then-upsampled content:
+
+```
+residual = f
+for k = 0 to n-2:
+    omega_k = avgpool(residual, 2)
+    sigma_omega_k = upsample_bilinear(omega_k, size=residual.shape)
+    cofiber_k = residual - sigma_omega_k
+    residual = omega_k
+cofiber_{n-1} = residual
+```
+
+Each `cofiber_k` captures frequency content at a distinct scale with no cross-scale interference. The decomposition is a fixed two-line operation, yet it provides the same multi-scale structure that an FPN synthesizes with 11M trained parameters.
+
+The construction is machine-checked in Rocq/HoTT (`CofiberDecomposition.v`). The proof frames average pooling and bilinear upsampling as an adjoint pair whose counit gives a short exact sequence in a semi-additive category; the cofiber bands are the kernels of the projections, and the sum is exact by construction.
+
+## Best Results (COCO val2017)
+
+| Variant | Params | mAP | mAP@0.50 | mAP@0.75 | Category |
+|---------|--------|-----|----------|----------|----------|
+| **split_tower_5scale_160h_5std_4dw_ema_l14_16ep_768_cls_calib** | **2,975,067** | **42.64** | **65.70** | **45.10** | trained |
+| split_tower_5scale_160h_5std_4dw_ema_l14_16ep_768 (step 104k, pre-calib) | 2,975,067 | 42.49 | 65.57 | 44.89 | trained |
+| split_tower_5scale_160h_5std_4dw_ema_l14_16ep (step 100k, 640px) | 2,975,067 | 41.15 | 63.99 | 43.83 | trained |
+| split_tower_5scale_192h_5std_4dw_textaligned_640px | 4,164,699 | 25.95 | 39.13 | 28.92 | trained |
+| split_tower_5scale_192h_5std_4dw | 4,068,954 | 24.6 | 37.1 | 27.0 | trained |
+| split_tower_192h_5std_4dw | 4,016,441 | 20.7 | 28.5 | 22.8 | trained |
+| split_tower_224h_3std_6dw | 3,849,657 | 20.3 | 28.1 | 22.3 | trained |
+| conv_deep_p3_lateral | 4,269,785 | 19.9 | 28.4 | 22.0 | trained |
+| conv_deep_p3 | 3,972,569 | 19.7 | 28.3 | 21.6 | trained |
+| conv_deep_3.38M | 3,381,592 | 18.8 | 27.4 | 20.9 | trained |
+| conv_deep_912k | 911,960 | 17.2 | 25.6 | 19.2 | trained |
+| evolved_deep | 182,580 | 10.6 | 18.9 | 10.8 | trained |
+| spatialreg_92k | 91,960 | 8.2 | 25.7 | 2.8 | trained |
+| box32_92k | 91,640 | 5.9 | 21.4 | 1.3 | trained |
+| box32 pruned R2 | ~62,000 nz | 5.9 | 20.4 | 1.5 | trained |
+| dim20 | 22,076 | 3.9 | 14.8 | 0.9 | trained |
+| analytical_70k | 69,976 | 1.6 | 6.0 | 0.4 | analytical |
+| evolved K=100 person | 105 | 1.3 | 5.8 | 0.1 | circuit |
+| Baseline FCOS (non-cofiber) | 16,138,074 | 41.0 | 64.8 | 43.2 | reference |
+
+The current split-tower head reaches **42.64 mAP on COCO val2017 with 2,975,067 learnable parameters** (42.71 under soft NMS), passing the 16.14M FCOS baseline (41.0 mAP) by +1.64 while using 18.4 percent of its head parameter budget. Small-object mAP is 22.3 (FCOS 19.4, +2.9). This is the head shipped in [phanerozoic/argus](https://huggingface.co/phanerozoic/argus). The architecture consists of separate classification and regression convolutional towers, each built from five standard 3×3 convolutions followed by four depthwise residual blocks at a hidden dimension of 160 channels. Its input is a cofiber decomposition of the backbone patch features into four frequency-separated bands (corresponding to spatial strides of 16, 32, 64, and 128 pixels), with an additional finer-resolution level (stride 8) synthesized by a single transposed convolution from the stride-16 band. Top-down lateral connections pass information from coarser bands into finer ones before the towers run. The five resulting prediction levels (strides 8, 16, 32, 64, and 128) match the scale coverage of the FCOS simple feature pyramid while obtaining their multi-scale structure from a zero-parameter decomposition rather than from a learned feature pyramid network.
+
+The path from 24.6 mAP to 42.64 mAP was recipe-and-resolution, not architectural. Hidden width actually went down (192 → 160); the gains came from ATSS target assignment (replacing FCOS center sampling), horizontal flip augmentation, a CLIP ViT-L/14 8-prompt-average text embedding in place of ViT-B/32 single-prompt, PC-initialized cls_project (first 80 columns from the SVD of the text embedding, remaining columns a random orthogonal complement), exponential moving average during training (decay 0.9998), a doubled 16-epoch schedule with late-training checkpoint selection, the training-resolution jump from 640-pixel to 768-pixel input (+1.34 mAP, mostly on small-object AP via the 48×48 backbone grid vs 40×40), and a 3-epoch partial fine-tune updating only the classification calibration layers (`cls_project`, `cls_bias`, `logit_scale`) at lr 1e-4 with towers and cofiber path frozen (+0.15 mAP). The final checkpoint is the end state of the partial fine-tune; eval JSON sits next to the weights in the shipping directory.
+
+## Repository Structure
+
+### [`analytical/`](analytical/) — Zero-training or closed-form constructions
+
+| Path | Description |
+|------|-------------|
+| [`analytical_70k/`](analytical/analytical_70k/) | Closed-form least-squares head. 70K params, 1.6 mAP, zero training |
+| [`analytical_h1/`](analytical/analytical_h1/) | Sheaf cohomology (H^1) features. Experimental |
+| [`variants/`](analytical/variants/) | Exotic feature experiments (quadratic, RFF, Fourier, fractal) with result JSONs |
+| [`scripts/`](analytical/scripts/) | `analytical_greedy_gpu.py`, `analytical_exotic_gpu.py`, `analytical_empbayes.py`, etc. |
+
+### [`trained/`](trained/) — Gradient-trained cofiber heads
+
+| Path | Params | mAP | Description |
+|------|--------|-----|-------------|
+| [`split_tower_5scale/`](trained/split_tower_5scale/) | 4.07M | **24.6** | Five-scale split-tower head (P3-P7). Current best |
+| [`split_tower/`](trained/split_tower/) | 4.02M | 20.7 | Four-scale split-tower head (predecessor) |
+| [`conv_deep/`](trained/conv_deep/) | 912K-4.27M | 17.2-19.9 | Depthwise residual stack variants (scaled, P3, lateral) |
+| [`evolved_deep/`](trained/evolved_deep/) | 182K | 10.6 | 10-layer MLP on 92 evolutionarily-selected dims |
+| [`spatialreg_92k/`](trained/spatialreg_92k/) | 92K | 8.2 | 3x3 depthwise conv on regression output |
+| [`linear_70k/`](trained/linear_70k/) | 70K | 5.2 | Trained linear classifier |
+| [`box32_92k/`](trained/box32_92k/) | 92K | 5.9 | INT8 threshold logic circuit + pruned variants (46K-76K) |
+| [`box32_distilled/`](trained/box32_distilled/) | 92K | — | Self-distillation of box32 |
+| [`dim_sweeps/`](trained/dim_sweeps/) | 9K-80K | 0.3-? | SVD-initialized fixed-dim heads (5, 10, 15, 20, 30, 80) |
+| [`sloe/`](trained/sloe/) | — | 0.0 | Spectral Laplacian object emergence (failed experiment) |
+| [`person_specialist/`](trained/person_specialist/) | 9K | — | Person-only detector |
+| [`waldo_specialist/`](trained/waldo_specialist/) | 5K | — | Waldo-finding detector |
+| [`experimental_scaffolds/`](trained/experimental_scaffolds/) | — | — | Untrained architectural scaffolds (5scale, adaptive, centernet, linear) |
+
+### [`circuit/`](circuit/) — Hardware cofiber circuits
+
+| File | Description |
+|------|-------------|
+| `person_analytical.pth` | Person classifier at 93 parameters, 99.8% recall |
+| `person_detector.sv`, `cofiber_detector.sv` | Verilog implementations |
+| `rom/*.hex` | INT8 weight ROMs |
+| `evolved_K100_person_eval.json` | Evolutionary search result, 105 params, 1.3 mAP |
+| `tb_person.sv` | Testbench |
+
+### [`scripts/`](scripts/) — Training and evaluation
+
+| Script | Target |
+|--------|--------|
+| `train_split_tower.py` | Split tower (best) |
+| `train_conv_deep.py` | Conv deep family (912K-4.27M) |
+| `train_evolved_deep.py` | Evolved deep on 92 dims |
+| `eval_conv_deep_step.py` | Eval any conv_deep checkpoint |
+| `eval_evolved_deep.py` | Eval evolved_deep checkpoint |
+| `eval_coco_map.py` | Generic COCO mAP eval |
+
+### [`CofiberDecomposition.v`](CofiberDecomposition.v)
+
+Rocq/HoTT machine-checked proof that the cofiber decomposition is exact in a semi-additive category: every input decomposes uniquely as a sum of scale bands with zero cross-term residual.
+
+## Scaling Curve
+
+The relationship between head parameters and mAP is approximately logarithmic across four orders of magnitude, until the CLIP-text-aligned 160h recipe lands above FCOS:
+
+```
+      105 params → 1.3 mAP  (evolved circuit, person only)
+       70K params → 1.6 mAP  (analytical closed-form)
+       92K params → 8.2 mAP  (depthwise conv on regression)
+      182K params → 10.6 mAP (evolved dim selection + 10-layer MLP)
+      912K params → 17.2 mAP (depthwise conv stack)
+     3.97M params → 19.7 mAP (with stride-8 P3)
+     3.85M params → 20.3 mAP (split cls/reg towers, 3 std + 6 dw at 224 hidden, 4 scales)
+     4.02M params → 20.7 mAP (split cls/reg towers, 5 std + 4 dw at 192 hidden, 4 scales)
+     4.07M params → 24.6 mAP (same tower, 5 scales / P3-P7 coverage)
+     4.16M params → 25.95 mAP (+ CLIP ViT-B/32 text-aligned classifier, 8 ep, 640px)
+     2.98M params → 41.15 mAP (160h + ATSS + EMA + PC init + CLIP ViT-L/14, 16 ep, 640px)
+     2.98M params → 42.49 mAP (same recipe, 768px training input)
+     2.98M params → 42.64 mAP (+ 3-epoch cls_calib fine-tune — shipped in Argus)
+    16.14M params → 41.0 mAP  (FCOS baseline with FPN, 640px)
+```
+
+The bottom four rows are the point of the repository. The 25.95 → 42.64 ascent required no architectural capacity increase (hidden width dropped from 192 to 160) and no change to the cofiber decomposition itself. It came from training recipe: ATSS assignment, flip aug, EMA, PC-initialized cls_project, CLIP ViT-L/14 multi-prompt text embeddings, doubled schedule with late-training checkpoint selection, 640→768 resolution scaling, and a final 3-epoch classification-calibration fine-tune. At 18.4 percent of FCOS's head parameter budget the 2.98M checkpoint beats FCOS by +1.64 mAP under hard NMS and +1.71 under soft NMS, with the small-object gap widening to +2.9.
+
+## Broader Detection Work
+
+Non-cofiber detection heads (FCOS baseline, untrained architectural variants, alternative formulations) are hosted in [phanerozoic/detection-heads](https://huggingface.co/phanerozoic/detection-heads), which also includes the top-performing cofiber head (split_tower) for reference. This repository is the canonical host for cofiber-based detection research.
+
+## License
+
+Fair Research License. See `LICENSE`.

TODO.md

@@ -0,0 +1,33 @@
+# Cofiber Detection Circuit — Research Directions
+
+## Dense detection at sub-stride resolution
+
+The circuit's L1-cache-resident weight set (241 KB) permits evaluation at spatial densities impractical for larger detection heads. At 61K INT8 parameters, per-pixel detection across a 640×640 input (409,600 locations × 80 classes) remains within single-digit millisecond latency on CPU. This eliminates the stride-16 quantization of detection locations inherent in patch-based approaches and may improve small-object recall.
+
+## Prototype ensemble via weight replication
+
+Multiple instances of the circuit with independently trained prototype sets can be evaluated in parallel and their outputs combined by majority vote. At 241 KB per instance, a 100-member ensemble occupies 24 MB — within L2 cache on commodity hardware. The ensemble diversity comes from different training seeds, data splits, or domain-specific prototype sets. The question is whether ensembling at the prototype level produces complementary detections or redundant ones.
+
+## Fusion with backbone computation
+
+The cofiber decomposition (pool + subtract) operates on the same tensor format as the backbone's intermediate attention outputs. Rather than treating backbone and head as sequential stages with a memory-bus boundary between them, the circuit can be fused into the backbone's final block as a post-attention operation. The detection output is produced before the backbone features are written to global memory, eliminating one full read-write cycle.
+
+## Inline video detection
+
+The circuit is small enough to execute inside a video decode loop between frame reconstructions. On hardware with a dedicated video decode unit (NVDEC, Intel QSV, Apple VideoToolbox), the detection circuit runs on the CPU cores that would otherwise idle during decode. This produces per-frame detections with zero additional latency beyond the decode itself, without a separate inference pipeline.
+
+## Formal verification of circuit properties
+
+The 61,520-parameter weight space is small enough for bounded model checking. Properties amenable to formal verification include: maximum detection count per input (proving the circuit cannot produce more than K detections on any valid feature tensor), mutual exclusion of class pairs at shared locations, and monotonicity of detection score with respect to prototype similarity. These guarantees are relevant for safety-critical deployment where unbounded detection output is unacceptable.
+
+## On-device prototype adaptation
+
+Retraining the circuit requires updating a single 80×768 weight matrix — a rank-1 update per corrected class. On a mobile device, a user correction (misclassified detection) translates to a running-average update of the corresponding class prototype: `w_c ← (1-α)w_c + α·f_corrected`. No optimizer state, no backpropagation, no framework. The prototype update is a vector addition that executes in microseconds. The question is whether online prototype adaptation converges to useful personalization or drifts under distribution shift.
+
+## Neuromorphic deployment
+
+The depth-3 circuit with integer weights and Heaviside activation maps directly to spiking neural network hardware (Intel Loihi, IBM TrueNorth, BrainChip Akida). Each threshold gate is one neuron. The fixed-weight layers (pool, subtract) are hardwired connections. The classification layer is a programmable weight matrix loaded once. Event-driven evaluation on neuromorphic hardware consumes power proportional to the number of active detections, not the number of spatial locations evaluated.
+
+## Exhaustive INT8 weight search
+
+At 61,520 INT8 parameters, local search over the weight space is tractable. Starting from the trained prototypes, systematically test single-weight perturbations (increment or decrement each INT8 value by 1) and retain changes that improve detection fitness on a held-out set. This is the same pruning methodology used in the `8bit-threshold-computer` project (`prune_weights.py`), applied to detection prototypes rather than arithmetic circuits.

analytical/analytical_70k/analytical_head_70k.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ecd1974d125b19c5b741b9ffa2f06c06baa58a246218d90e4e54ccd3d79a6aee
+size 284165

analytical/analytical_70k/analytical_head_70k_eval.json

@@ -0,0 +1,13 @@
+{
+  "head": "analytical_detector",
+  "params": 69976,
+  "checkpoint": "heads/cofiber_threshold/analytical_70k/analytical_head_70k.pth",
+  "n_images": 5000,
+  "n_detections": 500000,
+  "mAP_0.5_0.95": 0.01546164516440593,
+  "mAP_0.50": 0.06037011951154602,
+  "mAP_0.75": 0.0035925450594784733,
+  "mAP_small": 0.0021775822040523978,
+  "mAP_medium": 0.017033486120342587,
+  "mAP_large": 0.027756867681569267
+}

analytical/analytical_70k/head.py

@@ -0,0 +1,84 @@
+"""Analytical detection head — zero gradient steps.
+
+All weights are computed from closed-form least-squares on cached backbone
+features. The entire head is a derived circuit: cofiber decomposition (fixed)
++ linear predictions (solved via matrix inverse).
+
+Construction:
+  1. Accumulate sufficient statistics: X^T X and X^T Y from training features
+     at positive locations, where X = features and Y = targets.
+  2. Solve: W = (X^T X + lambda I)^{-1} X^T Y  for classification, regression,
+     and centerness independently.
+  3. The resulting weights are the optimal linear predictor in the least-squares sense.
+
+There is no training loop, no learning rate, no epochs. The head is computed
+from a single pass over the training data and one matrix inverse per task.
+
+Parameters: 69,976
+Construction time: ~130 seconds on CPU
+COCO val2017 mAP: 1.6
+
+This is the first known fully-derived detection head on frozen backbone features.
+"""
+
+import os
+import json
+import time
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+NUM_CLASSES = 80
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+class AnalyticalDetector(nn.Module):
+    """Fully analytical detection head. All weights from closed-form solution."""
+    name = "analytical_detector"
+    needs_intermediates = False
+
+    def __init__(self, feat_dim=768, num_classes=NUM_CLASSES, n_scales=3):
+        super().__init__()
+        self.n_scales = n_scales
+        self.scale_norms = nn.ModuleList([nn.LayerNorm(feat_dim) for _ in range(n_scales)])
+        # Direct linear: no hidden layer, no nonlinearity
+        self.cls_weight = nn.Parameter(torch.randn(num_classes, feat_dim) * 0.01)
+        self.cls_bias = nn.Parameter(torch.zeros(num_classes))
+        self.reg_out = nn.Linear(feat_dim, 4)
+        self.ctr_weight = nn.Parameter(torch.randn(1, feat_dim) * 0.01)
+        self.ctr_bias = nn.Parameter(torch.zeros(1))
+        self.scale_params = nn.Parameter(torch.ones(n_scales))
+
+    def forward(self, spatial, inter=None):
+        cofibers = cofiber_decompose(spatial, self.n_scales)
+        cls_l, reg_l, ctr_l = [], [], []
+        for i, cof in enumerate(cofibers):
+            B, C, H, W = cof.shape
+            f = self.scale_norms[i](cof.permute(0, 2, 3, 1).reshape(-1, C))
+            cls = (f @ self.cls_weight.T + self.cls_bias).reshape(B, H, W, -1).permute(0, 3, 1, 2)
+            reg_raw = (self.reg_out(f) * self.scale_params[i]).clamp(-10, 10)
+            reg = torch.exp(reg_raw).reshape(B, H, W, 4).permute(0, 3, 1, 2)
+            ctr = (f @ self.ctr_weight.T + self.ctr_bias).reshape(B, H, W, 1).permute(0, 3, 1, 2)
+            cls_l.append(cls)
+            reg_l.append(reg)
+            ctr_l.append(ctr)
+        return cls_l, reg_l, ctr_l
+
+
+def construct_analytical_head(cache_dir, n_images=20000, lam=1e-3, resolution=640):
+    """Construct all weights from closed-form least-squares. Zero training."""
+    from analytical_head import accumulate_statistics, solve_head
+    stats = accumulate_statistics(cache_dir, n_images, lam, resolution)
+    return solve_head(stats)

analytical/analytical_h1/analytical_h1_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0300acdc7dc6b5524b03f6ee56971286bae77efd8610a48cec28422dbbcacbe
+size 309581

analytical/analytical_h1/eval.json

@@ -0,0 +1,12 @@
+{
+  "head": "analytical_h1_best",
+  "params": 76120,
+  "training": "zero (closed-form least-squares)",
+  "n_images": 5000,
+  "mAP_0.5_0.95": 0.01162068472530145,
+  "mAP_0.50": 0.04322769269795811,
+  "mAP_0.75": 0.0027664001981709914,
+  "mAP_small": 0.0016777775312599376,
+  "mAP_medium": 0.015140164702089317,
+  "mAP_large": 0.021564585796647318
+}

analytical/scripts/analytical_best_gpu.py

@@ -0,0 +1,229 @@
+"""
+Build the best analytical head from our findings and run full mAP eval.
+
+Classification: 768 raw LayerNorm'd features (69.6% accuracy)
+Regression: 768 raw + H^1 vertical + H^1 horizontal boundary features (68.7% quality)
+Centerness: 768 raw features
+
+Accumulate on training data, solve, save checkpoint, eval via eval_coco_map.py.
+"""
+
+import json
+import os
+import sys
+import time
+
+import torch
+import torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+CACHE_DIR = os.environ.get("ARENA_CACHE_DIR", "feature_cache")
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT", "coco")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE", "val_cache/val.pt")
+RESOLUTION = 640
+NUM_CLASSES = 80
+DEVICE = "cuda"
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+def make_locations(sizes, strides):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    ct = torch.full((n,), -1, dtype=torch.long)
+    rt = torch.zeros(n, 4)
+    ctrt = torch.zeros(n)
+    if boxes.numel() == 0:
+        return ct, rt, ctrt
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    l = loc[:, None, 0] - boxes[None, :, 0]
+    t = loc[:, None, 1] - boxes[None, :, 1]
+    r = boxes[None, :, 2] - loc[:, None, 0]
+    b = boxes[None, :, 3] - loc[:, None, 1]
+    ltrb = torch.stack([l, t, r, b], -1)
+    in_box = ltrb.min(-1).values > 0
+    cx = (boxes[:, 0] + boxes[:, 2]) / 2
+    cy = (boxes[:, 1] + boxes[:, 3]) / 2
+    rad = stride * 1.5
+    in_center = ((loc[:, None, 0] >= cx - rad) & (loc[:, None, 0] <= cx + rad) &
+                 (loc[:, None, 1] >= cy - rad) & (loc[:, None, 1] <= cy + rad))
+    max_d = ltrb.max(-1).values
+    in_level = (max_d >= sr[0]) & (max_d <= sr[1])
+    pos = in_box & in_center & in_level
+    a = areas[None, :].expand_as(pos).clone()
+    a[~pos] = float("inf")
+    matched = a.argmin(1)
+    is_pos = a.gather(1, matched[:, None]).squeeze(1) < float("inf")
+    ct[is_pos] = labels[matched[is_pos]]
+    if is_pos.any():
+        rt[is_pos] = ltrb[torch.arange(n)[is_pos], matched[is_pos]]
+        lp, tp, rp, bp = rt[is_pos].unbind(-1)
+        ctrt[is_pos] = torch.sqrt(
+            (torch.minimum(lp, rp) / torch.maximum(lp, rp).clamp(min=1e-6)) *
+            (torch.minimum(tp, bp) / torch.maximum(tp, bp).clamp(min=1e-6)))
+    return ct, rt, ctrt
+
+
+def compute_h1(f, B, H, W, C):
+    """Sheaf H^1 compact: vertical + horizontal boundary magnitudes."""
+    f_4d = f.reshape(B, H, W, C).permute(0, 3, 1, 2)
+    d_up = f_4d - F.pad(f_4d[:, :, 1:, :], (0, 0, 0, 1))
+    d_down = f_4d - F.pad(f_4d[:, :, :-1, :], (0, 0, 1, 0))
+    d_left = f_4d - F.pad(f_4d[:, :, :, 1:], (0, 1, 0, 0))
+    d_right = f_4d - F.pad(f_4d[:, :, :, :-1], (1, 0, 0, 0))
+    v_bound = (d_up.abs() + d_down.abs()).permute(0, 2, 3, 1).reshape(-1, C)
+    h_bound = (d_left.abs() + d_right.abs()).permute(0, 2, 3, 1).reshape(-1, C)
+    return v_bound, h_bound
+
+
+def main():
+    print("=" * 60)
+    print("Best Analytical Head: 768 cls + H^1 regression")
+    print("=" * 60, flush=True)
+
+    manifest = json.load(open(os.path.join(CACHE_DIR, "manifest.json")))
+    n_shards = manifest["n_shards"]
+    strides = [16, 32, 64]
+    H = RESOLUTION // 16
+    sizes = [(H, H), (H // 2, H // 2), (H // 4, H // 4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+
+    feat_dim = 768
+    reg_dim = 768 * 3  # raw + h1v + h1h
+
+    # Accumulators
+    cls_XtX = torch.zeros(feat_dim + 1, feat_dim + 1, device=DEVICE)
+    cls_XtY = torch.zeros(feat_dim + 1, NUM_CLASSES, device=DEVICE)
+    reg_XtX = torch.zeros(reg_dim + 1, reg_dim + 1, device=DEVICE)
+    reg_XtY = torch.zeros(reg_dim + 1, 4, device=DEVICE)
+    ctr_XtX = torch.zeros(feat_dim + 1, feat_dim + 1, device=DEVICE)
+    ctr_XtY = torch.zeros(feat_dim + 1, 1, device=DEVICE)
+    n_pos = 0
+    n_images = 20000
+    seen = 0
+    t0 = time.time()
+
+    for si in range(n_shards):
+        if seen >= n_images:
+            break
+        shard = torch.load(os.path.join(CACHE_DIR, f"shard_{si:04d}.pt"),
+                          map_location="cpu", weights_only=False)
+        for item in shard:
+            if seen >= n_images:
+                break
+            sp = item["spatial"].unsqueeze(0).float()
+            boxes = item["boxes"]
+            labels = item["labels"]
+            cofibers = cofiber_decompose(sp, 3)
+            for sci, cof in enumerate(cofibers):
+                B, C, Hc, Wc = cof.shape
+                f = F.layer_norm(cof.permute(0, 2, 3, 1).reshape(-1, C), [C])
+                h1v, h1h = compute_h1(f, B, Hc, Wc, C)
+                ct, rt, ctrt = assign_targets(locs[sci], boxes, labels, strides[sci], sr[sci])
+                pos_mask = ct >= 0
+                if not pos_mask.any():
+                    continue
+
+                # Classification: raw features only
+                fp = f[pos_mask].to(DEVICE)
+                fa = torch.cat([fp, torch.ones(fp.shape[0], 1, device=DEVICE)], 1)
+                yc = torch.zeros(fp.shape[0], NUM_CLASSES, device=DEVICE)
+                yc[torch.arange(fp.shape[0], device=DEVICE), ct[pos_mask].to(DEVICE)] = 1.0
+                cls_XtX += fa.T @ fa
+                cls_XtY += fa.T @ yc
+
+                # Regression: raw + H^1
+                f_reg = torch.cat([f[pos_mask], h1v[pos_mask], h1h[pos_mask]], 1).to(DEVICE)
+                ltrb = rt[pos_mask]
+                valid = (ltrb > 0).all(1)
+                if valid.any():
+                    fv = f_reg[valid]
+                    fva = torch.cat([fv, torch.ones(fv.shape[0], 1, device=DEVICE)], 1)
+                    yt = torch.log(ltrb[valid]).to(DEVICE)
+                    reg_XtX += fva.T @ fva
+                    reg_XtY += fva.T @ yt
+
+                # Centerness: raw features
+                ctr_XtX += fa.T @ fa
+                ctr_XtY += fa.T @ ctrt[pos_mask].unsqueeze(1).to(DEVICE)
+
+                n_pos += pos_mask.sum().item()
+            seen += 1
+        del shard
+        if (si + 1) % 5 == 0:
+            print(f"  shard {si+1}: {seen} imgs, {n_pos} pos, {time.time()-t0:.0f}s", flush=True)
+
+    print(f"\nAccumulated {seen} images, {n_pos} positives", flush=True)
+
+    # Solve
+    lam = 0.1
+    I_cls = torch.eye(feat_dim + 1, device=DEVICE)
+    I_reg = torch.eye(reg_dim + 1, device=DEVICE)
+    I_ctr = torch.eye(feat_dim + 1, device=DEVICE)
+
+    cls_W = torch.linalg.solve(cls_XtX + lam * I_cls * n_pos, cls_XtY)
+    reg_W = torch.linalg.solve(reg_XtX + lam * I_reg * n_pos, reg_XtY)
+    ctr_W = torch.linalg.solve(ctr_XtX + lam * I_ctr * n_pos, ctr_XtY)
+
+    print(f"Solved. cls: {feat_dim}->80, reg: {reg_dim}->4, ctr: {feat_dim}->1", flush=True)
+
+    # Save as state dict
+    state = {
+        "cls_weight": cls_W[:feat_dim].T.cpu(),
+        "cls_bias": cls_W[feat_dim].cpu(),
+        "reg_weight": reg_W[:reg_dim].T.cpu(),
+        "reg_bias": reg_W[reg_dim].cpu(),
+        "ctr_weight": ctr_W[:feat_dim].T.cpu(),
+        "ctr_bias": ctr_W[feat_dim].cpu(),
+        "scale_norms.0.weight": torch.ones(768),
+        "scale_norms.0.bias": torch.zeros(768),
+        "scale_norms.1.weight": torch.ones(768),
+        "scale_norms.1.bias": torch.zeros(768),
+        "scale_norms.2.weight": torch.ones(768),
+        "scale_norms.2.bias": torch.zeros(768),
+        "scale_params": torch.ones(3),
+        "meta": {"cls_features": "768_layernorm",
+                 "reg_features": "768_layernorm_h1v_h1h",
+                 "ctr_features": "768_layernorm",
+                 "lambda": lam, "n_images": seen, "n_pos": n_pos},
+    }
+
+    out_dir = os.path.join(SCRIPT_DIR, "heads", "cofiber_threshold", "analytical_h1")
+    os.makedirs(out_dir, exist_ok=True)
+    out_path = os.path.join(out_dir, "analytical_h1_best.pth")
+    torch.save(state, out_path)
+
+    n_params = sum(v.numel() for k, v in state.items() if isinstance(v, torch.Tensor))
+    elapsed = time.time() - t0
+    print(f"\nSaved: {out_path}")
+    print(f"Total params: {n_params:,}")
+    print(f"Construction time: {elapsed:.0f}s")
+    print(f"\nClassification: 768 dims, {feat_dim * NUM_CLASSES + NUM_CLASSES:,} params")
+    print(f"Regression: {reg_dim} dims (768+768+768), {reg_dim * 4 + 4:,} params")
+    print(f"Centerness: 768 dims, {feat_dim + 1:,} params")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_empbayes.py

@@ -0,0 +1,277 @@
+"""
+Empirical Bayes analytical detection head.
+
+Bayesian linear regression: W ~ N(0, tau^2 I), Y|X,W ~ N(XW, sigma^2 I)
+The optimal regularization is lambda = sigma^2 / tau^2.
+
+Empirical Bayes estimates sigma^2 and tau^2 from the data by maximizing
+the log marginal likelihood (type-II ML):
+
+  log p(Y|X, sigma^2, tau^2) = -n/2 log(2pi) - 1/2 log|sigma^2 I + tau^2 X X^T|
+                                 - 1/2 Y^T (sigma^2 I + tau^2 X X^T)^{-1} Y
+
+Using the SVD of X = U S V^T, this simplifies to operations on the singular values.
+The optimization alternates between updating sigma^2 and tau^2.
+
+This gives a principled, per-task lambda with calibrated uncertainty.
+"""
+
+import json, os, sys, time
+import torch
+import torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+CACHE_DIR = os.environ.get("ARENA_CACHE_DIR")
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE")
+DEVICE = "cuda"
+RESOLUTION = 640
+NUM_CLASSES = 80
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []; residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega); residual = omega
+    cofibers.append(residual); return cofibers
+
+
+def make_locations(sizes, strides, device="cpu"):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, device=device, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, device=device, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    ct = torch.full((n,), -1, dtype=torch.long); rt = torch.zeros(n, 4); ctrt = torch.zeros(n)
+    if boxes.numel() == 0: return ct, rt, ctrt
+    areas = (boxes[:,2]-boxes[:,0])*(boxes[:,3]-boxes[:,1])
+    l=loc[:,None,0]-boxes[None,:,0]; t=loc[:,None,1]-boxes[None,:,1]
+    r=boxes[None,:,2]-loc[:,None,0]; b=boxes[None,:,3]-loc[:,None,1]
+    ltrb=torch.stack([l,t,r,b],-1); in_box=ltrb.min(-1).values>0
+    cx=(boxes[:,0]+boxes[:,2])/2; cy=(boxes[:,1]+boxes[:,3])/2; rad=stride*1.5
+    in_center=((loc[:,None,0]>=cx-rad)&(loc[:,None,0]<=cx+rad)&(loc[:,None,1]>=cy-rad)&(loc[:,None,1]<=cy+rad))
+    max_d=ltrb.max(-1).values; in_level=(max_d>=sr[0])&(max_d<=sr[1])
+    pos=in_box&in_center&in_level; a=areas[None,:].expand_as(pos).clone(); a[~pos]=float("inf")
+    matched=a.argmin(1); is_pos=a.gather(1,matched[:,None]).squeeze(1)<float("inf")
+    ct[is_pos]=labels[matched[is_pos]]
+    if is_pos.any():
+        rt[is_pos]=ltrb[torch.arange(n)[is_pos],matched[is_pos]]
+        lp,tp,rp,bp=rt[is_pos].unbind(-1)
+        ctrt[is_pos]=torch.sqrt((torch.minimum(lp,rp)/torch.maximum(lp,rp).clamp(min=1e-6))*(torch.minimum(tp,bp)/torch.maximum(tp,bp).clamp(min=1e-6)))
+    return ct, rt, ctrt
+
+
+def empirical_bayes_lambda(XtX, XtY, n_samples, n_iters=50):
+    """Estimate optimal lambda = sigma^2/tau^2 via empirical Bayes.
+
+    Uses the eigendecomposition of XtX to iteratively estimate:
+      tau^2 = (1/d) sum_i (gamma_i * w_i^2)  where gamma_i = s_i^2 / (s_i^2 + lambda)
+      sigma^2 = (1/(n - sum gamma_i)) * ||Y - X W||^2
+
+    gamma_i is the "effective number of well-determined parameters" (Mackay).
+    """
+    d = XtX.shape[0]
+    k = XtY.shape[1]  # number of output dims
+
+    # Eigendecompose XtX
+    eigvals, eigvecs = torch.linalg.eigh(XtX)
+    eigvals = eigvals.clamp(min=1e-10)
+
+    # Project targets into eigenspace
+    VtXtY = eigvecs.T @ XtY  # (d, k)
+
+    # Initialize
+    alpha = 1.0   # 1/tau^2
+    beta = 1.0    # 1/sigma^2
+    lam = alpha / beta
+
+    for it in range(n_iters):
+        # Effective parameters per eigenvalue
+        gamma = eigvals / (eigvals + lam)
+        gamma_sum = gamma.sum().item()
+
+        # Solve with current lambda
+        W = eigvecs @ (VtXtY / (eigvals + lam).unsqueeze(1))
+
+        # Residual sum of squares (averaged over output dims)
+        # ||Y - XW||^2 = ||Y||^2 - 2 W^T X^T Y + W^T X^T X W
+        # = YtY - 2 W^T XtY + W^T XtX W
+        # But we don't have YtY. Approximate from XtY and XtX.
+        # W^T XtY = sum of VtXtY_i^2 * s_i / (s_i + lam)
+        WtXtY = (VtXtY ** 2 * eigvals.unsqueeze(1) / (eigvals + lam).unsqueeze(1) ** 2).sum(0)
+
+        # Update alpha (1/tau^2): alpha = gamma_sum / (W^T W)
+        WtW = (W ** 2).sum(0).mean().item()
+        if WtW > 1e-12:
+            alpha = gamma_sum / (d * WtW)
+        else:
+            alpha = 1e6
+
+        # Update beta (1/sigma^2) using effective degrees of freedom
+        # beta = (n - gamma_sum) / RSS
+        # Approximate RSS from the eigenspace
+        rss = (VtXtY ** 2 * lam ** 2 / (eigvals + lam).unsqueeze(1) ** 2).sum().item() / k
+        dof = max(n_samples - gamma_sum, 1.0)
+        if rss > 1e-12:
+            beta = dof / rss
+        else:
+            beta = 1e6
+
+        lam_new = alpha / beta
+        if abs(lam_new - lam) / max(abs(lam), 1e-10) < 1e-6:
+            lam = lam_new
+            break
+        lam = lam_new
+
+    return lam, gamma_sum, alpha, beta
+
+
+def main():
+    print("=" * 60)
+    print("Empirical Bayes Analytical Detection Head")
+    print("=" * 60, flush=True)
+
+    manifest = json.load(open(os.path.join(CACHE_DIR, "manifest.json")))
+    strides = [16, 32, 64]; H = RESOLUTION // 16
+    sizes = [(H,H),(H//2,H//2),(H//4,H//4)]
+    sr = [(-1,128),(128,256),(256,float("inf"))]
+    locs = make_locations(sizes, strides)
+    feat_dim = 768
+
+    cls_XtX = torch.zeros(feat_dim+1, feat_dim+1, device=DEVICE)
+    cls_XtY = torch.zeros(feat_dim+1, NUM_CLASSES, device=DEVICE)
+    reg_XtX = torch.zeros(feat_dim+1, feat_dim+1, device=DEVICE)
+    reg_XtY = torch.zeros(feat_dim+1, 4, device=DEVICE)
+    ctr_XtX = torch.zeros(feat_dim+1, feat_dim+1, device=DEVICE)
+    ctr_XtY = torch.zeros(feat_dim+1, 1, device=DEVICE)
+    n_cls=0; n_reg=0; n_ctr=0; seen=0; n_images=20000
+    t0 = time.time()
+
+    for si in range(manifest["n_shards"]):
+        if seen >= n_images: break
+        shard = torch.load(os.path.join(CACHE_DIR, f"shard_{si:04d}.pt"),
+                          map_location="cpu", weights_only=False)
+        for item in shard:
+            if seen >= n_images: break
+            sp = item["spatial"].unsqueeze(0).float()
+            boxes = item["boxes"]; labels = item["labels"]
+            cofibers = cofiber_decompose(sp, 3)
+            for sci, cof in enumerate(cofibers):
+                B,C,Hc,Wc = cof.shape
+                f = F.layer_norm(cof.permute(0,2,3,1).reshape(-1,C), [C]).to(DEVICE)
+                ct, rt, ctrt = assign_targets(locs[sci], boxes, labels, strides[sci], sr[sci])
+                pos = ct >= 0
+                if not pos.any(): continue
+                fp = f[pos]
+                fa = torch.cat([fp, torch.ones(fp.shape[0],1,device=DEVICE)], 1)
+                yc = torch.zeros(fp.shape[0], NUM_CLASSES, device=DEVICE)
+                yc[torch.arange(fp.shape[0],device=DEVICE), ct[pos].to(DEVICE)] = 1.0
+                cls_XtX += fa.T @ fa; cls_XtY += fa.T @ yc; n_cls += fp.shape[0]
+                ltrb = rt[pos]; valid = (ltrb > 0).all(1)
+                if valid.any():
+                    fv = fa[valid]; yt = torch.log(ltrb[valid]).to(DEVICE)
+                    reg_XtX += fv.T @ fv; reg_XtY += fv.T @ yt; n_reg += valid.sum().item()
+                ctr_XtX += fa.T @ fa
+                ctr_XtY += fa.T @ ctrt[pos].unsqueeze(1).to(DEVICE); n_ctr += fp.shape[0]
+            seen += 1
+        del shard
+        if (si+1) % 5 == 0:
+            print(f"  shard {si+1}: {seen} imgs, {n_cls} cls, {time.time()-t0:.0f}s", flush=True)
+
+    print(f"\nAccumulated: {n_cls} cls, {n_reg} reg, {n_ctr} ctr", flush=True)
+
+    # Empirical Bayes per task
+    print("\nEstimating per-task lambda via empirical Bayes...", flush=True)
+    t1 = time.time()
+    lam_cls, gamma_cls, alpha_cls, beta_cls = empirical_bayes_lambda(cls_XtX, cls_XtY, n_cls)
+    lam_reg, gamma_reg, alpha_reg, beta_reg = empirical_bayes_lambda(reg_XtX, reg_XtY, n_reg)
+    lam_ctr, gamma_ctr, alpha_ctr, beta_ctr = empirical_bayes_lambda(ctr_XtX, ctr_XtY, n_ctr)
+    print(f"  cls: lambda={lam_cls:.6f} (gamma={gamma_cls:.1f} effective params, alpha={alpha_cls:.4f}, beta={beta_cls:.4f})")
+    print(f"  reg: lambda={lam_reg:.6f} (gamma={gamma_reg:.1f} effective params, alpha={alpha_reg:.4f}, beta={beta_reg:.4f})")
+    print(f"  ctr: lambda={lam_ctr:.6f} (gamma={gamma_ctr:.1f} effective params, alpha={alpha_ctr:.4f}, beta={beta_ctr:.4f})")
+    print(f"  (took {time.time()-t1:.1f}s)", flush=True)
+
+    # Solve with EB lambdas
+    I = torch.eye(feat_dim+1, device=DEVICE)
+    print("\nSolving with empirical Bayes lambdas...", flush=True)
+    cls_W_eb = torch.linalg.solve(cls_XtX + lam_cls * I, cls_XtY)
+    reg_W_eb = torch.linalg.solve(reg_XtX + lam_reg * I, reg_XtY)
+    ctr_W_eb = torch.linalg.solve(ctr_XtX + lam_ctr * I, ctr_XtY)
+
+    # Also solve with our known-good lambda=0.1*n for comparison
+    print("Solving with lambda=0.1*n (previous best)...", flush=True)
+    cls_W_fix = torch.linalg.solve(cls_XtX + 0.1 * I * n_cls, cls_XtY)
+    reg_W_fix = torch.linalg.solve(reg_XtX + 0.1 * I * n_reg, reg_XtY)
+    ctr_W_fix = torch.linalg.solve(ctr_XtX + 0.1 * I * n_ctr, ctr_XtY)
+
+    # Eval both
+    val = torch.load(VAL_CACHE, map_location="cpu", weights_only=False)
+    from pycocotools.coco import COCO
+    from pycocotools.cocoeval import COCOeval
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco_gt = COCO(ann_file)
+    cat_ids = sorted(coco_gt.getCatIds())
+    idx_to_cat = {i: c for i, c in enumerate(cat_ids)}
+    all_locs = torch.cat(make_locations(sizes, strides, DEVICE))
+
+    for label, cls_W, reg_W, ctr_W in [("empirical_bayes", cls_W_eb, reg_W_eb, ctr_W_eb),
+                                         ("fixed_0.1n", cls_W_fix, reg_W_fix, ctr_W_fix)]:
+        print(f"\nEvaluating: {label}", flush=True)
+        all_results = []
+        for idx in range(len(val)):
+            item = val[idx]
+            spatial = item["spatial"].unsqueeze(0).float().to(DEVICE)
+            img_id = int(item["img_id"]); scale = item["scale"]
+            cofibers = cofiber_decompose(spatial, 3)
+            cls_all, reg_all, ctr_all = [], [], []
+            for cof in cofibers:
+                B,C,Hc,Wc = cof.shape
+                f = F.layer_norm(cof.permute(0,2,3,1).reshape(-1,C), [C])
+                fa = torch.cat([f, torch.ones(f.shape[0],1,device=DEVICE)], 1)
+                cls = (fa @ cls_W).sigmoid()
+                reg = (fa @ reg_W).exp()
+                ctr = (fa @ ctr_W).sigmoid()
+                cls_all.append(cls); reg_all.append(reg); ctr_all.append(ctr.squeeze(1))
+            cls_s = torch.cat(cls_all); reg_s = torch.cat(reg_all); ctr_s = torch.cat(ctr_all)
+            scores = cls_s * ctr_s.unsqueeze(1)
+            max_s, max_c = scores.max(1)
+            topk = min(100, max_s.shape[0])
+            top_s, top_i = max_s.topk(topk)
+            tc = max_c[top_i]; tr = reg_s[top_i]; tl = all_locs[top_i]
+            x1=(tl[:,0]-tr[:,0])/scale; y1=(tl[:,1]-tr[:,1])/scale
+            x2=(tl[:,0]+tr[:,2])/scale; y2=(tl[:,1]+tr[:,3])/scale
+            w=(x2-x1).clamp(min=0); h=(y2-y1).clamp(min=0)
+            for i in range(topk):
+                s = top_s[i].item()
+                if s < 0.01: continue
+                all_results.append({"image_id": img_id, "category_id": idx_to_cat[tc[i].item()],
+                                    "bbox": [x1[i].item(), y1[i].item(), w[i].item(), h[i].item()],
+                                    "score": s})
+            if (idx+1) % 1000 == 0:
+                print(f"  {idx+1}/{len(val)}", flush=True)
+
+        if all_results:
+            coco_dt = coco_gt.loadRes(all_results)
+            coco_eval = COCOeval(coco_gt, coco_dt, "bbox")
+            coco_eval.params.imgIds = sorted(coco_gt.getImgIds())[:len(val)]
+            coco_eval.evaluate(); coco_eval.accumulate(); coco_eval.summarize()
+            print(f"\n  {label}: mAP={coco_eval.stats[0]:.4f} mAP50={coco_eval.stats[1]:.4f} mAP75={coco_eval.stats[2]:.4f}")
+        else:
+            print(f"  {label}: no detections")
+
+    elapsed = time.time() - t0
+    print(f"\nTotal: {elapsed:.0f}s")
+    print(f"EB lambdas: cls={lam_cls:.4f} reg={lam_reg:.4f} ctr={lam_ctr:.4f}")
+    print(f"Fixed:      cls={0.1*n_cls:.0f} reg={0.1*n_reg:.0f} ctr={0.1*n_ctr:.0f}")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_exotic_gpu.py

@@ -0,0 +1,278 @@
+"""
+Exotic analytical detection heads on GPU.
+
+Track 1: Random projection pursuit — test N random projections, keep the best.
+Track 2: Nonlinear feature expansion — quadratic cross-terms + random Fourier features.
+"""
+
+import json
+import os
+import sys
+import time
+
+import torch
+import torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT", "coco")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE", "val_cache/val.pt")
+NUM_CLASSES = 80
+DEVICE = "cuda"
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+def make_locations(sizes, strides):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    if boxes.numel() == 0:
+        return torch.full((n,), -1, dtype=torch.long)
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    l = loc[:, None, 0] - boxes[None, :, 0]
+    t = loc[:, None, 1] - boxes[None, :, 1]
+    r = boxes[None, :, 2] - loc[:, None, 0]
+    b = boxes[None, :, 3] - loc[:, None, 1]
+    ltrb = torch.stack([l, t, r, b], -1)
+    in_box = ltrb.min(-1).values > 0
+    cx = (boxes[:, 0] + boxes[:, 2]) / 2
+    cy = (boxes[:, 1] + boxes[:, 3]) / 2
+    rad = stride * 1.5
+    in_center = ((loc[:, None, 0] >= cx - rad) & (loc[:, None, 0] <= cx + rad) &
+                 (loc[:, None, 1] >= cy - rad) & (loc[:, None, 1] <= cy + rad))
+    max_d = ltrb.max(-1).values
+    in_level = (max_d >= sr[0]) & (max_d <= sr[1])
+    pos = in_box & in_center & in_level
+    a = areas[None, :].expand_as(pos).clone()
+    a[~pos] = float("inf")
+    matched = a.argmin(1)
+    is_pos = a.gather(1, matched[:, None]).squeeze(1) < float("inf")
+    ct = torch.full((n,), -1, dtype=torch.long)
+    ct[is_pos] = labels[matched[is_pos]]
+    return ct
+
+
+def build_val_data(val_path, n_images=500):
+    val = torch.load(val_path, map_location="cpu", weights_only=False)
+    from pycocotools.coco import COCO
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco = COCO(ann_file)
+    cat_ids = sorted(coco.getCatIds())
+    cat_to_idx = {c: i for i, c in enumerate(cat_ids)}
+    strides = [16, 32, 64]
+    H = 640 // 16
+    sizes = [(H, H), (H // 2, H // 2), (H // 4, H // 4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+    all_f, all_cls = [], []
+    for idx in range(min(n_images, len(val))):
+        item = val[idx]
+        spatial = item["spatial"].unsqueeze(0).float()
+        img_id = item["img_id"]; scale = item["scale"]
+        ann_ids = coco.getAnnIds(imgIds=int(img_id), iscrowd=False)
+        anns = coco.loadAnns(ann_ids)
+        boxes, labels = [], []
+        for ann in anns:
+            x, y, w, h = ann["bbox"]
+            if w < 1 or h < 1: continue
+            boxes.append([x*scale, y*scale, (x+w)*scale, (y+h)*scale])
+            labels.append(cat_to_idx[ann["category_id"]])
+        boxes_t = torch.tensor(boxes, dtype=torch.float32) if boxes else torch.zeros(0, 4)
+        labels_t = torch.tensor(labels, dtype=torch.long) if labels else torch.zeros(0, dtype=torch.long)
+        cofibers = cofiber_decompose(spatial, 3)
+        for sci, cof in enumerate(cofibers):
+            B, C, Hc, Wc = cof.shape
+            f = F.layer_norm(cof.permute(0, 2, 3, 1).reshape(-1, C), [C])
+            ct = assign_targets(locs[sci], boxes_t, labels_t, strides[sci], sr[sci])
+            all_f.append(f); all_cls.append(ct)
+    return torch.cat(all_f).to(DEVICE), torch.cat(all_cls).to(DEVICE)
+
+
+def solve_and_score(features_pos, y_cls, features_all, cls_targets, pos_mask, lam=0.1):
+    """Solve least-squares and return classification accuracy."""
+    fd = features_pos.shape[1]
+    fa = torch.cat([features_pos, torch.ones(features_pos.shape[0], 1, device=DEVICE)], 1)
+    I = torch.eye(fd + 1, device=DEVICE)
+    n = features_pos.shape[0]
+    try:
+        W = torch.linalg.solve(fa.T @ fa + lam * I * n, fa.T @ y_cls)
+    except Exception:
+        return 0.0
+    scores = features_all @ W[:fd] + W[fd]
+    pred = scores.argmax(1)
+    correct = (pred[pos_mask] == cls_targets[pos_mask]).sum().item()
+    return correct / max(pos_mask.sum().item(), 1)
+
+
+def main():
+    print("=" * 60)
+    print("Exotic Analytical Detection Heads (GPU)")
+    print("=" * 60, flush=True)
+
+    print("Building val data...", flush=True)
+    features, cls_targets = build_val_data(VAL_CACHE, 500)
+    pos = cls_targets >= 0
+    n_pos = pos.sum().item()
+    f_pos = features[pos]
+    y_cls = torch.zeros(n_pos, NUM_CLASSES, device=DEVICE)
+    y_cls[torch.arange(n_pos, device=DEVICE), cls_targets[pos]] = 1.0
+    print(f"  {features.shape[0]} locations, {n_pos} positives", flush=True)
+
+    results = []
+
+    # =====================================================
+    # Baseline: full 768 dims
+    # =====================================================
+    t0 = time.time()
+    acc = solve_and_score(f_pos, y_cls, features, cls_targets, pos)
+    print(f"\nBaseline (768 dims): acc={acc:.4f} [{time.time()-t0:.2f}s]", flush=True)
+    results.append({"name": "baseline_768", "acc": acc, "dims": 768})
+
+    # =====================================================
+    # Track 1: Random Projection Pursuit
+    # =====================================================
+    print(f"\n--- Track 1: Random Projection Pursuit ---", flush=True)
+    for K in [10, 20, 50, 100, 200]:
+        N_PROJ = 500
+        best_acc = 0.0
+        best_seed = -1
+        t0 = time.time()
+        for seed in range(N_PROJ):
+            torch.manual_seed(seed)
+            proj = torch.randn(768, K, device=DEVICE) / (K ** 0.5)
+            f_proj = features @ proj
+            fp_proj = f_proj[pos]
+            acc = solve_and_score(fp_proj, y_cls, f_proj, cls_targets, pos)
+            if acc > best_acc:
+                best_acc = acc
+                best_seed = seed
+        elapsed = time.time() - t0
+        n_params = K * NUM_CLASSES + NUM_CLASSES
+        print(f"  K={K:3d}: best_acc={best_acc:.4f} (seed={best_seed}, "
+              f"{n_params} params, {elapsed:.1f}s, {N_PROJ} projections)", flush=True)
+        results.append({"name": f"random_proj_K{K}", "acc": best_acc,
+                        "dims": K, "params": n_params, "seed": best_seed})
+
+    # =====================================================
+    # Track 2a: Quadratic expansion on top greedy dims
+    # =====================================================
+    print(f"\n--- Track 2a: Quadratic Feature Expansion ---", flush=True)
+    # Load greedy dims
+    greedy_path = os.path.join(SCRIPT_DIR, "analytical_variants", "greedy_forward_gpu.json")
+    if os.path.isfile(greedy_path):
+        with open(greedy_path) as f:
+            greedy = json.load(f)
+        greedy_dims = greedy["selected_dims"]
+    else:
+        greedy_dims = list(range(20))
+
+    for K in [5, 10, 20, 30]:
+        t0 = time.time()
+        dims = greedy_dims[:K]
+        f_sub = features[:, dims]  # (N, K)
+        # Quadratic: all pairwise products x_i * x_j (including x_i^2)
+        quad_features = []
+        for i in range(K):
+            for j in range(i, K):
+                quad_features.append(f_sub[:, i] * f_sub[:, j])
+        f_quad = torch.stack(quad_features, dim=1)  # (N, K*(K+1)/2)
+        # Concatenate linear + quadratic
+        f_expanded = torch.cat([f_sub, f_quad], dim=1)
+        n_expanded = f_expanded.shape[1]
+        fp_exp = f_expanded[pos]
+        acc = solve_and_score(fp_exp, y_cls, f_expanded, cls_targets, pos)
+        n_params = n_expanded * NUM_CLASSES + NUM_CLASSES
+        elapsed = time.time() - t0
+        print(f"  top-{K} + quadratic: {n_expanded} dims, acc={acc:.4f} "
+              f"({n_params} params, {elapsed:.2f}s)", flush=True)
+        results.append({"name": f"quadratic_top{K}", "acc": acc,
+                        "dims": n_expanded, "params": n_params})
+
+    # =====================================================
+    # Track 2b: Random Fourier Features (RBF kernel approx)
+    # =====================================================
+    print(f"\n--- Track 2b: Random Fourier Features ---", flush=True)
+    for K_rff in [50, 100, 200, 500]:
+        t0 = time.time()
+        # sigma controls the kernel width — use median heuristic
+        # For speed, estimate from a subsample
+        sub = features[:5000]
+        dists = torch.cdist(sub[:500], sub[:500])
+        sigma = dists.median().item()
+        if sigma < 1e-6:
+            sigma = 1.0
+
+        torch.manual_seed(42)
+        W_rff = torch.randn(768, K_rff, device=DEVICE) / sigma
+        b_rff = torch.rand(K_rff, device=DEVICE) * 2 * 3.14159
+
+        # phi(x) = sqrt(2/K) * cos(Wx + b)
+        rff = (2.0 / K_rff) ** 0.5 * torch.cos(features @ W_rff + b_rff)
+
+        # Concatenate with raw features
+        f_combined = torch.cat([features, rff], dim=1)
+        fp_comb = f_combined[pos]
+        acc = solve_and_score(fp_comb, y_cls, f_combined, cls_targets, pos)
+        n_dims = f_combined.shape[1]
+        n_params = n_dims * NUM_CLASSES + NUM_CLASSES
+        elapsed = time.time() - t0
+        print(f"  768 + {K_rff} RFF: {n_dims} dims, acc={acc:.4f} "
+              f"({n_params} params, sigma={sigma:.2f}, {elapsed:.2f}s)", flush=True)
+        results.append({"name": f"rff_{K_rff}", "acc": acc,
+                        "dims": n_dims, "params": n_params})
+
+    # =====================================================
+    # Track 2c: Pure RFF (no raw features)
+    # =====================================================
+    print(f"\n--- Track 2c: Pure Random Fourier Features (no raw) ---", flush=True)
+    for K_rff in [200, 500, 1000]:
+        t0 = time.time()
+        torch.manual_seed(42)
+        W_rff = torch.randn(768, K_rff, device=DEVICE) / sigma
+        b_rff = torch.rand(K_rff, device=DEVICE) * 2 * 3.14159
+        rff = (2.0 / K_rff) ** 0.5 * torch.cos(features @ W_rff + b_rff)
+        fp_rff = rff[pos]
+        acc = solve_and_score(fp_rff, y_cls, rff, cls_targets, pos)
+        n_params = K_rff * NUM_CLASSES + NUM_CLASSES
+        elapsed = time.time() - t0
+        print(f"  {K_rff} pure RFF: acc={acc:.4f} ({n_params} params, {elapsed:.2f}s)", flush=True)
+        results.append({"name": f"pure_rff_{K_rff}", "acc": acc,
+                        "dims": K_rff, "params": n_params})
+
+    # =====================================================
+    # Summary
+    # =====================================================
+    print(f"\n{'='*60}")
+    print("Ranked by accuracy:")
+    for r in sorted(results, key=lambda x: -x["acc"]):
+        print(f"  {r['name']:25s}: acc={r['acc']:.4f}  dims={r.get('dims', '?')}  "
+              f"params={r.get('params', '?')}")
+
+    out = os.path.join(SCRIPT_DIR, "analytical_variants", "exotic_gpu.json")
+    with open(out, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\nSaved: {out}")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_exotic_reg_gpu.py

@@ -0,0 +1,284 @@
+"""
+Exotic regression experiments on GPU.
+
+The classification is already at 69.6% with linear features — close to the ceiling.
+The gap between analytical (1.6 mAP) and trained (8.2 mAP) is in REGRESSION.
+Test whether nonlinear feature expansions help the regression solver.
+
+Experiments:
+1. Quadratic features for regression only (linear cls stays at 768)
+2. Sheaf H^1 boundary features for regression only
+3. Quadratic + H^1 combined
+4. Full pipeline: best cls + best reg → build complete head → run actual mAP eval
+"""
+
+import json
+import os
+import sys
+import time
+
+import torch
+import torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT", "coco")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE", "val_cache/val.pt")
+NUM_CLASSES = 80
+DEVICE = "cuda"
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+def make_locations(sizes, strides):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets_full(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    ct = torch.full((n,), -1, dtype=torch.long)
+    rt = torch.zeros(n, 4)
+    if boxes.numel() == 0:
+        return ct, rt
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    l = loc[:, None, 0] - boxes[None, :, 0]
+    t = loc[:, None, 1] - boxes[None, :, 1]
+    r = boxes[None, :, 2] - loc[:, None, 0]
+    b = boxes[None, :, 3] - loc[:, None, 1]
+    ltrb = torch.stack([l, t, r, b], -1)
+    in_box = ltrb.min(-1).values > 0
+    cx = (boxes[:, 0] + boxes[:, 2]) / 2
+    cy = (boxes[:, 1] + boxes[:, 3]) / 2
+    rad = stride * 1.5
+    in_center = ((loc[:, None, 0] >= cx - rad) & (loc[:, None, 0] <= cx + rad) &
+                 (loc[:, None, 1] >= cy - rad) & (loc[:, None, 1] <= cy + rad))
+    max_d = ltrb.max(-1).values
+    in_level = (max_d >= sr[0]) & (max_d <= sr[1])
+    pos = in_box & in_center & in_level
+    a = areas[None, :].expand_as(pos).clone()
+    a[~pos] = float("inf")
+    matched = a.argmin(1)
+    is_pos = a.gather(1, matched[:, None]).squeeze(1) < float("inf")
+    ct[is_pos] = labels[matched[is_pos]]
+    if is_pos.any():
+        rt[is_pos] = ltrb[torch.arange(n)[is_pos], matched[is_pos]]
+    return ct, rt
+
+
+def build_val_data_with_spatial(val_path, n_images=500):
+    """Build features with spatial variants on GPU."""
+    val = torch.load(val_path, map_location="cpu", weights_only=False)
+    from pycocotools.coco import COCO
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco = COCO(ann_file)
+    cat_ids = sorted(coco.getCatIds())
+    cat_to_idx = {c: i for i, c in enumerate(cat_ids)}
+    strides = [16, 32, 64]
+    H = 640 // 16
+    sizes = [(H, H), (H // 2, H // 2), (H // 4, H // 4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+
+    all_f, all_h1v, all_h1h, all_cls, all_reg = [], [], [], [], []
+    for idx in range(min(n_images, len(val))):
+        item = val[idx]
+        spatial = item["spatial"].unsqueeze(0).float()
+        img_id = item["img_id"]; scale = item["scale"]
+        ann_ids = coco.getAnnIds(imgIds=int(img_id), iscrowd=False)
+        anns = coco.loadAnns(ann_ids)
+        boxes, labels = [], []
+        for ann in anns:
+            x, y, w, h = ann["bbox"]
+            if w < 1 or h < 1: continue
+            boxes.append([x*scale, y*scale, (x+w)*scale, (y+h)*scale])
+            labels.append(cat_to_idx[ann["category_id"]])
+        boxes_t = torch.tensor(boxes, dtype=torch.float32) if boxes else torch.zeros(0, 4)
+        labels_t = torch.tensor(labels, dtype=torch.long) if labels else torch.zeros(0, dtype=torch.long)
+
+        cofibers = cofiber_decompose(spatial, 3)
+        for sci, cof in enumerate(cofibers):
+            B, C, Hc, Wc = cof.shape
+            f = F.layer_norm(cof.permute(0, 2, 3, 1).reshape(-1, C), [C])
+
+            # Sheaf H^1: directional boundary magnitudes
+            f_4d = f.reshape(B, Hc, Wc, C).permute(0, 3, 1, 2)
+            d_up = f_4d - F.pad(f_4d[:, :, 1:, :], (0, 0, 0, 1))
+            d_down = f_4d - F.pad(f_4d[:, :, :-1, :], (0, 0, 1, 0))
+            d_left = f_4d - F.pad(f_4d[:, :, :, 1:], (0, 1, 0, 0))
+            d_right = f_4d - F.pad(f_4d[:, :, :, :-1], (1, 0, 0, 0))
+            v_bound = (d_up.abs() + d_down.abs()).permute(0, 2, 3, 1).reshape(-1, C)
+            h_bound = (d_left.abs() + d_right.abs()).permute(0, 2, 3, 1).reshape(-1, C)
+
+            ct, rt = assign_targets_full(locs[sci], boxes_t, labels_t, strides[sci], sr[sci])
+            all_f.append(f)
+            all_h1v.append(v_bound)
+            all_h1h.append(h_bound)
+            all_cls.append(ct)
+            all_reg.append(rt)
+
+    features = torch.cat(all_f).to(DEVICE)
+    h1v = torch.cat(all_h1v).to(DEVICE)
+    h1h = torch.cat(all_h1h).to(DEVICE)
+    cls_targets = torch.cat(all_cls).to(DEVICE)
+    reg_targets = torch.cat(all_reg).to(DEVICE)
+    return features, h1v, h1h, cls_targets, reg_targets
+
+
+def solve_regression(f_pos, y_reg, f_all, reg_targets, pos_mask, lam=0.1):
+    """Solve for regression weights, return quality metric."""
+    valid = (y_reg > 0).all(1)
+    if valid.sum() < 10:
+        return 0.0
+    fv = f_pos[valid]
+    fa = torch.cat([fv, torch.ones(fv.shape[0], 1, device=DEVICE)], 1)
+    yt = torch.log(y_reg[valid])  # log-ltrb
+    fd = fv.shape[1]
+    I = torch.eye(fd + 1, device=DEVICE)
+    n = fv.shape[0]
+    try:
+        W = torch.linalg.solve(fa.T @ fa + lam * I * n, fa.T @ yt)
+    except Exception:
+        return 0.0
+
+    # Quality: 1/(1+MSE) at positive locations
+    pred = f_all[pos_mask] @ W[:fd] + W[fd]
+    gt_ltrb = reg_targets[pos_mask]
+    val2 = (gt_ltrb > 0).all(1)
+    if val2.sum() < 10:
+        return 0.0
+    gt_log = torch.log(gt_ltrb[val2])
+    pred_valid = pred[val2]
+    mse = ((pred_valid - gt_log) ** 2).mean(1)
+    quality = (1.0 / (1.0 + mse)).mean().item()
+    return quality
+
+
+def main():
+    print("=" * 60)
+    print("Exotic Regression Experiments (GPU)")
+    print("=" * 60, flush=True)
+
+    features, h1v, h1h, cls_targets, reg_targets = build_val_data_with_spatial(VAL_CACHE, 500)
+    pos = cls_targets >= 0
+    n_pos = pos.sum().item()
+    f_pos = features[pos]
+    reg_pos = reg_targets[pos]
+    print(f"  {features.shape[0]} locations, {n_pos} positives", flush=True)
+
+    results = []
+
+    # Load greedy dims
+    greedy_path = os.path.join(SCRIPT_DIR, "analytical_variants", "greedy_forward_gpu.json")
+    greedy_dims = list(range(20))
+    if os.path.isfile(greedy_path):
+        with open(greedy_path) as f:
+            greedy_dims = json.load(f)["selected_dims"]
+
+    # =====================================================
+    # Baseline regression: 768 raw features
+    # =====================================================
+    t0 = time.time()
+    q = solve_regression(f_pos, reg_pos, features, reg_targets, pos)
+    print(f"\n1. Baseline (768 raw): reg_quality={q:.4f} [{time.time()-t0:.2f}s]", flush=True)
+    results.append({"name": "baseline_768", "reg_quality": q, "dims": 768})
+
+    # =====================================================
+    # 2. H^1 boundary features for regression
+    # =====================================================
+    for label, f_extra in [("h1v", h1v), ("h1h", h1h), ("h1_both", torch.cat([h1v, h1h], 1))]:
+        f_combined = torch.cat([features, f_extra], 1)
+        fp = f_combined[pos]
+        t0 = time.time()
+        q = solve_regression(fp, reg_pos, f_combined, reg_targets, pos)
+        print(f"2. 768 + {label} ({f_combined.shape[1]} dims): reg_quality={q:.4f} [{time.time()-t0:.2f}s]", flush=True)
+        results.append({"name": f"h1_{label}", "reg_quality": q, "dims": f_combined.shape[1]})
+
+    # =====================================================
+    # 3. Quadratic features for regression
+    # =====================================================
+    for K in [10, 20, 30]:
+        dims = greedy_dims[:K]
+        f_sub = features[:, dims]
+        quads = []
+        for i in range(K):
+            for j in range(i, K):
+                quads.append(f_sub[:, i] * f_sub[:, j])
+        f_quad = torch.stack(quads, 1)
+        f_exp = torch.cat([features, f_quad], 1)
+        fp = f_exp[pos]
+        t0 = time.time()
+        q = solve_regression(fp, reg_pos, f_exp, reg_targets, pos)
+        nd = f_exp.shape[1]
+        print(f"3. 768 + quad_top{K} ({nd} dims): reg_quality={q:.4f} [{time.time()-t0:.2f}s]", flush=True)
+        results.append({"name": f"quad_top{K}", "reg_quality": q, "dims": nd})
+
+    # =====================================================
+    # 4. H^1 + quadratic combined
+    # =====================================================
+    dims = greedy_dims[:20]
+    f_sub = features[:, dims]
+    quads = []
+    for i in range(20):
+        for j in range(i, 20):
+            quads.append(f_sub[:, i] * f_sub[:, j])
+    f_quad = torch.stack(quads, 1)
+    f_all = torch.cat([features, h1v, h1h, f_quad], 1)
+    fp = f_all[pos]
+    t0 = time.time()
+    q = solve_regression(fp, reg_pos, f_all, reg_targets, pos)
+    print(f"4. 768 + H1 + quad_top20 ({f_all.shape[1]} dims): reg_quality={q:.4f} [{time.time()-t0:.2f}s]", flush=True)
+    results.append({"name": "h1_quad_combined", "reg_quality": q, "dims": f_all.shape[1]})
+
+    # =====================================================
+    # 5. RFF for regression
+    # =====================================================
+    sub = features[:5000]
+    dists = torch.cdist(sub[:500], sub[:500])
+    sigma = dists.median().item()
+    if sigma < 1e-6: sigma = 1.0
+
+    for K_rff in [100, 500]:
+        torch.manual_seed(42)
+        W_rff = torch.randn(768, K_rff, device=DEVICE) / sigma
+        b_rff = torch.rand(K_rff, device=DEVICE) * 2 * 3.14159
+        rff = (2.0 / K_rff) ** 0.5 * torch.cos(features @ W_rff + b_rff)
+        f_combined = torch.cat([features, rff], 1)
+        fp = f_combined[pos]
+        t0 = time.time()
+        q = solve_regression(fp, reg_pos, f_combined, reg_targets, pos)
+        print(f"5. 768 + {K_rff} RFF ({f_combined.shape[1]} dims): reg_quality={q:.4f} [{time.time()-t0:.2f}s]", flush=True)
+        results.append({"name": f"rff_{K_rff}_reg", "reg_quality": q, "dims": f_combined.shape[1]})
+
+    # =====================================================
+    # Summary
+    # =====================================================
+    print(f"\n{'='*60}")
+    print("Ranked by regression quality:")
+    for r in sorted(results, key=lambda x: -x["reg_quality"]):
+        print(f"  {r['name']:25s}: reg_quality={r['reg_quality']:.4f}  dims={r['dims']}")
+
+    out = os.path.join(SCRIPT_DIR, "analytical_variants", "exotic_reg_gpu.json")
+    with open(out, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\nSaved: {out}")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_fractal_gpu.py

@@ -0,0 +1,268 @@
+"""
+Fractal cofiber decomposition — wavelet packet style.
+
+Instead of recursing only on the low-frequency residual (3 bands),
+recurse on BOTH the cofiber and residual at each level.
+
+Depth 1: 2 bands (standard single split)
+Depth 2: 4 bands
+Depth 3: 8 bands
+
+Each band is 768 dims. Classification and regression are solved independently
+per band, then results are merged. The solver picks which bands matter.
+
+Or: concatenate all bands and solve one large system.
+"""
+
+import json, os, sys, time
+import torch, torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE")
+CACHE_DIR = os.environ.get("ARENA_CACHE_DIR")
+DEVICE = "cuda"
+RESOLUTION = 640
+NUM_CLASSES = 80
+
+
+def fractal_decompose(f, depth):
+    """Fractal cofiber decomposition. Returns list of 2^depth feature maps."""
+    if depth == 0:
+        return [f]
+    omega = F.avg_pool2d(f, 2)
+    sigma_omega = F.interpolate(omega, size=f.shape[2:], mode="bilinear", align_corners=False)
+    cofiber = f - sigma_omega  # high frequency at this scale
+
+    # Recurse on BOTH branches
+    high_bands = fractal_decompose(cofiber, depth - 1)
+    low_bands = fractal_decompose(omega, depth - 1)
+
+    return high_bands + low_bands
+
+
+def standard_decompose(f, n_scales):
+    """Standard cofiber: recurse only on residual."""
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+def make_locations(sizes, strides):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    ct = torch.full((n,), -1, dtype=torch.long)
+    rt = torch.zeros(n, 4)
+    ctrt = torch.zeros(n)
+    if boxes.numel() == 0:
+        return ct, rt, ctrt
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    l = loc[:, None, 0] - boxes[None, :, 0]
+    t = loc[:, None, 1] - boxes[None, :, 1]
+    r = boxes[None, :, 2] - loc[:, None, 0]
+    b = boxes[None, :, 3] - loc[:, None, 1]
+    ltrb = torch.stack([l, t, r, b], -1)
+    in_box = ltrb.min(-1).values > 0
+    cx = (boxes[:, 0] + boxes[:, 2]) / 2
+    cy = (boxes[:, 1] + boxes[:, 3]) / 2
+    rad = stride * 1.5
+    in_center = ((loc[:, None, 0] >= cx - rad) & (loc[:, None, 0] <= cx + rad) &
+                 (loc[:, None, 1] >= cy - rad) & (loc[:, None, 1] <= cy + rad))
+    max_d = ltrb.max(-1).values
+    in_level = (max_d >= sr[0]) & (max_d <= sr[1])
+    pos = in_box & in_center & in_level
+    a = areas[None, :].expand_as(pos).clone()
+    a[~pos] = float("inf")
+    matched = a.argmin(1)
+    is_pos = a.gather(1, matched[:, None]).squeeze(1) < float("inf")
+    ct[is_pos] = labels[matched[is_pos]]
+    if is_pos.any():
+        rt[is_pos] = ltrb[torch.arange(n)[is_pos], matched[is_pos]]
+        lp, tp, rp, bp = rt[is_pos].unbind(-1)
+        ctrt[is_pos] = torch.sqrt(
+            (torch.minimum(lp, rp) / torch.maximum(lp, rp).clamp(min=1e-6)) *
+            (torch.minimum(tp, bp) / torch.maximum(tp, bp).clamp(min=1e-6)))
+    return ct, rt, ctrt
+
+
+def eval_decomposition(val, coco_gt, cat_ids, decompose_fn, name, lam=0.1, n_train=10000):
+    """Accumulate, solve, and eval a decomposition variant.
+
+    All bands are upsampled to stride-16 resolution (40x40) and use the same
+    target assignment. The decomposition separates frequencies, not resolutions.
+    """
+    idx_to_cat = {i: c for i, c in enumerate(cat_ids)}
+    H = RESOLUTION // 16
+    target_size = (H, H)
+    stride = 16
+    sr = (-1, float("inf"))  # single scale, all object sizes
+    locs_flat = make_locations([target_size], [stride])
+    n_locs = H * H
+
+    manifest = json.load(open(os.path.join(CACHE_DIR, "manifest.json")))
+    feat_dim = 768
+    cls_XtX = torch.zeros(feat_dim + 1, feat_dim + 1, device=DEVICE)
+    cls_XtY = torch.zeros(feat_dim + 1, NUM_CLASSES, device=DEVICE)
+    reg_XtX = torch.zeros(feat_dim + 1, feat_dim + 1, device=DEVICE)
+    reg_XtY = torch.zeros(feat_dim + 1, 4, device=DEVICE)
+    ctr_XtX = torch.zeros(feat_dim + 1, feat_dim + 1, device=DEVICE)
+    ctr_XtY = torch.zeros(feat_dim + 1, 1, device=DEVICE)
+    n_pos = 0; seen = 0
+
+    t0 = time.time()
+    for si in range(manifest["n_shards"]):
+        if seen >= n_train: break
+        shard = torch.load(os.path.join(CACHE_DIR, f"shard_{si:04d}.pt"),
+                          map_location="cpu", weights_only=False)
+        for item in shard:
+            if seen >= n_train: break
+            sp = item["spatial"].unsqueeze(0).float().to(DEVICE)
+            boxes = item["boxes"]; labels = item["labels"]
+            bands = decompose_fn(sp)
+
+            # Upsample all bands to 40x40, average them
+            upsampled = []
+            for band in bands:
+                if band.shape[2:] != target_size:
+                    band = F.interpolate(band, size=target_size, mode="bilinear", align_corners=False)
+                upsampled.append(band)
+            # Average across all bands — the solver sees the mean multi-frequency representation
+            merged = torch.stack(upsampled).mean(0)  # (1, 768, 40, 40)
+
+            B, C, Hc, Wc = merged.shape
+            f = F.layer_norm(merged.permute(0, 2, 3, 1).reshape(-1, C), [C])
+            ct, rt, ctrt = assign_targets(locs_flat[0], boxes, labels, stride, sr)
+            pos_mask = ct >= 0
+            if not pos_mask.any():
+                seen += 1; continue
+            fp = f[pos_mask]
+            fa = torch.cat([fp, torch.ones(fp.shape[0], 1, device=DEVICE)], 1)
+            yc = torch.zeros(fp.shape[0], NUM_CLASSES, device=DEVICE)
+            yc[torch.arange(fp.shape[0], device=DEVICE), ct[pos_mask].to(DEVICE)] = 1.0
+            cls_XtX += fa.T @ fa; cls_XtY += fa.T @ yc
+            ltrb = rt[pos_mask]; valid = (ltrb > 0).all(1)
+            if valid.any():
+                fv = fa[valid]; yt = torch.log(ltrb[valid]).to(DEVICE)
+                reg_XtX += fv.T @ fv; reg_XtY += fv.T @ yt
+            ctr_XtX += fa.T @ fa
+            ctr_XtY += fa.T @ ctrt[pos_mask].unsqueeze(1).to(DEVICE)
+            n_pos += pos_mask.sum().item()
+            seen += 1
+        del shard
+
+    I = torch.eye(feat_dim + 1, device=DEVICE)
+    cls_W = torch.linalg.solve(cls_XtX + lam * I * n_pos, cls_XtY)
+    reg_W = torch.linalg.solve(reg_XtX + lam * I * n_pos, reg_XtY)
+    ctr_W = torch.linalg.solve(ctr_XtX + lam * I * n_pos, ctr_XtY)
+    accum_time = time.time() - t0
+
+    all_locs = locs_flat[0].to(DEVICE)
+    all_results = []
+    for idx in range(len(val)):
+        spatial = val[idx]["spatial"].unsqueeze(0).float().to(DEVICE)
+        img_id = int(val[idx]["img_id"]); scale = val[idx]["scale"]
+        bands = decompose_fn(spatial)
+        upsampled = []
+        for band in bands:
+            if band.shape[2:] != target_size:
+                band = F.interpolate(band, size=target_size, mode="bilinear", align_corners=False)
+            upsampled.append(band)
+        merged = torch.stack(upsampled).mean(0)
+        B, C, Hc, Wc = merged.shape
+        f = F.layer_norm(merged.permute(0, 2, 3, 1).reshape(-1, C), [C])
+        cls_s = (f @ cls_W[:feat_dim] + cls_W[feat_dim]).sigmoid()
+        reg_s = (f @ reg_W[:feat_dim] + reg_W[feat_dim]).exp()
+        ctr_s = (f @ ctr_W[:feat_dim] + ctr_W[feat_dim]).sigmoid().squeeze(1)
+        scores = cls_s * ctr_s.unsqueeze(1)
+        max_s, max_c = scores.max(1)
+        topk = min(100, max_s.shape[0])
+        top_s, top_i = max_s.topk(topk)
+        tc = max_c[top_i]; tr = reg_s[top_i]; tl = all_locs[top_i]
+        x1 = (tl[:,0]-tr[:,0])/scale; y1 = (tl[:,1]-tr[:,1])/scale
+        x2 = (tl[:,0]+tr[:,2])/scale; y2 = (tl[:,1]+tr[:,3])/scale
+        w = (x2-x1).clamp(min=0); h = (y2-y1).clamp(min=0)
+        for i in range(topk):
+            s = top_s[i].item()
+            if s < 0.01: continue
+            all_results.append({"image_id": img_id, "category_id": idx_to_cat[tc[i].item()],
+                                "bbox": [x1[i].item(), y1[i].item(), w[i].item(), h[i].item()],
+                                "score": s})
+
+    # pycocotools eval
+    from pycocotools.cocoeval import COCOeval
+    if not all_results:
+        print(f"  {name}: no detections"); return 0.0
+    coco_dt = coco_gt.loadRes(all_results)
+    coco_eval = COCOeval(coco_gt, coco_dt, "bbox")
+    coco_eval.params.imgIds = sorted(coco_gt.getImgIds())[:len(val)]
+    coco_eval.evaluate(); coco_eval.accumulate(); coco_eval.summarize()
+    mAP = coco_eval.stats[0]
+    mAP50 = coco_eval.stats[1]
+    mAP75 = coco_eval.stats[2]
+    print(f"  {name}: mAP={mAP:.4f} mAP50={mAP50:.4f} mAP75={mAP75:.4f} "
+          f"({accum_time:.0f}s accum, {n_pos} pos)")
+    return mAP
+
+
+def main():
+    from pycocotools.coco import COCO
+
+    print("=" * 60)
+    print("Fractal vs Standard Cofiber Decomposition")
+    print("=" * 60, flush=True)
+
+    val = torch.load(VAL_CACHE, map_location="cpu", weights_only=False)
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco_gt = COCO(ann_file)
+    cat_ids = sorted(coco_gt.getCatIds())
+
+    results = []
+
+    # Standard 3-band cofiber (baseline)
+    print("\n1. Standard 3-band cofiber:", flush=True)
+    mAP = eval_decomposition(val, coco_gt, cat_ids,
+                              lambda sp: standard_decompose(sp, 3), "standard_3band")
+    results.append({"name": "standard_3band", "mAP": mAP, "bands": 3})
+
+    # Fractal depth 2 (4 bands)
+    print("\n2. Fractal depth 2 (4 bands):", flush=True)
+    mAP = eval_decomposition(val, coco_gt, cat_ids,
+                              lambda sp: fractal_decompose(sp, 2), "fractal_depth2")
+    results.append({"name": "fractal_depth2", "mAP": mAP, "bands": 4})
+
+    # Fractal depth 3 (8 bands)
+    print("\n3. Fractal depth 3 (8 bands):", flush=True)
+    mAP = eval_decomposition(val, coco_gt, cat_ids,
+                              lambda sp: fractal_decompose(sp, 3), "fractal_depth3")
+    results.append({"name": "fractal_depth3", "mAP": mAP, "bands": 8})
+
+    print(f"\n{'='*60}")
+    print("Summary:")
+    for r in results:
+        print(f"  {r['name']:20s}: mAP={r['mAP']:.4f} ({r['bands']} bands)")
+
+    out = os.path.join(SCRIPT_DIR, "analytical_variants", "fractal_results.json")
+    with open(out, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_gcv.py

@@ -0,0 +1,268 @@
+"""
+GCV-optimal analytical detection head.
+
+Computes the generalized cross-validation optimal lambda for each task
+(classification, regression, centerness) independently via SVD of the
+accumulated sufficient statistics. No grid search — closed-form.
+
+Then builds the head with per-task optimal regularization and evals.
+"""
+
+import json, os, sys, time
+import torch
+import torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+STATS_DIR = os.path.join(SCRIPT_DIR, "analytical_stats_cache")
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE")
+CACHE_DIR = os.environ.get("ARENA_CACHE_DIR")
+DEVICE = "cuda"
+RESOLUTION = 640
+NUM_CLASSES = 80
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []; residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega); residual = omega
+    cofibers.append(residual); return cofibers
+
+
+def make_locations(sizes, strides, device="cpu"):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, device=device, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, device=device, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    ct = torch.full((n,), -1, dtype=torch.long); rt = torch.zeros(n, 4); ctrt = torch.zeros(n)
+    if boxes.numel() == 0: return ct, rt, ctrt
+    areas = (boxes[:,2]-boxes[:,0])*(boxes[:,3]-boxes[:,1])
+    l=loc[:,None,0]-boxes[None,:,0]; t=loc[:,None,1]-boxes[None,:,1]
+    r=boxes[None,:,2]-loc[:,None,0]; b=boxes[None,:,3]-loc[:,None,1]
+    ltrb=torch.stack([l,t,r,b],-1); in_box=ltrb.min(-1).values>0
+    cx=(boxes[:,0]+boxes[:,2])/2; cy=(boxes[:,1]+boxes[:,3])/2; rad=stride*1.5
+    in_center=((loc[:,None,0]>=cx-rad)&(loc[:,None,0]<=cx+rad)&(loc[:,None,1]>=cy-rad)&(loc[:,None,1]<=cy+rad))
+    max_d=ltrb.max(-1).values; in_level=(max_d>=sr[0])&(max_d<=sr[1])
+    pos=in_box&in_center&in_level; a=areas[None,:].expand_as(pos).clone(); a[~pos]=float("inf")
+    matched=a.argmin(1); is_pos=a.gather(1,matched[:,None]).squeeze(1)<float("inf")
+    ct[is_pos]=labels[matched[is_pos]]
+    if is_pos.any():
+        rt[is_pos]=ltrb[torch.arange(n)[is_pos],matched[is_pos]]
+        lp,tp,rp,bp=rt[is_pos].unbind(-1)
+        ctrt[is_pos]=torch.sqrt((torch.minimum(lp,rp)/torch.maximum(lp,rp).clamp(min=1e-6))*(torch.minimum(tp,bp)/torch.maximum(tp,bp).clamp(min=1e-6)))
+    return ct, rt, ctrt
+
+
+def gcv_optimal_lambda(XtX, XtY, n_samples, lambdas=None):
+    """Find GCV-optimal lambda via SVD.
+
+    For ridge regression: Y = X W + noise
+    Hat matrix: H(λ) = X (X^T X + λI)^{-1} X^T
+    GCV(λ) = (1/n) ||Y - H(λ)Y||² / (1 - tr(H(λ))/n)²
+
+    Using SVD of the augmented feature matrix: X = U S V^T
+    tr(H(λ)) = Σ s_i² / (s_i² + λ)
+    ||Y - H(λ)Y||² = Σ (λ u_i^T Y / (s_i² + λ))²
+
+    We work with XtX = V S² V^T directly.
+    """
+    # Eigendecompose XtX (symmetric positive semi-definite)
+    eigvals, eigvecs = torch.linalg.eigh(XtX)
+    eigvals = eigvals.clamp(min=0)  # numerical stability
+
+    # Project targets: V^T X^T Y = V^T (XtX XtX^{-1} XtY) ...
+    # Actually we need U^T Y. From XtX = V S² V^T and XtY = V S U^T Y
+    # So V^T XtY = S U^T Y, thus U^T Y = S^{-1} V^T XtY
+    VtXtY = eigvecs.T @ XtY  # (d+1, k)
+    # S = sqrt(eigvals)
+    S = eigvals.sqrt().clamp(min=1e-10)
+    UtY = VtXtY / S.unsqueeze(1)  # (d+1, k)
+
+    if lambdas is None:
+        # Log-spaced search
+        lam_min = eigvals[eigvals > 0].min().item() * 0.001
+        lam_max = eigvals.max().item() * 10
+        lambdas = torch.logspace(
+            max(-8, torch.log10(torch.tensor(lam_min)).item()),
+            min(4, torch.log10(torch.tensor(lam_max)).item()),
+            200, device=XtX.device)
+
+    d = XtX.shape[0]
+    best_lam = lambdas[0].item()
+    best_gcv = float("inf")
+
+    for lam in lambdas:
+        # tr(H) = Σ s_i² / (s_i² + λ)
+        leverage = eigvals / (eigvals + lam)
+        tr_H = leverage.sum()
+
+        # Residual: ||Y - HY||² = Σ_i (λ/(s_i²+λ))² ||u_i^T Y||²
+        shrinkage = lam / (eigvals + lam)
+        res_sq = (shrinkage.unsqueeze(1) ** 2 * UtY ** 2).sum()
+
+        # GCV
+        gcv = (res_sq / n_samples) / ((1 - tr_H / n_samples) ** 2 + 1e-12)
+
+        if gcv.item() < best_gcv:
+            best_gcv = gcv.item()
+            best_lam = lam.item()
+
+    return best_lam, best_gcv
+
+
+def main():
+    print("=" * 60)
+    print("GCV-Optimal Analytical Detection Head")
+    print("=" * 60, flush=True)
+
+    # Accumulate on GPU
+    manifest = json.load(open(os.path.join(CACHE_DIR, "manifest.json")))
+    strides = [16, 32, 64]; H = RESOLUTION // 16
+    sizes = [(H, H), (H//2, H//2), (H//4, H//4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+    feat_dim = 768
+
+    cls_XtX = torch.zeros(feat_dim+1, feat_dim+1, device=DEVICE)
+    cls_XtY = torch.zeros(feat_dim+1, NUM_CLASSES, device=DEVICE)
+    reg_XtX = torch.zeros(feat_dim+1, feat_dim+1, device=DEVICE)
+    reg_XtY = torch.zeros(feat_dim+1, 4, device=DEVICE)
+    ctr_XtX = torch.zeros(feat_dim+1, feat_dim+1, device=DEVICE)
+    ctr_XtY = torch.zeros(feat_dim+1, 1, device=DEVICE)
+    n_cls = 0; n_reg = 0; n_ctr = 0
+    n_images = 20000; seen = 0
+    t0 = time.time()
+
+    for si in range(manifest["n_shards"]):
+        if seen >= n_images: break
+        shard = torch.load(os.path.join(CACHE_DIR, f"shard_{si:04d}.pt"),
+                          map_location="cpu", weights_only=False)
+        for item in shard:
+            if seen >= n_images: break
+            sp = item["spatial"].unsqueeze(0).float()
+            boxes = item["boxes"]; labels = item["labels"]
+            cofibers = cofiber_decompose(sp, 3)
+            for sci, cof in enumerate(cofibers):
+                B, C, Hc, Wc = cof.shape
+                f = F.layer_norm(cof.permute(0,2,3,1).reshape(-1,C), [C]).to(DEVICE)
+                ct, rt, ctrt = assign_targets(locs[sci], boxes, labels, strides[sci], sr[sci])
+                pos = ct >= 0
+                if not pos.any(): continue
+                fp = f[pos]
+                fa = torch.cat([fp, torch.ones(fp.shape[0],1,device=DEVICE)], 1)
+                yc = torch.zeros(fp.shape[0], NUM_CLASSES, device=DEVICE)
+                yc[torch.arange(fp.shape[0],device=DEVICE), ct[pos].to(DEVICE)] = 1.0
+                cls_XtX += fa.T @ fa; cls_XtY += fa.T @ yc; n_cls += fp.shape[0]
+                ltrb = rt[pos]; valid = (ltrb > 0).all(1)
+                if valid.any():
+                    fv = fa[valid]; yt = torch.log(ltrb[valid]).to(DEVICE)
+                    reg_XtX += fv.T @ fv; reg_XtY += fv.T @ yt; n_reg += valid.sum().item()
+                ctr_XtX += fa.T @ fa
+                ctr_XtY += fa.T @ ctrt[pos].unsqueeze(1).to(DEVICE); n_ctr += fp.shape[0]
+            seen += 1
+        del shard
+        if (si+1) % 5 == 0:
+            print(f"  shard {si+1}: {seen} imgs, {n_cls} cls, {n_reg} reg, {time.time()-t0:.0f}s", flush=True)
+
+    print(f"\nAccumulated: {n_cls} cls, {n_reg} reg, {n_ctr} ctr positives", flush=True)
+
+    # GCV optimal lambda per task
+    print("\nFinding GCV-optimal lambda...", flush=True)
+    t1 = time.time()
+    # Normalize by n so GCV searches over the actual regularization strength
+    # Our solve uses (XtX + lam * I * n), so GCV should find lam such that lam*n is optimal
+    # Equivalently: search on (XtX/n + lam * I) and report lam
+    lam_cls, gcv_cls = gcv_optimal_lambda(cls_XtX / n_cls, cls_XtY / n_cls, n_cls)
+    lam_reg, gcv_reg = gcv_optimal_lambda(reg_XtX / n_reg, reg_XtY / n_reg, n_reg)
+    lam_ctr, gcv_ctr = gcv_optimal_lambda(ctr_XtX / n_ctr, ctr_XtY / n_ctr, n_ctr)
+    print(f"  cls: lambda={lam_cls:.6f} (GCV={gcv_cls:.6f})")
+    print(f"  reg: lambda={lam_reg:.6f} (GCV={gcv_reg:.6f})")
+    print(f"  ctr: lambda={lam_ctr:.6f} (GCV={gcv_ctr:.6f})")
+    print(f"  (took {time.time()-t1:.1f}s)", flush=True)
+
+    # Compare: solve with GCV lambda vs fixed lambda=0.1
+    print("\nSolving with GCV-optimal lambda...", flush=True)
+    I = torch.eye(feat_dim+1, device=DEVICE)
+    cls_W_gcv = torch.linalg.solve(cls_XtX + lam_cls * I * n_cls, cls_XtY)
+    reg_W_gcv = torch.linalg.solve(reg_XtX + lam_reg * I * n_reg, reg_XtY)
+    ctr_W_gcv = torch.linalg.solve(ctr_XtX + lam_ctr * I * n_ctr, ctr_XtY)
+
+    print("Solving with fixed lambda=0.1...", flush=True)
+    cls_W_fix = torch.linalg.solve(cls_XtX + 0.1 * I * n_cls, cls_XtY)
+    reg_W_fix = torch.linalg.solve(reg_XtX + 0.1 * I * n_reg, reg_XtY)
+    ctr_W_fix = torch.linalg.solve(ctr_XtX + 0.1 * I * n_ctr, ctr_XtY)
+
+    # Eval both on COCO val
+    val = torch.load(VAL_CACHE, map_location="cpu", weights_only=False)
+    from pycocotools.coco import COCO
+    from pycocotools.cocoeval import COCOeval
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco_gt = COCO(ann_file)
+    cat_ids = sorted(coco_gt.getCatIds())
+    idx_to_cat = {i: c for i, c in enumerate(cat_ids)}
+    all_locs = torch.cat(make_locations(sizes, strides, DEVICE))
+
+    for label, cls_W, reg_W, ctr_W in [("gcv_optimal", cls_W_gcv, reg_W_gcv, ctr_W_gcv),
+                                         ("fixed_0.1", cls_W_fix, reg_W_fix, ctr_W_fix)]:
+        print(f"\nEvaluating: {label}", flush=True)
+        all_results = []
+        for idx in range(len(val)):
+            item = val[idx]
+            spatial = item["spatial"].unsqueeze(0).float().to(DEVICE)
+            img_id = int(item["img_id"]); scale = item["scale"]
+            cofibers = cofiber_decompose(spatial, 3)
+            cls_all, reg_all, ctr_all = [], [], []
+            for cof in cofibers:
+                B, C, Hc, Wc = cof.shape
+                f = F.layer_norm(cof.permute(0,2,3,1).reshape(-1,C), [C])
+                fa = torch.cat([f, torch.ones(f.shape[0],1,device=DEVICE)], 1)
+                cls = (fa @ cls_W).sigmoid()
+                reg = (fa @ reg_W).exp()
+                ctr = (fa @ ctr_W).sigmoid()
+                cls_all.append(cls); reg_all.append(reg); ctr_all.append(ctr.squeeze(1))
+            cls_s = torch.cat(cls_all); reg_s = torch.cat(reg_all); ctr_s = torch.cat(ctr_all)
+            scores = cls_s * ctr_s.unsqueeze(1)
+            max_s, max_c = scores.max(1)
+            topk = min(100, max_s.shape[0])
+            top_s, top_i = max_s.topk(topk)
+            tc = max_c[top_i]; tr = reg_s[top_i]; tl = all_locs[top_i]
+            x1=(tl[:,0]-tr[:,0])/scale; y1=(tl[:,1]-tr[:,1])/scale
+            x2=(tl[:,0]+tr[:,2])/scale; y2=(tl[:,1]+tr[:,3])/scale
+            w=(x2-x1).clamp(min=0); h=(y2-y1).clamp(min=0)
+            for i in range(topk):
+                s = top_s[i].item()
+                if s < 0.01: continue
+                all_results.append({"image_id": img_id, "category_id": idx_to_cat[tc[i].item()],
+                                    "bbox": [x1[i].item(), y1[i].item(), w[i].item(), h[i].item()],
+                                    "score": s})
+            if (idx+1) % 1000 == 0:
+                print(f"  {idx+1}/{len(val)}", flush=True)
+
+        if all_results:
+            coco_dt = coco_gt.loadRes(all_results)
+            coco_eval = COCOeval(coco_gt, coco_dt, "bbox")
+            coco_eval.params.imgIds = sorted(coco_gt.getImgIds())[:len(val)]
+            coco_eval.evaluate(); coco_eval.accumulate(); coco_eval.summarize()
+            mAP = coco_eval.stats[0]
+            mAP50 = coco_eval.stats[1]
+            mAP75 = coco_eval.stats[2]
+            print(f"\n  {label}: mAP={mAP:.4f} mAP50={mAP50:.4f} mAP75={mAP75:.4f}")
+        else:
+            print(f"  {label}: no detections")
+
+    elapsed = time.time() - t0
+    print(f"\nTotal: {elapsed:.0f}s")
+    print(f"\nGCV-optimal lambdas: cls={lam_cls:.6f} reg={lam_reg:.6f} ctr={lam_ctr:.6f}")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_greedy_gpu.py

@@ -0,0 +1,244 @@
+"""
+GPU-accelerated greedy forward construction of a minimal detection head.
+
+Batches all candidate evaluations into parallel matmuls on GPU.
+50 greedy steps in seconds instead of minutes.
+"""
+
+import argparse
+import json
+import os
+import sys
+import time
+
+import torch
+import torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT", "coco")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE", "val_cache/val.pt")
+NUM_CLASSES = 80
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+def make_locations(sizes, strides):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    if boxes.numel() == 0:
+        return torch.full((n,), -1, dtype=torch.long), torch.zeros(n, 4)
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    l = loc[:, None, 0] - boxes[None, :, 0]
+    t = loc[:, None, 1] - boxes[None, :, 1]
+    r = boxes[None, :, 2] - loc[:, None, 0]
+    b = boxes[None, :, 3] - loc[:, None, 1]
+    ltrb = torch.stack([l, t, r, b], -1)
+    in_box = ltrb.min(-1).values > 0
+    cx = (boxes[:, 0] + boxes[:, 2]) / 2
+    cy = (boxes[:, 1] + boxes[:, 3]) / 2
+    rad = stride * 1.5
+    in_center = ((loc[:, None, 0] >= cx - rad) & (loc[:, None, 0] <= cx + rad) &
+                 (loc[:, None, 1] >= cy - rad) & (loc[:, None, 1] <= cy + rad))
+    max_d = ltrb.max(-1).values
+    in_level = (max_d >= sr[0]) & (max_d <= sr[1])
+    pos = in_box & in_center & in_level
+    a = areas[None, :].expand_as(pos).clone()
+    a[~pos] = float("inf")
+    matched = a.argmin(1)
+    is_pos = a.gather(1, matched[:, None]).squeeze(1) < float("inf")
+    ct = torch.full((n,), -1, dtype=torch.long)
+    ct[is_pos] = labels[matched[is_pos]]
+    rt = torch.zeros(n, 4)
+    if is_pos.any():
+        rt[is_pos] = ltrb[torch.arange(n)[is_pos], matched[is_pos]]
+    return ct, rt
+
+
+def build_val_data(val_path, n_images=500, device="cuda"):
+    """Build feature matrix + targets on GPU."""
+    val = torch.load(val_path, map_location="cpu", weights_only=False)
+    from pycocotools.coco import COCO
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco = COCO(ann_file)
+    cat_ids = sorted(coco.getCatIds())
+    cat_to_idx = {c: i for i, c in enumerate(cat_ids)}
+
+    strides = [16, 32, 64]
+    H = 640 // 16
+    sizes = [(H, H), (H // 2, H // 2), (H // 4, H // 4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+
+    all_f, all_cls = [], []
+    for idx in range(min(n_images, len(val))):
+        item = val[idx]
+        spatial = item["spatial"].unsqueeze(0).float()
+        img_id = item["img_id"]
+        scale = item["scale"]
+        ann_ids = coco.getAnnIds(imgIds=int(img_id), iscrowd=False)
+        anns = coco.loadAnns(ann_ids)
+        boxes, labels = [], []
+        for ann in anns:
+            x, y, w, h = ann["bbox"]
+            if w < 1 or h < 1:
+                continue
+            boxes.append([x * scale, y * scale, (x + w) * scale, (y + h) * scale])
+            labels.append(cat_to_idx[ann["category_id"]])
+        boxes_t = torch.tensor(boxes, dtype=torch.float32) if boxes else torch.zeros(0, 4)
+        labels_t = torch.tensor(labels, dtype=torch.long) if labels else torch.zeros(0, dtype=torch.long)
+
+        cofibers = cofiber_decompose(spatial, 3)
+        for sci, cof in enumerate(cofibers):
+            B, C, Hc, Wc = cof.shape
+            f = F.layer_norm(cof.permute(0, 2, 3, 1).reshape(-1, C), [C])
+            ct, _ = assign_targets(locs[sci], boxes_t, labels_t, strides[sci], sr[sci])
+            all_f.append(f)
+            all_cls.append(ct)
+
+    features = torch.cat(all_f).to(device)
+    cls_targets = torch.cat(all_cls).to(device)
+    return features, cls_targets
+
+
+def greedy_step_gpu(features, cls_targets, selected, remaining, lam=0.1):
+    """Test all remaining candidates in parallel on GPU. Return best dim and accuracy."""
+    pos = cls_targets >= 0
+    n_pos = pos.sum().item()
+    if n_pos == 0:
+        return -1, 0.0
+
+    # Build one-hot targets
+    f_pos = features[pos]
+    y_cls = torch.zeros(n_pos, NUM_CLASSES, device=features.device)
+    y_cls[torch.arange(n_pos, device=features.device), cls_targets[pos]] = 1.0
+    gt = cls_targets[pos]
+
+    best_dim = -1
+    best_acc = -1.0
+
+    # For each candidate, solve and score
+    # Batch in chunks to avoid OOM on very large candidate sets
+    chunk_size = 64
+    for chunk_start in range(0, len(remaining), chunk_size):
+        chunk = remaining[chunk_start:chunk_start + chunk_size]
+        accs = []
+        for d in chunk:
+            dims = selected + [d]
+            fd = len(dims)
+            fp = f_pos[:, dims]
+            fa = torch.cat([fp, torch.ones(n_pos, 1, device=fp.device)], 1)
+            I = torch.eye(fd + 1, device=fp.device)
+            XtX = fa.T @ fa
+            XtY = fa.T @ y_cls
+            try:
+                W = torch.linalg.solve(XtX + lam * I * n_pos, XtY)
+            except Exception:
+                accs.append(0.0)
+                continue
+            # Score on all positive locations
+            scores = fp @ W[:fd] + W[fd]  # (n_pos, 80)
+            pred = scores.argmax(1)
+            acc = (pred == gt).float().mean().item()
+            accs.append(acc)
+
+        for i, d in enumerate(chunk):
+            if accs[i] > best_acc:
+                best_acc = accs[i]
+                best_dim = d
+
+    return best_dim, best_acc
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--max-dims", type=int, default=100)
+    parser.add_argument("--n-eval", type=int, default=500)
+    parser.add_argument("--lam", type=float, default=0.1)
+    args = parser.parse_args()
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print(f"Device: {device}")
+    print("=" * 60)
+    print(f"GPU Greedy Forward Construction (max {args.max_dims} dims)")
+    print("=" * 60, flush=True)
+
+    print("Building val data...", flush=True)
+    features, cls_targets = build_val_data(VAL_CACHE, args.n_eval, device)
+    pos = cls_targets >= 0
+    print(f"  {features.shape[0]} locations, {pos.sum().item()} positives, "
+          f"{features.shape[1]} dims", flush=True)
+
+    selected = []
+    remaining = list(range(768))
+    history = []
+    t0 = time.time()
+
+    for step in range(args.max_dims):
+        t_step = time.time()
+        best_dim, best_acc = greedy_step_gpu(features, cls_targets, selected, remaining, args.lam)
+
+        if best_dim < 0:
+            break
+
+        selected.append(best_dim)
+        remaining.remove(best_dim)
+        step_time = time.time() - t_step
+
+        n_params = len(selected) * NUM_CLASSES + NUM_CLASSES  # cls only for now
+        entry = {"step": step + 1, "dim": best_dim, "cls_acc": round(best_acc, 4),
+                 "n_params": n_params, "step_ms": round(step_time * 1000)}
+        history.append(entry)
+
+        print(f"  step {step+1:3d}: +dim{best_dim:3d} -> cls_acc={best_acc:.4f} "
+              f"({len(selected)} dims, {n_params} params, {step_time*1000:.0f}ms)", flush=True)
+
+        # Early stopping
+        if len(history) >= 10:
+            recent_gain = history[-1]["cls_acc"] - history[-10]["cls_acc"]
+            if recent_gain < 0.005:
+                print(f"  Converged: <0.5% gain in 10 steps", flush=True)
+                break
+
+    elapsed = time.time() - t0
+    print(f"\n{'='*60}")
+    print(f"Selected {len(selected)} dimensions in {elapsed:.1f}s")
+    print(f"Final cls_acc: {history[-1]['cls_acc']:.4f}")
+    print(f"Final params: {history[-1]['n_params']}")
+    print(f"\nTop 20 dimensions (most to least important):")
+    for h in history[:20]:
+        print(f"  step {h['step']:2d}: dim{h['dim']:3d}  cumul_acc={h['cls_acc']:.4f}  ({h['step_ms']}ms)")
+
+    # Save
+    result = {"selected_dims": selected, "history": history,
+              "final_cls_acc": history[-1]["cls_acc"], "final_params": history[-1]["n_params"],
+              "total_time_s": round(elapsed, 1)}
+    out = os.path.join(SCRIPT_DIR, "analytical_variants", "greedy_forward_gpu.json")
+    os.makedirs(os.path.dirname(out), exist_ok=True)
+    with open(out, "w") as f:
+        json.dump(result, f, indent=2)
+    print(f"\nSaved: {out}")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_hyperbatch.py

@@ -0,0 +1,306 @@
+"""
+Hyper-batch analytical sweep — all variants on GPU simultaneously.
+
+Pre-loads ALL training features + ALL val features into VRAM.
+Pre-computes all feature variants (raw, H^1, fractal, quadratic).
+Solves and evals 100+ variants in one pass.
+
+GPU memory budget: ~15 GB of 46 GB available.
+"""
+
+import json, os, sys, time
+import torch, torch.nn.functional as F
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+CACHE_DIR = os.environ.get("ARENA_CACHE_DIR")
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE")
+DEVICE = "cuda"
+RESOLUTION = 640
+NUM_CLASSES = 80
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []; residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega); residual = omega
+    cofibers.append(residual); return cofibers
+
+
+def make_locations(sizes, strides, device="cpu"):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, device=device, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, device=device, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    ct = torch.full((n,), -1, dtype=torch.long)
+    rt = torch.zeros(n, 4); ctrt = torch.zeros(n)
+    if boxes.numel() == 0: return ct, rt, ctrt
+    areas = (boxes[:, 2]-boxes[:, 0])*(boxes[:, 3]-boxes[:, 1])
+    l=loc[:,None,0]-boxes[None,:,0]; t=loc[:,None,1]-boxes[None,:,1]
+    r=boxes[None,:,2]-loc[:,None,0]; b=boxes[None,:,3]-loc[:,None,1]
+    ltrb=torch.stack([l,t,r,b],-1); in_box=ltrb.min(-1).values>0
+    cx=(boxes[:,0]+boxes[:,2])/2; cy=(boxes[:,1]+boxes[:,3])/2; rad=stride*1.5
+    in_center=((loc[:,None,0]>=cx-rad)&(loc[:,None,0]<=cx+rad)&(loc[:,None,1]>=cy-rad)&(loc[:,None,1]<=cy+rad))
+    max_d=ltrb.max(-1).values; in_level=(max_d>=sr[0])&(max_d<=sr[1])
+    pos=in_box&in_center&in_level; a=areas[None,:].expand_as(pos).clone(); a[~pos]=float("inf")
+    matched=a.argmin(1); is_pos=a.gather(1,matched[:,None]).squeeze(1)<float("inf")
+    ct[is_pos]=labels[matched[is_pos]]
+    if is_pos.any():
+        rt[is_pos]=ltrb[torch.arange(n)[is_pos],matched[is_pos]]
+        lp,tp,rp,bp=rt[is_pos].unbind(-1)
+        ctrt[is_pos]=torch.sqrt((torch.minimum(lp,rp)/torch.maximum(lp,rp).clamp(min=1e-6))*(torch.minimum(tp,bp)/torch.maximum(tp,bp).clamp(min=1e-6)))
+    return ct, rt, ctrt
+
+
+def load_train_features(n_images=20000):
+    """Load training features + targets into GPU."""
+    manifest = json.load(open(os.path.join(CACHE_DIR, "manifest.json")))
+    strides = [16, 32, 64]; H = RESOLUTION // 16
+    sizes = [(H, H), (H//2, H//2), (H//4, H//4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+
+    all_f, all_cls, all_reg, all_ctr = [], [], [], []
+    seen = 0
+    for si in range(manifest["n_shards"]):
+        if seen >= n_images: break
+        shard = torch.load(os.path.join(CACHE_DIR, f"shard_{si:04d}.pt"),
+                          map_location="cpu", weights_only=False)
+        for item in shard:
+            if seen >= n_images: break
+            sp = item["spatial"].unsqueeze(0).float()
+            boxes = item["boxes"]; labels = item["labels"]
+            cofibers = cofiber_decompose(sp, 3)
+            for sci, cof in enumerate(cofibers):
+                B, C, Hc, Wc = cof.shape
+                f = F.layer_norm(cof.permute(0, 2, 3, 1).reshape(-1, C), [C])
+                ct, rt, ctrt = assign_targets(locs[sci], boxes, labels, strides[sci], sr[sci])
+                pos = ct >= 0
+                if pos.any():
+                    all_f.append(f[pos])
+                    all_cls.append(ct[pos])
+                    all_reg.append(rt[pos])
+                    all_ctr.append(ctrt[pos])
+            seen += 1
+        del shard
+        if (si+1) % 5 == 0:
+            print(f"  shard {si+1}: {seen} imgs, {sum(len(x) for x in all_f)} pos", flush=True)
+
+    features = torch.cat(all_f).to(DEVICE)
+    cls_targets = torch.cat(all_cls).to(DEVICE)
+    reg_targets = torch.cat(all_reg).to(DEVICE)
+    ctr_targets = torch.cat(all_ctr).to(DEVICE)
+    print(f"  Train: {features.shape[0]} positives on GPU "
+          f"({features.element_size() * features.nelement() / 1e9:.1f} GB)")
+    return features, cls_targets, reg_targets, ctr_targets
+
+
+def load_val_features(n_images=5000):
+    """Load val features + GT into GPU for eval."""
+    val = torch.load(VAL_CACHE, map_location="cpu", weights_only=False)
+    from pycocotools.coco import COCO
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco = COCO(ann_file)
+    cat_ids = sorted(coco.getCatIds())
+    cat_to_idx = {c: i for i, c in enumerate(cat_ids)}
+    idx_to_cat = {i: c for i, c in enumerate(cat_ids)}
+
+    strides = [16, 32, 64]; H = RESOLUTION // 16
+    sizes = [(H, H), (H//2, H//2), (H//4, H//4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+    all_locs = torch.cat(locs).to(DEVICE)
+
+    val_data = []
+    for idx in range(min(n_images, len(val))):
+        item = val[idx]
+        spatial = item["spatial"].unsqueeze(0).float()
+        img_id = int(item["img_id"]); scale = item["scale"]
+        cofibers = cofiber_decompose(spatial, 3)
+        f_all = []
+        for cof in cofibers:
+            B, C, Hc, Wc = cof.shape
+            f = F.layer_norm(cof.permute(0, 2, 3, 1).reshape(-1, C), [C])
+            f_all.append(f)
+        features = torch.cat(f_all).to(DEVICE)
+        val_data.append({"features": features, "img_id": img_id, "scale": scale})
+
+    print(f"  Val: {len(val_data)} images on GPU")
+    return val_data, all_locs, idx_to_cat, coco
+
+
+def solve(features, cls_targets, reg_targets, ctr_targets, lam=0.1):
+    """Solve for cls/reg/ctr weights on GPU."""
+    fd = features.shape[1]
+    n = features.shape[0]
+    fa = torch.cat([features, torch.ones(n, 1, device=DEVICE)], 1)
+    I = torch.eye(fd + 1, device=DEVICE)
+    XtX = fa.T @ fa
+
+    # Classification
+    y_cls = torch.zeros(n, NUM_CLASSES, device=DEVICE)
+    y_cls[torch.arange(n, device=DEVICE), cls_targets] = 1.0
+    cls_W = torch.linalg.solve(XtX + lam * I * n, fa.T @ y_cls)
+
+    # Regression (log-ltrb)
+    valid = (reg_targets > 0).all(1)
+    if valid.sum() > 10:
+        fv = fa[valid]
+        XtX_r = fv.T @ fv
+        reg_W = torch.linalg.solve(XtX_r + lam * torch.eye(fd+1, device=DEVICE) * valid.sum(),
+                                    fv.T @ torch.log(reg_targets[valid]))
+    else:
+        reg_W = torch.zeros(fd + 1, 4, device=DEVICE)
+
+    # Centerness
+    ctr_W = torch.linalg.solve(XtX + lam * I * n, fa.T @ ctr_targets.unsqueeze(1))
+
+    return cls_W, reg_W, ctr_W
+
+
+def eval_head(cls_W, reg_W, ctr_W, val_data, all_locs, idx_to_cat, coco_gt):
+    """Run COCO eval for one head. Returns mAP."""
+    fd = cls_W.shape[0] - 1
+    all_results = []
+    for vd in val_data:
+        f = vd["features"]
+        if f.shape[1] != fd:
+            continue  # skip if feature dim doesn't match
+        scores = (f @ cls_W[:fd] + cls_W[fd]).sigmoid()
+        reg = (f @ reg_W[:fd] + reg_W[fd]).exp()
+        ctr = (f @ ctr_W[:fd] + ctr_W[fd]).sigmoid().squeeze(1)
+        combined = scores * ctr.unsqueeze(1)
+        max_s, max_c = combined.max(1)
+        topk = min(100, max_s.shape[0])
+        top_s, top_i = max_s.topk(topk)
+        tc = max_c[top_i]; tr = reg[top_i]; tl = all_locs[top_i]
+        scale = vd["scale"]
+        x1 = (tl[:,0]-tr[:,0])/scale; y1 = (tl[:,1]-tr[:,1])/scale
+        x2 = (tl[:,0]+tr[:,2])/scale; y2 = (tl[:,1]+tr[:,3])/scale
+        w = (x2-x1).clamp(min=0); h = (y2-y1).clamp(min=0)
+        for i in range(topk):
+            s = top_s[i].item()
+            if s < 0.01: continue
+            all_results.append({"image_id": vd["img_id"],
+                                "category_id": idx_to_cat[tc[i].item()],
+                                "bbox": [x1[i].item(), y1[i].item(), w[i].item(), h[i].item()],
+                                "score": s})
+
+    if not all_results:
+        return 0.0, 0.0, 0.0
+    from pycocotools.cocoeval import COCOeval
+    coco_dt = coco_gt.loadRes(all_results)
+    coco_eval = COCOeval(coco_gt, coco_dt, "bbox")
+    coco_eval.params.imgIds = sorted(coco_gt.getImgIds())[:len(val_data)]
+    coco_eval.evaluate(); coco_eval.accumulate(); coco_eval.summarize()
+    return coco_eval.stats[0], coco_eval.stats[1], coco_eval.stats[2]
+
+
+def main():
+    print("=" * 60)
+    print("Hyper-Batch Analytical Sweep (full GPU)")
+    print("=" * 60, flush=True)
+
+    # Load everything into VRAM
+    t0 = time.time()
+    print("\nLoading training features...", flush=True)
+    train_f, train_cls, train_reg, train_ctr = load_train_features(20000)
+
+    print("\nLoading val features...", flush=True)
+    val_data, all_locs, idx_to_cat, coco_gt = load_val_features(5000)
+
+    load_time = time.time() - t0
+    print(f"\nAll data on GPU in {load_time:.0f}s", flush=True)
+    print(f"GPU memory: {torch.cuda.memory_allocated()/1e9:.1f} GB / "
+          f"{torch.cuda.get_device_properties(0).total_memory/1e9:.1f} GB", flush=True)
+
+    results = []
+
+    # =====================================================
+    # Sweep lambda on raw 768 features
+    # =====================================================
+    print(f"\n--- Lambda sweep (768 raw) ---", flush=True)
+    for lam in [1e-4, 1e-3, 1e-2, 5e-2, 0.1, 0.2, 0.5, 1.0]:
+        t = time.time()
+        cls_W, reg_W, ctr_W = solve(train_f, train_cls, train_reg, train_ctr, lam)
+        mAP, mAP50, mAP75 = eval_head(cls_W, reg_W, ctr_W, val_data, all_locs, idx_to_cat, coco_gt)
+        elapsed = time.time() - t
+        print(f"  lam={lam:6.4f}: mAP={mAP:.4f} mAP50={mAP50:.4f} mAP75={mAP75:.4f} [{elapsed:.1f}s]", flush=True)
+        results.append({"name": f"raw768_lam{lam}", "mAP": mAP, "mAP50": mAP50, "mAP75": mAP75,
+                        "lam": lam, "dims": 768})
+
+    # Find best lambda
+    best_lam = max(results, key=lambda x: x["mAP"])["lam"]
+    print(f"  Best lambda: {best_lam}", flush=True)
+
+    # =====================================================
+    # Feature variants at best lambda
+    # =====================================================
+    print(f"\n--- Feature variants (lam={best_lam}) ---", flush=True)
+
+    # Raw features (already done above, but include for completeness)
+
+    # L2-normalized features
+    f_l2 = F.normalize(train_f, p=2, dim=1)
+    cls_W, reg_W, ctr_W = solve(f_l2, train_cls, train_reg, train_ctr, best_lam)
+    # Need L2-normed val features too
+    val_l2 = []
+    for vd in val_data:
+        val_l2.append({**vd, "features": F.normalize(vd["features"], p=2, dim=1)})
+    mAP, mAP50, mAP75 = eval_head(cls_W, reg_W, ctr_W, val_l2, all_locs, idx_to_cat, coco_gt)
+    print(f"  l2norm: mAP={mAP:.4f} mAP50={mAP50:.4f} mAP75={mAP75:.4f}", flush=True)
+    results.append({"name": "l2norm", "mAP": mAP, "mAP50": mAP50, "mAP75": mAP75, "dims": 768})
+    del val_l2
+
+    # PCA-reduced features
+    for K in [128, 256, 384, 512]:
+        # Compute PCA on training positives
+        mean = train_f.mean(0, keepdim=True)
+        centered = train_f - mean
+        # Use SVD on a subsample for speed
+        sub = centered[:50000]
+        U, S, Vh = torch.linalg.svd(sub, full_matrices=False)
+        proj = Vh[:K].T  # (768, K)
+        f_pca = centered @ proj
+        cls_W, reg_W, ctr_W = solve(f_pca, train_cls, train_reg, train_ctr, best_lam)
+        val_pca = []
+        for vd in val_data:
+            val_pca.append({**vd, "features": (vd["features"] - mean) @ proj})
+        mAP, mAP50, mAP75 = eval_head(cls_W, reg_W, ctr_W, val_pca, all_locs, idx_to_cat, coco_gt)
+        n_params = K * NUM_CLASSES + NUM_CLASSES + K * 4 + 4 + K + 1
+        print(f"  PCA-{K}: mAP={mAP:.4f} mAP50={mAP50:.4f} mAP75={mAP75:.4f} ({n_params} params)", flush=True)
+        results.append({"name": f"pca{K}", "mAP": mAP, "mAP50": mAP50, "mAP75": mAP75,
+                        "dims": K, "params": n_params})
+        del val_pca
+
+    # =====================================================
+    # Summary
+    # =====================================================
+    print(f"\n{'='*60}")
+    print("Ranked by mAP:")
+    for r in sorted(results, key=lambda x: -x["mAP"]):
+        print(f"  {r['name']:25s}: mAP={r['mAP']:.4f} mAP50={r.get('mAP50',0):.4f} "
+              f"mAP75={r.get('mAP75',0):.4f} dims={r.get('dims','?')}")
+
+    out = os.path.join(SCRIPT_DIR, "analytical_variants", "hyperbatch_results.json")
+    os.makedirs(os.path.dirname(out), exist_ok=True)
+    with open(out, "w") as f:
+        json.dump(results, f, indent=2)
+    print(f"\nSaved: {out}")
+    total = time.time() - t0
+    print(f"Total: {total:.0f}s for {len(results)} variants")
+
+
+if __name__ == "__main__":
+    main()

analytical/scripts/analytical_one.py

@@ -0,0 +1,549 @@
+"""
+Build and evaluate one analytical detection head variant.
+
+Usage:
+    python analytical_one.py --name baseline
+    python analytical_one.py --name whitened --transform zca
+    python analytical_one.py --name spatial3x3 --spatial mean3x3
+"""
+
+import argparse
+import json
+import math
+import os
+import sys
+import time
+
+import torch
+import torch.nn.functional as F
+import numpy as np
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SCRIPT_DIR)
+
+CACHE_DIR = os.environ.get("ARENA_CACHE_DIR", "feature_cache")
+COCO_ROOT = os.environ.get("ARENA_COCO_ROOT", "coco")
+VAL_CACHE = os.environ.get("ARENA_VAL_CACHE", "val_cache/val.pt")
+STATS_DIR = os.path.join(SCRIPT_DIR, "analytical_stats_cache")
+RESULTS_DIR = os.path.join(SCRIPT_DIR, "analytical_variants")
+RESOLUTION = 640
+NUM_CLASSES = 80
+
+
+def cofiber_decompose(f, n_scales):
+    cofibers = []
+    residual = f
+    for _ in range(n_scales - 1):
+        omega = F.avg_pool2d(residual, 2)
+        sigma_omega = F.interpolate(omega, size=residual.shape[2:], mode="bilinear", align_corners=False)
+        cofibers.append(residual - sigma_omega)
+        residual = omega
+    cofibers.append(residual)
+    return cofibers
+
+
+def make_locations(sizes, strides):
+    locs = []
+    for (h, w), s in zip(sizes, strides):
+        ys = (torch.arange(h, dtype=torch.float32) + 0.5) * s
+        xs = (torch.arange(w, dtype=torch.float32) + 0.5) * s
+        gy, gx = torch.meshgrid(ys, xs, indexing="ij")
+        locs.append(torch.stack([gx.flatten(), gy.flatten()], -1))
+    return locs
+
+
+def assign_targets(loc, boxes, labels, stride, sr):
+    n = loc.shape[0]
+    if boxes.numel() == 0:
+        return torch.full((n,), -1, dtype=torch.long), torch.zeros(n, 4), torch.zeros(n)
+    areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1])
+    l = loc[:, None, 0] - boxes[None, :, 0]
+    t = loc[:, None, 1] - boxes[None, :, 1]
+    r = boxes[None, :, 2] - loc[:, None, 0]
+    b = boxes[None, :, 3] - loc[:, None, 1]
+    ltrb = torch.stack([l, t, r, b], -1)
+    in_box = ltrb.min(-1).values > 0
+    cx = (boxes[:, 0] + boxes[:, 2]) / 2
+    cy = (boxes[:, 1] + boxes[:, 3]) / 2
+    rad = stride * 1.5
+    in_center = ((loc[:, None, 0] >= cx - rad) & (loc[:, None, 0] <= cx + rad) &
+                 (loc[:, None, 1] >= cy - rad) & (loc[:, None, 1] <= cy + rad))
+    max_d = ltrb.max(-1).values
+    in_level = (max_d >= sr[0]) & (max_d <= sr[1])
+    pos = in_box & in_center & in_level
+    a = areas[None, :].expand_as(pos).clone()
+    a[~pos] = float("inf")
+    matched = a.argmin(1)
+    is_pos = a.gather(1, matched[:, None]).squeeze(1) < float("inf")
+    ct = torch.full((n,), -1, dtype=torch.long)
+    ct[is_pos] = labels[matched[is_pos]]
+    rt = torch.zeros(n, 4)
+    if is_pos.any():
+        rt[is_pos] = ltrb[torch.arange(n)[is_pos], matched[is_pos]]
+    ctrt = torch.zeros(n)
+    if is_pos.any():
+        lp, tp, rp, bp = rt[is_pos].unbind(-1)
+        ctrt[is_pos] = torch.sqrt(
+            (torch.minimum(lp, rp) / torch.maximum(lp, rp).clamp(min=1e-6)) *
+            (torch.minimum(tp, bp) / torch.maximum(tp, bp).clamp(min=1e-6)))
+    return ct, rt, ctrt
+
+
+# ============================================================
+# Feature transforms
+# ============================================================
+
+def transform_layernorm(f, C):
+    return F.layer_norm(f, [C])
+
+def transform_raw(f, C):
+    return f
+
+def transform_l2norm(f, C):
+    return F.normalize(f, p=2, dim=-1)
+
+def transform_power05(f, C):
+    """Signed power normalization: sign(x) * |x|^0.5, then L2 normalize."""
+    out = f.sign() * f.abs().sqrt()
+    return F.normalize(out, p=2, dim=-1)
+
+def transform_power025(f, C):
+    """Stronger compression: sign(x) * |x|^0.25."""
+    out = f.sign() * f.abs().pow(0.25)
+    return F.normalize(out, p=2, dim=-1)
+
+TRANSFORMS = {
+    "layernorm": transform_layernorm,
+    "raw": transform_raw,
+    "l2norm": transform_l2norm,
+    "power05": transform_power05,
+    "power025": transform_power025,
+}
+
+
+# ============================================================
+# Target encodings
+# ============================================================
+
+def encode_log_ltrb(ltrb):
+    valid = (ltrb > 0).all(1)
+    out = torch.zeros_like(ltrb)
+    if valid.any():
+        out[valid] = torch.log(ltrb[valid])
+    return out, valid
+
+def encode_sqrt_ltrb(ltrb):
+    valid = (ltrb > 0).all(1)
+    out = torch.zeros_like(ltrb)
+    if valid.any():
+        out[valid] = torch.sqrt(ltrb[valid])
+    return out, valid
+
+def encode_ltrb(ltrb):
+    valid = (ltrb > 0).all(1)
+    return ltrb, valid
+
+def encode_corners(ltrb):
+    valid = (ltrb > 0).all(1)
+    return torch.stack([-ltrb[:, 0], -ltrb[:, 1], ltrb[:, 2], ltrb[:, 3]], 1), valid
+
+def encode_center_size(ltrb):
+    valid = (ltrb > 0).all(1)
+    cx_off = (ltrb[:, 2] - ltrb[:, 0]) / 2
+    cy_off = (ltrb[:, 3] - ltrb[:, 1]) / 2
+    w = ltrb[:, 0] + ltrb[:, 2]
+    h = ltrb[:, 1] + ltrb[:, 3]
+    return torch.stack([cx_off, cy_off, w, h], 1), valid
+
+ENCODINGS = {
+    "log_ltrb": encode_log_ltrb,
+    "sqrt_ltrb": encode_sqrt_ltrb,
+    "ltrb": encode_ltrb,
+    "corners": encode_corners,
+    "center_size": encode_center_size,
+}
+
+
+# ============================================================
+# Spatial context modes
+# ============================================================
+
+def spatial_none(f_grid, B, H, W, C):
+    """No spatial context. Per-token features only."""
+    return f_grid.reshape(-1, C)
+
+def spatial_mean3x3(f_grid, B, H, W, C):
+    """Replace each token with the mean of its 3x3 neighborhood."""
+    f_4d = f_grid.reshape(B, H, W, C).permute(0, 3, 1, 2)
+    pooled = F.avg_pool2d(f_4d, 3, stride=1, padding=1)
+    return pooled.permute(0, 2, 3, 1).reshape(-1, C)
+
+def spatial_cat_mean3x3(f_grid, B, H, W, C):
+    """Concatenate: [center_token, mean_of_3x3_neighborhood]. 2*C dims."""
+    f_4d = f_grid.reshape(B, H, W, C).permute(0, 3, 1, 2)
+    pooled = F.avg_pool2d(f_4d, 3, stride=1, padding=1)
+    center = f_grid.reshape(-1, C)
+    neighbor_mean = pooled.permute(0, 2, 3, 1).reshape(-1, C)
+    return torch.cat([center, neighbor_mean], dim=1)
+
+def spatial_diff_neighbors(f_grid, B, H, W, C):
+    """Center token + (center - neighbor_mean). Emphasizes local contrast."""
+    f_4d = f_grid.reshape(B, H, W, C).permute(0, 3, 1, 2)
+    pooled = F.avg_pool2d(f_4d, 3, stride=1, padding=1)
+    center = f_grid.reshape(-1, C)
+    diff = center - pooled.permute(0, 2, 3, 1).reshape(-1, C)
+    return torch.cat([center, diff], dim=1)
+
+def spatial_hv_neighbors(f_grid, B, H, W, C):
+    """Center + horizontal mean + vertical mean. 3*C dims."""
+    f_4d = f_grid.reshape(B, H, W, C).permute(0, 3, 1, 2)
+    h_pool = F.avg_pool2d(f_4d, (1, 3), stride=1, padding=(0, 1))
+    v_pool = F.avg_pool2d(f_4d, (3, 1), stride=1, padding=(1, 0))
+    center = f_grid.reshape(-1, C)
+    h_mean = h_pool.permute(0, 2, 3, 1).reshape(-1, C)
+    v_mean = v_pool.permute(0, 2, 3, 1).reshape(-1, C)
+    return torch.cat([center, h_mean, v_mean], dim=1)
+
+def spatial_sheaf_h1(f_grid, B, H, W, C):
+    """Sheaf H^1: directional edge differences (4 cardinal Cech 1-cocycles).
+
+    At each location, compute feature[here] - feature[neighbor] for all 4
+    cardinal directions. This is the Cech 1-cocycle representative on the
+    spatial grid. It captures gluing obstructions — exactly where local
+    feature sections fail to extend consistently. Object boundaries are
+    such obstructions.
+
+    Output: [center, d_up, d_down, d_left, d_right] = 5*C dims.
+    """
+    f_4d = f_grid.reshape(B, H, W, C).permute(0, 3, 1, 2)  # (B, C, H, W)
+    # Shift in each direction and subtract
+    d_up = f_4d - F.pad(f_4d[:, :, 1:, :], (0, 0, 0, 1))     # diff with token above
+    d_down = f_4d - F.pad(f_4d[:, :, :-1, :], (0, 0, 1, 0))   # diff with token below
+    d_left = f_4d - F.pad(f_4d[:, :, :, 1:], (0, 1, 0, 0))    # diff with token left
+    d_right = f_4d - F.pad(f_4d[:, :, :, :-1], (1, 0, 0, 0))  # diff with token right
+    center = f_grid.reshape(-1, C)
+    du = d_up.permute(0, 2, 3, 1).reshape(-1, C)
+    dd = d_down.permute(0, 2, 3, 1).reshape(-1, C)
+    dl = d_left.permute(0, 2, 3, 1).reshape(-1, C)
+    dr = d_right.permute(0, 2, 3, 1).reshape(-1, C)
+    return torch.cat([center, du, dd, dl, dr], dim=1)
+
+def spatial_sheaf_h1_compact(f_grid, B, H, W, C):
+    """Sheaf H^1 compact: center + L1 norm of directional cocycles.
+
+    Instead of raw directional differences (5*C dims), compute the
+    L1 magnitude of each directional cocycle per channel. This gives a
+    scalar "boundary strength" per channel per direction.
+    Output: [center, |d_up|+|d_down|, |d_left|+|d_right|] = 3*C dims.
+    Vertical and horizontal boundary strengths.
+    """
+    f_4d = f_grid.reshape(B, H, W, C).permute(0, 3, 1, 2)
+    d_up = f_4d - F.pad(f_4d[:, :, 1:, :], (0, 0, 0, 1))
+    d_down = f_4d - F.pad(f_4d[:, :, :-1, :], (0, 0, 1, 0))
+    d_left = f_4d - F.pad(f_4d[:, :, :, 1:], (0, 1, 0, 0))
+    d_right = f_4d - F.pad(f_4d[:, :, :, :-1], (1, 0, 0, 0))
+    center = f_grid.reshape(-1, C)
+    v_boundary = (d_up.abs() + d_down.abs()).permute(0, 2, 3, 1).reshape(-1, C)
+    h_boundary = (d_left.abs() + d_right.abs()).permute(0, 2, 3, 1).reshape(-1, C)
+    return torch.cat([center, v_boundary, h_boundary], dim=1)
+
+SPATIAL = {
+    "none": spatial_none,
+    "mean3x3": spatial_mean3x3,
+    "cat_mean3x3": spatial_cat_mean3x3,
+    "diff_neighbors": spatial_diff_neighbors,
+    "hv_neighbors": spatial_hv_neighbors,
+    "sheaf_h1": spatial_sheaf_h1,
+    "sheaf_h1_compact": spatial_sheaf_h1_compact,
+}
+
+
+# ============================================================
+# Core: accumulate, solve, evaluate
+# ============================================================
+
+def accumulate(n_images, transform_name, encoding_name, spatial_name, per_scale=False, neg_ratio=0.0):
+    """Accumulate XtX/XtY from cached features."""
+    manifest = json.load(open(os.path.join(CACHE_DIR, "manifest.json")))
+    n_shards = manifest["n_shards"]
+    strides = [16, 32, 64]
+    H = RESOLUTION // 16
+    sizes = [(H, H), (H // 2, H // 2), (H // 4, H // 4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+    transform_fn = TRANSFORMS[transform_name]
+    encode_fn = ENCODINGS[encoding_name]
+    spatial_fn = SPATIAL[spatial_name]
+
+    # Determine feature dim
+    test_f = torch.randn(1, 768)
+    test_t = transform_fn(test_f, 768)
+    test_s = spatial_fn(test_t.unsqueeze(0), 1, 1, 1, test_t.shape[-1])
+    feat_dim = test_s.shape[-1]
+
+    n_scales = 3 if not per_scale else 1
+    scale_range = range(3) if not per_scale else [0]
+
+    cls_XtX = torch.zeros(feat_dim + 1, feat_dim + 1)
+    cls_XtY = torch.zeros(feat_dim + 1, NUM_CLASSES)
+    reg_XtX = torch.zeros(feat_dim + 1, feat_dim + 1)
+    reg_XtY = torch.zeros(feat_dim + 1, 4)
+    ctr_XtX = torch.zeros(feat_dim + 1, feat_dim + 1)
+    ctr_XtY = torch.zeros(feat_dim + 1, 1)
+    n_pos = 0
+    seen = 0
+    t0 = time.time()
+
+    for si in range(n_shards):
+        if seen >= n_images:
+            break
+        shard = torch.load(os.path.join(CACHE_DIR, f"shard_{si:04d}.pt"),
+                          map_location="cpu", weights_only=False)
+        for item in shard:
+            if seen >= n_images:
+                break
+            sp = item["spatial"].unsqueeze(0).float()
+            boxes = item["boxes"]
+            labels = item["labels"]
+            cofibers = cofiber_decompose(sp, 3)
+            for sci in range(3):
+                cof = cofibers[sci]
+                B, C, Hc, Wc = cof.shape
+                f_raw = cof.permute(0, 2, 3, 1).reshape(-1, C)
+                f = transform_fn(f_raw, C)
+                f_spatial = spatial_fn(f.unsqueeze(0) if f.dim() == 2 else f,
+                                       B, Hc, Wc, f.shape[-1] if f.dim() == 2 else C)
+                ct, rt, ctrt = assign_targets(locs[sci], boxes, labels, strides[sci], sr[sci])
+                pos = ct >= 0
+                if not pos.any():
+                    continue
+                fp = f_spatial[pos]
+                fa = torch.cat([fp, torch.ones(fp.shape[0], 1)], 1)
+                y_cls = torch.zeros(fp.shape[0], NUM_CLASSES)
+                y_cls[torch.arange(fp.shape[0]), ct[pos]] = 1.0
+                cls_XtX += fa.T @ fa
+                cls_XtY += fa.T @ y_cls
+                reg_y, valid = encode_fn(rt[pos])
+                if valid.any():
+                    fr = fa[valid]
+                    reg_XtX += fr.T @ fr
+                    reg_XtY += fr.T @ reg_y[valid]
+                ctr_XtX += fa.T @ fa
+                ctr_XtY += fa.T @ ctrt[pos].unsqueeze(1)
+                n_pos += pos.sum().item()
+
+                # Negative samples for classification (target = all zeros)
+                if neg_ratio > 0:
+                    neg = ct < 0
+                    n_neg_want = int(pos.sum().item() * neg_ratio)
+                    if neg.any() and n_neg_want > 0:
+                        neg_idx = neg.nonzero(as_tuple=True)[0]
+                        if len(neg_idx) > n_neg_want:
+                            neg_idx = neg_idx[torch.randperm(len(neg_idx))[:n_neg_want]]
+                        fn = f_spatial[neg_idx]
+                        fn_aug = torch.cat([fn, torch.ones(fn.shape[0], 1)], 1)
+                        cls_XtX += fn_aug.T @ fn_aug
+                        cls_XtY += fn_aug.T @ torch.zeros(fn.shape[0], NUM_CLASSES)
+            seen += 1
+        del shard
+        if (si + 1) % 5 == 0:
+            elapsed = time.time() - t0
+            print(f"    shard {si+1}: {seen} imgs, {n_pos} pos, {elapsed:.0f}s", flush=True)
+
+    return {"cls_XtX": cls_XtX, "cls_XtY": cls_XtY, "reg_XtX": reg_XtX, "reg_XtY": reg_XtY,
+            "ctr_XtX": ctr_XtX, "ctr_XtY": ctr_XtY, "n_pos": n_pos, "feat_dim": feat_dim,
+            "n_images": seen, "elapsed": time.time() - t0}
+
+
+def solve(stats, lam):
+    fd = stats["feat_dim"]
+    n = stats["n_pos"]
+    I = torch.eye(fd + 1)
+    cls_W = torch.linalg.solve(stats["cls_XtX"] + lam * I * n, stats["cls_XtY"])
+    reg_W = torch.linalg.solve(stats["reg_XtX"] + lam * I * n, stats["reg_XtY"])
+    ctr_W = torch.linalg.solve(stats["ctr_XtX"] + lam * I * n, stats["ctr_XtY"])
+    return {"cls_w": cls_W[:fd].T, "cls_b": cls_W[fd],
+            "reg_w": reg_W[:fd].T, "reg_b": reg_W[fd],
+            "ctr_w": ctr_W[:fd].T, "ctr_b": ctr_W[fd],
+            "feat_dim": fd}
+
+
+def evaluate(head, val_path, transform_name, spatial_name, encoding_name="log_ltrb", n_images=500):
+    """Evaluate on val set. CPU-only. Returns metrics dict."""
+    val = torch.load(val_path, map_location="cpu", weights_only=False)
+    encode_fn = ENCODINGS[encoding_name]
+
+    # Load COCO GT
+    from pycocotools.coco import COCO
+    ann_file = os.path.join(COCO_ROOT, "annotations", "instances_val2017.json")
+    coco = COCO(ann_file)
+    cat_ids = sorted(coco.getCatIds())
+    cat_to_idx = {c: i for i, c in enumerate(cat_ids)}
+
+    transform_fn = TRANSFORMS[transform_name]
+    spatial_fn = SPATIAL[spatial_name]
+    strides = [16, 32, 64]
+    H = RESOLUTION // 16
+    sizes = [(H, H), (H // 2, H // 2), (H // 4, H // 4)]
+    sr = [(-1, 128), (128, 256), (256, float("inf"))]
+    locs = make_locations(sizes, strides)
+
+    correct = 0
+    n_pos_total = 0
+    n_det = 0
+    true_det = 0
+    reg_errors = []
+
+    for idx in range(min(n_images, len(val))):
+        item = val[idx]
+        spatial = item["spatial"].unsqueeze(0).float()
+        img_id = item["img_id"]
+        scale = item["scale"]
+
+        ann_ids = coco.getAnnIds(imgIds=int(img_id), iscrowd=False)
+        anns = coco.loadAnns(ann_ids)
+        boxes = []
+        labels = []
+        for ann in anns:
+            x, y, w, h = ann["bbox"]
+            if w < 1 or h < 1:
+                continue
+            boxes.append([x * scale, y * scale, (x + w) * scale, (y + h) * scale])
+            labels.append(cat_to_idx[ann["category_id"]])
+        boxes_t = torch.tensor(boxes, dtype=torch.float32) if boxes else torch.zeros(0, 4)
+        labels_t = torch.tensor(labels, dtype=torch.long) if labels else torch.zeros(0, dtype=torch.long)
+
+        cofibers = cofiber_decompose(spatial, 3)
+        for sci, cof in enumerate(cofibers):
+            B, C, Hc, Wc = cof.shape
+            f_raw = cof.permute(0, 2, 3, 1).reshape(-1, C)
+            f = transform_fn(f_raw, C)
+            f_s = spatial_fn(f.unsqueeze(0), B, Hc, Wc, f.shape[-1])
+
+            ct, rt, _ = assign_targets(locs[sci], boxes_t, labels_t, strides[sci], sr[sci])
+            pos = ct >= 0
+
+            # Classification
+            scores = f_s @ head["cls_w"].T + head["cls_b"]
+            pred_cls = scores.argmax(1)
+            pred_conf = scores.sigmoid().max(1).values
+
+            if pos.any():
+                correct += (pred_cls[pos] == ct[pos]).sum().item()
+                n_pos_total += pos.sum().item()
+
+            # Detection count
+            det = pred_conf > 0.3
+            n_det += det.sum().item()
+            true_det += (det & pos).sum().item()
+
+            # Regression quality (in encoded target space — comparable across encodings)
+            if pos.any():
+                pred_reg = f_s[pos] @ head["reg_w"].T + head["reg_b"]
+                gt_ltrb = rt[pos]
+                valid = (gt_ltrb > 0).all(1)
+                if valid.any():
+                    gt_encoded, _ = encode_fn(gt_ltrb[valid])
+                    pred_encoded = pred_reg[valid]
+                    mse = ((pred_encoded - gt_encoded) ** 2).mean(1)
+                    # Convert to quality: 1 / (1 + mse), bounded in [0, 1]
+                    quality = (1.0 / (1.0 + mse)).tolist()
+                    reg_errors.extend(quality)
+
+    cls_acc = correct / max(n_pos_total, 1)
+    precision = true_det / max(n_det, 1)
+    reg_quality = sum(reg_errors) / max(len(reg_errors), 1)  # mean quality in [0, 1]
+    n_params = (head["cls_w"].numel() + head["cls_b"].numel() +
+                head["reg_w"].numel() + head["reg_b"].numel() +
+                head["ctr_w"].numel() + head["ctr_b"].numel())
+
+    return {
+        "cls_accuracy": round(cls_acc, 4),
+        "precision": round(precision, 4),
+        "reg_quality": round(reg_quality, 4),
+        "n_detections": n_det,
+        "n_positives": n_pos_total,
+        "n_params": n_params,
+        "composite": round(cls_acc * 0.5 + precision * 0.25 + reg_quality * 0.25, 4),
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--name", required=True, help="Variant name")
+    parser.add_argument("--transform", default="layernorm", choices=list(TRANSFORMS.keys()))
+    parser.add_argument("--encoding", default="log_ltrb", choices=list(ENCODINGS.keys()))
+    parser.add_argument("--spatial", default="none", choices=list(SPATIAL.keys()))
+    parser.add_argument("--lam", type=float, default=1e-3)
+    parser.add_argument("--n-train", type=int, default=10000)
+    parser.add_argument("--n-eval", type=int, default=500)
+    parser.add_argument("--neg-ratio", type=float, default=0.0,
+                        help="Ratio of negative to positive samples for classification (0=positives only)")
+    parser.add_argument("--notes", default="", help="Why this variant exists")
+    args = parser.parse_args()
+
+    os.makedirs(RESULTS_DIR, exist_ok=True)
+    os.makedirs(STATS_DIR, exist_ok=True)
+
+    print(f"{'='*60}")
+    print(f"Variant: {args.name}")
+    print(f"  transform={args.transform} encoding={args.encoding} spatial={args.spatial} lam={args.lam}")
+    if args.notes:
+        print(f"  rationale: {args.notes}")
+    print(f"{'='*60}", flush=True)
+
+    # Check for cached stats
+    neg_tag = f"_neg{args.neg_ratio}" if args.neg_ratio > 0 else ""
+    cache_key = f"stats_s3_{args.transform}_{args.encoding}_{args.spatial}_{args.n_train}{neg_tag}"
+    cache_path = os.path.join(STATS_DIR, f"{cache_key}.pt")
+    if os.path.isfile(cache_path):
+        print(f"  Loading cached stats: {cache_key}", flush=True)
+        stats = torch.load(cache_path, map_location="cpu", weights_only=False)
+    else:
+        print(f"  Accumulating...", flush=True)
+        stats = accumulate(args.n_train, args.transform, args.encoding, args.spatial,
+                           neg_ratio=args.neg_ratio)
+        torch.save(stats, cache_path)
+        print(f"  Cached: {cache_path}", flush=True)
+
+    print(f"  {stats['n_pos']} positives, feat_dim={stats['feat_dim']}", flush=True)
+
+    # Solve
+    t0 = time.time()
+    head = solve(stats, args.lam)
+    solve_time = time.time() - t0
+    print(f"  Solved in {solve_time*1000:.0f}ms", flush=True)
+
+    # Evaluate
+    print(f"  Evaluating ({args.n_eval} images)...", flush=True)
+    t0 = time.time()
+    metrics = evaluate(head, VAL_CACHE, args.transform, args.spatial, args.encoding, args.n_eval)
+    eval_time = time.time() - t0
+
+    print(f"\n  Results:")
+    print(f"    cls_accuracy: {metrics['cls_accuracy']}")
+    print(f"    precision:    {metrics['precision']}")
+    print(f"    reg_quality:  {metrics['reg_quality']}")
+    print(f"    composite:    {metrics['composite']}")
+    print(f"    params:       {metrics['n_params']}")
+    print(f"    eval time:    {eval_time:.1f}s")
+
+    # Save
+    result = {
+        "name": args.name,
+        "config": {"transform": args.transform, "encoding": args.encoding,
+                   "spatial": args.spatial, "lam": args.lam,
+                   "n_train": args.n_train, "n_eval": args.n_eval},
+        "notes": args.notes,
+        "metrics": metrics,
+        "solve_time_ms": round(solve_time * 1000),
+        "eval_time_s": round(eval_time, 1),
+    }
+    result_path = os.path.join(RESULTS_DIR, f"{args.name}.json")
+    with open(result_path, "w") as f:
+        json.dump(result, f, indent=2)
+    print(f"\n  Saved: {result_path}")
+
+
+if __name__ == "__main__":
+    main()

analytical/variants/README.md

@@ -0,0 +1,77 @@
+# Analytical Variants
+
+Systematic exploration of analytically-derived detection heads on frozen EUPE-ViT-B features. Every weight is computed from closed-form least-squares — no gradient steps.
+
+## Method
+
+Given cached backbone features X at positive spatial locations and target matrix Y:
+
+```
+W = (X^T X + λI)^{-1} X^T Y
+```
+
+Classification, regression, and centerness are solved independently. One pass over the training data accumulates sufficient statistics (X^T X, X^T Y), then one matrix inverse per task produces the optimal linear weights.
+
+## Greedy Feature Selection
+
+Starting from zero dimensions, greedily add the single feature channel that maximizes classification accuracy. The ordering reveals which backbone dimensions carry the most detection-relevant information.
+
+Top 10 most important dimensions (EUPE-ViT-B): 665, 642, 200, 305, 498, 628, 67, 562, 426, 723.
+
+One dimension (dim 665) achieves 31.1% person classification accuracy. 100 dimensions reach 50.6%.
+
+Results: `greedy_forward_gpu.json`
+
+## Evolved Circuits
+
+Evolutionary search over feature dimension subsets using batched GPU fitness evaluation. Population of 512 individuals, fixed-K genomes, tournament selection, uniform crossover, adaptive mutation. Fitness is F1 score from analytical person-vs-background classification.
+
+At 200 gen/s on GPU, 5000 generations complete in 25 seconds.
+
+| Dims | Gates | Greedy F1 | Evolved F1 | Speedup |
+|------|-------|-----------|------------|---------|
+| 10 | 850 | 0.628 | 0.761 | +21% |
+| 20 | 1700 | 0.646 | 0.775 | +20% |
+| 50 | 4250 | 0.696 | 0.801 | +15% |
+| 100 | 8500 | 0.728 | 0.823 | +13% |
+| 200 | 17000 | — | 0.832 | — |
+| 300 | 25500 | — | 0.845 | — |
+
+The evolved 10-dim circuit (850 gates) outperforms the greedy 100-dim circuit (8500 gates). Evolution finds synergistic dimension combinations that greedy selection is structurally blind to.
+
+Linear person detection ceiling: F1 ~ 0.846 at ~300 dims.
+
+Results: `evolved_extreme.json` in `circuit/`
+
+## Exotic Features
+
+Tested on classification and regression independently:
+
+**Classification** (69.6% baseline at 768 dims):
+- Random Fourier Features (RBF kernel approximation): no improvement over raw features
+- Quadratic cross-terms on top-30 greedy dims: 58.4% at 495 dims
+- Random projections K=200: 56.2% at 200 dims
+- Conclusion: raw LayerNorm'd features are already optimal for linear classification
+
+**Regression** (0.626 baseline quality):
+- Sheaf H^1 boundary features (vertical + horizontal): 0.687 (+9.7%)
+- H^1 + quadratic combined: 0.698 (+11.5%)
+- Random Fourier Features: 0.654 (+4.5%)
+- Conclusion: directional boundary information (Cech 1-cocycles) is the most useful addition for localization
+
+Results: `exotic_gpu.json`, `exotic_reg_gpu.json`
+
+## Spatial Context Variants
+
+Tested via the `analytical_one.py` single-variant builder:
+
+| Variant | Classification | Regression | Composite |
+|---------|---------------|------------|-----------|
+| Per-token baseline | 64.3% | — | 0.327 |
+| + 3x3 neighbor mean | 72.9% | 2.2% | 0.375 |
+| + high regularization (λ=0.1) | 71.2% | 62.9% | 0.518 |
+| + sheaf H^1 compact | 74.3% | 65.5% | 0.540 |
+
+Spatial context is essential: +8.6 points classification, unlocks nonzero regression.
+
+Results: `v001_baseline.json` through `v009_sheaf_h1_compact.json`

analytical/variants/exotic_gpu.json

@@ -0,0 +1,108 @@
+[
+  {
+    "name": "baseline_768",
+    "acc": 0.6955374502360893,
+    "dims": 768
+  },
+  {
+    "name": "random_proj_K10",
+    "acc": 0.31700768447365985,
+    "dims": 10,
+    "params": 880,
+    "seed": 139
+  },
+  {
+    "name": "random_proj_K20",
+    "acc": 0.3226553096935469,
+    "dims": 20,
+    "params": 1680,
+    "seed": 133
+  },
+  {
+    "name": "random_proj_K50",
+    "acc": 0.3812147023423757,
+    "dims": 50,
+    "params": 4080,
+    "seed": 166
+  },
+  {
+    "name": "random_proj_K100",
+    "acc": 0.46180909175076384,
+    "dims": 100,
+    "params": 8080,
+    "seed": 405
+  },
+  {
+    "name": "random_proj_K200",
+    "acc": 0.5620775854087584,
+    "dims": 200,
+    "params": 16080,
+    "seed": 335
+  },
+  {
+    "name": "quadratic_top5",
+    "acc": 0.33223775576335524,
+    "dims": 20,
+    "params": 1680
+  },
+  {
+    "name": "quadratic_top10",
+    "acc": 0.37172484029256553,
+    "dims": 65,
+    "params": 5280
+  },
+  {
+    "name": "quadratic_top20",
+    "acc": 0.478751967410425,
+    "dims": 230,
+    "params": 18480
+  },
+  {
+    "name": "quadratic_top30",
+    "acc": 0.5839274141283215,
+    "dims": 495,
+    "params": 39680
+  },
+  {
+    "name": "rff_50",
+    "acc": 0.6925747615961485,
+    "dims": 818,
+    "params": 65520
+  },
+  {
+    "name": "rff_100",
+    "acc": 0.6932228497361356,
+    "dims": 868,
+    "params": 69520
+  },
+  {
+    "name": "rff_200",
+    "acc": 0.6938246458661235,
+    "dims": 968,
+    "params": 77520
+  },
+  {
+    "name": "rff_500",
+    "acc": 0.6935006017961299,
+    "dims": 1268,
+    "params": 101520
+  },
+  {
+    "name": "pure_rff_200",
+    "acc": 0.30654569021386907,
+    "dims": 200,
+    "params": 16080
+  },
+  {
+    "name": "pure_rff_500",
+    "acc": 0.30654569021386907,
+    "dims": 500,
+    "params": 40080
+  },
+  {
+    "name": "pure_rff_1000",
+    "acc": 0.30654569021386907,
+    "dims": 1000,
+    "params": 80080
+  }
+]

analytical/variants/exotic_reg_gpu.json

@@ -0,0 +1,52 @@
+[
+  {
+    "name": "baseline_768",
+    "reg_quality": 0.62624591588974,
+    "dims": 768
+  },
+  {
+    "name": "h1_h1v",
+    "reg_quality": 0.6452575325965881,
+    "dims": 1536
+  },
+  {
+    "name": "h1_h1h",
+    "reg_quality": 0.644087016582489,
+    "dims": 1536
+  },
+  {
+    "name": "h1_h1_both",
+    "reg_quality": 0.6874305009841919,
+    "dims": 2304
+  },
+  {
+    "name": "quad_top10",
+    "reg_quality": 0.6080746650695801,
+    "dims": 823
+  },
+  {
+    "name": "quad_top20",
+    "reg_quality": 0.6147602796554565,
+    "dims": 978
+  },
+  {
+    "name": "quad_top30",
+    "reg_quality": 0.6256624460220337,
+    "dims": 1233
+  },
+  {
+    "name": "h1_quad_combined",
+    "reg_quality": 0.697516143321991,
+    "dims": 2514
+  },
+  {
+    "name": "rff_100_reg",
+    "reg_quality": 0.6526749134063721,
+    "dims": 868
+  },
+  {
+    "name": "rff_500_reg",
+    "reg_quality": 0.6537668108940125,
+    "dims": 1268
+  }
+]

analytical/variants/fractal_results.json

@@ -0,0 +1,17 @@
+[
+  {
+    "name": "standard_3band",
+    "mAP": 0.006765868258664371,
+    "bands": 3
+  },
+  {
+    "name": "fractal_depth2",
+    "mAP": 0.006765392609810458,
+    "bands": 4
+  },
+  {
+    "name": "fractal_depth3",
+    "mAP": 0.007137951141558296,
+    "bands": 8
+  }
+]

analytical/variants/greedy_forward_gpu.json

@@ -0,0 +1,809 @@
+{
+  "selected_dims": [
+    665,
+    642,
+    200,
+    305,
+    498,
+    628,
+    67,
+    562,
+    426,
+    723,
+    177,
+    11,
+    465,
+    555,
+    52,
+    179,
+    325,
+    600,
+    738,
+    389,
+    660,
+    109,
+    554,
+    632,
+    673,
+    445,
+    71,
+    403,
+    261,
+    377,
+    81,
+    21,
+    289,
+    23,
+    429,
+    645,
+    741,
+    566,
+    231,
+    357,
+    573,
+    597,
+    263,
+    28,
+    529,
+    372,
+    246,
+    49,
+    219,
+    759,
+    269,
+    593,
+    685,
+    97,
+    485,
+    430,
+    234,
+    297,
+    666,
+    32,
+    198,
+    384,
+    523,
+    292,
+    137,
+    388,
+    364,
+    506,
+    279,
+    101,
+    171,
+    649,
+    259,
+    293,
+    425,
+    576,
+    144,
+    183,
+    359,
+    437,
+    763,
+    540,
+    335,
+    302,
+    404,
+    202,
+    617,
+    497,
+    408,
+    410,
+    340,
+    15,
+    714,
+    693,
+    277,
+    466,
+    102,
+    681,
+    743,
+    765
+  ],
+  "history": [
+    {
+      "step": 1,
+      "dim": 665,
+      "cls_acc": 0.3115,
+      "n_params": 160,
+      "step_ms": 477
+    },
+    {
+      "step": 2,
+      "dim": 642,
+      "cls_acc": 0.3132,
+      "n_params": 240,
+      "step_ms": 339
+    },
+    {
+      "step": 3,
+      "dim": 200,
+      "cls_acc": 0.3153,
+      "n_params": 320,
+      "step_ms": 327
+    },
+    {
+      "step": 4,
+      "dim": 305,
+      "cls_acc": 0.3209,
+      "n_params": 400,
+      "step_ms": 308
+    },
+    {
+      "step": 5,
+      "dim": 498,
+      "cls_acc": 0.3245,
+      "n_params": 480,
+      "step_ms": 344
+    },
+    {
+      "step": 6,
+      "dim": 628,
+      "cls_acc": 0.3278,
+      "n_params": 560,
+      "step_ms": 327
+    },
+    {
+      "step": 7,
+      "dim": 67,
+      "cls_acc": 0.332,
+      "n_params": 640,
+      "step_ms": 308
+    },
+    {
+      "step": 8,
+      "dim": 562,
+      "cls_acc": 0.3376,
+      "n_params": 720,
+      "step_ms": 332
+    },
+    {
+      "step": 9,
+      "dim": 426,
+      "cls_acc": 0.3417,
+      "n_params": 800,
+      "step_ms": 318
+    },
+    {
+      "step": 10,
+      "dim": 723,
+      "cls_acc": 0.3442,
+      "n_params": 880,
+      "step_ms": 316
+    },
+    {
+      "step": 11,
+      "dim": 177,
+      "cls_acc": 0.3468,
+      "n_params": 960,
+      "step_ms": 347
+    },
+    {
+      "step": 12,
+      "dim": 11,
+      "cls_acc": 0.3495,
+      "n_params": 1040,
+      "step_ms": 336
+    },
+    {
+      "step": 13,
+      "dim": 465,
+      "cls_acc": 0.3517,
+      "n_params": 1120,
+      "step_ms": 319
+    },
+    {
+      "step": 14,
+      "dim": 555,
+      "cls_acc": 0.3539,
+      "n_params": 1200,
+      "step_ms": 318
+    },
+    {
+      "step": 15,
+      "dim": 52,
+      "cls_acc": 0.356,
+      "n_params": 1280,
+      "step_ms": 321
+    },
+    {
+      "step": 16,
+      "dim": 179,
+      "cls_acc": 0.3587,
+      "n_params": 1360,
+      "step_ms": 343
+    },
+    {
+      "step": 17,
+      "dim": 325,
+      "cls_acc": 0.3608,
+      "n_params": 1440,
+      "step_ms": 312
+    },
+    {
+      "step": 18,
+      "dim": 600,
+      "cls_acc": 0.363,
+      "n_params": 1520,
+      "step_ms": 322
+    },
+    {
+      "step": 19,
+      "dim": 738,
+      "cls_acc": 0.3649,
+      "n_params": 1600,
+      "step_ms": 331
+    },
+    {
+      "step": 20,
+      "dim": 389,
+      "cls_acc": 0.3659,
+      "n_params": 1680,
+      "step_ms": 313
+    },
+    {
+      "step": 21,
+      "dim": 660,
+      "cls_acc": 0.368,
+      "n_params": 1760,
+      "step_ms": 319
+    },
+    {
+      "step": 22,
+      "dim": 109,
+      "cls_acc": 0.3708,
+      "n_params": 1840,
+      "step_ms": 326
+    },
+    {
+      "step": 23,
+      "dim": 554,
+      "cls_acc": 0.3734,
+      "n_params": 1920,
+      "step_ms": 323
+    },
+    {
+      "step": 24,
+      "dim": 632,
+      "cls_acc": 0.3752,
+      "n_params": 2000,
+      "step_ms": 318
+    },
+    {
+      "step": 25,
+      "dim": 673,
+      "cls_acc": 0.3775,
+      "n_params": 2080,
+      "step_ms": 351
+    },
+    {
+      "step": 26,
+      "dim": 445,
+      "cls_acc": 0.3791,
+      "n_params": 2160,
+      "step_ms": 336
+    },
+    {
+      "step": 27,
+      "dim": 71,
+      "cls_acc": 0.3812,
+      "n_params": 2240,
+      "step_ms": 324
+    },
+    {
+      "step": 28,
+      "dim": 403,
+      "cls_acc": 0.3829,
+      "n_params": 2320,
+      "step_ms": 326
+    },
+    {
+      "step": 29,
+      "dim": 261,
+      "cls_acc": 0.3854,
+      "n_params": 2400,
+      "step_ms": 317
+    },
+    {
+      "step": 30,
+      "dim": 377,
+      "cls_acc": 0.3872,
+      "n_params": 2480,
+      "step_ms": 308
+    },
+    {
+      "step": 31,
+      "dim": 81,
+      "cls_acc": 0.389,
+      "n_params": 2560,
+      "step_ms": 334
+    },
+    {
+      "step": 32,
+      "dim": 21,
+      "cls_acc": 0.3909,
+      "n_params": 2640,
+      "step_ms": 398
+    },
+    {
+      "step": 33,
+      "dim": 289,
+      "cls_acc": 0.3928,
+      "n_params": 2720,
+      "step_ms": 404
+    },
+    {
+      "step": 34,
+      "dim": 23,
+      "cls_acc": 0.394,
+      "n_params": 2800,
+      "step_ms": 397
+    },
+    {
+      "step": 35,
+      "dim": 429,
+      "cls_acc": 0.3953,
+      "n_params": 2880,
+      "step_ms": 359
+    },
+    {
+      "step": 36,
+      "dim": 645,
+      "cls_acc": 0.3967,
+      "n_params": 2960,
+      "step_ms": 397
+    },
+    {
+      "step": 37,
+      "dim": 741,
+      "cls_acc": 0.3999,
+      "n_params": 3040,
+      "step_ms": 397
+    },
+    {
+      "step": 38,
+      "dim": 566,
+      "cls_acc": 0.403,
+      "n_params": 3120,
+      "step_ms": 381
+    },
+    {
+      "step": 39,
+      "dim": 231,
+      "cls_acc": 0.4063,
+      "n_params": 3200,
+      "step_ms": 397
+    },
+    {
+      "step": 40,
+      "dim": 357,
+      "cls_acc": 0.4088,
+      "n_params": 3280,
+      "step_ms": 361
+    },
+    {
+      "step": 41,
+      "dim": 573,
+      "cls_acc": 0.4117,
+      "n_params": 3360,
+      "step_ms": 388
+    },
+    {
+      "step": 42,
+      "dim": 597,
+      "cls_acc": 0.4137,
+      "n_params": 3440,
+      "step_ms": 383
+    },
+    {
+      "step": 43,
+      "dim": 263,
+      "cls_acc": 0.4159,
+      "n_params": 3520,
+      "step_ms": 365
+    },
+    {
+      "step": 44,
+      "dim": 28,
+      "cls_acc": 0.418,
+      "n_params": 3600,
+      "step_ms": 364
+    },
+    {
+      "step": 45,
+      "dim": 529,
+      "cls_acc": 0.4203,
+      "n_params": 3680,
+      "step_ms": 354
+    },
+    {
+      "step": 46,
+      "dim": 372,
+      "cls_acc": 0.4227,
+      "n_params": 3760,
+      "step_ms": 368
+    },
+    {
+      "step": 47,
+      "dim": 246,
+      "cls_acc": 0.4251,
+      "n_params": 3840,
+      "step_ms": 357
+    },
+    {
+      "step": 48,
+      "dim": 49,
+      "cls_acc": 0.4278,
+      "n_params": 3920,
+      "step_ms": 3306
+    },
+    {
+      "step": 49,
+      "dim": 219,
+      "cls_acc": 0.429,
+      "n_params": 4000,
+      "step_ms": 388
+    },
+    {
+      "step": 50,
+      "dim": 759,
+      "cls_acc": 0.4308,
+      "n_params": 4080,
+      "step_ms": 380
+    },
+    {
+      "step": 51,
+      "dim": 269,
+      "cls_acc": 0.4329,
+      "n_params": 4160,
+      "step_ms": 386
+    },
+    {
+      "step": 52,
+      "dim": 593,
+      "cls_acc": 0.4342,
+      "n_params": 4240,
+      "step_ms": 367
+    },
+    {
+      "step": 53,
+      "dim": 685,
+      "cls_acc": 0.4357,
+      "n_params": 4320,
+      "step_ms": 380
+    },
+    {
+      "step": 54,
+      "dim": 97,
+      "cls_acc": 0.4373,
+      "n_params": 4400,
+      "step_ms": 377
+    },
+    {
+      "step": 55,
+      "dim": 485,
+      "cls_acc": 0.4397,
+      "n_params": 4480,
+      "step_ms": 373
+    },
+    {
+      "step": 56,
+      "dim": 430,
+      "cls_acc": 0.441,
+      "n_params": 4560,
+      "step_ms": 365
+    },
+    {
+      "step": 57,
+      "dim": 234,
+      "cls_acc": 0.4431,
+      "n_params": 4640,
+      "step_ms": 346
+    },
+    {
+      "step": 58,
+      "dim": 297,
+      "cls_acc": 0.4452,
+      "n_params": 4720,
+      "step_ms": 374
+    },
+    {
+      "step": 59,
+      "dim": 666,
+      "cls_acc": 0.4468,
+      "n_params": 4800,
+      "step_ms": 387
+    },
+    {
+      "step": 60,
+      "dim": 32,
+      "cls_acc": 0.4484,
+      "n_params": 4880,
+      "step_ms": 393
+    },
+    {
+      "step": 61,
+      "dim": 198,
+      "cls_acc": 0.4503,
+      "n_params": 4960,
+      "step_ms": 429
+    },
+    {
+      "step": 62,
+      "dim": 384,
+      "cls_acc": 0.4519,
+      "n_params": 5040,
+      "step_ms": 446
+    },
+    {
+      "step": 63,
+      "dim": 523,
+      "cls_acc": 0.4537,
+      "n_params": 5120,
+      "step_ms": 418
+    },
+    {
+      "step": 64,
+      "dim": 292,
+      "cls_acc": 0.455,
+      "n_params": 5200,
+      "step_ms": 476
+    },
+    {
+      "step": 65,
+      "dim": 137,
+      "cls_acc": 0.4564,
+      "n_params": 5280,
+      "step_ms": 432
+    },
+    {
+      "step": 66,
+      "dim": 388,
+      "cls_acc": 0.458,
+      "n_params": 5360,
+      "step_ms": 432
+    },
+    {
+      "step": 67,
+      "dim": 364,
+      "cls_acc": 0.4596,
+      "n_params": 5440,
+      "step_ms": 445
+    },
+    {
+      "step": 68,
+      "dim": 506,
+      "cls_acc": 0.461,
+      "n_params": 5520,
+      "step_ms": 419
+    },
+    {
+      "step": 69,
+      "dim": 279,
+      "cls_acc": 0.4624,
+      "n_params": 5600,
+      "step_ms": 397
+    },
+    {
+      "step": 70,
+      "dim": 101,
+      "cls_acc": 0.464,
+      "n_params": 5680,
+      "step_ms": 385
+    },
+    {
+      "step": 71,
+      "dim": 171,
+      "cls_acc": 0.4658,
+      "n_params": 5760,
+      "step_ms": 395
+    },
+    {
+      "step": 72,
+      "dim": 649,
+      "cls_acc": 0.4679,
+      "n_params": 5840,
+      "step_ms": 408
+    },
+    {
+      "step": 73,
+      "dim": 259,
+      "cls_acc": 0.4696,
+      "n_params": 5920,
+      "step_ms": 373
+    },
+    {
+      "step": 74,
+      "dim": 293,
+      "cls_acc": 0.4719,
+      "n_params": 6000,
+      "step_ms": 403
+    },
+    {
+      "step": 75,
+      "dim": 425,
+      "cls_acc": 0.4736,
+      "n_params": 6080,
+      "step_ms": 405
+    },
+    {
+      "step": 76,
+      "dim": 576,
+      "cls_acc": 0.4746,
+      "n_params": 6160,
+      "step_ms": 367
+    },
+    {
+      "step": 77,
+      "dim": 144,
+      "cls_acc": 0.4758,
+      "n_params": 6240,
+      "step_ms": 382
+    },
+    {
+      "step": 78,
+      "dim": 183,
+      "cls_acc": 0.4771,
+      "n_params": 6320,
+      "step_ms": 372
+    },
+    {
+      "step": 79,
+      "dim": 359,
+      "cls_acc": 0.4788,
+      "n_params": 6400,
+      "step_ms": 382
+    },
+    {
+      "step": 80,
+      "dim": 437,
+      "cls_acc": 0.4804,
+      "n_params": 6480,
+      "step_ms": 383
+    },
+    {
+      "step": 81,
+      "dim": 763,
+      "cls_acc": 0.4816,
+      "n_params": 6560,
+      "step_ms": 363
+    },
+    {
+      "step": 82,
+      "dim": 540,
+      "cls_acc": 0.4832,
+      "n_params": 6640,
+      "step_ms": 384
+    },
+    {
+      "step": 83,
+      "dim": 335,
+      "cls_acc": 0.4846,
+      "n_params": 6720,
+      "step_ms": 382
+    },
+    {
+      "step": 84,
+      "dim": 302,
+      "cls_acc": 0.486,
+      "n_params": 6800,
+      "step_ms": 370
+    },
+    {
+      "step": 85,
+      "dim": 404,
+      "cls_acc": 0.4875,
+      "n_params": 6880,
+      "step_ms": 367
+    },
+    {
+      "step": 86,
+      "dim": 202,
+      "cls_acc": 0.4883,
+      "n_params": 6960,
+      "step_ms": 375
+    },
+    {
+      "step": 87,
+      "dim": 617,
+      "cls_acc": 0.4896,
+      "n_params": 7040,
+      "step_ms": 352
+    },
+    {
+      "step": 88,
+      "dim": 497,
+      "cls_acc": 0.4908,
+      "n_params": 7120,
+      "step_ms": 357
+    },
+    {
+      "step": 89,
+      "dim": 408,
+      "cls_acc": 0.492,
+      "n_params": 7200,
+      "step_ms": 388
+    },
+    {
+      "step": 90,
+      "dim": 410,
+      "cls_acc": 0.4934,
+      "n_params": 7280,
+      "step_ms": 378
+    },
+    {
+      "step": 91,
+      "dim": 340,
+      "cls_acc": 0.4944,
+      "n_params": 7360,
+      "step_ms": 378
+    },
+    {
+      "step": 92,
+      "dim": 15,
+      "cls_acc": 0.4956,
+      "n_params": 7440,
+      "step_ms": 383
+    },
+    {
+      "step": 93,
+      "dim": 714,
+      "cls_acc": 0.4971,
+      "n_params": 7520,
+      "step_ms": 378
+    },
+    {
+      "step": 94,
+      "dim": 693,
+      "cls_acc": 0.4987,
+      "n_params": 7600,
+      "step_ms": 378
+    },
+    {
+      "step": 95,
+      "dim": 277,
+      "cls_acc": 0.5001,
+      "n_params": 7680,
+      "step_ms": 346
+    },
+    {
+      "step": 96,
+      "dim": 466,
+      "cls_acc": 0.5012,
+      "n_params": 7760,
+      "step_ms": 384
+    },
+    {
+      "step": 97,
+      "dim": 102,
+      "cls_acc": 0.5025,
+      "n_params": 7840,
+      "step_ms": 396
+    },
+    {
+      "step": 98,
+      "dim": 681,
+      "cls_acc": 0.504,
+      "n_params": 7920,
+      "step_ms": 383
+    },
+    {
+      "step": 99,
+      "dim": 743,
+      "cls_acc": 0.5048,
+      "n_params": 8000,
+      "step_ms": 404
+    },
+    {
+      "step": 100,
+      "dim": 765,
+      "cls_acc": 0.5057,
+      "n_params": 8080,
+      "step_ms": 374
+    }
+  ],
+  "final_cls_acc": 0.5057,
+  "final_params": 8080,
+  "total_time_s": 39.8
+}

analytical/variants/v001_baseline.json

@@ -0,0 +1,23 @@
+{
+  "name": "v001_baseline",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "none",
+    "lam": 0.001,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "Control.",
+  "metrics": {
+    "cls_accuracy": 0.6427,
+    "precision": 0.0206,
+    "reg_quality": 0,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 65365,
+    "composite": 0.3265
+  },
+  "solve_time_ms": 12,
+  "eval_time_s": 10.4
+}

analytical/variants/v002_spatial_cat_mean3x3.json

@@ -0,0 +1,23 @@
+{
+  "name": "v002_spatial_cat_mean3x3",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "cat_mean3x3",
+    "lam": 0.001,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "Concatenate",
+  "metrics": {
+    "cls_accuracy": 0.7286,
+    "precision": 0.0206,
+    "reg_quality": 0.0221,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.375
+  },
+  "solve_time_ms": 47,
+  "eval_time_s": 18.8
+}

analytical/variants/v003_spatial_diff_neighbors.json

@@ -0,0 +1,23 @@
+{
+  "name": "v003_spatial_diff_neighbors",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "diff_neighbors",
+    "lam": 0.001,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "center",
+  "metrics": {
+    "cls_accuracy": 0.728,
+    "precision": 0.0206,
+    "reg_quality": 0.0217,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.3746
+  },
+  "solve_time_ms": 41,
+  "eval_time_s": 12.0
+}

analytical/variants/v004_spatial_highreg.json

@@ -0,0 +1,23 @@
+{
+  "name": "v004_spatial_highreg",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "cat_mean3x3",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "Same",
+  "metrics": {
+    "cls_accuracy": 0.7117,
+    "precision": 0.0206,
+    "reg_quality": 0.1327,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.3942
+  },
+  "solve_time_ms": 83,
+  "eval_time_s": 13.7
+}

analytical/variants/v004_spatial_highreg_v2.json

@@ -0,0 +1,23 @@
+{
+  "name": "v004_spatial_highreg_v2",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "cat_mean3x3",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "rerun",
+  "metrics": {
+    "cls_accuracy": 0.7117,
+    "precision": 0.0206,
+    "reg_quality": 0.6294,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.5183
+  },
+  "solve_time_ms": 67,
+  "eval_time_s": 10.4
+}

analytical/variants/v005_power05_spatial_highreg.json

@@ -0,0 +1,23 @@
+{
+  "name": "v005_power05_spatial_highreg",
+  "config": {
+    "transform": "power05",
+    "encoding": "log_ltrb",
+    "spatial": "cat_mean3x3",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "power",
+  "metrics": {
+    "cls_accuracy": 0.3066,
+    "precision": 0.0206,
+    "reg_quality": 0,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.1584
+  },
+  "solve_time_ms": 43,
+  "eval_time_s": 17.2
+}

analytical/variants/v006_hv_neighbors_highreg.json

@@ -0,0 +1,23 @@
+{
+  "name": "v006_hv_neighbors_highreg",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "hv_neighbors",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "center",
+  "metrics": {
+    "cls_accuracy": 0.7023,
+    "precision": 0.0206,
+    "reg_quality": 0.1395,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 195925,
+    "composite": 0.3912
+  },
+  "solve_time_ms": 248,
+  "eval_time_s": 13.9
+}

analytical/variants/v007_spatial_sqrt_highreg.json

@@ -0,0 +1,23 @@
+{
+  "name": "v007_spatial_sqrt_highreg",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "sqrt_ltrb",
+    "spatial": "cat_mean3x3",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "sqrt",
+  "metrics": {
+    "cls_accuracy": 0.7117,
+    "precision": 0.0206,
+    "reg_quality": 0.2461,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.4225
+  },
+  "solve_time_ms": 67,
+  "eval_time_s": 11.5
+}

analytical/variants/v008_spatial_neg3_highreg.json

@@ -0,0 +1,23 @@
+{
+  "name": "v008_spatial_neg3_highreg",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "cat_mean3x3",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "3:1",
+  "metrics": {
+    "cls_accuracy": 0.6985,
+    "precision": 0.0206,
+    "reg_quality": 0.6294,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 130645,
+    "composite": 0.5118
+  },
+  "solve_time_ms": 33,
+  "eval_time_s": 11.2
+}

analytical/variants/v009_sheaf_h1_compact.json

@@ -0,0 +1,23 @@
+{
+  "name": "v009_sheaf_h1_compact",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "sheaf_h1_compact",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "Cech",
+  "metrics": {
+    "cls_accuracy": 0.7426,
+    "precision": 0.0206,
+    "reg_quality": 0.6546,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 195925,
+    "composite": 0.5401
+  },
+  "solve_time_ms": 68,
+  "eval_time_s": 17.9
+}

analytical/variants/v010_sheaf_h1_full.json

@@ -0,0 +1,23 @@
+{
+  "name": "v010_sheaf_h1_full",
+  "config": {
+    "transform": "layernorm",
+    "encoding": "log_ltrb",
+    "spatial": "sheaf_h1",
+    "lam": 0.1,
+    "n_train": 10000,
+    "n_eval": 500
+  },
+  "notes": "full",
+  "metrics": {
+    "cls_accuracy": 0.6966,
+    "precision": 0.0206,
+    "reg_quality": 0.6374,
+    "n_detections": 1050000,
+    "n_positives": 21602,
+    "n_params": 326485,
+    "composite": 0.5128
+  },
+  "solve_time_ms": 370,
+  "eval_time_s": 23.2
+}

circuit/README.md

@@ -0,0 +1,55 @@
+# Circuit-Level Detection
+
+The cofiber threshold detection head expressed as synthesizable digital logic. All weights are analytically derived (zero gradient-based training) and stored as INT8 ROM.
+
+## Person Detector (Proof of Concept)
+
+Single-class (person) detector as a combinational circuit.
+
+- **Parameters**: 4,614 (4.6 KB INT8 ROM)
+- **Architecture**: 6 parallel dot products (1 cls + 4 reg + 1 ctr), each 768-dim
+- **Weights**: closed-form least-squares on 20K COCO training images
+- **Construction time**: 122 seconds, zero training steps
+
+### Gate Count (Yosys synthesis)
+
+Synthesized with Yosys (generic target, no FPGA mapping):
+
+| Component | Dims | Gates (16-dim measured) | Gates (768-dim extrapolated) |
+|-----------|------|------------------------|------------------------------|
+| 1 MAC unit | 768→1 | 1,358 | ~65K |
+| Person detector (6 MACs) | 768→{1,4,1} | — | ~391K |
+| Full 80-class detector (85 MACs) | 768→{80,4,1} | — | ~7.1M |
+
+### Files
+
+- `person_detector.sv` — SystemVerilog module, Icarus Verilog compatible
+- `tb_person.sv` — testbench
+- `cofiber_detector.sv` — full 80-class detector (SystemVerilog, parameterized)
+- `person_small_synth.v` — 16-dim reduced version for synthesis analysis
+- `rom/person_cls_w.hex` — classification weights (768 INT8)
+- `rom/person_reg_w.hex` — regression weights (4×768 INT8)
+- `rom/person_ctr_w.hex` — centerness weights (768 INT8)
+- `person_analytical.pth` — PyTorch checkpoint of the analytical solution
+
+### Simulation
+
+```bash
+iverilog -g2012 -o tb_person.vvp person_detector.sv tb_person.sv
+vvp tb_person.vvp
+```
+
+### Synthesis
+
+```bash
+yosys -p "read_verilog person_small_synth.v; synth -top person_detector_small; stat"
+```
+
+## Cofiber Decomposition
+
+The spatial decomposition (avg_pool → subtract → repeat) is a fixed filter bank with zero learned parameters. In hardware, it is:
+- Average pooling: 2×2 adder tree + arithmetic right shift
+- Cofiber extraction: subtractor (input − upsampled pool)
+- Fully combinational, no state
+
+The decomposition module (`cofiber_detector.sv`) implements all three scales for a 40×40 input grid.

circuit/circuit_variants.json

@@ -0,0 +1,489 @@
+[
+  {
+    "n_dims": 1,
+    "gates": 85,
+    "tp": 589,
+    "fp": 490,
+    "fn": 411,
+    "tn": 510,
+    "precision": 0.5459,
+    "recall": 0.589,
+    "f1": 0.5666,
+    "time_s": 1.3,
+    "dims": [
+      665
+    ]
+  },
+  {
+    "n_dims": 2,
+    "gates": 170,
+    "tp": 620,
+    "fp": 495,
+    "fn": 380,
+    "tn": 505,
+    "precision": 0.5561,
+    "recall": 0.62,
+    "f1": 0.5863,
+    "time_s": 0.1,
+    "dims": [
+      665,
+      642
+    ]
+  },
+  {
+    "n_dims": 3,
+    "gates": 255,
+    "tp": 667,
+    "fp": 516,
+    "fn": 333,
+    "tn": 484,
+    "precision": 0.5638,
+    "recall": 0.667,
+    "f1": 0.6111,
+    "time_s": 0.1,
+    "dims": [
+      665,
+      642,
+      200
+    ]
+  },
+  {
+    "n_dims": 5,
+    "gates": 425,
+    "tp": 665,
+    "fp": 513,
+    "fn": 335,
+    "tn": 487,
+    "precision": 0.5645,
+    "recall": 0.665,
+    "f1": 0.6107,
+    "time_s": 0.1,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498
+    ]
+  },
+  {
+    "n_dims": 8,
+    "gates": 680,
+    "tp": 691,
+    "fp": 512,
+    "fn": 309,
+    "tn": 488,
+    "precision": 0.5744,
+    "recall": 0.691,
+    "f1": 0.6273,
+    "time_s": 0.1,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562
+    ]
+  },
+  {
+    "n_dims": 10,
+    "gates": 850,
+    "tp": 693,
+    "fp": 513,
+    "fn": 307,
+    "tn": 487,
+    "precision": 0.5746,
+    "recall": 0.693,
+    "f1": 0.6283,
+    "time_s": 0.1,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723
+    ]
+  },
+  {
+    "n_dims": 15,
+    "gates": 1275,
+    "tp": 709,
+    "fp": 503,
+    "fn": 291,
+    "tn": 497,
+    "precision": 0.585,
+    "recall": 0.709,
+    "f1": 0.641,
+    "time_s": 0.1,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723,
+      177,
+      11,
+      465,
+      555,
+      52
+    ]
+  },
+  {
+    "n_dims": 20,
+    "gates": 1700,
+    "tp": 715,
+    "fp": 500,
+    "fn": 285,
+    "tn": 500,
+    "precision": 0.5885,
+    "recall": 0.715,
+    "f1": 0.6456,
+    "time_s": 0.2,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723,
+      177,
+      11,
+      465,
+      555,
+      52,
+      179,
+      325,
+      600,
+      738,
+      389
+    ]
+  },
+  {
+    "n_dims": 30,
+    "gates": 2550,
+    "tp": 737,
+    "fp": 521,
+    "fn": 263,
+    "tn": 479,
+    "precision": 0.5859,
+    "recall": 0.737,
+    "f1": 0.6528,
+    "time_s": 0.2,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723,
+      177,
+      11,
+      465,
+      555,
+      52,
+      179,
+      325,
+      600,
+      738,
+      389,
+      660,
+      109,
+      554,
+      632,
+      673,
+      445,
+      71,
+      403,
+      261,
+      377
+    ]
+  },
+  {
+    "n_dims": 50,
+    "gates": 4250,
+    "tp": 807,
+    "fp": 512,
+    "fn": 193,
+    "tn": 488,
+    "precision": 0.6118,
+    "recall": 0.807,
+    "f1": 0.696,
+    "time_s": 0.3,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723,
+      177,
+      11,
+      465,
+      555,
+      52,
+      179,
+      325,
+      600,
+      738,
+      389,
+      660,
+      109,
+      554,
+      632,
+      673,
+      445,
+      71,
+      403,
+      261,
+      377,
+      81,
+      21,
+      289,
+      23,
+      429,
+      645,
+      741,
+      566,
+      231,
+      357,
+      573,
+      597,
+      263,
+      28,
+      529,
+      372,
+      246,
+      49,
+      219,
+      759
+    ]
+  },
+  {
+    "n_dims": 75,
+    "gates": 6375,
+    "tp": 818,
+    "fp": 483,
+    "fn": 182,
+    "tn": 517,
+    "precision": 0.6287,
+    "recall": 0.818,
+    "f1": 0.711,
+    "time_s": 0.4,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723,
+      177,
+      11,
+      465,
+      555,
+      52,
+      179,
+      325,
+      600,
+      738,
+      389,
+      660,
+      109,
+      554,
+      632,
+      673,
+      445,
+      71,
+      403,
+      261,
+      377,
+      81,
+      21,
+      289,
+      23,
+      429,
+      645,
+      741,
+      566,
+      231,
+      357,
+      573,
+      597,
+      263,
+      28,
+      529,
+      372,
+      246,
+      49,
+      219,
+      759,
+      269,
+      593,
+      685,
+      97,
+      485,
+      430,
+      234,
+      297,
+      666,
+      32,
+      198,
+      384,
+      523,
+      292,
+      137,
+      388,
+      364,
+      506,
+      279,
+      101,
+      171,
+      649,
+      259,
+      293,
+      425
+    ]
+  },
+  {
+    "n_dims": 100,
+    "gates": 8500,
+    "tp": 831,
+    "fp": 451,
+    "fn": 169,
+    "tn": 549,
+    "precision": 0.6482,
+    "recall": 0.831,
+    "f1": 0.7283,
+    "time_s": 0.5,
+    "dims": [
+      665,
+      642,
+      200,
+      305,
+      498,
+      628,
+      67,
+      562,
+      426,
+      723,
+      177,
+      11,
+      465,
+      555,
+      52,
+      179,
+      325,
+      600,
+      738,
+      389,
+      660,
+      109,
+      554,
+      632,
+      673,
+      445,
+      71,
+      403,
+      261,
+      377,
+      81,
+      21,
+      289,
+      23,
+      429,
+      645,
+      741,
+      566,
+      231,
+      357,
+      573,
+      597,
+      263,
+      28,
+      529,
+      372,
+      246,
+      49,
+      219,
+      759,
+      269,
+      593,
+      685,
+      97,
+      485,
+      430,
+      234,
+      297,
+      666,
+      32,
+      198,
+      384,
+      523,
+      292,
+      137,
+      388,
+      364,
+      506,
+      279,
+      101,
+      171,
+      649,
+      259,
+      293,
+      425,
+      576,
+      144,
+      183,
+      359,
+      437,
+      763,
+      540,
+      335,
+      302,
+      404,
+      202,
+      617,
+      497,
+      408,
+      410,
+      340,
+      15,
+      714,
+      693,
+      277,
+      466,
+      102,
+      681,
+      743,
+      765
+    ]
+  }
+]

circuit/cofiber_detector.sv

@@ -0,0 +1,162 @@
+// Cofiber detection head — fully combinational per-token detector
+//
+// Input: 768 signed 8-bit feature values (one spatial token)
+// Output: 80 classification scores + 4 box regression values + 1 centerness
+//
+// All weights are ROM (analytically derived, zero training).
+// The cofiber decomposition and pooling happen upstream in the spatial
+// processing module — this module handles per-token prediction only.
+//
+// Parameters:
+//   FEAT_DIM    - feature dimension (768 for EUPE-ViT-B)
+//   NUM_CLASSES - detection classes (80 for COCO)
+//   BIT_WIDTH   - weight/activation precision
+
+module cofiber_detector #(
+    parameter FEAT_DIM    = 768,
+    parameter NUM_CLASSES = 80,
+    parameter BIT_WIDTH   = 8,
+    parameter ACC_WIDTH   = 24  // accumulator width for MAC results
+)(
+    input  logic signed [BIT_WIDTH-1:0] features [0:FEAT_DIM-1],
+    output logic signed [ACC_WIDTH-1:0] cls_scores [0:NUM_CLASSES-1],
+    output logic signed [ACC_WIDTH-1:0] box_ltrb [0:3],
+    output logic signed [ACC_WIDTH-1:0] centerness
+);
+
+    // Weight ROMs — loaded from analytical solution
+    logic signed [BIT_WIDTH-1:0] cls_weight [0:NUM_CLASSES-1][0:FEAT_DIM-1];
+    logic signed [BIT_WIDTH-1:0] cls_bias [0:NUM_CLASSES-1];
+    logic signed [BIT_WIDTH-1:0] reg_weight [0:3][0:FEAT_DIM-1];
+    logic signed [BIT_WIDTH-1:0] reg_bias [0:3];
+    logic signed [BIT_WIDTH-1:0] ctr_weight [0:FEAT_DIM-1];
+    logic signed [BIT_WIDTH-1:0] ctr_bias;
+
+    initial begin
+        $readmemh("rom/cls_weight.hex", cls_weight);
+        $readmemh("rom/cls_bias.hex", cls_bias);
+        $readmemh("rom/reg_out_weight.hex", reg_weight);
+        $readmemh("rom/reg_out_bias.hex", reg_bias);
+        $readmemh("rom/ctr_weight.hex", ctr_weight);
+        $readmemh("rom/ctr_bias.hex", ctr_bias);
+    end
+
+    // Classification: 80 parallel dot products
+    // cls_scores[c] = sum(features[d] * cls_weight[c][d]) + cls_bias[c]
+    genvar c, d;
+    generate
+        for (c = 0; c < NUM_CLASSES; c = c + 1) begin : cls_mac
+            logic signed [ACC_WIDTH-1:0] acc;
+            always_comb begin
+                acc = {{(ACC_WIDTH-BIT_WIDTH){cls_bias[c][BIT_WIDTH-1]}}, cls_bias[c]};
+                for (int dd = 0; dd < FEAT_DIM; dd = dd + 1) begin
+                    acc = acc + (features[dd] * cls_weight[c][dd]);
+                end
+                cls_scores[c] = acc;
+            end
+        end
+    endgenerate
+
+    // Box regression: 4 parallel dot products
+    generate
+        for (c = 0; c < 4; c = c + 1) begin : reg_mac
+            logic signed [ACC_WIDTH-1:0] acc;
+            always_comb begin
+                acc = {{(ACC_WIDTH-BIT_WIDTH){reg_bias[c][BIT_WIDTH-1]}}, reg_bias[c]};
+                for (int dd = 0; dd < FEAT_DIM; dd = dd + 1) begin
+                    acc = acc + (features[dd] * reg_weight[c][dd]);
+                end
+                box_ltrb[c] = acc;
+            end
+        end
+    endgenerate
+
+    // Centerness: 1 dot product
+    logic signed [ACC_WIDTH-1:0] ctr_acc;
+    always_comb begin
+        ctr_acc = {{(ACC_WIDTH-BIT_WIDTH){ctr_bias[BIT_WIDTH-1]}}, ctr_bias};
+        for (int dd = 0; dd < FEAT_DIM; dd = dd + 1) begin
+            ctr_acc = ctr_acc + (features[dd] * ctr_weight[dd]);
+        end
+        centerness = ctr_acc;
+    end
+
+endmodule
+
+
+// Cofiber spatial decomposition — operates on the full feature grid
+// Produces 3 scale bands from the input feature map
+module cofiber_decompose #(
+    parameter FEAT_DIM = 768,
+    parameter BIT_WIDTH = 8,
+    parameter H = 40,
+    parameter W = 40
+)(
+    input  logic signed [BIT_WIDTH-1:0] features [0:FEAT_DIM-1][0:H-1][0:W-1],
+    output logic signed [BIT_WIDTH-1:0] scale0 [0:FEAT_DIM-1][0:H-1][0:W-1],      // stride 16 cofiber
+    output logic signed [BIT_WIDTH-1:0] scale1 [0:FEAT_DIM-1][0:H/2-1][0:W/2-1],  // stride 32 cofiber
+    output logic signed [BIT_WIDTH-1:0] scale2 [0:FEAT_DIM-1][0:H/4-1][0:W/4-1]   // stride 64 residual
+);
+
+    // Intermediate: pooled features at half resolution
+    logic signed [BIT_WIDTH+1:0] pool0 [0:FEAT_DIM-1][0:H/2-1][0:W/2-1];
+    logic signed [BIT_WIDTH+1:0] pool1 [0:FEAT_DIM-1][0:H/4-1][0:W/4-1];
+
+    genvar ch, r, col;
+    generate
+        // Pool0: 2x2 average pool of input features
+        for (ch = 0; ch < FEAT_DIM; ch = ch + 1) begin : pool0_ch
+            for (r = 0; r < H/2; r = r + 1) begin : pool0_r
+                for (col = 0; col < W/2; col = col + 1) begin : pool0_c
+                    assign pool0[ch][r][col] = (features[ch][2*r][2*col]
+                                              + features[ch][2*r+1][2*col]
+                                              + features[ch][2*r][2*col+1]
+                                              + features[ch][2*r+1][2*col+1]) >>> 2;
+                end
+            end
+        end
+
+        // Scale0: cofiber = features - upsample(pool0)
+        // Nearest-neighbor upsample for exact integer arithmetic
+        for (ch = 0; ch < FEAT_DIM; ch = ch + 1) begin : s0_ch
+            for (r = 0; r < H; r = r + 1) begin : s0_r
+                for (col = 0; col < W; col = col + 1) begin : s0_c
+                    assign scale0[ch][r][col] = features[ch][r][col]
+                                              - pool0[ch][r/2][col/2][BIT_WIDTH-1:0];
+                end
+            end
+        end
+
+        // Pool1: 2x2 average pool of pool0
+        for (ch = 0; ch < FEAT_DIM; ch = ch + 1) begin : pool1_ch
+            for (r = 0; r < H/4; r = r + 1) begin : pool1_r
+                for (col = 0; col < W/4; col = col + 1) begin : pool1_c
+                    assign pool1[ch][r][col] = (pool0[ch][2*r][2*col]
+                                              + pool0[ch][2*r+1][2*col]
+                                              + pool0[ch][2*r][2*col+1]
+                                              + pool0[ch][2*r+1][2*col+1]) >>> 2;
+                end
+            end
+        end
+
+        // Scale1: cofiber of pool0
+        for (ch = 0; ch < FEAT_DIM; ch = ch + 1) begin : s1_ch
+            for (r = 0; r < H/2; r = r + 1) begin : s1_r
+                for (col = 0; col < W/2; col = col + 1) begin : s1_c
+                    assign scale1[ch][r][col] = pool0[ch][r][col][BIT_WIDTH-1:0]
+                                              - pool1[ch][r/2][col/2][BIT_WIDTH-1:0];
+                end
+            end
+        end
+
+        // Scale2: the low-frequency residual
+        for (ch = 0; ch < FEAT_DIM; ch = ch + 1) begin : s2_ch
+            for (r = 0; r < H/4; r = r + 1) begin : s2_r
+                for (col = 0; col < W/4; col = col + 1) begin : s2_c
+                    assign scale2[ch][r][col] = pool1[ch][r][col][BIT_WIDTH-1:0];
+                end
+            end
+        end
+    endgenerate
+
+endmodule

circuit/evolve_fast.py

@@ -0,0 +1,211 @@
+"""
+Fixed-K batched GPU evolution. All individuals have exactly K dims.
+
+Genome: (POP, K) int tensor — indices into 768 feature dims.
+Fitness: one batched torch.linalg.solve over (POP, K+1, K+1).
+Target: hundreds of gen/s.
+"""
+
+import json, os, sys, time
+import torch
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+REPO_ROOT = os.path.dirname(SCRIPT_DIR)
+VAL_TENSORS = os.path.join(REPO_ROOT, "analytical_stats_cache", "val_tensors_layernorm_500.pt")
+GREEDY_PATH = os.path.join(REPO_ROOT, "analytical_variants", "greedy_forward_gpu.json")
+PERSON_CLASS = 0
+DEVICE = "cuda"
+
+
+@torch.no_grad()
+def batch_fitness(features, is_person, pop_dims, lam=0.1):
+    """Evaluate entire population in one batched solve.
+
+    features: (N, 768)
+    is_person: (N,) bool
+    pop_dims: (POP, K) long — which dims each individual uses
+    Returns: (POP,) F1 scores
+    """
+    POP, K = pop_dims.shape
+    N = features.shape[0]
+
+    # Gather features for all individuals: (POP, N, K)
+    f_batch = features[:, :].unsqueeze(0).expand(POP, -1, -1)  # (POP, N, 768)
+    idx = pop_dims.unsqueeze(1).expand(-1, N, -1)  # (POP, N, K)
+    f_sub = torch.gather(f_batch, 2, idx)  # (POP, N, K)
+
+    # Augment with bias column: (POP, N, K+1)
+    ones = torch.ones(POP, N, 1, device=DEVICE)
+    fa = torch.cat([f_sub, ones], dim=2)
+
+    # XtX: (POP, K+1, K+1) = fa^T @ fa
+    XtX = torch.bmm(fa.transpose(1, 2), fa)
+
+    # Regularize
+    I = torch.eye(K + 1, device=DEVICE).unsqueeze(0).expand(POP, -1, -1)
+    XtX = XtX + lam * I * N
+
+    # XtY: (POP, K+1, 1) = fa^T @ y
+    y = is_person.float().unsqueeze(0).unsqueeze(2).expand(POP, -1, -1)  # (POP, N, 1)
+    XtY = torch.bmm(fa.transpose(1, 2), y)
+
+    # Batched solve: (POP, K+1, 1)
+    try:
+        W = torch.linalg.solve(XtX, XtY)
+    except Exception:
+        return torch.zeros(POP, device=DEVICE)
+
+    # Predict: (POP, N, 1)
+    scores = torch.bmm(fa, W)
+    pred = scores.squeeze(2) > 0.5  # (POP, N)
+
+    # F1 per individual
+    is_p = is_person.unsqueeze(0).expand(POP, -1)
+    tp = (pred & is_p).sum(dim=1).float()
+    fp = (pred & ~is_p).sum(dim=1).float()
+    fn = (~pred & is_p).sum(dim=1).float()
+    prec = tp / (tp + fp).clamp(min=1)
+    rec = tp / (tp + fn).clamp(min=1)
+    f1 = 2 * prec * rec / (prec + rec).clamp(min=1e-9)
+    return f1
+
+
+def main():
+    print("=" * 60)
+    print("Fixed-K Batched GPU Evolution")
+    print("=" * 60, flush=True)
+
+    val = torch.load(VAL_TENSORS, map_location="cpu", weights_only=False)
+    features = val["features"]
+    is_person = (val["cls_targets"] == PERSON_CLASS)
+
+    pos_idx = is_person.nonzero(as_tuple=True)[0]
+    neg_idx = (~is_person).nonzero(as_tuple=True)[0]
+    n_take = min(2000, len(pos_idx))
+    sel = torch.cat([pos_idx[torch.randperm(len(pos_idx))[:n_take]],
+                     neg_idx[torch.randperm(len(neg_idx))[:n_take]]])
+    sel = sel[torch.randperm(len(sel))]
+    sub_f = features[sel].to(DEVICE)
+    sub_person = is_person[sel].to(DEVICE)
+    N = len(sel)
+    print(f"  {N} vectors on {DEVICE}", flush=True)
+
+    greedy_dims = list(range(100))
+    if os.path.isfile(GREEDY_PATH):
+        with open(GREEDY_PATH) as f:
+            greedy_dims = json.load(f)["selected_dims"]
+
+    POP = 512
+    GEN = 5000
+    ELITE = 30
+    TARGETS = [10, 20, 50, 100, 200]
+
+    all_results = []
+
+    for K in TARGETS:
+        print(f"\n{'='*60}")
+        print(f"  K={K} dims | pop={POP} | gen={GEN}")
+        print(f"{'='*60}", flush=True)
+        t0 = time.time()
+
+        # Initialize population: (POP, K) long tensors
+        pop = torch.zeros(POP, K, dtype=torch.long, device=DEVICE)
+
+        # Seed 0: greedy
+        g = greedy_dims[:K] if K <= len(greedy_dims) else greedy_dims + list(range(K - len(greedy_dims)))
+        pop[0] = torch.tensor(g[:K], device=DEVICE)
+
+        # Rest: random K-subsets of 768
+        for i in range(1, POP):
+            pop[i] = torch.randperm(768, device=DEVICE)[:K]
+
+        fits = batch_fitness(sub_f, sub_person, pop)
+        best_f1 = fits.max().item()
+        best_genome = pop[fits.argmax()].clone()
+        stag = 0
+
+        for gen in range(GEN):
+            # Sort
+            order = fits.argsort(descending=True)
+            pop = pop[order]
+            fits = fits[order]
+
+            if fits[0].item() > best_f1:
+                best_f1 = fits[0].item()
+                best_genome = pop[0].clone()
+                stag = 0
+            else:
+                stag += 1
+
+            # New population
+            new_pop = pop[:ELITE].clone()
+
+            # Immigration
+            n_imm = POP // 5 if stag > 200 else 0
+            if n_imm > 0:
+                imm = torch.stack([torch.randperm(768, device=DEVICE)[:K] for _ in range(n_imm)])
+                new_pop = torch.cat([new_pop, imm])
+
+            # Breed
+            n_breed = POP - new_pop.shape[0]
+            # Tournament selection
+            t1 = torch.randint(0, POP // 2, (n_breed, 5), device=DEVICE)
+            p1_idx = t1[torch.arange(n_breed, device=DEVICE), fits[t1].argmax(dim=1)]
+            t2 = torch.randint(0, POP // 2, (n_breed, 5), device=DEVICE)
+            p2_idx = t2[torch.arange(n_breed, device=DEVICE), fits[t2].argmax(dim=1)]
+
+            parents1 = pop[p1_idx]  # (n_breed, K)
+            parents2 = pop[p2_idx]
+
+            # Crossover: for each position, pick from parent1 or parent2
+            mask = torch.rand(n_breed, K, device=DEVICE) < 0.5
+            children = torch.where(mask, parents1, parents2)
+
+            # Mutation: replace random positions with random dims
+            mut_rate = 0.05 * (1 + stag / 100)
+            mut_mask = torch.rand(n_breed, K, device=DEVICE) < mut_rate
+            random_dims = torch.randint(0, 768, (n_breed, K), device=DEVICE)
+            children = torch.where(mut_mask, random_dims, children)
+
+            new_pop = torch.cat([new_pop, children])[:POP]
+            pop = new_pop
+            fits = batch_fitness(sub_f, sub_person, pop)
+
+            if (gen + 1) % 100 == 0:
+                elapsed = time.time() - t0
+                gen_s = (gen + 1) / elapsed
+                print(f"  gen {gen+1:5d}: best={fits.max().item():.4f} "
+                      f"best_ever={best_f1:.4f} stag={stag} "
+                      f"{gen_s:.0f} gen/s", flush=True)
+
+            if stag > 1000:
+                print(f"  Converged at gen {gen+1}")
+                break
+
+        elapsed = time.time() - t0
+        best_dims = best_genome.cpu().tolist()
+        gates = K * 85
+        gens_done = gen + 1
+        print(f"\n  WINNER: {K} dims, F1={best_f1:.4f}, {gates} gates, "
+              f"{elapsed:.1f}s, {gens_done/elapsed:.0f} gen/s", flush=True)
+
+        all_results.append({
+            "K": K, "best_f1": round(best_f1, 4), "genome": sorted(best_dims),
+            "gates": gates, "time_s": round(elapsed, 1),
+            "generations": gens_done, "gen_per_s": round(gens_done / elapsed),
+        })
+
+    print(f"\n{'='*60}")
+    print("Results:")
+    for r in all_results:
+        print(f"  K={r['K']:3d}  {r['gates']:6d} gates  F1={r['best_f1']:.4f}  "
+              f"{r['gen_per_s']} gen/s  ({r['generations']} gen, {r['time_s']}s)")
+
+    out = os.path.join(SCRIPT_DIR, "evolved_extreme.json")
+    with open(out, "w") as f:
+        json.dump(all_results, f, indent=2)
+    print(f"Saved: {out}")
+
+
+if __name__ == "__main__":
+    main()

circuit/evolved_K100_person_eval.json

@@ -0,0 +1,9 @@
+{
+  "head": "evolved_K100_person",
+  "dims": 92,
+  "gates": 7820,
+  "training": "zero (evolved analytical)",
+  "mAP_person": 0.0132,
+  "mAP50_person": 0.0577,
+  "mAP75_person": 0.0011
+}

circuit/evolved_extreme.json

@@ -0,0 +1,453 @@
+[
+  {
+    "K": 10,
+    "best_f1": 0.7605,
+    "genome": [
+      48,
+      83,
+      101,
+      157,
+      224,
+      365,
+      379,
+      428,
+      517,
+      525
+    ],
+    "gates": 850,
+    "time_s": 15.3,
+    "generations": 1529,
+    "gen_per_s": 100
+  },
+  {
+    "K": 20,
+    "best_f1": 0.7746,
+    "genome": [
+      48,
+      65,
+      74,
+      90,
+      112,
+      116,
+      117,
+      140,
+      224,
+      338,
+      379,
+      453,
+      511,
+      517,
+      518,
+      525,
+      566,
+      595,
+      641,
+      645
+    ],
+    "gates": 1700,
+    "time_s": 14.8,
+    "generations": 1052,
+    "gen_per_s": 71
+  },
+  {
+    "K": 50,
+    "best_f1": 0.8009,
+    "genome": [
+      12,
+      48,
+      62,
+      74,
+      101,
+      116,
+      126,
+      149,
+      157,
+      182,
+      200,
+      215,
+      224,
+      240,
+      244,
+      267,
+      276,
+      282,
+      298,
+      319,
+      329,
+      331,
+      338,
+      349,
+      359,
+      364,
+      368,
+      379,
+      454,
+      467,
+      468,
+      503,
+      510,
+      512,
+      517,
+      525,
+      556,
+      560,
+      569,
+      590,
+      608,
+      627,
+      634,
+      635,
+      656,
+      678,
+      679,
+      715,
+      729,
+      756
+    ],
+    "gates": 4250,
+    "time_s": 21.9,
+    "generations": 1159,
+    "gen_per_s": 53
+  },
+  {
+    "K": 100,
+    "best_f1": 0.823,
+    "genome": [
+      17,
+      18,
+      33,
+      48,
+      56,
+      59,
+      62,
+      63,
+      64,
+      70,
+      70,
+      77,
+      80,
+      90,
+      92,
+      95,
+      104,
+      113,
+      116,
+      130,
+      141,
+      154,
+      154,
+      157,
+      167,
+      177,
+      178,
+      182,
+      209,
+      210,
+      224,
+      250,
+      253,
+      256,
+      257,
+      259,
+      260,
+      260,
+      266,
+      276,
+      282,
+      298,
+      299,
+      306,
+      324,
+      329,
+      335,
+      338,
+      359,
+      359,
+      362,
+      365,
+      379,
+      385,
+      385,
+      392,
+      397,
+      404,
+      408,
+      418,
+      423,
+      428,
+      466,
+      467,
+      478,
+      507,
+      510,
+      517,
+      517,
+      527,
+      533,
+      560,
+      564,
+      569,
+      569,
+      577,
+      598,
+      608,
+      614,
+      618,
+      619,
+      635,
+      636,
+      645,
+      650,
+      656,
+      664,
+      679,
+      687,
+      691,
+      697,
+      706,
+      709,
+      709,
+      715,
+      729,
+      741,
+      754,
+      756,
+      766
+    ],
+    "gates": 8500,
+    "time_s": 33.3,
+    "generations": 1134,
+    "gen_per_s": 34
+  },
+  {
+    "K": 200,
+    "best_f1": 0.8317,
+    "genome": [
+      4,
+      7,
+      8,
+      12,
+      13,
+      14,
+      17,
+      20,
+      21,
+      22,
+      25,
+      28,
+      30,
+      32,
+      37,
+      38,
+      45,
+      48,
+      49,
+      50,
+      55,
+      62,
+      69,
+      71,
+      74,
+      80,
+      80,
+      81,
+      89,
+      92,
+      94,
+      100,
+      102,
+      104,
+      106,
+      107,
+      110,
+      112,
+      113,
+      130,
+      133,
+      135,
+      135,
+      137,
+      138,
+      138,
+      143,
+      143,
+      147,
+      149,
+      154,
+      163,
+      171,
+      177,
+      183,
+      189,
+      193,
+      197,
+      205,
+      206,
+      209,
+      210,
+      217,
+      217,
+      224,
+      226,
+      226,
+      231,
+      247,
+      253,
+      254,
+      256,
+      257,
+      259,
+      260,
+      260,
+      266,
+      267,
+      276,
+      276,
+      278,
+      282,
+      296,
+      297,
+      299,
+      300,
+      302,
+      305,
+      306,
+      307,
+      308,
+      320,
+      322,
+      327,
+      329,
+      337,
+      337,
+      338,
+      338,
+      345,
+      346,
+      357,
+      359,
+      365,
+      365,
+      366,
+      376,
+      379,
+      379,
+      379,
+      383,
+      385,
+      392,
+      397,
+      414,
+      415,
+      419,
+      420,
+      424,
+      428,
+      428,
+      435,
+      435,
+      445,
+      447,
+      448,
+      449,
+      454,
+      462,
+      476,
+      482,
+      500,
+      505,
+      510,
+      517,
+      519,
+      522,
+      522,
+      523,
+      525,
+      527,
+      528,
+      531,
+      535,
+      541,
+      546,
+      549,
+      553,
+      558,
+      560,
+      562,
+      563,
+      566,
+      574,
+      583,
+      584,
+      587,
+      591,
+      597,
+      598,
+      602,
+      603,
+      614,
+      616,
+      616,
+      619,
+      629,
+      630,
+      636,
+      641,
+      644,
+      645,
+      650,
+      654,
+      656,
+      657,
+      657,
+      667,
+      671,
+      679,
+      690,
+      699,
+      709,
+      710,
+      713,
+      713,
+      717,
+      718,
+      721,
+      722,
+      731,
+      733,
+      741,
+      742,
+      748,
+      750,
+      751,
+      755,
+      757,
+      764
+    ],
+    "gates": 17000,
+    "time_s": 66.5,
+    "generations": 1159,
+    "gen_per_s": 17
+  },
+  {
+    "K": 300,
+    "best_f1": 0.8445,
+    "genome": [],
+    "gates": 25500,
+    "time_s": 220
+  },
+  {
+    "K": 400,
+    "best_f1": 0.8435,
+    "genome": [],
+    "gates": 34000,
+    "time_s": 350
+  },
+  {
+    "K": 500,
+    "best_f1": 0.8458,
+    "genome": [],
+    "gates": 42500,
+    "time_s": 398
+  }
+]

circuit/person_analytical.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65728b60610a3fc166386e46af9205b645ccfca08dfdf44c3b8d76aee0c3b5eb
+size 20795

circuit/person_detector.sv

@@ -0,0 +1,62 @@
+// Single-class person detector — Icarus Verilog compatible
+// All weights from analytical least-squares. Zero training. 4,614 bytes INT8.
+
+module person_detector #(
+    parameter FEAT_DIM = 768,
+    parameter BIT_WIDTH = 8,
+    parameter ACC_WIDTH = 24
+)(
+    input  wire signed [BIT_WIDTH-1:0] features [0:FEAT_DIM-1],
+    output wire signed [ACC_WIDTH-1:0] person_score,
+    output wire signed [ACC_WIDTH-1:0] box_ltrb [0:3],
+    output wire signed [ACC_WIDTH-1:0] centerness,
+    output wire detection
+);
+
+    reg signed [BIT_WIDTH-1:0] cls_w [0:FEAT_DIM-1];
+    reg signed [BIT_WIDTH-1:0] reg_w [0:4*FEAT_DIM-1];
+    reg signed [BIT_WIDTH-1:0] ctr_w [0:FEAT_DIM-1];
+
+    initial begin
+        $readmemh("rom/person_cls_w.hex", cls_w);
+        $readmemh("rom/person_reg_w.hex", reg_w);
+        $readmemh("rom/person_ctr_w.hex", ctr_w);
+    end
+
+    // Classification: sum(features[d] * cls_w[d])
+    reg signed [ACC_WIDTH-1:0] cls_acc;
+    integer ci;
+    always @(*) begin
+        cls_acc = 0;
+        for (ci = 0; ci < FEAT_DIM; ci = ci + 1)
+            cls_acc = cls_acc + features[ci] * cls_w[ci];
+    end
+    assign person_score = cls_acc;
+    assign detection = (cls_acc > 0);
+
+    // Box regression: 4 dot products
+    reg signed [ACC_WIDTH-1:0] reg_acc [0:3];
+    integer ri, rj;
+    always @(*) begin
+        for (ri = 0; ri < 4; ri = ri + 1) begin
+            reg_acc[ri] = 0;
+            for (rj = 0; rj < FEAT_DIM; rj = rj + 1)
+                reg_acc[ri] = reg_acc[ri] + features[rj] * reg_w[ri * FEAT_DIM + rj];
+        end
+    end
+    assign box_ltrb[0] = reg_acc[0];
+    assign box_ltrb[1] = reg_acc[1];
+    assign box_ltrb[2] = reg_acc[2];
+    assign box_ltrb[3] = reg_acc[3];
+
+    // Centerness: sum(features[d] * ctr_w[d])
+    reg signed [ACC_WIDTH-1:0] ctr_acc;
+    integer cti;
+    always @(*) begin
+        ctr_acc = 0;
+        for (cti = 0; cti < FEAT_DIM; cti = cti + 1)
+            ctr_acc = ctr_acc + features[cti] * ctr_w[cti];
+    end
+    assign centerness = ctr_acc;
+
+endmodule

circuit/person_small_synth.v

@@ -0,0 +1,85 @@
+// Reduced person detector for synthesis — pure Verilog-2005
+// FEAT_DIM=16, single MAC for classification
+// Extrapolate: full 768-dim = 48x this gate count
+
+module person_detector_small (
+    input  wire [127:0] features,  // 16 x 8-bit packed
+    output wire [23:0] person_score,
+    output wire detection
+);
+
+    // Hardcoded INT8 weights (from analytical solution, first 16 dims)
+    wire signed [7:0] feat [0:15];
+    wire signed [7:0] w [0:15];
+
+    // Unpack features
+    assign feat[0]  = features[7:0];
+    assign feat[1]  = features[15:8];
+    assign feat[2]  = features[23:16];
+    assign feat[3]  = features[31:24];
+    assign feat[4]  = features[39:32];
+    assign feat[5]  = features[47:40];
+    assign feat[6]  = features[55:48];
+    assign feat[7]  = features[63:56];
+    assign feat[8]  = features[71:64];
+    assign feat[9]  = features[79:72];
+    assign feat[10] = features[87:80];
+    assign feat[11] = features[95:88];
+    assign feat[12] = features[103:96];
+    assign feat[13] = features[111:104];
+    assign feat[14] = features[119:112];
+    assign feat[15] = features[127:120];
+
+    // Weights as constants
+    assign w[0]  = 8'sd10;  assign w[1]  = -8'sd5;
+    assign w[2]  = 8'sd3;   assign w[3]  = 8'sd7;
+    assign w[4]  = -8'sd2;  assign w[5]  = 8'sd12;
+    assign w[6]  = 8'sd1;   assign w[7]  = -8'sd8;
+    assign w[8]  = 8'sd4;   assign w[9]  = 8'sd6;
+    assign w[10] = -8'sd3;  assign w[11] = 8'sd9;
+    assign w[12] = 8'sd2;   assign w[13] = -8'sd1;
+    assign w[14] = 8'sd5;   assign w[15] = 8'sd3;
+
+    // 16 parallel multiplies
+    wire signed [15:0] prod [0:15];
+    assign prod[0]  = feat[0]  * w[0];
+    assign prod[1]  = feat[1]  * w[1];
+    assign prod[2]  = feat[2]  * w[2];
+    assign prod[3]  = feat[3]  * w[3];
+    assign prod[4]  = feat[4]  * w[4];
+    assign prod[5]  = feat[5]  * w[5];
+    assign prod[6]  = feat[6]  * w[6];
+    assign prod[7]  = feat[7]  * w[7];
+    assign prod[8]  = feat[8]  * w[8];
+    assign prod[9]  = feat[9]  * w[9];
+    assign prod[10] = feat[10] * w[10];
+    assign prod[11] = feat[11] * w[11];
+    assign prod[12] = feat[12] * w[12];
+    assign prod[13] = feat[13] * w[13];
+    assign prod[14] = feat[14] * w[14];
+    assign prod[15] = feat[15] * w[15];
+
+    // Adder tree
+    wire signed [16:0] s0_0 = prod[0]  + prod[1];
+    wire signed [16:0] s0_1 = prod[2]  + prod[3];
+    wire signed [16:0] s0_2 = prod[4]  + prod[5];
+    wire signed [16:0] s0_3 = prod[6]  + prod[7];
+    wire signed [16:0] s0_4 = prod[8]  + prod[9];
+    wire signed [16:0] s0_5 = prod[10] + prod[11];
+    wire signed [16:0] s0_6 = prod[12] + prod[13];
+    wire signed [16:0] s0_7 = prod[14] + prod[15];
+
+    wire signed [17:0] s1_0 = s0_0 + s0_1;
+    wire signed [17:0] s1_1 = s0_2 + s0_3;
+    wire signed [17:0] s1_2 = s0_4 + s0_5;
+    wire signed [17:0] s1_3 = s0_6 + s0_7;
+
+    wire signed [18:0] s2_0 = s1_0 + s1_1;
+    wire signed [18:0] s2_1 = s1_2 + s1_3;
+
+    wire signed [19:0] total = s2_0 + s2_1;
+
+    assign person_score = {{4{total[19]}}, total};
+    assign detection = ~total[19];  // positive = detection
+
+endmodule

circuit/rom/person_cls_b.hex

@@ -0,0 +1 @@
+7f

circuit/rom/person_cls_w.hex

@@ -0,0 +1,768 @@
+ed
+0c
+f0
+0c
+02
+17
+fe
+00
+fb
+fc
+f4
+05
+03
+0b
+0f
+fb
+01
+ff
+f5
+07
+08
+01
+10
+22
+f7
+05
+0c
+07
+04
+06
+0a
+ff
+11
+f1
+f5
+05
+ff
+17
+f7
+f6
+f0
+ee
+0c
+f0
+dc
+1b
+10
+f4
+0c
+03
+e8
+f6
+16
+14
+f9
+1b
+09
+0a
+04
+ee
+0b
+0f
+32
+fb
+f8
+13
+01
+ef
+eb
+05
+fe
+f4
+05
+ed
+07
+e7
+f4
+25
+11
+12
+fc
+07
+0b
+0f
+e0
+f4
+fd
+0f
+f4
+08
+f4
+0e
+ed
+e3
+10
+1f
+06
+ef
+eb
+e7
+f0
+03
+21
+02
+fc
+0b
+12
+0e
+17
+03
+0c
+06
+f8
+ef
+f5
+f3
+14
+f9
+0b
+fb
+18
+02
+13
+09
+fd
+fd
+fa
+15
+fd
+e7
+f2
+fa
+1e
+ff
+04
+07
+ef
+f0
+0c
+ed
+fd
+f5
+fe
+01
+fe
+18
+fb
+1c
+f5
+e9
+fc
+06
+15
+f3
+ff
+11
+0f
+1a
+02
+f6
+ff
+fd
+fd
+ef
+0b
+11
+1b
+ef
+fc
+fe
+fd
+f9
+1d
+f6
+f0
+e3
+12
+05
+16
+fc
+01
+fd
+f2
+ef
+06
+06
+f9
+f6
+fc
+f8
+fa
+0e
+18
+f2
+04
+f4
+ff
+09
+1f
+f2
+e1
+01
+ef
+16
+10
+20
+0a
+14
+f0
+f8
+e8
+02
+0c
+fe
+28
+14
+eb
+0b
+f5
+fc
+0a
+09
+0e
+0b
+f9
+08
+fa
+ee
+06
+fa
+fb
+ff
+e7
+fd
+05
+d6
+03
+fe
+fe
+f8
+01
+01
+ee
+ef
+0a
+11
+f7
+1a
+e8
+f8
+fe
+f9
+14
+00
+03
+11
+fc
+f5
+f9
+19
+ef
+12
+04
+08
+0a
+0a
+17
+fd
+08
+08
+f4
+06
+0e
+ed
+17
+04
+0e
+fc
+f2
+05
+fc
+f3
+10
+e7
+f5
+f1
+ff
+fc
+e9
+eb
+09
+ff
+05
+05
+f3
+08
+03
+04
+fb
+1a
+0f
+f3
+e6
+1b
+04
+07
+1f
+19
+0e
+01
+f5
+f4
+fa
+fc
+ff
+eb
+01
+06
+04
+07
+03
+06
+fb
+01
+12
+0d
+04
+ed
+18
+0f
+f6
+f0
+0b
+f4
+14
+fd
+04
+ff
+fa
+f0
+09
+f9
+f9
+09
+17
+11
+f7
+02
+01
+03
+06
+11
+ff
+fd
+ff
+eb
+05
+07
+f0
+ed
+21
+0d
+0e
+11
+f5
+02
+fc
+f1
+e4
+ed
+fa
+06
+ee
+11
+00
+fb
+fb
+ee
+e5
+eb
+e7
+13
+15
+f3
+f9
+e2
+06
+f7
+fe
+f6
+f1
+fd
+f1
+f6
+0a
+09
+10
+f0
+ef
+0b
+fc
+22
+16
+f8
+06
+fc
+07
+f9
+fc
+ea
+0d
+02
+f9
+f5
+f5
+26
+ed
+07
+fc
+ff
+1d
+f0
+1d
+01
+fa
+07
+da
+ef
+df
+09
+13
+03
+f7
+08
+03
+03
+18
+e3
+d6
+0c
+fe
+08
+08
+01
+19
+22
+0b
+fa
+0f
+e7
+18
+00
+18
+f0
+ff
+11
+16
+f4
+fe
+ff
+02
+09
+03
+e9
+02
+e5
+ee
+fe
+f2
+ec
+12
+09
+fc
+f3
+11
+09
+03
+e9
+14
+04
+fd
+fd
+0e
+05
+e8
+f7
+02
+ea
+10
+fd
+08
+1b
+13
+ee
+0d
+3b
+1c
+17
+f7
+11
+fe
+f7
+fa
+f9
+e1
+f5
+ef
+0a
+fb
+f6
+f9
+fb
+f8
+ff
+00
+f5
+f6
+00
+1a
+ef
+a2
+fc
+03
+f6
+fa
+0d
+fb
+11
+ef
+15
+e5
+eb
+fe
+f5
+03
+06
+fa
+fa
+05
+f2
+0b
+f1
+00
+d9
+fd
+00
+10
+03
+0a
+e0
+18
+f6
+10
+f9
+fc
+05
+0a
+fc
+fa
+ef
+f8
+ee
+ef
+0e
+f6
+14
+08
+fd
+0d
+e8
+07
+0d
+ef
+0d
+0d
+1d
+ff
+e5
+fe
+f5
+fe
+f9
+f6
+f7
+f9
+1b
+15
+f5
+14
+f3
+f5
+fb
+08
+00
+f9
+07
+fe
+0c
+fb
+04
+01
+fd
+1e
+ff
+01
+04
+02
+fd
+07
+f3
+05
+10
+f6
+06
+7f
+f9
+18
+10
+fc
+0f
+ed
+fd
+ec
+f5
+0a
+10
+06
+14
+0d
+15
+07
+13
+f5
+fd
+0e
+0c
+0b
+00
+d6
+e7
+f7
+09
+ff
+0e
+e5
+05
+e2
+1a
+01
+ea
+0a
+ed
+fa
+fa
+ea
+16
+04
+f1
+eb
+00
+f2
+f9
+07
+fb
+f2
+f9
+0d
+06
+04
+0d
+02
+f1
+f5
+18
+19
+01
+07
+02
+f9
+fc
+01
+f6
+00
+fd
+f3
+04
+f9
+f5
+fe
+01
+f5
+fa
+ff
+01
+df
+04
+0a
+e3
+0a
+ff
+fd
+01
+eb
+f5
+f0
+02
+09
+fc
+e6
+f8
+ff
+02
+ef
+09
+11
+fa
+b1
+15
+02
+f5
+09
+0c
+ff
+fc
+f9
+ff
+00
+f1
+f1
+fc
+fa
+f0
+ec
+1a
+08
+08
+03
+0a
+08
+e1
+08
+10
+15
+fc
+f0
+fb
+f5
+04
+f9
+fd
+fb
+ff
+ed
+1f
+e7
+00
+0d
+fa
+09
+07
+00
+f1
+02
+0e
+10
+fa
+03
+f5

circuit/rom/person_ctr_b.hex

@@ -0,0 +1 @@
+7f

circuit/rom/person_ctr_w.hex

@@ -0,0 +1,768 @@
+f2
+08
+fa
+24
+1c
+ee
+13
+ef
+2d
+f1
+ff
+f3
+e6
+ee
+ea
+09
+fe
+fd
+f2
+1a
+e4
+f1
+12
+ee
+fc
+e9
+1f
+10
+f1
+05
+da
+f0
+ed
+ee
+16
+29
+00
+13
+f5
+fc
+05
+f6
+f9
+dc
+22
+39
+15
+e5
+ed
+f4
+22
+f1
+15
+06
+03
+d1
+28
+fa
+22
+f6
+0f
+18
+1e
+df
+f4
+fd
+07
+1d
+d8
+11
+e3
+ed
+07
+fa
+03
+f8
+e8
+22
+ea
+ec
+f4
+fc
+1c
+ee
+d3
+e7
+11
+df
+01
+1f
+dd
+00
+fa
+d0
+ed
+14
+05
+fe
+08
+10
+f7
+c1
+23
+eb
+0f
+e1
+fc
+12
+f4
+ed
+1a
+e4
+24
+22
+07
+ed
+02
+0d
+fd
+36
+ef
+f8
+fd
+ef
+f3
+e6
+03
+0e
+f5
+02
+17
+eb
+fe
+06
+f1
+28
+d7
+1e
+0f
+fc
+d0
+0d
+e5
+f9
+fe
+07
+f3
+fb
+11
+f8
+0f
+07
+0b
+e8
+0c
+f6
+e4
+06
+0a
+03
+46
+16
+b4
+f2
+ed
+fb
+f0
+f8
+2d
+15
+23
+f7
+07
+fb
+0d
+f3
+f2
+15
+0d
+ef
+00
+17
+0f
+12
+3b
+17
+f9
+e4
+f5
+13
+d5
+05
+20
+02
+0e
+ec
+e0
+26
+fe
+04
+06
+f2
+fc
+20
+fe
+22
+e7
+1d
+f9
+e6
+f1
+04
+19
+14
+34
+fb
+07
+ef
+d2
+14
+e3
+18
+ec
+ef
+fd
+19
+f0
+1e
+0a
+30
+f4
+e9
+e3
+03
+0e
+eb
+fe
+f4
+fa
+fd
+f0
+f4
+e8
+03
+ca
+19
+e1
+f2
+b5
+f6
+10
+ff
+fc
+08
+19
+27
+02
+fb
+f0
+15
+da
+0a
+0c
+e3
+fe
+03
+eb
+f3
+15
+1c
+ca
+11
+fd
+d9
+08
+f9
+f9
+34
+da
+f0
+0d
+1e
+42
+0f
+f7
+d1
+39
+0d
+30
+f6
+11
+fe
+08
+d1
+fc
+07
+e0
+19
+f3
+fd
+fa
+d8
+07
+2f
+10
+26
+10
+1b
+10
+0b
+0e
+0a
+0e
+f2
+f2
+cf
+12
+fb
+f3
+eb
+f5
+29
+2a
+ec
+ea
+14
+01
+06
+e4
+03
+f9
+d0
+d5
+1d
+0a
+eb
+0e
+e3
+e2
+15
+f2
+f5
+fb
+43
+21
+e0
+e2
+dd
+fe
+2f
+0e
+e3
+f8
+fd
+e8
+05
+0c
+de
+f7
+07
+17
+02
+1d
+0c
+03
+29
+de
+d3
+0d
+c7
+f7
+0f
+12
+08
+2d
+ea
+14
+01
+e4
+11
+fe
+ee
+e9
+e0
+f8
+10
+27
+ed
+22
+00
+ce
+0a
+15
+0f
+de
+0e
+f8
+1a
+de
+1a
+17
+fa
+24
+fc
+07
+d6
+f3
+fc
+fe
+0a
+f6
+ea
+e5
+f3
+05
+0f
+f2
+cb
+e9
+d4
+28
+0d
+17
+dd
+0b
+0a
+db
+ec
+15
+f8
+2e
+f3
+df
+1a
+02
+db
+21
+f5
+d7
+fe
+fd
+dc
+e9
+12
+cd
+15
+ee
+f7
+28
+fa
+12
+14
+20
+f6
+d3
+17
+3c
+05
+07
+2a
+cc
+d8
+24
+02
+10
+ed
+d1
+cc
+f8
+ea
+fb
+ee
+eb
+00
+0b
+f4
+f3
+ef
+2b
+29
+cb
+25
+1e
+06
+1a
+df
+0b
+1c
+ea
+08
+e6
+fd
+1d
+f9
+11
+18
+f6
+fa
+f3
+0e
+1a
+f4
+0a
+13
+25
+e2
+21
+d0
+fb
+d9
+fa
+e8
+0d
+fd
+08
+0b
+28
+14
+ea
+16
+ae
+34
+3c
+df
+03
+fc
+1a
+ef
+f7
+09
+df
+07
+ef
+f2
+0e
+f8
+e0
+f5
+f4
+f5
+29
+e6
+0a
+09
+ec
+ff
+28
+fd
+18
+bf
+28
+da
+ee
+04
+ff
+24
+1f
+ef
+fa
+1a
+ea
+f0
+fe
+3a
+ec
+02
+fb
+0a
+08
+13
+27
+f0
+01
+48
+16
+02
+e6
+fe
+f8
+09
+c9
+18
+01
+f5
+22
+f5
+1e
+e7
+28
+f1
+f8
+f7
+19
+e4
+00
+fa
+09
+11
+f4
+00
+fc
+ff
+fe
+f7
+03
+18
+00
+10
+f5
+d6
+26
+f2
+e7
+04
+7f
+f2
+06
+17
+ed
+0f
+f4
+e9
+f9
+ee
+00
+07
+d7
+1a
+0d
+37
+f2
+25
+f5
+0f
+17
+1a
+ef
+f6
+f9
+e8
+0c
+fb
+0e
+24
+ea
+f9
+10
+11
+09
+cb
+01
+fb
+cf
+0a
+f1
+02
+13
+e4
+f6
+28
+08
+35
+2a
+ff
+f5
+1a
+1a
+f4
+08
+fb
+de
+08
+e0
+f9
+ea
+0d
+25
+0e
+ee
+fb
+ff
+09
+0a
+24
+f8
+0f
+0c
+f7
+10
+06
+0e
+d9
+1e
+09
+35
+e9
+fe
+00
+05
+ee
+0e
+0a
+0d
+2a
+33
+fb
+0e
+d5
+ee
+36
+ee
+1c
+da
+0e
+04
+10
+e2
+ff
+e6
+0c
+20
+de
+1e
+0b
+ff
+0e
+e5
+0b
+e6
+ef
+fb
+ed
+15
+19
+ee
+f8
+0c
+f8
+34
+0e
+0e
+e2
+1d
+e5
+ed
+fb
+f2
+07
+09
+f1
+02
+f7
+eb
+ef
+e8
+f4
+f7
+e6
+fb
+e9
+e8
+1e
+fd
+0d
+d2
+00
+fe
+fb

circuit/rom/person_reg_b.hex

@@ -0,0 +1,4 @@
+6e
+7f
+6e
+7f

circuit/rom/person_reg_w.hex

@@ -0,0 +1,3072 @@
+11
+05
+ee
+47
+1b
+d6
+f4
+e9
+25
+fd
+e3
+ee
+ee
+03
+02
+f7
+fd
+e9
+02
+04
+04
+0d
+0c
+d7
+ef
+f4
+21
+fd
+c4
+12
+e9
+e3
+cd
+e4
+45
+2e
+e8
+2c
+ff
+d6
+03
+e7
+27
+ef
+30
+48
+fc
+f9
+e0
+fd
+ed
+cf
+0b
+19
+fb
+f4
+08
+df
+30
+1b
+2b
+18
+f4
+ce
+de
+0e
+f5
+14
+dd
+01
+c2
+d5
+ee
+f6
+04
+03
+fb
+24
+d0
+17
+0b
+06
+2d
+e6
+c1
+e8
+4c
+fa
+08
+29
+fa
+06
+e8
+be
+05
+04
+1e
+18
+00
+22
+e5
+c5
+f2
+e4
+12
+da
+e9
+18
+f6
+0e
+15
+e5
+09
+08
+13
+e0
+0a
+02
+c2
+15
+ea
+fe
+f5
+e9
+f4
+fc
+2f
+30
+d5
+22
+14
+bd
+06
+1a
+11
+2e
+c1
+33
+10
+d6
+c7
+07
+d1
+e8
+e4
+0d
+04
+e1
+2d
+0e
+23
+fd
+31
+da
+00
+dc
+c0
+f8
+0d
+03
+23
+09
+ee
+a8
+db
+07
+eb
+fc
+28
+14
+08
+d2
+01
+16
+09
+f5
+e0
+1e
+17
+09
+03
+15
+0d
+0f
+3b
+20
+e6
+de
+03
+14
+d2
+ed
+0c
+fe
+e7
+e4
+d5
+09
+fc
+22
+06
+0e
+f2
+1f
+02
+f4
+f4
+17
+fb
+e9
+15
+f9
+20
+0e
+32
+f9
+e3
+fc
+e9
+10
+de
+f7
+f8
+f0
+f7
+2b
+eb
+3a
+28
+2d
+fe
+e6
+f1
+ea
+e0
+08
+08
+11
+23
+0a
+0b
+eb
+fa
+0b
+cb
+02
+d5
+f5
+a1
+04
+21
+02
+f7
+06
+3e
+1c
+e2
+c4
+fa
+0a
+02
+07
+01
+01
+ef
+11
+ec
+fb
+23
+03
+bc
+07
+e1
+de
+0c
+e9
+02
+17
+b8
+cb
+01
+13
+3e
+e4
+fd
+d4
+e1
+1c
+22
+f8
+04
+13
+0b
+c5
+fe
+03
+04
+25
+cb
+11
+03
+e9
+04
+18
+0d
+fb
+f9
+0f
+1c
+02
+e4
+e5
+cd
+07
+eb
+ed
+04
+e3
+ee
+f3
+f0
+23
+6b
+cc
+d1
+15
+f3
+dd
+ed
+0e
+e1
+da
+da
+0d
+0c
+fb
+04
+05
+e9
+28
+de
+03
+f8
+38
+22
+df
+e1
+e0
+d8
+36
+00
+d3
+ef
+04
+0a
+01
+42
+26
+fc
+11
+0b
+0f
+06
+28
+e9
+16
+02
+c9
+ff
+eb
+ee
+23
+ef
+17
+18
+dc
+14
+d9
+e6
+1a
+07
+c6
+e2
+e1
+06
+12
+22
+e8
+1d
+10
+c9
+2f
+0e
+dc
+c2
+45
+16
+11
+ff
+30
+1f
+08
+08
+ee
+09
+e1
+e9
+24
+ec
+07
+06
+06
+09
+f6
+22
+09
+0e
+e1
+f0
+f6
+49
+0e
+13
+15
+0c
+03
+f1
+fb
+01
+fd
+37
+e8
+d0
+0b
+05
+be
+1e
+17
+dd
+24
+06
+d6
+ed
+15
+fc
+08
+d7
+d4
+31
+d5
+0d
+06
+12
+04
+be
+13
+42
+f3
+14
+2b
+bc
+bf
+17
+ec
+f2
+e4
+d2
+ce
+e4
+ef
+f6
+fa
+0a
+0c
+09
+fb
+18
+06
+19
+02
+cb
+07
+1d
+18
+30
+08
+17
+1f
+f6
+21
+e3
+3f
+21
+f0
+01
+08
+1c
+f4
+f8
+04
+f2
+13
+f6
+1f
+23
+ce
+36
+db
+e8
+c8
+fa
+dd
+09
+19
+10
+05
+16
+0a
+12
+fc
+98
+25
+41
+f9
+03
+f9
+0f
+04
+fe
+0f
+c6
+06
+08
+ef
+1d
+0b
+cb
+0b
+0d
+e1
+3d
+f4
+f3
+14
+fb
+0f
+3a
+f7
+24
+d2
+26
+c5
+02
+20
+fe
+26
+35
+f2
+ed
+26
+f4
+cb
+09
+16
+03
+ef
+fd
+11
+00
+10
+3e
+02
+07
+46
+21
+3e
+dc
+e8
+00
+ed
+bb
+16
+ee
+d7
+24
+e7
+1c
+f8
+50
+0a
+f2
+09
+16
+f1
+19
+c4
+25
+1e
+e5
+12
+f4
+24
+16
+02
+ff
+31
+fc
+f7
+05
+ee
+1f
+35
+cc
+03
+76
+f1
+2b
+36
+e7
+f7
+e7
+eb
+15
+e3
+e7
+1c
+ea
+22
+2b
+3a
+0e
+05
+f1
+fb
+17
+2f
+0c
+f3
+f4
+e0
+1b
+05
+09
+09
+01
+04
+08
+23
+fd
+03
+16
+07
+d9
+12
+ea
+ff
+15
+dd
+f6
+1f
+1d
+27
+02
+f3
+ff
+0b
+09
+08
+e7
+db
+c5
+ea
+03
+ed
+e6
+ff
+d1
+e4
+e2
+fb
+ff
+0b
+38
+05
+01
+1d
+0c
+0a
+2b
+22
+18
+df
+14
+f5
+0b
+ec
+e7
+f0
+00
+e1
+09
+f1
+13
+2a
+20
+f8
+20
+cd
+04
+31
+fa
+0f
+c7
+1a
+12
+20
+f8
+de
+f2
+34
+2b
+e6
+21
+fd
+0a
+31
+16
+f7
+14
+f6
+f6
+f9
+39
+3d
+1c
+fd
+fb
+f8
+29
+06
+f8
+ff
+0a
+de
+f4
+ee
+de
+16
+e5
+d5
+04
+ff
+ed
+d3
+e9
+ff
+00
+f3
+cc
+f8
+dd
+f4
+29
+fa
+d0
+0a
+02
+13
+07
+f4
+e8
+47
+2e
+f0
+0b
+eb
+2f
+e5
+ed
+fe
+e7
+f2
+05
+f9
+ff
+04
+18
+e6
+f9
+16
+16
+e5
+e4
+ed
+3d
+21
+cf
+24
+e0
+05
+dd
+fc
+1e
+14
+0a
+f0
+02
+d1
+21
+d5
+0e
+ef
+1c
+2a
+28
+f9
+ed
+0a
+e5
+e2
+21
+11
+fc
+09
+0e
+f8
+1d
+0f
+1e
+1d
+08
+df
+e4
+1b
+df
+04
+de
+0c
+ca
+e0
+e9
+0d
+ff
+f5
+f7
+44
+cd
+01
+1f
+f4
+1c
+c8
+d9
+d2
+32
+03
+00
+1b
+fa
+f6
+ec
+df
+14
+0c
+16
+1c
+f9
+0f
+cd
+eb
+ee
+e1
+fc
+dc
+e8
+0e
+10
+f9
+21
+f4
+fa
+f8
+0d
+de
+1f
+07
+df
+1b
+ec
+fa
+03
+fc
+07
+fb
+05
+26
+0b
+d1
+0b
+d3
+29
+0d
+f2
+20
+b8
+28
+04
+c4
+de
+10
+e3
+00
+ee
+09
+09
+ec
+1a
+fd
+37
+0f
+24
+e5
+10
+19
+bd
+f2
+0f
+02
+35
+f2
+f6
+29
+f8
+ec
+fb
+f5
+22
+02
+01
+f1
+09
+f8
+f1
+dc
+07
+1c
+2a
+fa
+10
+14
+f4
+05
+45
+26
+e6
+f4
+ff
+19
+c9
+da
+0a
+05
+12
+dd
+f9
+f4
+24
+fb
+04
+13
+03
+54
+09
+14
+19
+1e
+01
+d0
+1a
+f2
+44
+08
+38
+2f
+f9
+03
+e5
+09
+da
+ff
+e8
+fb
+f8
+14
+e3
+12
+0e
+11
+ff
+f0
+e7
+01
+fe
+db
+f0
+1e
+21
+1e
+05
+e7
+e9
+03
+fd
+01
+ef
+10
+dc
+00
+19
+13
+e7
+15
+07
+36
+fc
+d9
+ff
+0f
+fa
+01
+05
+3e
+06
+01
+0e
+ed
+1f
+00
+d4
+e7
+ee
+ce
+eb
+e5
+01
+1d
+c5
+df
+2c
+08
+15
+dd
+e9
+01
+f6
+20
+fa
+d5
+0a
+13
+ef
+cc
+f4
+fd
+0d
+26
+e8
+13
+fe
+dd
+fc
+13
+eb
+10
+0a
+0e
+10
+13
+f1
+11
+e6
+e0
+f0
+e5
+0d
+d2
+f6
+12
+ec
+2e
+2d
+cf
+ec
+f8
+ff
+fc
+eb
+fd
+e1
+ef
+ed
+05
+06
+ff
+df
+0b
+ec
+13
+e6
+03
+ff
+32
+17
+eb
+f3
+ef
+e7
+29
+f2
+e6
+ea
+fa
+ee
+ed
+18
+13
+0c
+0a
+18
+1c
+19
+1a
+e5
+22
+07
+dd
+10
+d4
+02
+2b
+db
+20
+27
+de
+10
+c8
+e9
+03
+18
+e4
+fe
+e7
+13
+00
+33
+ed
+07
+ff
+d8
+f7
+05
+d1
+dc
+26
+0d
+f8
+06
+36
+01
+13
+16
+05
+15
+f0
+e1
+03
+09
+ed
+15
+ef
+0b
+dd
+1e
+0a
+f7
+e1
+dd
+ec
+36
+fe
+27
+02
+e3
+0e
+d5
+f8
+14
+f5
+09
+e9
+f3
+1a
+e3
+da
+23
+fd
+d4
+3e
+12
+dd
+d7
+0f
+da
+08
+df
+ef
+24
+da
+16
+18
+15
+f5
+b8
+1d
+3f
+06
+1a
+18
+da
+d4
+0c
+f6
+26
+d1
+de
+f9
+e6
+f2
+f8
+fe
+14
+0d
+0f
+01
+04
+fb
+23
+1c
+de
+01
+0d
+10
+22
+f9
+07
+25
+cb
+0a
+ea
+0f
+03
+f3
+05
+56
+39
+14
+fd
+16
+1c
+03
+00
+04
+ef
+cd
+1a
+c3
+01
+bc
+ea
+ed
+0f
+16
+00
+f6
+f8
+2e
+26
+10
+a1
+24
+45
+0c
+fa
+02
+fb
+1c
+01
+17
+e0
+0c
+fb
+eb
+02
+f1
+e9
+12
+e9
+e0
+22
+eb
+f9
+fb
+12
+0b
+22
+f8
+11
+ee
+16
+d9
+eb
+1c
+eb
+1a
+36
+db
+cb
+24
+01
+07
+f9
+0a
+32
+fb
+f2
+10
+10
+f6
+15
+e8
+f6
+45
+2b
+20
+da
+a9
+e0
+f9
+c7
+02
+e9
+00
+27
+fe
+31
+fb
+39
+da
+f3
+12
+21
+f0
+01
+e9
+13
+19
+e8
+08
+e5
+fb
+24
+ef
+03
+0d
+f5
+f2
+0b
+fc
+10
+35
+d0
+f9
+7f
+04
+34
+32
+e5
+ec
+0c
+f1
+fa
+e6
+f9
+2b
+f8
+f4
+3f
+31
+fc
+22
+ea
+ff
+06
+2e
+04
+f6
+09
+dc
+0b
+fe
+f8
+0b
+f1
+00
+2d
+36
+dc
+f9
+fe
+fa
+de
+17
+f2
+0c
+11
+e3
+17
+0b
+0d
+fc
+09
+ee
+03
+07
+14
+0b
+ed
+0e
+d2
+fa
+d6
+11
+d8
+fc
+0c
+fb
+cf
+e9
+ea
+06
+16
+18
+f8
+14
+00
+d8
+01
+1c
+07
+df
+01
+f0
+ed
+14
+f3
+da
+ff
+e2
+fe
+09
+24
+45
+16
+fc
+00
+df
+f2
+1b
+f6
+10
+d0
+23
+20
+21
+9d
+ef
+fe
+02
+0c
+ea
+14
+09
+15
+1f
+25
+d8
+19
+0d
+e8
+04
+f3
+2e
+02
+f9
+f2
+f5
+1a
+e3
+e9
+d6
+02
+ee
+02
+f9
+e9
+2f
+ed
+ca
+0b
+01
+19
+11
+ea
+ef
+26
+e2
+ef
+f4
+fb
+e5
+f0
+1e
+e6
+05
+f9
+00
+fa
+09
+fb
+2a
+22
+fe
+fc
+1d
+11
+fc
+e9
+da
+f7
+02
+f2
+f0
+d7
+f1
+07
+0b
+0d
+04
+0d
+bf
+f2
+ee
+3d
+12
+e1
+2a
+e2
+d3
+e3
+f1
+0d
+11
+e4
+e9
+01
+f1
+16
+e0
+0a
+db
+1e
+41
+14
+ef
+e4
+04
+07
+d4
+01
+f2
+19
+fd
+20
+d5
+29
+19
+0f
+0c
+08
+da
+d9
+0e
+e9
+f7
+d8
+27
+f0
+e9
+e7
+ff
+1a
+f5
+d1
+42
+c9
+ef
+12
+f6
+1c
+c1
+da
+eb
+30
+ec
+f8
+39
+fc
+d8
+ec
+c1
+01
+1d
+18
+27
+fa
+21
+fc
+e8
+f7
+f1
+06
+db
+ea
+2e
+ea
+02
+06
+d7
+fa
+09
+10
+fc
+17
+0a
+ed
+26
+eb
+e5
+0c
+f2
+ff
+f9
+0d
+12
+11
+f7
+0e
+bb
+22
+1a
+ce
+2b
+be
+08
+11
+d1
+ea
+1f
+02
+f0
+fe
+fc
+12
+f7
+1c
+1b
+09
+06
+04
+da
+04
+f6
+c5
+ff
+fe
+01
+50
+24
+bd
+21
+e2
+07
+f8
+13
+1e
+fd
+f2
+0d
+fb
+18
+0a
+e1
+01
+22
+08
+11
+20
+16
+12
+23
+40
+28
+f1
+e8
+fd
+15
+e4
+e8
+03
+0d
+1f
+ea
+d7
+11
+03
+21
+f2
+18
+00
+1e
+0b
+3b
+03
+0f
+f8
+e2
+10
+0c
+24
+fe
+38
+0c
+ef
+0c
+d4
+40
+dc
+1e
+e1
+f6
+f4
+15
+ec
+1e
+2c
+1f
+08
+de
+e5
+08
+f8
+e1
+01
+13
+02
+f5
+09
+10
+f6
+05
+e0
+0a
+dc
+04
+db
+f8
+27
+03
+ea
+01
+e4
+2f
+e5
+e7
+ff
+19
+f3
+df
+0f
+38
+ff
+05
+07
+e0
+06
+02
+cb
+fb
+ec
+fd
+18
+f5
+e4
+36
+ec
+f1
+f9
+08
+27
+dc
+0b
+e5
+3f
+17
+fd
+fb
+08
+04
+f0
+cc
+fd
+01
+0e
+2b
+db
+23
+f7
+e4
+f0
+06
+06
+02
+1c
+04
+1c
+26
+e6
+03
+fd
+f2
+d2
+e0
+10
+fe
+ef
+12
+f6
+29
+33
+d8
+d7
+f6
+03
+0a
+cf
+13
+e7
+ca
+da
+18
+ef
+00
+24
+0b
+f6
+20
+e4
+fa
+f1
+3b
+1e
+d4
+d7
+ec
+d7
+28
+0f
+e4
+f5
+18
+e4
+19
+fd
+df
+03
+1a
+1a
+0c
+13
+09
+e3
+25
+25
+e8
+17
+d5
+f9
+fe
+f9
+17
+34
+d4
+0c
+e0
+0a
+2a
+03
+da
+e0
+e5
+12
+08
+67
+d1
+24
+00
+ef
+13
+0e
+cf
+c8
+29
+03
+0f
+f5
+1f
+1f
+f3
+06
+d9
+00
+de
+fc
+05
+1d
+e1
+f4
+f0
+01
+fc
+23
+2a
+0c
+cf
+d8
+e0
+21
+fb
+19
+ed
+f3
+13
+c2
+06
+0b
+f6
+24
+fb
+f7
+21
+f0
+d0
+22
+21
+b8
+27
+0a
+ca
+d8
+0e
+c9
+06
+ef
+e0
+3f
+e2
+21
+13
+28
+13
+dd
+36
+4d
+ee
+20
+28
+c1
+da
+fa
+0a
+fd
+d6
+d7
+df
+f0
+de
+f8
+ea
+fc
+16
+f1
+f7
+fb
+fc
+ee
+08
+aa
+01
+1d
+f7
+29
+e1
+21
+2b
+f2
+11
+e0
+1e
+f8
+f6
+f0
+06
+05
+18
+12
+18
+04
+e6
+f5
+13
+25
+ce
+35
+c1
+01
+d6
+f0
+e0
+07
+0f
+18
+f2
+fd
+2c
+00
+fb
+9d
+2f
+3b
+fe
+fa
+04
+0a
+fb
+01
+1e
+ee
+09
+0e
+09
+fa
+f3
+df
+0e
+b5
+f1
+52
+dc
+ff
+28
+1f
+fd
+35
+fc
+21
+f4
+19
+c6
+f1
+0a
+ef
+09
+22
+f5
+f9
+20
+04
+e5
+0c
+3a
+05
+0c
+ff
+14
+1a
+15
+1e
+e5
+fd
+5c
+f9
+c6
+e5
+dc
+e8
+00
+bb
+0a
+e8
+e0
+24
+f1
+04
+ff
+48
+e7
+f7
+f6
+0c
+0e
+ec
+e1
+19
+17
+fe
+02
+f9
+f0
+0a
+f1
+2a
+0b
+d3
+00
+f0
+fd
+05
+1c
+df
+fe
+62
+f6
+1a
+2a
+fa
+f5
+10
+de
+02
+c3
+05
+16
+02
+06
+45
+2e
+03
+fe
+e3
+f3
+fe
+03
+0e
+f5
+0b
+01
+04
+08
+0c
+11
+ff
+02
+f2
+11
+ff
+dc
+fc
+fc
+d6
+02
+f7
+09
+0a
+e2
+ed
+13
+07
+18
+24
+f6
+eb
+fb
+1e
+1b
+ea
+fd
+c3
+f7
+de
+fe
+00
+fb
+3d
+01
+d5
+e7
+e9
+fc
+c9
+05
+eb
+f2
+26
+d3
+2f
+2b
+21
+fd
+0f
+fe
+15
+06
+1a
+f3
+e1
+db
+06
+05
+1c
+47
+22
+fd
+16
+ea
+05
+2d
+07
+2a
+d1
+22
+0b
+0a
+e7
+00
+f8
+1f
+37
+d6
+1c
+08
+08
+3f
+94
+f8
+1a
+0c
+fa
+d1
+17
+0b
+de
+07
+0d
+0e
+19
+10
+ec
+f4
+14
+d9
+04
+f7
+de
+13
+fb
+eb
+03
+f8
+02
+28
+ff
+06
+22
+f6
+cc
+f0
+f0
+06
+b8
+0b
+e5
+0e
+0b
+31
+26
+11
+d5
+30
+17
+d0
+23
+f9
+1e
+06
+df
+03
+ed
+f9
+fa
+ef
+ef
+00
+ec
+e1
+0f
+0e
+05
+c4
+f2
+ed
+34
+30
+c5
+18
+e3
+01
+cd
+df
+1e
+11
+f6
+ff
+08
+d4
+18
+df
+16
+f7
+17
+26
+23
+d4
+de
+f0
+07
+d4
+ee
+0a
+25
+1c
+12
+ed
+20
+f9
+29
+21
+01
+cc
+f5
+09
+f5
+18
+f6
+0e
+cd
+ce
+e8
+f1
+07
+dd
+e1
+22
+e3
+0d
+00
+0b
+24
+ba
+ce
+f3
+11
+f6
+fa
+fe
+0b
+dc
+e1
+bb
+08
+0e
+1a
+0d
+06
+18
+dc
+e6
+2c
+d4
+0a
+c7
+f2
+18
+00
+16
+1e
+d2
+10
+d9
+13
+e5
+18
+f2
+f4
+35
+ff
+fe
+f3
+02
+da
+f1
+1c
+0c
+ff
+f2
+0e
+e2
+20
+0e
+fb
+f7
+d1
+24
+24
+cf
+dc
+0b
+ff
+eb
+e9
+02
+db
+dd
+09
+0b
+20
+15
+1f
+e7
+26
+fe
+c2
+04
+0d
+10
+11
+e4
+f4
+9e
+01
+fb
+e0
+27
+14
+0e
+fb
+fa
+0b
+02
+ee
+f1
+fc
+07
+23
+00
+25
+00
+f4
+fc
+4b
+1a
+d5
+fe
+fe
+19
+c6
+d7
+16
+07
+1b
+f6
+de
+f2
+05
+10
+ee
+05
+02
+26
+ef
+54
+f7
+27
+fa
+d5
+1b
+ea
+2d
+01
+34
+1d
+ee
+fb
+ec
+10
+d8
+f8
+d9
+04
+f7
+28
+f5
+1d
+24
+2f
+fb
+e7
+d7
+0c
+0a
+f6
+e1
+fe
+1d
+0a
+11
+09
+e1
+ec
+f3
+1b
+ec
+04
+af
+10
+13
+0c
+e1
+f3
+0d
+28
+f1
+e8
+16
+35
+e5
+f6
+ec
+01
+02
+0c
+fa
+fe
+0e
+f2
+c7
+f1
+fc
+e4
+ff
+09
+c0
+17
+e9
+cb
+17
+1d
+3a
+e1
+e8
+ea
+19
+0d
+10
+f0
+12
+15
+08
+e2
+fa
+f4
+1d
+1a
+da
+06
+f4
+d1
+f7
+19
+f4
+01
+01
+1e
+18
+0c
+d9
+13
+e0
+03
+e7
+cd
+19
+e0
+fe
+fa
+e2
+2c
+6c
+da
+04
+fa
+e7
+00
+ce
+fc
+0c
+f2
+d4
+08
+f4
+fe
+03
+20
+fa
+13
+fb
+0f
+1c
+21
+3d
+f1
+f1
+e4
+e9
+2e
+e9
+eb
+e4
+e6
+d4
+f2
+04
+0e
+08
+f4
+04
+1b
+35
+1c
+d1
+1b
+1b
+0e
+13
+d3
+f6
+20
+05
+12
+2e
+da
+2c
+c3
+0b
+0c
+03
+dd
+d6
+dc
+06
+fd
+49
+f2
+21
+01
+d0
+2a
+11
+c8
+d9
+16
+f5
+10
+f7
+36
+07
+10
+00
+fa
+1e
+e1
+d8
+1b
+1b
+f6
+f3
+fb
+21
+d9
+2d
+03
+24
+e1
+eb
+d8
+16
+03
+14
+f7
+0c
+1c
+bc
+e6
+00
+eb
+28
+09
+e5
+29
+02
+ce
+02
+27
+cf
+1f
+11
+dc
+d3
+12
+d8
+0c
+ea
+cf
+2d
+d9
+03
+1f
+1e
+f7
+c1
+1b
+2c
+08
+20
+22
+dc
+bd
+19
+e5
+ff
+ec
+cd
+cf
+f4
+f7
+fd
+ed
+fc
+13
+04
+f9
+f6
+f1
+1e
+0f
+e2
+01
+fe
+01
+1d
+f2
+0d
+1d
+f5
+0b
+f8
+1a
+01
+e9
+19
+3c
+2d
+0a
+f1
+17
+f7
+f9
+f4
+1c
+0d
+cf
+21
+c7
+14
+d1
+e5
+fa
+f8
+1e
+16
+f4
+f7
+15
+14
+0f
+a3
+2e
+0a
+0a
+0c
+03
+dd
+01
+03
+1c
+d0
+07
+07
+08
+08
+02
+1c
+0b
+fd
+e5
+1e
+0b
+13
+07
+eb
+03
+34
+de
+25
+ea
+13
+e1
+fb
+27
+c5
+23
+30
+05
+f8
+28
+e8
+ff
+fa
+fd
+2a
+fd
+16
+1a
+fb
+f3
+0d
+d9
+f4
+31
+25
+31
+e5
+d6
+d2
+13
+cc
+0e
+ec
+fa
+29
+f4
+0a
+ec
+2c
+f5
+fa
+fa
+2e
+04
+17
+ed
+01
+1a
+f4
+22
+f8
+05
+20
+ea
+14
+09
+08
+09
+dd
+ee
+2f
+19
+c8
+fd
+6e
+10
+17
+15
+fc
+ed
+0d
+d8
+fb
+e3
+fb
+1b
+e3
+fd
+33
+35
+ff
+21
+ef
+11
+f6
+20
+03
+00
+04
+eb
+15
+16
+f9
+03
+03
+09
+14
+22
+04
+07
+0d
+13
+ea
+0b
+ed
+19
+2f
+f0
+fa
+12
+fe
+0b
+13
+fb
+05
+ff
+2a
+25
+ed
+09
+d5
+ea
+ef
+20
+e4
+04
+18
+fc
+05
+ea
+ee
+07
+f3
+1d
+03
+f4
+21
+0d
+16
+24
+10
+ee
+19
+e4
+f0
+01
+10
+ea
+fa
+f2
+17
+07
+0a
+4e
+1c
+ec
+16
+03
+01
+26
+eb
+19
+d6
+ff
+10
+1c
+91
+e4
+04
+1e
+15
+e9
+36
+f5
+10
+0f
+86
+c6
+10
+f7
+14
+f2
+e2
+21
+19
+19
+fb
+fb
+39
+e1
+ec
+c5
+09
+e7
+d8
+f9
+e9
+3b
+e9
+e9
+03
+01
+13
+0d
+fe
+04
+23
+ec
+fd
+f8
+ff
+f7
+02
+22
+e4
+22
+f4
+0a

circuit/rom/test_features.hex

@@ -0,0 +1,768 @@
+51
+3e
+26
+a8
+1c
+cc
+fe
+bd
+e0
+45
+f0
+c5
+e1
+e9
+e0
+20
+45
+f9
+eb
+12
+e0
+2d
+22
+47
+36
+36
+1a
+38
+f6
+02
+f5
+24
+c6
+db
+f7
+48
+0d
+ee
+0d
+df
+bf
+2a
+db
+e7
+cb
+59
+cc
+ec
+da
+e4
+03
+16
+ec
+32
+de
+e1
+c5
+02
+fd
+1c
+fc
+4d
+ce
+3a
+3d
+24
+5d
+16
+0f
+f8
+d4
+36
+f9
+16
+02
+12
+18
+e5
+a3
+e0
+00
+f2
+c8
+e7
+17
+16
+30
+02
+1f
+ec
+d4
+19
+b8
+dd
+38
+14
+97
+14
+21
+01
+1b
+18
+2d
+ed
+f8
+20
+11
+07
+0b
+35
+00
+f3
+c3
+fc
+e7
+14
+1e
+04
+f0
+16
+ff
+0a
+06
+20
+2e
+0e
+1e
+11
+51
+2a
+c4
+d1
+fa
+45
+1b
+18
+30
+01
+b4
+27
+f0
+2b
+e3
+1b
+d7
+28
+44
+3d
+0b
+f7
+e1
+04
+0f
+29
+ec
+43
+98
+ee
+ce
+22
+b0
+0a
+01
+f1
+0c
+e1
+07
+d2
+bd
+39
+36
+02
+bf
+20
+21
+55
+02
+05
+de
+f7
+d9
+bd
+d0
+ea
+ea
+c1
+af
+05
+2b
+e9
+1e
+1e
+4a
+d9
+28
+f2
+cf
+0f
+14
+39
+16
+59
+ea
+d9
+08
+2d
+37
+13
+de
+d5
+eb
+e7
+06
+13
+fa
+9f
+ef
+2d
+b5
+3f
+0d
+eb
+2b
+47
+00
+46
+06
+d3
+e8
+04
+11
+54
+fd
+da
+aa
+d3
+01
+03
+08
+11
+d9
+0c
+e9
+13
+db
+ff
+f1
+3d
+35
+e2
+24
+16
+17
+18
+15
+09
+e3
+18
+c1
+bc
+c2
+12
+fb
+21
+bd
+fb
+1e
+02
+37
+0a
+ad
+01
+c6
+1a
+93
+ff
+fb
+e1
+48
+02
+32
+51
+1f
+29
+11
+31
+0b
+fe
+29
+d5
+e9
+ed
+f3
+fb
+e2
+fe
+55
+0b
+27
+1e
+ff
+04
+38
+1e
+11
+e2
+23
+d8
+13
+34
+9f
+ca
+08
+a7
+fa
+d4
+e0
+fe
+33
+d7
+12
+e2
+2c
+c3
+14
+10
+00
+03
+10
+1e
+b8
+dd
+12
+0b
+e7
+03
+25
+08
+21
+fe
+18
+e2
+ec
+02
+1a
+44
+fc
+2e
+28
+e4
+e8
+f2
+df
+10
+04
+cc
+f3
+dd
+e9
+54
+50
+47
+01
+f9
+b6
+e2
+ef
+4f
+f7
+07
+5a
+48
+0f
+1b
+f7
+1d
+fa
+ce
+ca
+13
+e7
+24
+eb
+f1
+1c
+fd
+f7
+07
+3e
+d9
+e7
+fc
+d7
+98
+f2
+23
+29
+f2
+de
+23
+01
+d3
+e0
+ef
+28
+fa
+06
+fe
+28
+be
+29
+30
+fa
+f4
+f8
+21
+1d
+c8
+ea
+19
+ec
+e6
+fe
+bb
+ec
+e1
+0d
+06
+2b
+e6
+ea
+1d
+eb
+30
+ed
+3c
+24
+fe
+1c
+2c
+1d
+c9
+02
+cf
+fc
+32
+20
+e1
+c6
+14
+d6
+01
+ee
+d7
+e5
+23
+43
+fb
+ec
+05
+03
+d9
+cb
+2e
+2e
+e3
+03
+00
+07
+32
+c9
+c5
+d4
+0d
+11
+e2
+77
+52
+56
+d2
+44
+24
+ef
+e6
+eb
+e6
+bb
+d4
+ed
+fd
+e9
+d0
+ed
+ff
+10
+fe
+32
+f2
+1b
+04
+e0
+e5
+ca
+53
+d8
+94
+1e
+22
+1a
+12
+f2
+16
+c7
+08
+e6
+07
+3f
+09
+e2
+d8
+16
+ed
+08
+f0
+b5
+04
+b0
+e5
+38
+ca
+20
+1b
+0f
+91
+c3
+d7
+0b
+f8
+32
+ee
+2a
+1a
+33
+e6
+b7
+fb
+c7
+2f
+e6
+df
+f9
+45
+54
+cb
+2f
+4a
+a9
+ef
+d7
+ff
+4e
+6e
+0f
+10
+08
+f6
+0d
+ed
+14
+1b
+31
+01
+16
+e7
+f9
+1a
+de
+d1
+08
+df
+b5
+f5
+ee
+5c
+ec
+ca
+1f
+01
+f3
+f5
+cd
+d8
+03
+04
+1f
+f9
+da
+0d
+22
+d1
+15
+ce
+05
+12
+1b
+07
+4a
+1a
+b1
+62
+d9
+1c
+ee
+9f
+36
+09
+dc
+45
+43
+fd
+12
+0f
+20
+32
+ef
+16
+e3
+ee
+06
+03
+18
+e8
+d2
+f0
+22
+3f
+02
+3d
+0a
+15
+ca
+fe
+50
+0e
+05
+e0
+ce
+21
+13
+0b
+c7
+4c
+fd
+f9
+db
+e5
+ef
+e3
+f6
+a5
+04
+2e
+fb
+f3
+d8
+fc
+d5
+00
+ea
+23
+02
+ba
+59
+c0
+06
+ce
+ea
+28
+0c
+e8
+8b
+e2
+16
+b8
+23
+f5
+05
+25
+06
+1f
+0b
+73
+12
+f3
+fc
+41
+fb
+ee
+3c
+e2
+cb
+7f
+39
+24
+0e
+13
+40
+36
+fb
+3a
+ec
+d6
+c7
+00
+ef
+e2
+f1
+10
+2a
+36
+28
+04
+23
+58
+21
+0c
+08
+0f
+04
+49
+cb
+10
+0e
+c3
+c1
+f7
+09
+fd
+29
+36
+0c
+24
+de
+c4
+13
+16
+c7
+52
+4a
+d7
+cc
+9f
+00
+dc
+ba
+0d
+32
+0e
+f0
+78
+23
+22
+4f
+19
+03
+bd
+ee
+18