MNVP — how a number should be seen
Multi-layer Numerical Visualization Protocol
ICNS answers what a numeral is. MNVP answers how an already-interpreted number should be shown — under a task, a medium, an audience, accessibility requirements and an explicit information-loss budget. It treats rendering as constrained semantic compilation rather than a front-end styling decision, and it refuses to let cognitive convenience be bought with semantic distortion.
- Version
- v1.0.0
- Protocol
- 1.0
- Frozen
- 2026-07-30
- Status
- STABLE
- Profiles
- 4
- Visual profiles
- 7
- Render targets
- 5
- Stable API paths
- 49
- Tests
- 266
- License
- undecided
Correct is not the same as readable
Scientific notation is exact. It is also five separate acts of mental work before a reader can say which of two numbers is bigger. And the older failure is worse: a display can be perfectly legal and still assert a relationship that does not exist.
SemanticallyCorrect(x) =>/= CognitivelyAccessible(x) 4.4 x 10^26 vs 1.6 x 10^-35 exact, and yet the reader must first: 1. split coefficient from exponent 2. read the sign 3. compute or estimate the exponent gap 4. turn that gap into scale intuition 5. decide whether the two belong on one axis at all and the failure that is not about effort at all: version 0.9 vs 0.10 shown on a decimal axis -> the picture says 0.10 > 0.9 the schema says otherwise -> the display did not lose information, it ASSERTED a false order
MNVP’s first principle follows directly: semantics before appearance. Given the bare string `0.91` with no schema, a renderer may print the literal characters and nothing more — it may not decide to draw it as a version ladder, a decimal proportion or a percentage. Unresolved input caps what a projection is allowed to claim.
Rendering as constrained semantic compilation
A projection takes three inputs and must return two outputs. The second output is the part conventional rendering never produces: a machine-readable account of what this particular view preserved, omitted and can still be trusted for.
V : N x C x P -> G x R
N numerical object value, schema_ref, scale, unit, precision, resolution,
uncertainty, quality, derivation, provenance, constraints
C projection context task, medium, audience, interaction, accessibility,
disclosure level, loss budget
P visual profile required semantics, channel map, disclosure, fidelity,
accessibility contract
G perceptual output primary display + channel map + layers + alt text
R report preserved / omitted / unknown, loss, fidelity checks
field states: KNOWN UNKNOWN NOT_APPLICABLE WITHHELD INFERRED
UNKNOWN must never be rendered as zero,
NOT_APPLICABLE must never be rendered as missingFrozen in 1.0: six value kinds (scalar, scientific, tuple, interval, distribution, samples), seven uncertainty kinds (none, unknown, plus-minus, interval, distribution, samples, scenario-set) and three distribution families (normal, lognormal, uniform). A `±` is not self-explanatory, so `interpretation` — standard deviation vs. confidence interval — is carried explicitly rather than assumed.
Seven rules a projection has to obey
Most of these are restraints on the renderer, not features for the reader. That is deliberate: the failure mode being designed against is a beautiful view that quietly changed the answer.
Semantics before appearance
A renderer must not infer full semantics from how something looks. No schema means no semantic projection — only the literal string.
Projection depends on task
There is no task-free best representation. Engineering wants scale, finance wants fixed precision, science wants uncertainty, audit wants provenance. Two different views of one number are not evidence that one of them is wrong.
Compression must not distort what matters
The task-critical semantics must be a subset of what the projection preserves. If the task is deciding whether two measurements are meaningfully apart, a centre-value-only chart is not a faithful projection of them.
Progressive disclosure, not permanent deletion
Simplifying is allowed; it must be expandable. A lower layer may omit, but must keep the expansion path, the omission hint, the full value and the machine-readable data underneath. Hidden costs less than destroyed.
Cross-medium semantic equivalence
SVG, plain text, LaTeX, speech and touch may look nothing alike, but the task-critical semantics must decode to the same meaning. Equivalence is about what can be recovered, not about appearance.
Incomparability must stay visible
If two objects share no comparison domain, placing them on one axis must not imply they can be ordered. The view has to say INCOMPARABLE, CONVERSION_REQUIRED, SCHEMA_MISMATCH, UNIT_MISMATCH or UNCERTAINTY_OVERLAP — a missing rule may not be dressed up as a size difference.
Accessibility is redundancy, not an add-on
Colour may enhance a channel but may never be the only one carrying information. If hue encodes scale or confidence, text, shape, pattern, position, stroke or an assistive-technology label must carry it too. WCAG 2.2 is the floor here, not the goal.
Visual channels are not interchangeable
Position on a common scale and length support precise quantitative comparison in a way that angle, area and hue do not — a result from the graphical-perception literature. MNVP encodes that as default channel policy rather than as a universal psychological law, and every mapping stays overridable per profile.
| Semantic | Preferred channel |
|---|---|
| value | Position on a common axis; length or text as secondary |
| scale | Logarithmic or banded position; exponent text |
| precision | Significant digits, boundary markers, stroke |
| uncertainty | Interval, distribution or sample set; text |
| unit | Text, icon, grouping position |
| quality | Badge, stroke style, explicit state text |
| incomparable | Separated regions, a blocking marker, diagnostic text |
Channels can also collide: map magnitude and uncertainty both to area and a reader cannot separate them. MNVP scores that as a conflict and requires the renderer to switch channels, lower the disclosure level, split into several views, or emit W_CHANNEL_CONFLICT.
Four layers, and a manifest of what is missing
A finite medium cannot always show complete semantics, so MNVP does not demand zero loss — it demands that loss be declarable, measurable and controllable. Each semantic carries a task weight; the omitted weights are summed and compared against the context’s budget.
| Layer | Name |
|---|---|
| L0 | Primary |
| L1 | Comparative |
| L2 | Interpretive |
| L3 | Audit |
If a semantic carries infinite weight — a currency, a fixed precision, a decisive uncertainty, a revoked state — omitting it does not merely exceed the budget, it makes the render fail with E_LOSS_BUDGET_EXCEEDED. This is the mechanism that turns "should we simplify?" from a style preference into a checkable rule, including for an AI writing the output.
Eight checks, and what each one catches
Fidelity here does not mean the picture resembles the number. It means the projection did not change the judgement the current task depends on — so it is task-relative by construction, and a view can be faithful for rough ranking while unfaithful for deciding whether two distributions overlap.
Value, order, sign, scale
- Value decodes back to the input, or stays inside a declared approximation bound
- Truncated axes and area ratios may not reverse a required ordering (E_ORDER_REVERSED)
- A minus sign, direction or inverse state may not vanish into formatting (E_SIGN_HIDDEN)
- A non-linear scale must be visibly declared or readable by assistive technology
Precision, uncertainty, unit, comparability
- Displayed precision may never exceed input precision — 0.9 must not become 0.900000 (E_PRECISION_OVERSTATED)
- If the profile requires uncertainty, dropping it fails rather than warns (E_UNCERTAINTY_DROPPED)
- A unit may not be hidden where the number is read (E_UNIT_HIDDEN)
- Upstream INCOMPARABLE forbids any total-order axis downstream (E_INCOMPARABLE_ALIGNED)
Accessibility as a hard check
- Colour-only encoding is an error, not a lint warning (E_COLOR_ONLY)
- Missing alternative text is an error (E_ALT_TEXT_MISSING)
- Key information behind hover only is flagged (W_HOVER_ONLY)
- SVG output must carry <title>, <desc> and a traceable object id
Visual spoofing
- Hidden minus signs, zero-width characters and Unicode homoglyphs
- Low-contrast critical information and truncated axes
- Undeclared non-linear scales and selective omission of inconvenient data
- Weakening a REVOKED state into an ordinary colour
MNVP also keeps five things apart that get collapsed constantly: CONTENT_VALID, SIGNATURE_VALID, PUBLISHER_TRUSTED, SEMANTICALLY_CORRECT and EMPIRICALLY_TRUE. A valid signature says nothing about whether the number is right about the world.
Seven frozen profiles, each pinned by digest
A visual profile is the contract: which semantics are required, which channels carry them, how disclosure behaves, what fidelity must hold, what accessibility must hold. Profile identity is immutable — the same ID and version may never point at different content.
| Profile | For |
|---|---|
| [email protected] | Fast reading in tight space |
| [email protected] | Measurement and comparison |
| [email protected] | Estimation and tolerance |
| [email protected] | Version tuples |
| [email protected] | Intervals, distributions, samples |
| [email protected] | Audit |
| [email protected] | Assistive technology |
The whitepaper also drafts a financial profile (decimal exactness, currency, rounding mode, minimum unit, audit state); it is not in the frozen built-in set, so it is a draft here and not a shipped capability. Custom and signed third-party profiles are supported through the registry — Ed25519, with the trust states TRUSTED, VALID_UNTRUSTED, VALID_REVOKED_KEY, UNSIGNED and INVALID kept distinct.
The rendering pipeline
The renderer never mutates the numerical object, and high-risk profiles validate fidelity before an artifact is returned rather than after. Context resolution has a fixed priority — inline request, component, document, application, user accessibility preferences, system default — and an accessibility preference may not be overridden by a lower layer.
Five built-in targets come out of it — text, HTML, SVG, LaTeX and Vega-Lite — plus a cross-scale view and an uncertainty view. MNVP sits between structured numerical data and chart grammar rather than replacing either: it can compile to Vega-Lite, and it can refuse to let semantically incomplete or incomparable data reach a chart that would misrepresent it.
Four profiles, 31 features, one contract hash
MNVP went from theory to capped spec in one cycle — v0.1 prototype, v0.2 uncertainty, v0.3 document binding and LSP, v0.4 signed profiles and conformance, v0.5 renderer packages and the pre-integration baseline, then 1.0 — with every stage keeping the previous stage’s regressions.
Core 1.0 — 6 features
- Numerical Object validation and normalization
- Projection Context: task, medium, audience, interaction, accessibility, loss budget
- Visual Profile model with immutable profile identity
- Six value kinds and seven uncertainty kinds
- Canonical normalization to protocol 1.0 while still accepting 0.1–0.5 objects
Projection 1.0 — 12 features
- Task- and profile-aware channel planning
- Progressive disclosure and the omission manifest
- Task-relative semantic loss budget
- Fidelity checks: value, order, sign, scale, precision, uncertainty, unit, comparability
- Accessibility: alternative text, non-colour redundancy, audit
- Five renderers plus cross-scale and uncertainty views
Interop 1.0 — 8 features
- ICNS adapter: token to provenance, canonical to value, schema id/version/hash to schema_ref
- Markdown inline syntax, sidecar document bindings, embedded mnvp JSON blocks
- Batch rendering and reproducible Artifact Manifests that can be re-verified offline
- Ed25519-signed visual profiles with a local trust store and an immutable registry
- Declarative renderer packages — templates with no arbitrary code execution — signed and shipped as reproducible .mnvp-plugin.zip
- Capability negotiation and object/profile migration with verifiable migration reports
Tooling 1.0 — 5 features
- CLI: validate, plan, render, fidelity, adapt-icns, cross-scale and more
- REST API across 49 frozen paths with a locked OpenAPI document
- Language server with diagnostics over MNVP documents
- Offline Manifest V3 browser extension
- Conformance runner: mnvp-core-v1.0, 12 cases, PASS, package and report both digest-pinned
Verified by 266 regression tests across six suites, a release audit and a smoke report, all PASS, with 23 JSON Schemas and the whole contract pinned at sha256:1aff494b…. Two honest details from the release itself: component formats are versioned independently of the product, so profile IDs at @0.1/@0.2, profile signature 0.4 and renderer package 0.5 were deliberately NOT renamed or re-signed just because the product reached 1.0 — and the release ships no private key, so it is UNSIGNED and offers verifiable SHA-256 integrity only.
What MNVP refuses to become
The post-1.0 plan opens with seven principles, and the sharpest ones are limits on ambition rather than statements of capability.
Not a general visualization system
MNVP is numerical semantics to perceptual projection. It is not business BI, not data storytelling, not a full statistics suite, not a 3D engine, not a design tool, not a database and not a reporting platform. It integrates with those; it must not swallow them.
It does not redefine numbers
How a bare numeral parses, whether `0.91` is a decimal or a version, whether a trailing zero changes equality, whether a successor exists — none of that is MNVP’s question. It starts after semantics exist, and refuses to guess when they do not.
Fidelity is not correct decision-making
A view can faithfully present the data and the reader can still reach a wrong conclusion through missing background or decision bias. MNVP constrains the projection, not the reasoning that follows it.
Verifiable is not true
It can verify that a projection met its spec, that an artifact was not modified, that a signature is valid, that conformance passed. It cannot prove the data source is right, the statistical model is reasonable, the publisher is trustworthy, or that one view helps everyone understand.
Channel rankings are contextual
Graphical-perception research is the foundation, but device, culture, age, training and task can change the outcome. MNVP does not write any single experiment’s ordering into the spec as an unmodifiable universal law, and it claims no fixed improvement factor for any profile.
Experimental must not pose as stable
Audio, tactile, AR/VR numerals, AI-chosen graphics, adaptive profiles, personalized cognitive mapping and cross-cultural visual models are all marked EXPERIMENTAL. AI may propose a profile or channel plan, but it must be labelled AI-generated, pass static validation, fidelity check, accessibility audit and human review — and it may never overwrite a stable profile or enter a trusted registry automatically.
Personalization has a fairness limit
Adapting a view to a reader may improve understanding, but it can also mean different people see different critical information, inconsistent decisions, and weakened risk warnings. Fairness here does not mean identical pixels for everyone — it means critical risk and decision information may not be quietly weakened by personalization.
Not a standard, and not yet licensed
`application/vnd.mnvp+json` is not a registered media type, and standardization is meant to follow real interoperability demand. Like its siblings, 1.0 freezes technical contracts only — no open-source license was selected because no publisher authorization was supplied for one.
Where this sits relative to ICNS and EML
MNVP and ICNS are one pipeline, deliberately split at a seam: a raw token becomes a semantically complete number through ICNS, and that number becomes a faithful perceptual projection through MNVP. The seam is enforced in code — MNVP ships an ICNS adapter that maps token to provenance.original_token, canonical to value, schema id/version/hash to schema_ref, trust state to quality.verification — and the post-1.0 plan explicitly forbids MNVP from re-implementing numeral parsing, version semantics, schema registries, comparison rules or successors. Neither layer is allowed to absorb the other.
The shared failure they were both built around is the same one: `0.9` versus `0.10`. ICNS refuses to answer which is larger until a schema says which system the token belongs to. MNVP refuses to draw the answer on a decimal axis once the schema says it is a version tuple — its version profile must render 0 · 9 · 1 with field labels, and rendering it as 0.91 is a recorded conformance failure, not a cosmetic preference.
The link to EML is a shared invariant rather than shared code. EML puts no LLM in its transpilation chain and treats round-trip faithfulness as an invariant instead of a feature; MNVP puts fidelity above visual effect and makes an AI unable to drop an infinite-weight semantic for the sake of brevity. Both projects are, in the end, betting that the useful thing to hand an AI is not a more capable generator but a layer that can refuse — and that says exactly what it refused and why.
The one-line principle MNVP wants to outlive itself: once a number is projected onto a finite medium, it must state what it kept, what it lost, who it was shown for, and whether it is still faithful to the original semantics.
Theory, whitepaper, frozen spec
One thing worth reading in order: the independent theory paper argues the problem exists, the whitepaper turns it into an implementable protocol, and the 1.0 freeze contract is what the reference implementation is actually held to. The main line is now STABLE / MAINTENANCE with ten explicit restart conditions.
MNVP 獨立理論：從數值語義到認知投影的多層數值視覺化協定
theory paper · v0.1 · 2026-07-30
Why semantic correctness and cognitive accessibility are different layers: the core objects, the seven principles, visual channels, progressive disclosure, fidelity, the loss budget, cross-scale comparison, the six propositions, and the separation of precision, resolution, uncertainty, confidence and derivation depth.
MNVP 技術白皮書
whitepaper · v0.1 · Draft / Experimental
The implementable spec with RFC-style MUST/SHOULD language: numerical object fields, value and uncertainty models, projection context, profile model, the channel vocabulary, disclosure layers, the fidelity contract, serialization, the ICNS compatibility adapter, REST and CLI drafts, error and warning codes, conformance levels C0–C4, and the MVP scope. Note its own status line — it is the draft the 1.0 freeze was built from, not the frozen contract.
spec/mnvp-1.0-freeze.json
sha256:1aff494b…
The machine-readable stability contract: 4 profiles, 31 features with stability labels, 7 digest-pinned built-in visual profiles, 5 built-in targets, 49 stable API paths, 47 stable error codes, 23 schemas with integrity hashes, the independent component-format versions, and the compatibility policy. The implementation verifies itself against this for drift.
spec/MNVP-1.0-Core / Projection-and-Fidelity / Profiles / Interop-and-Packages / Versioning / Conformance / Maintenance-Baseline
7 normative documents
The 1.0 normative document set, each pinned inside the freeze contract and re-checked by `spec-status` and `spec-freeze-verify`.
conformance/mnvp-core-v1.0.package.json
12 cases · PASS
The normative conformance package. Its cases are the interesting part: a version tuple must not render as 0.91, precision must not inflate, a REVOKED state needs a non-colour channel and the literal word, incomparable units must not share an axis.
MNVP 1.0 後續發展與未來計畫
non-normative · v0.1 · 2026-07-30
Five development lines (1.x maintenance, 2.0 research, ecosystem, productization, theory bridges), the seven principles, the priority order, and the ten restart conditions. One of them is having a second independent implementation — the plan names a TypeScript core as the way to prove the spec is real rather than merely written.
Like CAIR and ICNS, MNVP is a research and engineering archive: no public repository, no selected license, so nothing here is a download link. Its own first-priority list starts with exactly that — license decision, public repo, spec site, playground, conformance runner.
Canonical Authoritative Intermediate Representation
A program does not have to be owned by one text surface. Text, graph, grid, natural language, AI candidates, tensors and governance are projections of one authoritative computational ontology.
Interpretation-Complete Numeral Specification
`0.91` is not a number. It is a surface string whose semantics have not been declared — it can be 0.91, (0,91) or (0,9,1), and no amount of prefixing fixes that.