# What each badge and verdict means Programming+ takes a procedure from an idea to Mojo to the machine. The idea is written in lingo (steps in plain English), matho (equations written in LaTeX), pseudo (pseudocode precise enough to run, prove and translate) or speco (a specification to prove against); then comes Mojo (Modular's programming language, pinned to version 1.2.0), then x86-64 on a model machine. pplus-web shows the badges; the verdicts behind them come from pplus-core (the prover, the fuzzer, the translators, the compiler's stored and live answers, the model machine). This page is kept here, beside what produces them. Programming+ is built for checking work that someone or something else produced, so every claim it shows names what answered it, and none claims more than that. This page lists each one: who earns it, what it means, and what it does not mean. When a new badge or verdict is added, it gets a row here in the same commit. The texts below are pplus-web's (`src/ui/shell.ts`, `src/ui/provenance.ts`, `src/ui/home.ts`, `src/ui/library.ts`, `src/ui/views/`); pplus-web's `tests/trust.test.mjs` fails when a badge the site draws has no row here. ## Where code came from | Shown | Earned by | Means | Does not mean | |---|---|---|---| | **Generated from pseudo** | The Bridge's Mojo tab, always (`mojoProvenance` in pplus-web's `src/core/provenance.ts`); Mojo copied from it with **Edit in Developer** | The translator wrote this Mojo from the pseudo, literally, with a header comment saying so | That anyone has read it, or that it is the Mojo a person would write | | **Generated from pseudo, with N best-practice rewrites** | The Best practices tab's rewrite of generated Mojo | The best-practice rules rewrote N places of the generated Mojo | That the rewrite was compiled. Copy it into the Developer area and Compile & run to ask | | **Started from generated Mojo** | Generated Mojo edited in the Developer area (`mojoOrigin: 'generated-edited'`) | A person has changed generated Mojo | That the person reviewed the parts they did not change | | (badge cleared) | **I've reviewed this**, in the Developer area only | The person says they reviewed it; the header comment goes too | That anything checked the review. Compiling and editing never clear the badge | ## What a compiler said | Shown | Earned by | Means | Does not mean | |---|---|---|---| | **Compiled on godbolt** (ran, exit N / compiled, did not run / did not compile / timed out) | An answer from the compile backend (`src/services/compile-backend.ts`, godbolt.org with Mojo 1.2.0 by default) for this exact source, input and build level, made in this browser | The real compiler answered as shown | That the program is right. The badge is keyed by a hash, so any edit, other input or other level removes it, and a share link never carries it | | **Edited since compile** | An edit after a compile | The compiler's answer is for an earlier text | Anything about the current text | | The Compile & run tab's own badge: **compiling**, **ran, exit 0**, **exited with N**, **compiled, did not run**, **did not compile**, **timed out**, **no answer** | The last request from this browser to the compile backend, and whether it is still waiting | What the backend answered for the source it was sent, built the one way Programming+ builds Mojo (`--target-cpu x86-64-v3 --fp-mode contract=off`, then `-O0` and line tables at the default level: [mojo-corpus.md](mojo-corpus.md#how-every-program-is-built)), so the listing is the same whichever of godbolt's machines answers; when the pane has changed since, the tab says so | That the current pane compiles, or anything when there was no answer (a network failure, for one). That `mojo build` on your own machine gives the same listing or the same last digits: with no arguments it targets your processor and fuses `a * b + c` into one rounding | | **verified on Mojo 1.2.0** | An exercise's own program in `library/mojo/local/`, shown unchanged, when godbolt's stored answer for that exact source passed the file's own expectation: its `# expect-stdout:` lines, or `# expect: fail` for a starter whose bug the student is to find (`pixi run mojo-verify`) | The program did what its file says it should, on the real compiler | That the program is right on other inputs, or that a starter is right at all | | **not verified** | An exercise's own program, shown unchanged, with no passing stored answer for that exact source | Not yet asked, or the answer did not pass; the badge's tooltip says which | That it fails | | **your edits** | An exercise's own program after the student changed it | The text is no longer the one that was verified | Anything about the new text; Compile & run asks about it | | **Mojo 1.2.0** (no other word) | A Mojo pane whose text is neither an exercise's own program nor generated | The pinned version the checker, the interpreter and Compile & run use | Anything about this program | | The home page's **verified** chip on a problem | The problem's own Mojo program has the **verified on Mojo 1.2.0** badge | As that badge | As that badge | | The home page's **your edits saved** chip | A saved version of the problem in this browser | Opening it brings back the saved text | Anything about that text | | A Mojo checker error, warning or note | Programming+'s own checker (`src/mojo/`) | The compiler would report this. The checker may never report an error on a program the compiler accepts: `tests/mojo-check.test.mjs` holds it to that on every program the corpus holds with a stored answer, and `pixi run mojo-local` and `mojo-fuzz` on the programs they build | That a program without checker errors compiles. Only the compiler says that | | A **best practices** note | The optional helper (`src/mojo/practices.ts`), off by default | A more idiomatic way to write a line, whose rewrite keeps the output the same where it offers one | An error. Notes never look like the compiler | | Mojo output in the Run view and stepper | Programming+'s Mojo interpreter (`src/mojo/interp.ts`) | For a program the compiler builds, what it prints, or the interpreter declines and says why. One listed exception: `probes/struct-field-loop-copy`, which Mojo 1.2.0 builds into a program that crashes (it frees a struct's List field twice); the interpreter runs it as written, and the test holds that difference by name. `tests/mojo-run.test.mjs` holds it to that on every program godbolt ran, from the stored answers; `pixi run mojo-local` and `mojo-fuzz` hold it to the pinned compiler on a developer's machine | That the program compiles. The interpreter can run a program the compiler rejects (`print(Int(3.9))` prints `3` here; Mojo 1.2.0 refuses to build it), so Compile & run is the word on whether it compiles. On a program outside the corpus, agreement is the rule the tests hold it to, not a proof. Its FLOAT arithmetic is the compiler's as Programming+ builds it: every build passes `--fp-mode contract=off` (`library/mojo/pin.json`), so `a * b + c` is rounded twice, as the interpreter rounds it (`probes/float-contract-runtime-off`). Three things it does not promise. The last digits of a program built another way: with Mojo's default, `--fp-mode contract=fast`, the built program fuses a multiply with an add or subtract into one rounding where the operands arrive at run time (`probes/float-contract-runtime` is built that way on purpose, and `pixi run mojo-local` lists it as the interpreter's one difference of this kind), so `mojo build` on your own machine can differ in a last digit. A float raised to a power that is not a whole number, and std.math's transcendental functions (`sin`, `cos`, `exp`, `log`, `cbrt` and the others), which Mojo computes with routines of its own or the C library's, so the interpreter declines them (a whole power it computes as Mojo does, by squaring; `fma`, `hypot`, `nextafter`, `ulp`, `copysign`, `sqrt`, `gcd`, `lcm` and `comb` it computes exactly as Mojo does, each held to a probe), as it declines random numbers, whose values come from Mojo's own generator. And input: the interpreter hands `input()` one line per call, as a terminal does; in Mojo 1.1.0 and 1.2.0 each `input()` opens its own buffered reader, so when the input is a pipe (Compile & run, a script) the first call takes every line and the second raises `EOF` | ## What a proof says The Prove tab reports every obligation in three statuses (`src/engines/pseudo/vcgen.ts`, `src/services/pseudo.ts`). | Shown | Earned by | Means | Does not mean | |---|---|---|---| | **Proved** | The built-in prover (`solver.ts`), on every path it examined, in a unit it examined completely | The claim follows from what is known, in the notation's number model: INTEGER as whole numbers of any size, the sized types (INT8 … UINT64) exactly, with an `overflow` obligation wherever a value could leave its range, FLOAT and FLOAT32 as finite numbers whose rounding is not seen into. The prover is meant to be sound: `tests/prover-soundness.test.mjs` holds it to every known hole (the regression programs in `library/pseudo/prover/`), to a canary, and to every corpus program run and fuzzed; an audit in November 2026 closed 18 rules that proved what a run breaks. In a program that says `USE IEEE` nothing is marked proved | That the Mojo made from the program has the same property. A 64-bit `Int` wraps and a `Float64` becomes `inf` or `nan`; the `int-model` and `float-model` notes say when a proof leans on the number model. That the prover has no hole left: a "proved" that a run breaks is a soundness bug ([engines.md](engines.md#soundness)) | | **Broken** | A generated input (the fuzzer, seeded) or a run that breaks the claim at that place | There is an input for which the claim is false, and **Step through** shows it | Anything about other claims. A run outranks the prover: a proved obligation that an input breaks is shown as broken (and would be a soundness bug) | | **Open** | Neither of the above | The checker could not finish the argument, usually because a loop needs an INVARIANT | That the claim is false | | **partial: not every path was examined**, on a unit | The prover left some paths of the unit unexamined (more paths than its limit, or past its time limit) | Nothing in the unit is marked proved: what it would have proved shows as open | That anything in it is wrong | | An invariant "the checker found on its own" | Inference in `vcgen.ts`, kept only at a fixed point | It holds on entry and survives every pass, and the proof used it | That it is the invariant a reader needs | ## What testing says | Shown | Earned by | Means | Does not mean | |---|---|---|---| | A routine's cases in the Tests tab, under **no failures**, **N ways of failing** or **not tested** | The fuzzer (`src/common/fuzz.ts`), with the seed and input count shown; **not tested** when it cannot generate inputs for the routine, with the reason | Every input listed was run and checked against each claim and limit | That untried inputs pass. "Held on 300 inputs" is evidence, not proof | | A failure's shrunk input | Shrinking in the fuzzer | The smallest input it found that fails the same way | The smallest input that fails, or the only one | ## What a translation says | Shown | Earned by | Means | Does not mean | |---|---|---|---| | ⇄ in step (lingo, matho, speco) | The translator, which reads its own output back and holds it to the pseudo (`tests/sync-lingo.test.mjs`, `sync-matho.test.mjs`, `sync-speco.test.mjs`) | The two panes describe the same program, as far as the round trip checks | A proof that they are equivalent on every input | | ⚠ not in step | A language that cannot say the program, or a pane that does not read | The pane keeps its last text and says why | That the pane is wrong | | Generated Mojo agreeing with the pseudo | `tests/sync-mojo.test.mjs`, over every exercise and corpus program, in core's interpreter; and `pixi run mojo-local` and `mojo-fuzz`, on the pinned compiler itself, over those programs, the library's routines, and generated ones | On those programs, the Mojo compiles and prints what the pseudo prints: in the tests by core's interpreter, and by the compiler only on a machine with the pinned Mojo (`mojo-local` and `mojo-fuzz`) | That the translator is verified. Where a line has no faithful Mojo, the translation stops with `not translated` rather than guess. Numbers agree to their last digits or nearly: the compiler's `std.math` is its own (in Mojo 1.2.0, `**` to a fractional power is good to about 13 digits and to a whole power, done by repeated multiplication, to the last digit or two; `exp` and `cosh` are good to about 13 digits near 1 and about 10 at 100 (`probes/float-cosh-accuracy`); `log2` to about 9; a whole exponent near 1e10 stops the built program, and `gcd` of an even number and a much larger odd one does not come back), while its arithmetic is the pseudo's, each FLOAT operation rounded on its own, since every program is built with contraction off; the translation carries a note where it writes `**` or `log2`. Mojo writes some FLOATs as other text (6.02e+23 for 6.02e23), so a FLOAT made into text is translated where it is printed and is `not translated` where the program uses the text itself | ## What the machine says | Shown | Earned by | Means | Does not mean | |---|---|---|---| | Registers, caches, pipeline and counters in the Hardware area | The model machine (`src/engines/asm86/`), on the preset machine named in Setup | What that model does with these instructions | A measurement of a real processor. Cycle counts are a teaching model; compare a run with itself across edits | | "stopped: … standard library, not on the model machine" | A call into a function the model does not have | The real program would enter the library here | That the library call does anything in particular | ## Library routines A routine of pplus-library (`USE md`) carries the record of `pixi run library-check` ([library.md](library.md)). | Shown | Earned by | Means | Does not mean | |---|---|---|---| | **Cases pass** | Running the pseudo on the cases in `routine.json` | The routine gives those results; they are what every reference is held to | That the results are right for other inputs | | **Prover: pass** | Every obligation of the routine proved, as for any pseudo | Its contracts hold for every input that meets its REQUIRE, in the notation's number model | Anything about the value of FLOAT arithmetic beyond what the contracts say | | **Prover: open** | Some obligation not proved, none broken | The routine's comment says which and why (usually FLOAT rounding, which is opaque to the prover; `tests/documents.test.mjs` fails when the comment does not mention it) | That it is wrong | | **A reference agrees** | Python, C at -O0 and -O2, core's Mojo interpreter, the pinned Mojo compiler on the machine that ran the check (`compiler`), or the pinned compiler on godbolt, run on the cases. A C or Mojo reference's program holds no case: it reads every case's arguments from stdin at run time, each FLOAT bit for bit (`tests/library-harness.test.mjs`), so the compiler cannot work them out while it builds | That implementation, at that level, prints the pseudo's results exactly, or within the stated tolerance, computed by the code the compiler made for inputs it did not know. A Mojo reference is built with the pin's arguments, contraction off among them, so that code rounds each FLOAT operation on its own, as the pseudo does; Mojo's own math library (`exp`, `log2`, `cosh`, `**`) is not the pseudo's, and a reference that calls it states a tolerance and why | That it agrees on other inputs, or built with other flags: with Mojo's defaults the code fuses a multiply and an add into one rounding where it can (`probes/float-contract-runtime`), and a last digit can differ | | **Mojo: unverified** | No stored answer from the pinned compiler for that exact program and input | Not yet asked (`pixi run library-verify-mojo`) | That it fails | | **Proof: pass** | The pinned Dafny verified the proof file (or its stored verdict for this exact text) | The method is correct over exact numbers, as the proof states it | That the FLOAT version computes the same digits: rounding is outside the proof |