| # Stabilizing Beyond 105 Qubits Instrument v0.2 — Implementation Architecture |
|
|
| **Three-Run Stabilization Architecture: Public Backtrace, HIR/OAM Settlement, and Diamond-Gate Hexshell Stabilization** |
|
|
| Created and Developed by Collin D. Weber · Creator and Developer of Primordial Calculus / HIR-OAM · Systems Architect / Systems Integrity Steward |
|
|
| > Public-review structural instrument only. Not quantum hardware control. Not direct qubit measurement. Not QEC replacement. Not a Google / Willow product claim. Public constraints only. Run C is a theoretical HIR architecture model, not a hardware validation. |
|
|
| --- |
|
|
| ## 0. Reading guide |
|
|
| This document is the build contract. It is deterministic and self-contained: given the same control inputs, the same numbers come out, every time, with no randomness. The instrument is a **structural pressure model**. It does not measure physical qubits. It scores how three different *stabilization grammars* respond to the same modeled pressure field. Output is always labeled **"theoretical qubit-equivalent stabilization ceiling"** / **"model-internal stabilization ceiling."** |
|
|
| The eleven sections below map 1:1 to the requested deliverables. |
|
|
| --- |
|
|
| ## 1. Naming and version structure |
|
|
| | Field | Value | |
| |---|---| |
| | `artifact_name` | `Stabilizing Beyond 105 Qubits Instrument` | |
| | `version` | `0.2.0` | |
| | `codename` | `Three-Run Stabilization Architecture` | |
| | `subtitle` | `Public Backtrace, HIR/OAM Settlement, and Diamond-Gate Hexshell Stabilization` | |
| | `schema_version` | `hir-oam-review-packet/2` | |
| | `run_ids` | `A` = Public Constraint Backtrace · `B` = HIR/OAM Encapsulated Settlement · `C` = Full HIR Architecture / Diamond-Gate Hexshell | |
|
|
| Versioning rule: `MAJOR.MINOR.PATCH`. MINOR increments when a run's state machine or scoring band changes; PATCH for copy/UI; MAJOR for a change to the core `S_field` / `S_full` formulas or packet schema. The `schema_version` is independent of artifact version so downstream readers can validate packets across artifact revisions. |
|
|
| --- |
|
|
| ## 2. Full data model |
|
|
| All control values are normalized **0.0–1.0** unless noted. "Good" sliders raise stability; "pressure" sliders raise system pressure. Internal scores are kept as floats in `[-1, 1]` or `[0, 1]` and mapped to a `0–100` display band only at render time. |
|
|
| ``` |
| ModelState |
| ├── meta |
| │ ├── artifact_name, version, schema_version |
| │ ├── boundary_statement |
| │ └── timestamp (ISO 8601, generated at packet export) |
| │ |
| ├── controls.shared // applies to A, B, C |
| │ ├── localTraceStability [0..1] good → T |
| │ ├── latticePressure [0..1] → Q (inverse), P_lattice |
| │ ├── correlationLevel [0..1] → P_correlation, independence (inverse) |
| │ ├── decoderStrain [0..1] → R (inverse), P_decoder |
| │ ├── controlDrift [0..1] → P_control, temporal validity (inverse) |
| │ ├── runtimePressure [0..1] → P_runtime |
| │ ├── resourcePressure [0..1] → P_resource |
| │ ├── provenanceContinuity [0..1] good → G, P_provenance (inverse) |
| │ ├── securityRisk [0..1] → P_security |
| │ ├── publicClaimPressure [0..1] → P_public |
| │ ├── pUnknown [0..1] → P_unknown (residual uncertainty) |
| │ ├── evidenceQuality [0..1] good → ECS |
| │ └── operationType enum // severity multiplier |
| │ |
| ├── controls.runC // additional, Run C only |
| │ ├── shellCount int 2..7 |
| │ ├── gateDensity [0..1] |
| │ ├── gateHandoffEfficiency [0..1] → DG |
| │ ├── alignmentStrength [0..1] instantaneous alignment under pressure |
| │ ├── routingEfficiency [0..1] omnidirectional relief |
| │ ├── ramLearningRate [0..1] → RAM |
| │ ├── immuneRetention [0..1] |
| │ ├── redTeamSensitivity [0..1] |
| │ ├── redTeamFalsePositive [0..1] pressure |
| │ ├── redTeamFalseNegative [0..1] pressure |
| │ ├── encapsulationThreshold [0..1] cryptobiotic trigger point |
| │ ├── malformedPressure [0..1] |
| │ ├── counterfeitResonance [0..1] |
| │ ├── myceliumPropagation [0..1] → DM |
| │ ├── hirInternalization [0..1] |
| │ ├── gritDensity [0..1] |
| │ ├── uwcThermalBurden [0..1] cost (inverse to UWC) |
| │ └── resourceTruthVisibility [0..1] good (raises UWC) |
| │ |
| └── derived (recomputed every tick — never stored as source of truth) |
| ├── factors: T, Q, R, G, DG, RAM, IM, DM, UWC |
| ├── pressures: P_lattice … P_unknown, P_malformed, P_constraint, P_system, P_total |
| ├── runA, runB, runC readout objects |
| ├── ecs, hardInvariantFlags[] |
| └── qCeiling, qCeilingFull |
| ``` |
|
|
| Operation-type enum and its severity multiplier `σ` (used to harden invariants for higher-stakes operations): |
|
|
| | `operationType` | σ | |
| |---|---| |
| | `diagnostic` (Diagnostic review) | 0.5 | |
| | `calibration` (Calibration review) | 0.7 | |
| | `current_branch` (Current branch operation) | 1.0 | |
| | `final_logical` (Final logical operation) | 1.3 | |
| | `public_claim` (Public claim / benchmark interpretation) | 1.6 | |
| | `safety_critical` (Safety-critical downstream use) | 2.0 | |
|
|
| --- |
|
|
| ## 3. Control list |
|
|
| **Shared (all runs):** local trace stability · lattice pressure · correlation level · decoder strain · control drift · runtime scheduler pressure · resource pressure · provenance continuity · security risk · public claim pressure · P_unknown / residual uncertainty · evidence quality · operation type. |
| |
| **Run C additional:** shell count · diamond gate density · gate handoff efficiency · instantaneous alignment strength · omnidirectional routing efficiency · RAM learning rate · immune memory retention · authorized red-team capture sensitivity · red-team false-positive pressure · red-team false-negative pressure · cryptobiotic encapsulation threshold · malformed data pressure · counterfeit resonance pressure · Digital Mycelium repair propagation · HIR internalization · grit density · UWC thermal/resource burden · resource-truth visibility. |
| |
| UI control types: all `[0..1]` fields are range sliders (step 0.01) with a live numeric badge; `shellCount` is a stepped slider (int); `operationType` is a `<select>`. Every slider has a one-line tooltip stating direction ("higher = more pressure" vs "higher = better"). |
| |
| --- |
| |
| ## 4. Formula design |
| |
| Helper: `clamp(x,a,b)`, `lerp`, `norm01(x)`, `pct(x) = round(clamp(x,0,1)*100)`. All weights below are fixed constants in the build. |
| |
| **Composite factors (each clamped to [0,1]):** |
| |
| ``` |
| T = localTraceStability |
| Q = clamp(1 - 0.65*latticePressure - 0.35*correlationLevel) |
| R = clamp(1 - 0.6*decoderStrain - 0.4*runtimePressure) |
| G = clamp(0.5*provenanceContinuity + 0.3*evidenceQuality + 0.2*(1-securityRisk)) |
| |
| // Run C stack factors |
| DG = clamp(0.5*gateHandoffEfficiency + 0.3*alignmentStrength + 0.2*routingEfficiency) |
| RAM = clamp(0.6*ramLearningRate + 0.4*immuneRetention) |
| IM = clamp(0.55*redTeamSensitivity + 0.25*immuneRetention |
| - 0.4*redTeamFalseNegative - 0.2*redTeamFalsePositive + 0.4) // floored |
| DM = clamp(0.7*myceliumPropagation + 0.3*hirInternalization) |
| UWC = clamp(0.6*resourceTruthVisibility + 0.4*(1 - uwcThermalBurden)) |
| ``` |
| |
| **Pressure terms (each [0,1]):** |
| |
| ``` |
| P_lattice = latticePressure |
| P_correlation = correlationLevel |
| P_decoder = decoderStrain |
| P_control = controlDrift |
| P_runtime = runtimePressure |
| P_resource = resourcePressure |
| P_provenance = 1 - provenanceContinuity |
| P_security = securityRisk |
| P_public = publicClaimPressure * (0.5 + 0.5*σ_norm) // σ_norm = σ/2 |
| P_unknown = pUnknown |
| P_malformed = clamp(0.6*malformedPressure + 0.4*counterfeitResonance) // Run C |
| P_constraint = clamp(0.5*(1-routingEfficiency) + 0.5*(1-gateDensity)) // Run C |
| ``` |
| |
| **System / total pressure** (weighted means → keep in [0,1]): |
| |
| ``` |
| P_system = Σ(w_i * P_i) over the 10 shared terms, Σw_i = 1 |
| weights: lattice .14, correlation .12, decoder .14, control .08, |
| runtime .08, resource .08, provenance .12, security .10, |
| public .08, unknown .06 |
| |
| P_total = 0.78 * P_system + 0.12 * P_malformed + 0.10 * P_constraint // Run C |
| ``` |
| |
| **Base field pressure (spec form):** |
| |
| ``` |
| S_field = T * Q * R * G - P_system // float in ~[-1, 1] |
| display_A = pct((S_field + 1) / 2) // 0..100 |
| ``` |
| |
| **Evidence Conversion Score:** |
| |
| ``` |
| Provenance = provenanceContinuity |
| Independence = 1 - correlationLevel |
| ScopeMatch = clamp(1 - publicClaimPressure * σ_norm) |
| PressureMatch = clamp(1 - |declaredScopePressure - P_system|) |
| // declaredScopePressure approximated from operationType band |
| TemporalValidity = 1 - controlDrift |
| RepeatStability = clamp(localTraceStability * (1 - decoderStrain)) |
| CorrelationPenalty = correlationLevel |
| SelfCertPenalty = clamp((1-Independence) * (1-Provenance)) |
| BoundaryViolationPenalty = clamp(publicClaimPressure * σ_norm) |
| |
| ECS_raw = Provenance + Independence + ScopeMatch + PressureMatch |
| + TemporalValidity + RepeatStability |
| - CorrelationPenalty - SelfCertPenalty - BoundaryViolationPenalty // [-3, 6] |
| ECS = pct((ECS_raw + 3) / 9) |
| ``` |
| |
| **Run C full-stack form (spec form):** |
| |
| ``` |
| coreC = T*Q*R*G*DG*RAM*IM*DM*UWC // product of 9 factors, small but monotonic |
| S_full = coreC - P_total // literal spec value, stored raw in packet |
|
|
| // display normalization (documented, monotonic, never inflates the literal): |
| S_full_norm = clamp( pow(coreC, 0.25) - 0.35*P_total ) // [0,1] display proxy |
| display_C = pct(S_full_norm) |
| ``` |
| |
| **Theoretical stabilization ceiling:** |
| |
| ``` |
| Q_base = 105 |
| ShellMultiplier = 1 + 0.12*(shellCount - 2) // more shells → more headroom |
| GateDensityF = 0.5 + 0.5*gateDensity |
| AlignmentFactor = 0.5 + 0.5*alignmentStrength |
| RecoveryFactor = clamp(0.4*RAM + 0.3*DM + 0.3*IM + 0.3) |
| |
| Q_ceiling_A = round( Q_base * (1 + max(0, S_field) ) ) // backtrace ceiling |
| Q_ceiling_full = round( Q_base * (1 + S_full_norm * ShellMultiplier |
| * GateDensityF * AlignmentFactor * RecoveryFactor) ) // Run C ceiling |
| ``` |
| |
| **Pressure failure condition (Run C):** |
| |
| ``` |
| GateCapacity = DG * GateDensityF * AlignmentFactor |
| RAMRecovery = 0.5 * RAM |
| ImmuneCapture = 0.5 * IM |
| RepairPropagation = 0.5 * DM |
| ResourceTruthCorrection = 0.4 * UWC |
|
|
| defense = GateCapacity + RAMRecovery + ImmuneCapture |
| + RepairPropagation + ResourceTruthCorrection |
|
|
| FAIL_CLOSED ⇔ P_total > defense |
| saturationMargin = defense - P_total // < 0 means saturated |
| ``` |
| |
| All constants are fixed in source; nothing is sampled. |
| |
| --- |
| |
| ## 5. Deterministic scoring logic |
| |
| Single pure function `compute(state) -> derived`. Pipeline, evaluated top to bottom on every control change: |
| |
| 1. Read controls → clamp all to declared ranges. |
| 2. Resolve `σ` from `operationType`; `σ_norm = σ/2`. |
| 3. Compute factors `T,Q,R,G` and (for C) `DG,RAM,IM,DM,UWC`. |
| 4. Compute all `P_*`, then `P_system`, then `P_total`. |
| 5. `S_field` → Run A score + Run A state. |
| 6. ECS + hard invariant flags → Run B score + settlement authority + Run B state. |
| 7. `coreC`, `S_full`, `S_full_norm` → Run C score; `defense` vs `P_total` → failure condition; cryptobiotic state; immune state; RAM state; UWC burden. |
| 8. `Q_ceiling_A`, `Q_ceiling_full`. |
| 9. Recommended actions per run from state + flags. |
| 10. Assemble readout objects (no DOM writes inside `compute`; render is separate). |
|
|
| Purity guarantees: no `Date.now()` inside `compute` (timestamp is taken only at packet export), no `Math.random()`, no reads of prior derived state. This makes the artifact fully reviewable — a reviewer can recompute any field by hand. |
|
|
| --- |
|
|
| ## 6. Run A / B / C state machines |
|
|
| State is chosen by ordered guard clauses (first match wins), so output is unambiguous. |
|
|
| **Run A — Public Constraint Backtrace** (drivers: `S_field`, `decoderStrain`, `correlationLevel`, `publicClaimPressure`, `pUnknown`) |
|
|
| ``` |
| if S_field >= 0.55 → CORRECTED FOR LIMITED SCOPE |
| elif decoderStrain >= 0.6 → DECODER STRAIN |
| elif correlationLevel >= 0.6 → CORRELATED PRESSURE RISK |
| elif publicClaimPressure >= 0.6 → BENCHMARK SCOPE ONLY |
| elif pUnknown >= 0.55 → UNRESOLVED PRESSURE COMPRESSED |
| else → RECHECK RECOMMENDED |
| ``` |
| Run A always attempts to keep output usable; it has no settlement authority and no scope-bound closure. Residual pressure not corrected is reported as a *warning*, and may be "compressed into confidence" (flagged, never hidden). |
|
|
| **Run B — HIR/OAM Encapsulated Settlement** (drivers: `ECS`, hard invariant flags, `P_unknown`, `publicClaimPressure`, `securityRisk`) |
|
|
| Hard invariant flags (each boolean, any TRUE caps settlement): |
| ``` |
| PROVENANCE_BROKEN = provenanceContinuity < 0.4 |
| SELF_CERTIFIED = SelfCertPenalty > 0.4 |
| PUBLIC_OVERREACH = publicClaimPressure*σ_norm > 0.6 |
| UNRESOLVED_PRESSURE = pUnknown > 0.55 |
| SECURITY_RISK = securityRisk > 0.6 |
| SCOPE_MISMATCH = PressureMatch < 0.45 |
| ``` |
| State: |
| ``` |
| if PUBLIC_OVERREACH → PUBLIC CLAIM BOUNDARY REQUIRED |
| elif SECURITY_RISK or PROVENANCE_BROKEN → FAIL CLOSED FOR AFFECTED PATH |
| elif ECS >= 72 and no flags → FIELD HELD FOR CURRENT SCOPE |
| elif ECS >= 55 → LOCAL STRAIN ONLY |
| elif UNRESOLVED_PRESSURE → MUST RECHECK FIELD |
| elif ECS >= 40 → PARTIAL SETTLEMENT ONLY |
| else → ERROR ADDRESSED, NOT CLOSED |
| ``` |
| Settlement authority label: `SETTLED (scope-bound)` / `CONDITIONAL` / `WITHHELD`, derived from the state tier. |
|
|
| **Run C — Full HIR / Diamond-Gate Hexshell** (drivers: `defense` vs `P_total`, `P_malformed` vs `IM`, encapsulation, routing) |
|
|
| ``` |
| saturationMargin = defense - P_total |
| encapStrain = P_total - encapsulationThreshold |
| |
| immuneTriggered = P_malformed > IM*0.8 OR counterfeitResonance > 0.55 |
| encapTriggered = encapStrain > 0 AND IM < 0.7 // too strained to handle lawfully |
| |
| primary state (first match): |
| if saturationMargin < 0 → GATE NETWORK SATURATED |
| elif encapStrain > 0.15 → FAIL CLOSED AT SHELL BOUNDARY |
| elif encapTriggered → CRYPTOBIOTIC ENCAPSULATION ACTIVE |
| elif immuneTriggered → IMMUNE CAPTURE EVENT (+ MALFORMED TRACE QUARANTINED) |
| elif routingEfficiency >= 0.6 and gateDensity>=0.5 → OMNIDIRECTIONAL RELIEF ACTIVE |
| elif ramLearningRate >= 0.5 → PRESSURE LEARNED INTO RAM |
| elif saturationMargin >= 0.25 → GATE-ALIGNED FIELD HELD |
| else → SHELL RE-ROUTE SUCCESSFUL |
| |
| side flags (can stack): MALFORMED TRACE QUARANTINED, RESOURCE BURDEN VISIBLE (uwcThermalBurden>0.5) |
| ``` |
|
|
| **Cryptobiotic encapsulation sub-state machine** (independent track, drives the encapsulation readout): |
| ``` |
| OPEN : P_total <= encapsulationThreshold*0.6 |
| HELD : P_total <= encapsulationThreshold*0.85 |
| STRAINED : P_total < encapsulationThreshold |
| ENCAPSULATED: P_total >= encapsulationThreshold and IM < 0.7 |
| DORMANT : ENCAPSULATED and myceliumPropagation < 0.3 |
| REPAIRING : ENCAPSULATED and myceliumPropagation >= 0.5 |
| REOPENED : was ENCAPSULATED and now P_total < encapsulationThreshold*0.8 (hysteresis) |
| MUST STOP : saturationMargin < -0.2 (defense overwhelmed) |
| ``` |
| (REOPENED uses hysteresis on the previous tick; this is the one place a single prior boolean is retained, and it is explicitly part of the documented machine, not hidden state.) |
|
|
| --- |
|
|
| ## 7. UI layout |
|
|
| ``` |
| ┌────────────────────────────────────────────────────────────────────┐ |
| │ HEADER title + subtitle │ |
| │ BOUNDARY BOX (always visible, high-contrast, top of fold) │ |
| ├──────────────┬─────────────────────────────┬───────────────────────┤ |
| │ LEFT │ CENTER │ RIGHT │ |
| │ Pressure │ 105-qubit-scale pressure │ Three run readouts │ |
| │ Field │ field visual. │ (A / B / C) stacked on │ |
| │ Controls │ Run toggle: A flat lattice / │ narrow screens, side- │ |
| │ (shared + │ B trace-tagged + Evidence │ by-side ≥ 1100px. │ |
| │ Run C group │ overlay / C concentric │ Each: score dial + │ |
| │ collapsible)│ hexshells + diamond gates + │ status chips + ceiling │ |
| │ │ routing pathways. │ + recommended action. │ |
| ├──────────────┴─────────────────────────────┴───────────────────────┤ |
| │ EXPORT BAR: [Copy JSON Review Packet] [Download JSON Review Packet] │ |
| ├──────────────────────────────────────────────────────────────────────┤ |
| │ SECTIONS 1–13 (long-form, below the dashboard) │ |
| └──────────────────────────────────────────────────────────────────────┘ |
| ``` |
|
|
| Responsive: CSS grid `grid-template-columns: 320px 1fr 420px` on wide; collapses to a single column stack `<900px`. Right-panel readouts use `display:flex; flex-wrap:wrap`. No external CSS/JS. Sliders update the model on `input`; render is throttled with `requestAnimationFrame`. |
|
|
| Readout field lists (exactly as specified): |
| - **Run A:** baseline stability score · correction status · decoder strain status · correlation risk · public claim boundary · residual pressure warning · model-internal ceiling. |
| - **Run B:** field stability score · P_system profile · P_unknown honesty reservoir · ECS · hard invariant flags · settlement authority · recommended action · model-internal ceiling. |
| - **Run C:** full-stack stabilization score · diamond gate capacity · shell handoff status · omnidirectional relief status · RAM learning state · immune capture state · cryptobiotic encapsulation state · resource-truth burden · theoretical qubit-equivalent stabilization ceiling · recommended action. |
|
|
| --- |
|
|
| ## 8. Visual model description |
|
|
| A single inline `<svg>` re-rendered per tick; the run toggle swaps which layer group is drawn. |
|
|
| - **Run A — flat lattice.** A square grid of qubit-equivalent nodes. Node color = local pressure heat (green→amber→red) computed from a smooth function of `P_system` plus a fixed deterministic spatial pattern (sine of node index, no randomness) so the field reads as "pressure spreading." No gates, no shells. High pressure → red bleed across the lattice; correction status overlaid as a banner. |
|
|
| - **Run B — trace-tagged lattice.** Same grid, but nodes carry small "trace capsule" tags; an **Evidence Gate** overlay (a vertical settlement bar) sits on the field. Nodes that violate an invariant get an outline ring; scope-bound region is drawn as a dashed boundary box labeled with the operation type. Color still encodes pressure but with settlement annotations. |
|
|
| - **Run C — concentric hexshells.** `shellCount` nested hexagons drawn from outer→inner. Between each adjacent shell, **diamond gates** (rotated squares) sit on the shell vertices; `gateDensity` controls how many vertices carry a gate. Active **routing pathways** are drawn as lines fanning omnidirectionally from saturated regions toward open gates (more lines when `routingEfficiency` is high). Gate fill encodes per-gate decision: pass (green), tag (cyan), quarantine (red), encapsulate (violet), fail-closed (grey). The innermost shell shows the protected trace field. A small RAM ring and an immune-capture marker animate (CSS only) when those states are active. |
|
|
| All geometry is computed deterministically from controls; the only motion is CSS pulse/opacity transitions, never data-affecting. |
|
|
| --- |
|
|
| ## 9. JSON packet schema |
|
|
| `schema_version: "hir-oam-review-packet/2"`. Exact top-level keys (as requested), filled from `derived`: |
|
|
| ```jsonc |
| { |
| "artifact_name": "Stabilizing Beyond 105 Qubits Instrument", |
| "version": "0.2.0", |
| "schema_version": "hir-oam-review-packet/2", |
| "boundary_statement": "Public-review structural instrument only…", |
| "timestamp": "2026-…Z", |
| "input_controls": { "shared": {…}, "runC": {…}, "operationType": "…" }, |
| "shared_pressure_field": { |
| "factors": { "T":…, "Q":…, "R":…, "G":… }, |
| "S_field": …, "display_A_score": … |
| }, |
| "run_a_public_constraint_backtrace": { |
| "stability_score": …, "correction_status": "…", "decoder_strain_status": "…", |
| "correlation_risk": "…", "public_claim_boundary": "…", |
| "residual_pressure_warning": "…", "model_internal_ceiling": … |
| }, |
| "run_b_hir_oam_encapsulated": { |
| "field_stability_score": …, "settlement_authority": "…", |
| "recommended_action": "…", "state": "…", "model_internal_ceiling": … |
| }, |
| "run_c_full_hir_architecture": { |
| "full_stack_score": …, "S_full_raw": …, "S_full_norm": …, |
| "shell_handoff_status": "…", "omnidirectional_relief_status": "…", |
| "ram_learning_state": "…", "immune_capture_state": "…", |
| "state": "…", "recommended_action": "…", |
| "theoretical_qubit_equivalent_ceiling": … |
| }, |
| "p_system_profile": { "P_lattice":…, …, "P_unknown":…, "P_system":…, "P_total":… }, |
| "p_unknown": …, |
| "evidence_conversion_score": { "ECS": …, "components": {…} }, |
| "hard_invariant_flags": ["PUBLIC_OVERREACH", …], |
| "diamond_gate_profile": { "DG":…, "GateCapacity":…, "gateDensity":…, "saturationMargin":… }, |
| "shell_profile": { "shellCount":…, "ShellMultiplier":…, "RecoveryFactor":… }, |
| "ram_learning_profile": { "RAM":…, "state":"…" }, |
| "immune_capture_profile": { "IM":…, "state":"…", "quarantined": true|false }, |
| "cryptobiotic_encapsulation_state": "OPEN|HELD|…|MUST STOP", |
| "uwc_resource_truth_profile": { "UWC":…, "thermal_burden":…, "visibility":…, "penalty_applied": bool }, |
| "theoretical_qubit_equivalent_ceiling": …, |
| "settlement_authority": "SETTLED (scope-bound)|CONDITIONAL|WITHHELD", |
| "recommended_action": "…", // overall, from highest-stakes run |
| "public_claim_boundary": "…", |
| "claims_not_made": [ "No physical qubits stabilized", "No QEC replacement", … ] |
| } |
| ``` |
|
|
| `timestamp` is the **only** non-deterministic field and is generated solely at export. Copy uses `navigator.clipboard.writeText`; Download builds a `Blob` and an object-URL anchor. |
|
|
| --- |
|
|
| ## 10. Boundary language |
|
|
| Verbatim strings baked into the build (header boundary box + Sections 1, 12, 13): |
|
|
| - Boundary box: *"Public-review structural instrument only. Not quantum hardware control. Not direct qubit measurement. Not QEC replacement. Not a Google / Willow product claim. Public constraints only. Run C is a theoretical HIR architecture model, not a hardware validation."* |
| - `claims_not_made` array: no physical qubits are stabilized; no quantum error correction is performed or replaced; no hardware is controlled or measured; no Google / Willow endorsement, access, or product relationship; "ceiling" values are **model-internal / theoretical qubit-equivalent** only; all results are bounded to the declared operation scope. |
|
|
| Output naming is fixed: the scaling result is always rendered as **"theoretical qubit-equivalent stabilization ceiling"** or **"model-internal stabilization ceiling,"** never "qubits stabilized." |
|
|
| --- |
|
|
| ## 11. Suggested next-step implementation plan (single-file static HTML) |
|
|
| 1. **Skeleton** — one `index.html`; `<style>` with CSS variables for theme (dark instrument palette, per-run accent), `<body>` with header, boundary box, dashboard grid, export bar, sections, single `<script>`. |
| 2. **State + controls** — declare `controls` object with defaults; generate sliders from a config array (label, key, min/max/step, direction tooltip) so adding a control is one line. Bind `input` listeners → mutate `controls` → schedule render. |
| 3. **`compute(controls)`** — pure function implementing §4/§5/§6. Unit-checkable by hand. Returns `derived`. |
| 4. **`render(derived)`** — write the three readout panels and the SVG. Keep DOM writes out of `compute`. |
| 5. **SVG layers** — three draw functions (`drawLatticeA`, `drawLatticeB`, `drawHexshellC`) sharing a node-grid helper; run toggle picks one. All geometry deterministic. |
| 6. **Export** — `buildPacket(controls, derived)` → JSON; wire Copy and Download buttons; stamp `timestamp` here only. |
| 7. **Sections 1–13** — static long-form copy with the boundary language from §10. |
| 8. **QA pass** — verify determinism (same inputs → identical packet sans timestamp), responsive collapse `<900px`, no external requests, no `Math.random` in `compute`, and that no string anywhere claims physical qubit stabilization. |
|
|
| No frameworks, no build step, no network calls — drops straight into a static Hugging Face Space. |
|
|
