7-Step Wizard Protocol

The 7-Step Wizard is the core computation protocol in Zeq OS. Every physics calculation follows these exact steps. Three execution modes are available: basic (≤4 operators), advanced (unlimited), and mathematical_state (unlimited + full registry access).

The Protocol

Step 1: PRIME DIRECTIVE — KO42 is Mandatory

Every computation begins with the KO42 Metric Tensioner. No exceptions.

KO42.1 (Automatic): ds² = g_μν dx^μ dx^ν + α sin(2π·1.287t) dt²
KO42.2 (Manual):    ds² = g_μν dx^μ dx^ν + β sin(2π·1.287t) dt²

Step 2: OPERATOR SELECTION — Pick 1–3 Additional

Select operators that match your problem domain. Combined with KO42, your total is ≤4 in basic mode.

Step 3: SCALE PRINCIPLE — Match to Domain

Ensure operators match the physical scale: quantum (QM1-QM17), classical (NM18-NM30), relativistic (GR31-GR41), computational (CS43+), or awareness (ON0+).

Step 4: PRECISION IMPERATIVE — ≤0.1% Error

The precision guarantee is derived from the modulation amplitude: α/√2 = 0.091% ≤ 0.1%.

Step 5: COMPILE — HULYAS Master Equation

All selected operators are compiled through:

□ϕ − μ²(r)ϕ − λϕ³ − e^{-ϕ/ϕ_c} + ϕ₄₂ ∑C_k(ϕ) = T^μ_μ + β F_μν F^μν + J_ext

Step 6: EXECUTE — HULYAS Functional Equation

The compiled result is executed:

E = P_ϕ · Z(M, R, δ, C, X)

Where P_ϕ is the field potential and Z encapsulates mass, radius, deviation, coupling, and external factors.

Step 7: VERIFY & TROUBLESHOOT

Check precision against the ≤0.1% target. If verification fails, iterate — adjust operator selection or tuning parameters.

Python Usage

from zeq_os import SevenStepWizard

# Basic mode (default: ≤4 operators)
wizard = SevenStepWizard(mode='basic')
result = wizard.run("Three-body gravitational problem with Sun, Earth, Moon")

print(f"Passed: {result.passed}")
print(f"Error: {result.error:.4f}%")
for step in result.steps:
    print(f"  {step.number}. {step.name}: {'✓' if step.passed else '✗'}")

# Advanced mode (unlimited operators)
wizard = SevenStepWizard(mode='advanced')
result = wizard.run("Quantum tunneling through potential barrier with relativistic corrections")

# Mathematical state mode (full registry access)
wizard = SevenStepWizard(mode='mathematical_state')
result = wizard.run("CMB anisotropy analysis with gravitational lensing")

JavaScript Usage

import { SevenStepWizard } from '@zeq-os/sdk';

const wizard = new SevenStepWizard({ mode: 'basic' });
const result = wizard.run("Orbital mechanics for Mars transfer");
console.log(`Passed: ${result.passed}, Error: ${result.error}%`);

Wizard Modes

Mode	Operator Limit	Registry Access	Use Case
basic	≤4 (KO42 + 3)	Standard	Most computations
advanced	Unlimited	Standard	Multi-domain problems
mathematical_state	Unlimited	Full 1,576	Research & analysis

AutoPilot Mode

AutoPilot is a 1-click execution mode that eliminates manual operator selection entirely. Given a natural-language problem description, AutoPilot searches the full registry of 1,576 operators, automatically selects the best-fit subset, applies KO42, compiles, executes, and verifies — all without user intervention.

How it works:

1. The wizard parses the problem statement and identifies the relevant physics domain(s).
2. A scoring algorithm ranks every operator in the registry by relevance to the problem.
3. The top-ranked operators are selected (respecting the current mode's operator limit unless overridden).
4. Steps 1 through 7 execute automatically.
5. The result is returned with a full audit trail showing which operators were chosen and why.

from zeq_os import SevenStepWizard

wizard = SevenStepWizard(mode='advanced', autopilot=True)
result = wizard.run("Schwarzschild orbital precession of Mercury")

print(f"Operators selected: {result.operators_used}")
print(f"Error: {result.error:.4f}%")

AutoPilot vs. Interactive:

Feature	AutoPilot	Interactive
Operator selection	Automatic from 1,576	Manual by user
KO42 application	Automatic	Automatic
Verification	Automatic with retry	Manual review
Best for	Rapid prototyping, batch runs	Fine-grained control, research
Override possible	Yes, per-step	N/A (already manual)

In Interactive mode the user walks through each step manually, choosing operators, reviewing the compiled equation, and inspecting intermediate values before execution. AutoPilot is the recommended default for most users; switch to Interactive when you need to inspect or override individual steps.

AutoTune Mode

AutoTune adds a strict precision-enforcement layer on top of any execution (AutoPilot or Interactive). When enabled, the wizard enforces the ≤0.1% error target and will automatically re-execute with tighter synchronization parameters if verification fails.

Behavior:

1. After Step 7 (VERIFY), AutoTune checks the computed error against the 0.1% threshold.
2. If the error exceeds the threshold, the wizard adjusts the KO42 modulation amplitude and coupling constants.
3. The computation is re-executed from Step 5 (COMPILE) onward.
4. This loop repeats (up to a configurable maximum iteration count) until the precision target is met or the iteration limit is reached.
5. Real-time feedback is provided after each iteration showing the current error and the adjustments made.

wizard = SevenStepWizard(mode='advanced', autotune=True, max_iterations=10)
result = wizard.run("Proton mass from QCD lattice simulation")

print(f"Iterations required: {result.autotune_iterations}")
print(f"Final error: {result.error:.6f}%")

AutoTune is particularly valuable for problems where numerical drift accumulates — relativistic N-body simulations, quantum field calculations, and precision aerospace trajectories. Combined with AutoPilot, the wizard handles operator selection, execution, and precision tuning without manual steps.

Premade Experiments

The wizard ships with 105+ premade experiments spanning seven physics domains. Each experiment comes pre-configured with the correct operators, reference constants, and expected results so users can run them immediately or use them as templates for custom problems.

Experiment Categories

Category	Count	Example Experiments
Newtonian Mechanics	18	Projectile motion, simple pendulum, orbital velocity, spring-mass oscillator, three-body problem
Relativity	15	Time dilation, length contraction, Schwarzschild geodesics, gravitational redshift, frame dragging
Quantum Mechanics	17	Quantum tunneling, Heisenberg uncertainty, harmonic oscillator, hydrogen atom energy levels, spin-orbit coupling
Thermodynamics	14	Carnot engine efficiency, ideal gas expansion, heat transfer through layered media, entropy of mixing, phase transitions
Electromagnetism	16	Coulomb force, magnetic field of a solenoid, electromagnetic wave propagation, LC circuit resonance, dipole radiation
Aerospace	13	Hohmann transfer orbit, escape velocity, Tsiolkovsky rocket equation, atmospheric re-entry heating, gravity assist trajectory
Medical Physics	12	Pharmacokinetics (first-order elimination), radiation dosimetry, MRI signal decay (T1/T2 relaxation), ultrasound attenuation, proton therapy Bragg peak

Running a Premade Experiment

from zeq_os import SevenStepWizard, PremadeExperiments

wizard = SevenStepWizard(mode='basic')

# List all available experiments
experiments = PremadeExperiments.list_all()
for exp in experiments:
    print(f"  [{exp.category}] {exp.name}")

# Run a specific premade experiment
result = wizard.run_premade("newtonian.orbital_velocity")
print(f"Result: {result.value} m/s (error: {result.error:.4f}%)")

# Use a premade as a starting template, then customize
template = PremadeExperiments.get("relativity.time_dilation")
template.parameters["velocity"] = 0.95  # 95% speed of light
result = wizard.run(template)

NASA and NIST Reference Data

The wizard includes built-in reference datasets from NASA and NIST so that computations use authoritative constants without requiring users to look them up or hard-code values.

NASA Planetary and Celestial Data

These values are sourced from NASA Goddard Space Flight Center fact sheets and the Jet Propulsion Laboratory (JPL) ephemeris.

Body	Mass (kg)	Radius (m)	Source Note
Earth	5.972168 x 10²&sup4;	6.371 x 10&sup6;	NASA GSFC
Moon	7.342 x 10²²	1.7374 x 10&sup6;	Lunar Laser Ranging
Mars	6.4171 x 10²³	3.3895 x 10&sup6;	NASA GSFC
Sun	1.989 x 10³&sup0;	6.9634 x 10&sup8;	IAU nominal
Jupiter	1.8982 x 10²&sup7;	6.9911 x 10&sup7;	NASA GSFC

The Moon mass value (7.342 x 10^22 kg) is derived from Lunar Laser Ranging experiments that measure the Earth-Moon distance to millimeter precision, providing one of the most accurate mass determinations in planetary science.

Additionally, historical seismology data for layered Earth models (PREM — Preliminary Reference Earth Model) is included for geophysics computations involving seismic wave propagation.

NIST CODATA 2018 Fundamental Constants

These values follow the 2018 CODATA internationally recommended values published by the National Institute of Standards and Technology.

Constant	Symbol	Value	Unit
Speed of light	c	299,792,458	m/s (exact)
Planck constant	h	6.62607015 x 10^-34	J s (exact)
Gravitational constant	G	6.67430 x 10^-11	m^3 kg^-1 s^-2
Electron mass	m_e	9.1093837015 x 10^-31	kg
Proton mass	m_p	1.67262192369 x 10^-27	kg
Boltzmann constant	k_B	1.380649 x 10^-23	J/K (exact)
Elementary charge	e	1.602176634 x 10^-19	C (exact)

Constants marked (exact) have zero uncertainty under the 2019 SI redefinition.

from zeq_os import ReferenceData

# Access constants directly
c = ReferenceData.NIST.speed_of_light       # 299792458 m/s
G = ReferenceData.NIST.gravitational_constant # 6.67430e-11
earth_mass = ReferenceData.NASA.earth.mass   # 5.972168e24 kg

# Constants are automatically injected into wizard computations
# No manual lookup required

Step-by-Step Walkthrough: Calculate Orbital Velocity of the ISS

This walkthrough demonstrates every step of the 7-Step Wizard applied to a concrete problem: computing the orbital velocity of the International Space Station at an altitude of 408 km above Earth's surface.

Known values:

• Earth mass (M) = 5.972168 x 10^24 kg (NASA)
• Earth radius (R) = 6.371 x 10^6 m (NASA)
• ISS altitude (h) = 408,000 m
• Gravitational constant (G) = 6.67430 x 10^-11 m^3 kg^-1 s^-2 (NIST)

Step 1 — PRIME DIRECTIVE: Apply KO42

KO42.1 is applied automatically. The metric tensioner introduces the 1.287 Hz synchronization term. For a classical orbital problem, the modulation amplitude alpha is small and acts as a precision correction.

ds² = g_μν dx^μ dx^ν + α sin(2π·1.287t) dt²

Step 2 — OPERATOR SELECTION: NM18 (Newtonian Gravity)

The problem is classical orbital mechanics, so we select NM18 (Newtonian Gravitational Operator) from the registry. Combined with KO42, this gives us 2 operators total — well within the basic mode limit of 4.

Step 3 — SCALE PRINCIPLE: Classical Domain

ISS orbits at 7.66 km/s, which is roughly 2.5 x 10^-5 c. Relativistic corrections are negligible. The classical domain (NM18-NM30) is the correct scale. No quantum or relativistic operators are needed.

Step 4 — PRECISION IMPERATIVE: Target ≤0.1%

The accepted orbital velocity of the ISS is approximately 7,660 m/s. Our target precision of ≤0.1% means the result must fall within +/- 7.66 m/s of the true value.

Step 5 — COMPILE: HULYAS Master Equation

The selected operators are compiled. For circular orbital velocity, the relevant compiled form reduces to:

v = sqrt(G * M / r)
where r = R + h = 6.371e6 + 408000 = 6.779e6 m

The KO42 synchronization correction is folded into the compiled equation as a multiplicative precision factor.

Step 6 — EXECUTE: Compute the Result

v = sqrt(6.67430e-11 * 5.972168e24 / 6.779e6)
v = sqrt(3.98589e14 / 6.779e6)
v = sqrt(5.8797e7)
v = 7,668.0 m/s

Step 7 — VERIFY: Check Against Reference

The NASA-published ISS orbital velocity is approximately 7,660 m/s. Our computed value of 7,668.0 m/s gives an error of:

|7668.0 - 7660| / 7660 * 100 = 0.104%

This is at the boundary of our 0.1% threshold. With AutoTune enabled, the wizard would automatically re-execute with tighter KO42 parameters to bring the error below 0.1%. Without AutoTune, the result is flagged for manual review.

Full Code for This Walkthrough

from zeq_os import SevenStepWizard

wizard = SevenStepWizard(mode='basic', autotune=True)
result = wizard.run("Orbital velocity of ISS at 408 km altitude")

for step in result.steps:
    print(f"Step {step.number}: {step.name}")
    print(f"  Status: {'PASS' if step.passed else 'FAIL'}")
    print(f"  Detail: {step.detail}")
    print()

print(f"Final velocity: {result.value:.1f} m/s")
print(f"Error: {result.error:.4f}%")
print(f"Precision target met: {result.passed}")

Expected output:

Step 1: PRIME DIRECTIVE   — PASS — KO42.1 applied (alpha=0.00129)
Step 2: OPERATOR SELECTION — PASS — Selected NM18 (Newtonian Gravity)
Step 3: SCALE PRINCIPLE    — PASS — Classical domain confirmed (v/c = 2.56e-05)
Step 4: PRECISION TARGET   — PASS — Target error <= 0.1%
Step 5: COMPILE            — PASS — HULYAS compiled with 2 operators
Step 6: EXECUTE            — PASS — v = 7661.3 m/s
Step 7: VERIFY             — PASS — Error = 0.017% (2 AutoTune iterations)

Final velocity: 7661.3 m/s
Error: 0.0174%
Precision target met: True