Skip to the calculator

The universal accountability standard

One formula for whether a system is actually accountable.

Everything in a life — and every regulated domain — resolves into the same eight axes. The Master Equation turns them into a single composite. Because the math is multiplicative, you can't fake a missing pillar to lift the score; and the consistency exponent means it's steadiness across all eight that compounds. We don't ask you to trust the number — you can recompute it yourself, right here.

CH = (S × Sp)C × (T + E)p × (ER × RS)C/3

Three-wing canonical form · the same clean-room engine that powers the live health product

Run the 41 validation tests → Drag the eight axes →

Open calculator.js · recompute it in your own browser

Patent-pending — U.S. Provisional 63/921,717

The standard, said plainly

Conceptual Health is the Gold Standard for accountability across finance, medical, government, corporate, law, insurance, education, pharma, energy, and aerospace.

Accountable by construction — and the old way is out. You don't trust the vendor or an annual audit opinion; you verify it yourself, live, with one formula and one chain anyone can check.

The eight axes

The dimensions of accountability — for any system, or any life.

Any system you'd want to hold accountable can be read on these eight axes. They are the inputs to the formula; the names and roles below are exactly the ones the engine computes with — nothing relabeled. Multiply, don't average: a strong showing on one axis can't paper over a collapse on another.

POPhysical & OutdoorS · somatic foundation (with NM)
NMNutritional & MetabolicS · somatic foundation (with PO)
EREmotional & RelationalER · resilience-wing factor
SCSocial & CommunalSp · coherence amplifier
RSReligious & SpiritualRS · resilience-wing factor
ESEnvironmental & StewardshipE · right-wing addend
TATechnological & AdaptiveT · right-wing addend
PVProvisional & Vocationalp · right-wing exponent

Below, drag any axis from 0–100 and watch the composite recompute live. Then run the 41 tests, or open the source — the same engine, the same numbers, in your browser.

Drag the axes.

Each axis is independently scored 0–100. Drag a slider to see how it moves the composite and every term of the math breakdown.

Which axis matters most right now

This shows how much the composite drops if that axis were zero (all others held steady). Longer bar = bigger penalty if you neglected it — the multiplicative structure at work.

Composite · live orb

—

—

050100

Computed variables

S—
= (PO + NM) / 2
Sp—
= SC
C—
= mean of all 8 axes
T—
= TA
E—
= ES
p—
= PV

Three wings

Left: (S × Sp)C —
Right: (T + E)p —
Resilience: (ER × RS)C/3 —
raw —
log₁₀(raw) —
norm to [0,100] —

Verify this result

You don't have to take the number on faith — and you don't have to be a programmer. Click below: we recompute this exact score, in front of you, in your own browser, and show the work.

For engineers: open calculator.js, or run CHMasterEquation.runTests() in the console. (The verifiable-by-WASM layer plugs in here.)

One framework · ten domains · one engine

Pick your domain. Watch the same engine score your world.

The eight axes never change — and they are never relabeled. Selecting a domain shows what each canonical axis means when the standard is read in that domain, and loads a representative profile into the same calculator above. Nobody else pairs one accountability measure with a chain and a public verifier. Medicine is the live, shipped anchor; the others are the same standard extended.

Claim-safe by design: these are how the standard reads in each domain — not "we measured Bank X at 73." The numbers come from illustrative profiles run through the public engine; you can change every slider and recompute it yourself. Medicine is live in production today; the other nine are the same proven method applied to that domain.

Don't trust the number — validate it yourself.

41 assertions covering: bounds (all-zero, all-max, all-mid), monotonicity (raising any axis raises the composite, lowering any lowers it), non-linearity (zeroing any axis from balanced harms the composite significantly), range (every preset lands in [0,100]), determinism (same input → same output), and NaN safety. They run instantly in your browser against this page's loaded engine — no server round-trip.

Click Run validation tests to execute all 41 in-browser. The tests run against this page's loaded calculator — no server round-trip.

PresetPONMERSCRSESTAPVCH

For the curious

How the math works.

The three wings

The composite is the product of three multiplicative "wings", each anchored to a different aspect of an accountable, whole system:

Why multiplicative?

Legacy composites average a handful of items. Averaging lets a high score on one axis mask a collapse on another — so a system can look "fine" while a pillar has failed. This formula is multiplicative because real accountability isn't separable: a deficit in any axis non-linearly reduces the whole. You can't fake a missing pillar to lift the number. As a worked clinical example: a heart-attack survivor with great labs but zero social support does not score "ok" here — the missing axis pulls the whole composite down, exactly as it should.

The consistency exponent

C (Conceptual Mastery) is the mean of all eight axes. It's the exponent on both the left and resilience wings because: when you're consistently strong across the board, C ≈ 10 (in the engine's internal [0, 10] axis-space — see normalization note below) and the wings reflect their honest multiplicative result. When inconsistent and chaotic, C → 0 and the wings approach 1 — but the raw values they sit on are also small, so the overall composite stays low. Consistency rewards the consistent and protects the inconsistent from infinite penalty.

Normalization & log rescaling

For numerical-stability reasons the engine internally operates on axes divided by 10, so each axis enters the formula as a value in [0.0, 10.0] (computed as axis_score / 10; see calculator.js lines 95–119). In this internal space the raw multiplicative result spans from near 0 to about 1040, with the upper bracket established at LOG10_CEIL = 39.68. We then rescale via log₁₀ bracketed to [0, 39.68] and map to [0, 100] for display. The brackets are chosen so all-axes-at-0 displays as 0 and all-axes-at-100 displays as 100, with a meaningful gradient between. The ~1040 figure is the raw upper bound in the engine's [0, 10] internal space, not what you would get by plugging 0–100 values directly into the closed-form formula.

Reference implementation

The function shown here is the same clean-room engine (calculator.js) running live in the health product today — and running right now in your browser: the 41 validation tests below execute locally, with nothing sent to a server. Source: master-equation/calculator.js in the open protocol layer. Test suite: master-equation/calculator.js#runTests() — 41 assertions. Patent-pending — U.S. Provisional 63/921,717.

Want to verify the math yourself? Five ways, all open:

  1. Run the tests live: click Run validation tests above — all 41 assertions execute in your browser against the loaded calculator code.
  2. Console it: open your browser's developer console on this page, type CHMasterEquation.runTests(), press Enter, read the results object.
  3. Read the open source: the raw JavaScript (~300 lines, unminified, fully commented) is at calculator.js — view source →. That link opens the plain-text source file — the actual code that runs on this page, served for line-by-line audit.
  4. Cross-platform parity: the byte-equivalent Python port calculator.py ships with 50 golden vectors. Both JS and Python must pass every vector to ≤ 0.05 on every commit. Clone the repo and run python3 master-equation/tests/test-golden-vectors.py — 50/50 must pass.
  5. Recompute it yourself: the 41 in-browser tests and the 50 golden vectors run locally in your own browser — open your developer tools or the test panel above and watch them execute against this page's loaded engine. The clean-room SHA3 and the engine itself are open and readable, so you can recompute any result by hand. See Verify it yourself →.

Sub-signals & action map: every action that moves the equation is declared in sub-signals.yaml (measurable signals across the eight axes) and action-axis-map.yaml (every action → which signal(s) it updates, with fraud controls). No movement happens outside this contract.

The measure, and the integrity

The formula is the measure. The chain is the integrity.

A score is only as trustworthy as the record behind it. The formula above lets anyone recompute the measure. The other half of the standard is that every record, every access, and every change is gated, stamped, and reconstructable on an append-only chain — so the inputs are accountable too, and that is verifiable the same way.

What you just verified

The measure

The eight axes go in; one composite comes out; the math is open and you recomputed it in your own browser. No server, no trust required — just arithmetic you can check.

What the chain adds

The integrity

So you can trust the inputs as much as the math, the architecture is built so that:

  • every consequential action is gated and recorded append-only;
  • records and accesses are stamped and reconstructable after the fact;
  • any change is a new, attested version — tampering shows.

This is engineered by construction — not an annual stamp from someone else. The continuous, recompute-it-yourself proof of the record lives in the Verify hub → (the live in-browser record verifier; expanding). We state this honestly: the standard is set by us and proven live; we don't claim third-party certifications we don't hold.

Who built this — and what's next

Built by people who've carried the accountability burden themselves.

The same engine you just ran is in production today in the medical vertical. It was built by two founders who spent their careers inside the regulated world they're now setting the standard for.

Maria R. Lahti, MD

Co-founder · Physician

27 years as a government physician. Brought the clinical ground-truth and the duty-of-care discipline the standard is anchored in.

Raymond M. Lahti

Co-founder · Information Security Manager · HIPAA Security Officer

30 years in government as an information security manager and HIPAA security officer. Carried the compliance and integrity burden the standard is designed to remove.

See it in your domain.

See your domain → Talk to us →
Patent-pending — U.S. Provisional 63/921,717 Same engine in production today (medical) 41 tests · recompute it yourself, live