Add files using upload-large-folder tool

backup.py

@@ -21,11 +21,16 @@ anything outside the target you asked for:
   ("data/spatial codes/<model>/...") and ground-truth ("data/spatial codes/ground
   truth/...") codes in one call, satisfying "upload after the regenerate spatial code
   parts" without a separate target for it.
-- "code" covers every source directory (harness, symbolic, analysis, encoder,
-  inference, tests) plus the top-level README.md, backup.py, and setup.sh -- everything
+- "code" covers every source directory (harness, symbolic, analysis, corruption,
+  encoder, inference, tests) plus the top-level README.md, backup.py, and setup.sh -- everything
   needed to reproduce or re-run the experiment, not just its output. Deliberately
   excludes data/ and results/ (covered by their own targets already) and experiments/
-  (a separate, concluded track, not part of the reproducible pipeline).
+  (its own target below, not part of the reproducible pipeline this "code" target
+  covers).
+- "experiments" covers the separate, concluded geometry-formula-tuning track (its own
+  code, caches, and results all live under one experiments/ tree) -- kept as its own
+  target rather than folded into "code" since it's large and conceptually separate from
+  the main A/B/C/D/symbolic pipeline.
 
 Usage:
     python backup.py --repo-id <you>/<repo> --target A
@@ -40,8 +45,10 @@ Run after each plan finishes:
     Plan B done            -> python backup.py --repo-id <you>/<repo> --target B
     Plan C done            -> python backup.py --repo-id <you>/<repo> --target C
     Plan D done            -> python backup.py --repo-id <you>/<repo> --target D
+    blind floor (E) done   -> python backup.py --repo-id <you>/<repo> --target E
     symbolic runs done     -> python backup.py --repo-id <you>/<repo> --target symbolic
     code/setup changed     -> python backup.py --repo-id <you>/<repo> --target code
+    experiments/ changed   -> python backup.py --repo-id <you>/<repo> --target experiments
 
 --repo-id, --target, and the Hugging Face token are all prompted for interactively
 (the token hidden) when not supplied via flag or $HF_TOKEN -- no separate shell wrapper
@@ -64,6 +71,8 @@ TARGETS = {
     "B": ["results/B"],
     "C": ["results/C"],
     "D": ["results/D"],
+    "E": ["results/E"],
+    "corruption": ["results/corruption"],
     "symbolic": ["results/symbolic"],
     "spatial-codes": ["data/spatial codes"],
     "code": [
@@ -73,10 +82,12 @@ TARGETS = {
         "harness",
         "symbolic",
         "analysis",
+        "corruption",
         "encoder",
         "inference",
         "tests",
     ],
+    "experiments": ["experiments"],
 }
 
 

symbolic/solver.py

@@ -56,7 +56,29 @@ import re
 _NUMBER_RE = re.compile(r"[-+]?\d*\.?\d+")
 
 
+# ==========================================================================================
+# OPERATION COUNTING (H25) -- an executable per-question difficulty metric. Every core
+# primitive increments a counter; answer() snapshots the counts for the question it just
+# answered into LAST_ANSWER_OPS. Zero effect on any answer -- counting only.
+# ==========================================================================================
+
+_OP_KEYS = (
+    "numeric reads",
+    "class lookups",
+    "table lookups",
+    "geometric computations",
+    "direction classifications",
+)
+OP_COUNTS = {key: 0 for key in _OP_KEYS}
+LAST_ANSWER_OPS = {}
+
+
+def _count(op):
+    OP_COUNTS[op] += 1
+
+
 def _parse_meters(s):
+    _count("numeric reads")
     """'3.59 meters' -> 3.59. Also accepts a bare number/int/float, so callers never need to
     special-case whether a value has already been parsed."""
     if isinstance(s, (int, float)):
@@ -68,6 +90,7 @@ def _parse_meters(s):
 
 
 def _parse_square_meters(s):
+    _count("numeric reads")
     """'48.4 square meters' -> 48.4. Same numeric parse as _parse_meters -- 'square' doesn't
     change the regex match, kept as a separate function name for readability at call sites."""
     return _parse_meters(s)
@@ -82,6 +105,7 @@ def _parse_square_meters(s):
 
 
 def _instance_xy(code, cls_name, index=0):
+    _count("geometric computations")
     """The (x, y) floor-plane position of one instance of `cls_name` -- index 0 (strongest
     evidence) unless a specific instance is requested. Returns None if the class isn't in the
     spatial code at all (SAM3 never detected it in this scene)."""
@@ -94,6 +118,7 @@ def _instance_xy(code, cls_name, index=0):
 
 
 def _rel_direction(point_a, point_b, point_c, mode="hard"):
+    _count("direction classifications")
     """Standing at A facing B, where is C? Same formula as
     encoder/geometric.py's answer_rel_direction(), specialized to the 2D floor plane (the
     spatial code's frame has no raw height needed for this -- direction is a floor-plane
@@ -124,6 +149,7 @@ def _rel_direction(point_a, point_b, point_c, mode="hard"):
 
 
 def _classify_turn(h_in, h_out):
+    _count("direction classifications")
     """Rotation h_in -> h_out in the floor plane -> 'turn left'/'turn right'/'turn back'
     (135 degree cutoff, matching VSI's own 'back' threshold and
     encoder/geometric.py's _classify_turn())."""
@@ -144,6 +170,7 @@ def _classify_turn(h_in, h_out):
 
 
 def _primary_instance_distance_estimate(code, cls_a, cls_b):
+    _count("geometric computations")
     """A cheap, schema-safe lower-bound estimate of the distance between two classes' PRIMARY
     (instance[0]) instances: 3D center-to-center distance minus each instance's own
     'longest dimension' / 2 (a rough radius), floored at 0 -- built only from fields the
@@ -179,6 +206,7 @@ def _primary_instance_distance_estimate(code, cls_a, cls_b):
 
 
 def _closest_distance_meters(code, cls_a, cls_b):
+    _count("table lookups")
     """Reads the precomputed 'closest classes distance meters from' table directly -- this
     engine never recomputes point-cloud distances itself (the spatial code doesn't carry raw
     point clouds at all; the table is the only distance information available, by design)."""
@@ -201,6 +229,7 @@ def _closest_distance_meters(code, cls_a, cls_b):
 
 
 def _find_class(name, code):
+    _count("class lookups")
     """Best-effort match of a free-text object name to an actual class key in the spatial
     code's objects dict -- exact match first, then substring either direction (mirrors
     encoder/geometric.py's _find_cls() matching strategy). Returns None if nothing matches."""
@@ -642,7 +671,13 @@ def answer(question_type, question, options, code):
     fn = _ANSWER_FUNCTIONS.get(question_type)
     if fn is None:
         return None
-    return fn(question, options, code)
+    for key in _OP_KEYS:
+        OP_COUNTS[key] = 0
+    result = fn(question, options, code)
+    LAST_ANSWER_OPS.clear()
+    LAST_ANSWER_OPS.update(OP_COUNTS)
+    LAST_ANSWER_OPS["total"] = sum(OP_COUNTS.values())
+    return result
 
 
 # ==========================================================================================