New Vocabulary - KISS
Add new terms AT THE TOP of the table the moment a report or chain introduces them. One line each, plain language, 140 chars max. Put further insights in INSIGHTS.md.
General Rules
- ALWAYS explain what you are measuring, what it means and why. Definitions should be self-consistent where possible.
- ALWAYS use correct scientific/mathematical terminology.
- NEVER make up words to simplify or clarify things for the user. If a term is not clearly scientific (eg. ghost, oracle, lottery), explain where it comes from (in INSIGHTS, not this doc) -> The user will clarify it at the source.
- NEVER surface train-of-thought abbreviations. (user-facing claude output is 90% tool use, and search is glitchy at best)
- NEVER include claims and numerical values in this chart.
| term | definition | success is measured by | where is it in code |
|---|---|---|---|
| orbit-synced termination | The control loop ends the mission when the centre of mass finishes traversing the orbit (achieved progress reaches the last sample), not at a fixed duration. | No overrun past orbit completion; the trajectory stops at the natural orbit end. | com_controller.py run_control_loop break on COMGuidance.orbit_complete |
| hierarchical Γ reconstruction | Recover the generalized velocity by solving the singular arm row alone (damped), then the centre-of-mass/base row in closed form. The arm-singularity damping never touches the CoM channel, so the CoM velocity stays exact near a singularity. | CoM velocity error does not inherit arm-singularity damping; end-effector floor unchanged. | breve_controller.py reconstruct_generalized_velocity / _qdot |
| COMController | The CoM force law (feedforward + proportional-derivative feedback + integral) as a standalone class, composed by the control loop (has-a), not inherited. Co-located with COMGuidance. | The CoM reference and the law regulating against it live in one file; loop composes it by reference. | GNC/com_guidance.py COMController |
| campaign (dispatch) | One dispatch batch from a single manifest. Its name is the manifest filename minus _manifest.txt; all its artifacts (archived manifest, journal, collected per-stem runs) nest under one dir logs/logs_<date>/<campaign>/. | collect/status/resume find the batch by the campaign dir, not wall-clock today. | analysis/dispatch.py campaign_dir_of, cmd_run |
| PollKind | The wire-status vocabulary a box reports for a run: FINISHED / RUNNING / VANISHED / FAILED(code). A StrEnum (UPPERCASE values) defined by the producer detached_run and consumed by dispatch. | The SSH status line stays byte-stable across the parse. | analysis/detached_run.py PollKind, classify |
| State (dispatch) | The controller-internal lifecycle of one stem: PENDING→ASSIGNED→DISPATCHED→RUNNING→FINISHED→COLLECTED (or FAILED/VANISHED/EXHAUSTED). A lowercase StrEnum; this is what the dispatch journal serialises. | A stem reaches a terminal state (COLLECTED or EXHAUSTED). | analysis/dispatch.py State, apply_status |
| divergent duplicate | When the same stem completes on two boxes, the second-arriving run is kept beside the canonical (both retained) rather than overwriting it — unless --force, which overwrites. | No silent data loss when two boxes race a stem. | analysis/dispatch.py reconcile |
| consistent floor | The cruise-lag floor (eq 4.14) evaluated at the velocity the EE actually tracks — d/dt(committed pose) — so the derivation’s v->v_des assumption holds and the prediction is honest. | p_e/consistent_floor ~ 1 (at the floor) within one run, not cross-run. | breve_controller.py floor_pe_consistent / _v_breve_consistent; current_sota §4.5 |
| frame angle (θ_frame) | Geodesic angle between the desired and realized EE frames, ‖so3_log(R_ed^T R_te)‖. Large θ_frame with tiny pointing error = rotation about the (near-common) boresight, i.e. roll. | Distinguishes a frame/metric artifact (roll) from a real tracking/aim error. | breve_controller.py diagnostics.frame.ee_angle; validation/nu_e_roll_figures.py |
| topic page | A cross-file wiki page documenting one concept that spans several source files; links DOWN to the per-file pages that hold each part’s contract. | The concept is found and understood from one page, not reassembled from many. | wiki/topics/ |
| circumcentroidal (⊕) velocities | The reduced velocity set the coordinated map produces: [v_c, ω_b, ν_e⊕] — CoM velocity, base angular rate, CoM-referenced EE velocity. | The three blocks are kept distinct (e.g. v_c is the CoM, not the base). | utils/robot.py (Γ assembly); current_sota §2 |
| BreveCoreController | The shared intermediate controller base (sits between CC_Controller and BaseController/BreveController) holding the methods both subclasses had byte-identical. The EE/arm leaves it calls are overridden per-subclass (Template Method), so one shared template yields the base-only diagnostic path and the full coordinated path. | A method moved into it reproduces every baseline byte-identically (checked, not re-pinned). | GNC/breve_core_controller.py |
| structural clone detection (multiset Jaccard) | Finding copy-paste-then-rename duplicates by reducing each function to a multiset of AST subtree shapes and scoring overlap as Σmin/Σmax over those shapes — blind to variable names by construction, so a renamed copy still matches. | A high-scoring pair confirmed by a human to be genuine duplication. | validation/ast_duplication.py |
| clone type (Type-1/2/3/4) | Standard software-clone taxonomy: Type-1 exact, Type-2 renamed/retyped, Type-3 small edits, Type-4 same behaviour via different structure. AST-Jaccard sees 1–3 and is blind to 4. | The tool’s scope stated against the taxonomy, never over-claimed. | concept; ast_duplication.py header |
| witness route (q_O) | The wall-clear joint path the schedule-κ oracle exhibited — the constructive half of the existence proof. It witnesses that no wall is forced by the demand; it does not promise the live system can follow it (that gap is the U₁–U₃ bounds). | U₁–U₃ computed along it offline before any lever build. | generated_reports/math/posture_proof.md |
| fiber coordinate (φ) | One number locating the arm on its self-motion circle for a given camera pose. Reduces “steer the 7th DOF’s posture” to tracking a scalar reference φ_O(s) with bounded rate — a 1-D problem with a 2-line stability story. | The drift + reference-rate budget check U₃ < 1. | posture_proof.md §4 Gap 3 (extends fiber/section/z_a) |
| Weyl’s inequality (σ_min form) | For same-shape matrices, σ_min(A+E) ≥ σ_min(A) − ‖E‖₂: a perturbation can lower the smallest singular value by at most its own spectral norm. Lets logged base-tracking error be converted into a worst-case σ₆ margin loss with a theorem, not a simulation. | The margin-consumption bound U₂ < 1 at p99. | posture_proof.md §4 Gap 2; any matrix-analysis text (Horn & Johnson) |
| arm route / route lottery | For a redundant arm the demand does NOT fix the joint path — a one-parameter family of postures serves every camera pose, and WHICH route the arm takes is set by the null-space policy + history. “Route lottery”: a ±2% retiming reshuffles the route and so the singular encounters, without moving any wall — the CHAIN_13 refinement of CHAIN_10’s SEED verdict. | The 7-DOF’s potholes attributed to the route (policy), not the demand: the oracle tracks the same demand wall-clear at every speed. | chain13_diagnostics_verdict.md (D3 mechanism reading) |
| schedule-κ oracle | Offline predictor: evaluate the arm’s conditioning along the DEMANDED schedule (kinematics only — no flight, no dynamics) to locate near-singular phase bands for each candidate (speed, standoff) pair. Converts “why did κ spike?” into “where does the demanded path graze the wall?”, answerable before flying. | Calibration first: it must reproduce the 8 logged runs’ hot bands (≥7/8) before ANY prediction is cited. | validation/schedule_kappa_oracle.py (CHAIN_13 D3) |
| attribution audit | Splitting an error budget among the mitigation layers that were ACTIVE when the error accrued — asks whether the protection stack itself creates the events it guards against (threshold switches manufacture transients). | The dominant owner named per run, against pre-registered implication rules. | CHAIN_13 D2, extending kappa_peak_forensics.py |
| σ engagement bands | The four protection layers are nested thresholds on ONE signal (σ₆): Γ-Tikhonov below ≈0.049, derate + kernel freeze below 0.025, J⁺ damping below 0.02, hold-last-inverse below 0.005. So “which layer was on” is a band membership, not independent flags — and the bands are reconstructable offline from the logged σ₆ series. | Band edges re-derived from config in-script, never hand-copied. | table in tasks/chain13_criteria.md D2 |
| margin band (certified operating point) | Adopting a schedule/standoff setting only if its whole neighborhood (±2% speed × ±10% standoff) is predicted wall-clear — a band, not a point, because the clean +2% run sits next to a non-monotone dwell cliff (431/231/3.27 s). | Zero predicted post-startup σ₆ < 0.025 entries across the entire neighborhood. | D3 stage (b) certification rule |
| shoulder-frame reach | The extension-margin driver measured from the arm’s mount (shoulder), not the base CoM: ‖p_e − p_shoulder‖. The honest H3 test — σ-based drivers are near-circular at κ peaks since κ = σ₁/σ₆ by definition. | Cliff’s δ ≥ +0.5 with consistent sign across runs ⇒ H3 confirmed. | D1 driver in kappa_peak_forensics.logged_drivers |
| S / R (AMENDMENT-2 levers) | The two config-only round-2 levers the singularities study elevated above L1: S = deliberate schedule re-timing (7-DOF; operating point certified by the oracle over a margin band), R = reach-corridor standoff retune via sampling.radius_scale (6-DOF; targets the saturated 0.64–0.80 derate fraction). | Same adoption rule as L1–L4: full-helix A/B, target metric improves, no gate regression. | tasks/phase00_protocol.md AMENDMENT 2 |
| generalized Jacobian (GJM, J*) | The floating-base version of the arm Jacobian: joint rates → end-effector velocity with the base free to react, built by folding momentum/inertia coupling into the map. Our kJ/kG are condition numbers of this family. Born in umetani1989resolved; canonical modern build in wilde2018equations. | We measure the matrix the literature means: J⁺ (arm-side) and Γ (full map). | utils/robot.py:238-255; study: generated_reports/docs/research/singularities.md §2 |
| dynamic singularity | A singular pose of the generalized Jacobian — its location depends on mass/inertia distribution, not arm geometry alone (papadopoulos1993dynamic). Heavy-base limit: as base inertia grows these collapse onto the ordinary fixed-base kinematic singularities — our regime. | Knowing which kind we face: ours are kinematic (full reach), per the +1.0 extension correlation. | concept; see singularities.md §3.2 |
| PIW / PDW | Path-Independent vs Path-Dependent Workspace: in the PIW no path to a pose can ever be singular; in the PDW the same pose is singular or not depending on the joint path taken to it. Why a ±2% retiming changes singular encounters without moving the singular set. | Schedules whose demanded poses stay PIW-side (reach margin). | concept (papadopoulos1993dynamic); singularities.md §3.1 |
| singular wall | Our shorthand for the literature’s fixed singular hypersurfaces in joint space: the walls never move — the schedule’s joint-space path either grazes them or doesn’t. A local σ threshold can step across a thin wall undetected (calzolari2020singularity). | Hot bands predicted offline from the demanded path, not discovered in flight. | concept; oracle follow-up in singularities.md §8 |
| damped least squares (DLS) | Singularity-robust inversion: add λ² to every σ² before inverting, so nothing divides by ~0. Price (quantified): tracking error injected into ALL directions, λ²/(σᵢ²+λ²) each. Our Tikhonov layers are DLS-shaped. | Damping only where needed (see directional damping); error cost attributed before adding more. | breve_controller.py:498-516, utils/robot.py:173-210 |
| directional (filtered) damping | DLS upgrade: damp only along the one dying direction u_m instead of isotropically — healthy directions keep pseudo-inverse accuracy (chiaverini1997singularity eq. 16). Candidate fix if the Tikhonov layer owns our in-window pointing error. | pe_p99 protected in healthy directions while joint rates stay bounded. | not implemented; singularities.md §4.3 |
| algorithmic singularity | Rank loss created by stacking tasks: the projected/restricted map goes singular while each underlying Jacobian is healthy — tasks in conflict, not mechanism locked (chiaverini1997singularity). Risk attaches to our 7-DOF null-space machinery, not the bare 6-DOF. | Log σ_min of the projected map next to kJ/kG; the collapsing determinant fingers the culprit (sone2016reactionless fingerprint). | watch-item for L2; singularities.md §4.2 |
| task-priority control | Architecture where a primary task (EE tracking) pseudo-inverts a map that is full-rank everywhere (base+arm together) and secondary tasks (base pose) ride the null space — the controller never blows up; the secondary task is what degrades (bruschi2025singularity). | EE tracking survives singular bands; cost shows in base-pose excursion/fuel. | alternative architecture; singularities.md §4.2 |
| singularity-consistent (SC) handling | Near a singularity, scale down the speed of the commanded motion but keep its direction exact — error appears only as schedule lag, never as direction error (sone2016reactionless). Our derate is SC-shaped; that is its published justification. | In-window pointing error traced to DLS/switch layers, not to the derate. | base_guidance.py:118-141; singularities.md §4.3 |
| H_norm (SVD entropy) | Normalized entropy of a matrix’s singular-value spectrum: 0 = one mode DOMINATES, 1 = evenly spread (das2025understanding eq. 29, defined there on the base–arm coupling matrix). Adapting it to our Jacobian as a “one dying σ vs broadband” discriminator is OUR extrapolation — and one near-zero σ among healthy ones is a weak signature (≈0.92 of max for n=7). | Offline pilot on the 8 npz must show real discriminating power BEFORE any live logging. | pilot only; spectrum available in utils/robot.py |
| Mesh (utils/mesh.py) | The one object that owns the target’s surface geometry: mesh load, raycasting scene, kd-trees, area-uniform sampling, and the orbit→surface aim path. Replaced the scattered copies in target_finder + the retired OrbitSurfacePath. | One mesh load per consumer (finder unification lands with Chain B); surface_path bit-identical to the retired class. | utils/mesh.py (CHAIN_11 A3; prototype: sandbox/mesh_oo) |
| quantile-matched threshold | How to compare a cutoff across two different-scale signals: pick the second signal’s threshold so the SAME FRACTION of samples falls below it as the original cutoff catches. Used to test whether s_min_G and s_min_J make the same derate decisions (they do: agreement 1.0000). | Decision agreement near 1 ⇒ the signals are interchangeable for that decision. | validation/sming_vs_sminj_study.py |
| L1–L4 (round-2 levers) | The four pre-registered hardening knobs from the Phase 00 protocol: L1 = velocity-lag feedforward (feed the desired velocity forward so the arm stops trailing the moving reference; targets pe_p99), L2 = σ-gradient null-space pull (7-DOF only), L3 = pointing smoothing retune, L4 = kernel-freeze thaw policy (7-DOF only). | Each adopted only if its target metric improves with no gate regression (full helix A/B). | tasks/phase00_protocol.md Round 2 + AMENDMENT 1 |
| κ peak | A sharp excursion of the arm’s condition number — one of the run’s worst lopsided-arm moments. CHAIN_10 extracts each run’s top-10 by a pre-registered prominence bar. | Peaks explained by a named driver (or explicitly unresolved), never tuned-to-result. | validation/kappa_peak_forensics.top_peaks |
| peak-triggered window | The span around a κ peak (out to where the excursion decays to 25% of its height) used to compare driver signals against matched calm “control windows”. | Effect sizes (Cliff’s δ) computed peak-vs-control, bar pre-registered at 0.5. | top_peaks lo/hi + control_windows |
| pothole entry rate | How OFTEN a run crosses into the near-singular regime (σ₆ < 0.025), as opposed to how LONG it stays per visit. CHAIN_10’s H4 test: entries moving ⇒ the schedule changes the seed; durations moving alone ⇒ the dwell loop amplifies. | Verdict: SEED — r1 entries 23/14/2 at nominal/−2%/+2%. | dwell_episodes.extract rows count |
| hot band | A narrow stretch of orbit phase where one run’s κ peaks cluster. The CHAIN_10 signature: ±2% speed MOVES the 7-DOF’s hot band (0.29–0.35 at −2%; gone entirely post-startup at +2%) while the 6-DOF’s bands stay put. | Hot-band location explained by reach-phase alignment (H3 follow-up). | peak phases in chain10_offline_tables.md |
| singular factor | The named arm geometry that drives σ₆ toward zero — the 6R arm has three (shoulder/reach R, elbow sinθ₃, wrist sinθ₅). “The reach factor” = the shoulder near full extension. | Knowing WHICH factor is active when conditioning degrades (they need different fixes). | factored det(J): det = R(θ)·sinθ₃·sinθ₅; see decisions.md Jun 8 |
| helix / 30-rev helix | The full inspection path: a pole-to-pole spiral around the target satellite, 30 revolutions. Short runs sweep only the southern cap — full-helix runs are the only trusted verdict basis. | Full helix flown to completion (progress reaches the path end). | utils/orbit.generate_spherical_helix |
| self-motion (a.k.a. null-space motion, ghost motion, k̂) | The one combined arm+base motion that changes NOTHING the mission watches: arm swings along its free direction, base counter-shuffles, so CoM, base attitude, and camera all stay frozen. The 7th joint’s whole gift. “Null-space motion” is correct — but it’s the null space of the coordinated map Γ (arm + base counter-shuffle), NOT the fixed-base joint null space, and NOT a free-floating reactionless mode (our base is actuated and deliberately moves). | It exists wherever σ₆ > 0, and we (not numerics) decide what it does. | dyn.k_hat, utils/robot.all_dynamics_terms |
| v_n (ghost speedometer) | One number: how much of the robot’s current velocity is self-motion. Zero = the ghost is parked. | ~0 with suppression ON (mission mean 0.0016 vs 0.157 uncontrolled). | dyn.z_a @ v; offline run_7dof_mission.v_n_series |
| z_a (the ruler) | The mass-weighted measuring row that reads 1 on pure self-motion and 0 on every mission motion. Mass-weighting means it can never break while σ₆ > 0. | z_a·k̂ = 1 exactly; zero kinetic-energy cross-terms (Theorem 1, dynamics_modifications_7dof.md). | dyn.z_a, utils/robot.py |
| fiber | ALL the robot velocities that produce one given task command — an affine line of options, one line per command. The controller must pick a point on it. | (concept; see section) | solution set of Γx = y |
| section | The RULE that picks one point on every fiber = a reconstruction convention. Ours picks the v_n = 0 point (“park the ghost”). NOT the same word as fiber — a section crosses every fiber once. | z_a·x ≈ 0 at every step (suppression tests). | _augment_with_null_row + reconstruct_generalized_velocity |
| M-orthogonal / dynamically consistent | ”Perpendicular as kinetic energy measures it” (mass-weighted), vs plain geometric perpendicular. Khatib’s name for it is “dynamically consistent”; geometric mechanics calls the same choice the “mechanical connection” (Marsden–Montgomery). | Energy bookkeeping splits cleanly: ghost and task keep separate kinetic-energy accounts. | the augmented [Γ; ẑ_a] solve |
| min-norm reconstruction (the ghost injector) | The old default: lstsq picks the smallest-Euclidean-norm velocity. “Smallest” ignores mass, so it silently CONTAINS self-motion — it was the source of the uncontrolled ghost. | retired for 7-DOF (measured mean |v_n| 0.157, non-decaying). | the un-augmented lstsq/normal-equation branch |
| elbow orbit | The human-arm picture of the self-motion: touch your nose, hold it, swing your elbow. Hand fixed, shoulder fixed, elbow circles (our version adds the base counter-shuffle). | (intuition; the real n̂ spreads over all 7 joints) | upper_arm_roll_joint, models/ur3/ur3_7dof_with_capsules.xml |
| frozen-roll oracle | Test trick: with the new roll joint clamped at 0, the 7-DOF model must be EXACTLY the 6-DOF model — so any difference at all is a bug, with machine-precision sensitivity. | FK match < 1e-10 across random configs; total mass exact. | test_robot7_model.test_frozen_roll_fk_equivalence |
| σ₆ pothole | A stretch of orbit poses where σ₆ dips toward the floor. ENTERING one is schedule-hypersensitive (tiny timetable changes decide); LEAVING is dwell-locked (see dwell). | few entries, short stays (freeze run: 5 entries, 6 s mean). | episodes in validation/dwell_episodes.py |
| missing contact exclusion (7-DOF) | Inserting the roll link made shoulder/upper-arm grandparent–grandchild, so MuJoCo’s automatic parent-child contact exclusion lapsed → a permanent cosmetic 9.5 mm mesh “contact” at the joint in videos. | FIXED: the pair is absent over all 6000 video frames (<exclude> in the XML survives scene attachment). | <contact><exclude> in ur3_7dof_with_capsules.xml |
| hull contact (mesh collision) | MuJoCo collides the CONVEX HULL of each mesh, and slim links have fat hulls — so the video’s collision counter reads contacts between links that aren’t physically touching. Pre-existing in the 6-DOF model too (36% of baseline frames); NOT a 7-DOF artifact. The capsules are the curated collision proxies; ironically the video counter ignores capsules and counts only hulls — read it as pessimistic. | Counter only trusted for CHANGES (a new persistent pair = new model defect); absolute zero is not expected. | count_contacts_no_capsules, utils/mj.py |
| success metadata | Per-metric block declaring what “good” means: direction (lower/higher is better), gate threshold, ranking weight, and a plain-language meaning. The single home for scoreboard weights. | Every scoreboard metric has one; the metric verifier checks the block’s fields. | YAMLs_by_domain/metrics.yaml success: blocks (CHAIN_7) |
| weighted rank sum | Ranking score across runs: per metric, rank runs 1..n in the better direction (runs within 0.1% share the mean rank so rounding noise can’t order them), multiply by the metric’s weight, add up. Lower total wins. Gates always sort first. | The rule text printed in each report matches the computed order. | DataSummary.scoreboard_tables (CHAIN_7) |
| frac_below | Reduction: the fraction of logged samples strictly below the metric’s threshold:. Gives the throttled fraction from the σ₆ series (threshold 0.025). | Exact on synthetic data; matches the chain scripts up to the startup-window difference (pipeline = whole log). | Reductions.FRAC_BELOW, analysis/data_analyzer.py (CHAIN_7) |
| scoreboard (in-report) | The comparison table with per-metric best (bold) / gate failures (italic), a how-to-read guide table, and the ranked run list in the Conclusions. | Same gates-first ordering as the console tool on shared metrics. | DataSummary.scoreboard_tables + Reporter; console superset: validation/run_scoreboard.py |
σ₆ (a.k.a. sj, s_min_J) | The arm’s smallest “leverage” number: how much camera motion the weakest joint direction can still produce. Near zero = near a singular (locked-up) pose. | Staying comfortably above 0.025 (the floor below which the controller intervenes). | logged as diagnostics.conditioning.s_min_J; saved as sj in mission npz |
κ (kappa, kJ) | Condition number κ = σ₁/σ₆: ratio of the arm’s strongest to weakest direction. 1 = perfectly even; large = lopsided/fragile. | Small and steady. p50 = typical, p95 = bad-moment value. We log it but the derate fraction remains the headline (κ proved noisier across runs). | logged kappa_J; saved as kJ in new npz; offline: r1_kernel_continuity.kappa_series |
| derate / derate fraction | When σ₆ drops below 0.025 the controller deliberately slows the whole vehicle (like a laptop throttling when hot) — that is a “derate”. The fraction = share of mission steps spent throttled. | Small (baseline run: 2.4% of steps; the bad −2%-speed run: 33%). | ramp: base_guidance.derate_desired_by_gamma; fraction counted in run_7dof_mission.analyze |
| gate / gate regression | A “gate” is a pass/fail mission criterion: tracking error p99 < 0.2 m, coverage ≈ 1.0, completion time. A “regression” = a gate metric getting WORSE after a change, by more than run-to-run noise. | All gates pass; no metric worsens beyond the noise band. | run_7dof_mission.analyze prints them; bands computed in the chain verdict scripts |
| noise band / replicate-pair deltas | How different two IDENTICAL runs can look — the yardstick for “is this change real?”. Ideally measured by running the same config twice (replicate pair); our identical configs are bit-identical (zero noise), so we fall back to the spread between the 1800 s and 1600 s grid runs. | An effect only counts if it exceeds this band. | recomputed per verdict script (e.g. r1_freeze_ab_verdict.py) |
| schedule sensitivity | How much mission statistics change when only the TIMETABLE is nudged (±2% cruise speed, or a different orbit sampling grid) — nothing physical changed. | Small swings = robust. Verdict: NOT small — 2% slower tripled the throttled time. A first-class risk source for the CVaR phase. | validation/p2_schedule_sensitivity.py |
| dwell / dwell episode | The arm LINGERING at a near-singular pose: bad pose → vehicle throttles → progress stalls → the aim schedule waits → camera keeps aiming at the same spot → pose stays bad. One contiguous such stretch = an episode. | Few and short episodes (baseline: 4 episodes, 32 s total; worst run: 615 s). | validation/dwell_episodes.py |
| dwell fixed point | The self-sustaining equilibrium of that loop — the system can sit there indefinitely because each link feeds the next. Breaking ANY link breaks the loop. | A mechanism that provably removes the equilibrium (the lead-cap knob failed: it just moved the fixed point 0.05 m ahead). | loop spans base_guidance (throttle) ↔ ee_guidance.orbit_path_pose (aim wait) |
| stall fraction | Share of mission steps where the inspection makes NO forward progress along the orbit (the progress counter doesn’t tick). | Small (baseline 0.8%; worst run 10%). | validation/dwell_episodes.py |
| aim clock (fig. CHAIN_6_2c) | The schedule deciding where along the orbit the camera should aim RIGHT NOW. Since CHAIN_3 it follows achieved progress (closed-loop) instead of wall time (open-loop). Panel 2c plots how far an experimental knob let the aim run AHEAD of achieved progress. | Aim stays synced to real progress; any lead stays bounded and useful (the tested knob’s 0.05 m cap saturated uselessly). | ee_guidance.orbit_path_pose; knob orbit_path.aim_floor_rate/aim_lead_max (default OFF) |
| kernel (n̂) | The 7-joint arm has one “free” direction it can move WITHOUT moving the camera (the null-space / kernel direction). Near singular poses this direction becomes numerically ill-defined and flips erratically. | A steady, slowly-turning kernel direction. | computed in utils/robot.all_dynamics_terms |
| kernel freeze | The fix for that flipping: below the σ₆ floor, reuse the last well-defined kernel direction instead of recomputing a garbage one. Thaws (recomputes) when conditioning recovers. | Zero kernel jitter below the floor (verified exactly 0) AND mission gates improving (they did: tracking, dwell, completion all better). | utils/robot.py ~307–323; knob controller.arm.null_space.freeze_floor (0.025) |
| thaw jump | The one-time direction change when the freeze releases: cached direction vs freshly computed one. The freeze’s price — it trades thousands of tiny flips for a few big steps. | We pre-registered “p99 < 10°” and measured 83° → recorded FAIL; context: only 10 jumps per mission vs 19k steps of chatter, and total motion is 2.2× lower. | r1_kernel_continuity.effective_kernel_series (thaw_deg) |
| sub-floor kernel swings | Step-to-step kernel rotations WHILE below the σ₆ floor — exactly the jitter the freeze must remove. | Exactly zero with freeze ON (measured: zero). | same as above, derated stratum |
| kernel transport | Total angle the kernel direction sweeps over a whole mission — an odometer for direction wandering. | Lower = steadier. Freeze ON 1924° vs OFF 4222°. | validation/r1_freeze_ab_verdict.py |
| engagement gate / engagement check | Proof that a feature actually DID something in a run — not just that its config flag was set. (Hard-won lesson: flags can be set yet inert, or “engaged” yet produce zero effect.) | Direct evidence in the data: e.g. the aim knob’s floor active on 7% of steps, first state divergence one step after first engagement. | per-verdict, e.g. the recurrence replay in validation/p3_aim_clock_verdict.py |
| freeze fingerprint | A provenance trick: the freeze code is provably inert while σ₆ ≥ floor, so two runs differing ONLY in the freeze must be bit-identical until the first sub-floor step. Divergence exactly there = freeze-config difference; divergence elsewhere = something else. | Used to prove which historical run had the freeze on (it corrected a misremembered launch flag in minutes). | validation/replicate_divergence.py |
| n= (fig. CHAIN_6_3a) | On the dwell bars: the COUNT of separate dwell episodes. Bar height = total seconds; n = how many episodes it took. | Both small. | validation/chain6_composite.py |
| pre-registration | Writing the pass/fail thresholds DOWN before running the experiment, then reporting against them verbatim — even when the threshold turns out to have been a bad guess (the 10° thaw target). No moving goalposts. | Verdicts that a hostile reviewer can audit: criteria text predates the data. | tasks/daily_log/Jun11_26/CHAIN_6.md “Pre-registered criteria” |
| trusted baseline | The single run all comparisons are measured against, designated only after its provenance was verified (freeze ON, 1800 s, normal speed). | Every A/B names its baseline; nothing compares against an unverified log. | logs/m7_on_s45_freeze.npz |
| Monte Carlo (MC) | The brute-force way to handle randomness: instead of deriving the output distribution with math, run the SAME experiment many times with different random draws and look at the spread of outcomes. Named after the casino. One “MC cell” = one noise setting; its repeats differ only in the random sequence. | Enough repeats that the mean ± 95% CI is tight relative to the effect you’re claiming (Phase 0: 5 repeats per cell). | validation/fragility_study.py (Phase 0 T7) |
| seed / seeded run | The integer that initializes the random-number generator. Same seed → the EXACT same “random” sequence every time, so a noisy run is still perfectly reproducible. MC repeats = same config, seeds 0..N−1. | Any table number regenerates bit-for-bit from (config, seed). | uncertainty.seed in parameters.yaml; np.random.default_rng(seed) |
| truth side vs belief side | Two places uncertainty can live. Truth side: noise in what PHYSICALLY happens (the camera actually points off-axis, the thruster delivers a noisy force). Belief side: error in what the controller THINKS the state is (it feeds back an estimated CoM, not the real one), while physics stays exact. | The two are parameterized by the same object (UncertaintyModel) so the injected truth noise and the covariance the planner believes can never drift apart. | GNC/uncertainty_model.py |
| fragility (study) | How fast each nominal performance metric degrades as ONE noise source grows, all else untouched — the degradation yardstick later risk-aware methods must beat. Not robustness (no mitigation is active); it measures the UNPROTECTED system. | Monotone degradation with magnitude (non-monotone ⇒ the injection or metric is broken — pre-registered STOP condition E1). | tasks/fragility_criteria.md; validation/fragility_study.py |
| Phase 00 | The pre-risk configuration shootout + hardening: pick the nominal architecture (6 vs 7 joints × path / reactive / hybrid targeting) by a pre-registered scoreboard rule, then harden the winner. Freezes the baseline that all risk work (Phase 0+) measures against. | Winner survives the ±2% speed probe; stretch: pe_p99 < 0.1 m, ze_p99 < 0.001, coverage 1.000. | high_level_plans/phase00.md; tasks/phase00_protocol.md |
| anchor mode (path-anchored scorer) | The hybrid targeting scheme: the orbit path’s aim clock picks WHERE along the schedule to look (a camera-side vantage on the COM orbit), and the reactive scorer keeps its JUDGMENT about which surface target to pick from there. “Schedule from the path, judgment from the scorer.” | Inherits the path’s pacing AND the scorer’s adaptivity; pose mode stays byte-identical when anchor is off. | orbit_path.mode: anchor; ee_guidance.set_ee_target |
| pointing-error p99 (ze_p99) | 99th-percentile of ‖z_e − z_e_des‖ — how far the camera’s actual optical axis strays from where it should point, as the chord distance between two unit vectors (≈ the angle in radians for small errors; 0.86 ≈ 51°). | Smaller = camera aimed truer. Stretch < 0.001 (~0.06°). | logged tracking_error.arm.z_e(_desired); run_mission.analyze |
| step-jump p99 (nu_jump_p99) | 99th-percentile of per-step change in the end-effector twist ‖Δν_e‖ — the smoothness witness from TASK_14. Units are mixed (twist = m/s stacked with rad/s), so compare across runs, not against a physical constant. | Smaller = smoother commands; round-2 rule: no >10% regression while improving pe/ze. | logged tracking_error.arm.nu_e; run_mission.analyze |