4. Verdicts and extrapolation levels

The four verdicts

Every investigation in PSI gets exactly one of four verdicts for your condition. They are decided by fixed rules; no language model takes part.

• Applicable. Your condition lies inside what the investigation tested, in every respect you stated. Its results are directly comparable.
• Extrapolation. Everything is comparable in kind (same regime), but your numbers fall outside the tested region. The verdict also says how far outside (see "Extrapolation and its four levels").
• Insufficient evidence. The investigation's records do not say enough to place your condition: something you asked about was not recorded, or cannot be used. This is not a "no"; it is "not enough is stated in the extracted records".
• Not comparable: different gravity, fuel or atmosphere. You set a regime (gravity, fuel phase, diluent, flame type) that differs from the one the investigation was tested in. No distance is defined across a regime: it is a different situation, not a long distance.

When several verdicts exist inside one investigation (for different regimes it was tested in), the best one is the investigation's verdict. The order is Applicable, then Extrapolation, then Insufficient evidence, then Not comparable.

Two honest limits are built into the wording: PYRION says "in PSI" and never "no data exists", because it only knows the records it extracted from PSI; and none of the verdicts says a condition is safe or unsafe.

## For engineers

type Verdict = 'APPLICABLE' | 'EXTRAPOLATION' | 'INSUFFICIENT_EVIDENCE' | 'REGIME_BARRIER' (engine/src/types.ts). Order constant: VERDICT_ORDER (engine/src/verdict.ts:42). Display names: VERDICT_LABELS in engine/src/labels.ts (Applicable / Extrapolation / Insufficient evidence / Not comparable: different gravity, fuel or atmosphere).

Decision order inside judgeCluster (verdict.ts:149, "4. Verdict"):

1. a stated regime axis differs from the cluster's known value: REGIME_BARRIER;
2. else a stated regime axis is missing or conflicting, or a stated continuous axis has no usable value in any test, or no test is complete on all stated axes: INSUFFICIENT_EVIDENCE;
3. else any axis outside its range (beyond tolerance) or (O2, pressure) outside the hull: EXTRAPOLATION;
4. else, if there are no pairable (O2, pressure) points: INSUFFICIENT_EVIDENCE;
5. else APPLICABLE.

distance is defined only for APPLICABLE and EXTRAPOLATION (normalized Euclidean distance to the nearest measured point); for the other two it is null, never Infinity (canonicalJson refuses non-finite numbers, engine/src/json.ts). compareRanked (verdict.ts:504) sorts by verdict order, then distance, then accession, then cluster key.

Records with status insufficient_evidence never count as evidence; with the option minimumStatus: 'verified' only verified records count (engine/src/evidence.ts, counts).

Applicable

Applicable means that, for this investigation, every axis you set is inside the range its tests covered, and your oxygen and pressure together fall inside the region its tests cover.

Two details make this stricter than it sounds:

• "Inside" is checked on each axis separately and on oxygen and pressure together. A condition can be inside the oxygen range and inside the pressure range and still sit in an untested corner. That case is not Applicable (it is Extrapolation, level "combination").
• "Inside" allows a small measurement tolerance of 0.5 %, so typing 101.3 kPa instead of 101.325 kPa does not change the verdict.

Applicable does not mean "the same experiment". It means your numbers fall within what that investigation measured, in the same regime. The investigation's records, with their sources and DOI, are the receipt.

## For engineers

Per-axis check in judgeCluster: for each stated continuous axis, over the complete tests, min/max of recorded values; tol = MEASUREMENT_TOLERANCE_REL × |target|; the axis is inside if min - tol ≤ target ≤ max + tol. When only the tolerance puts it inside, AxisCheck.viaTolerance is true and the reason says "is within the 0.5 % measurement tolerance of the tested ..." (engine/src/verdict.ts).

Plane check: points (o2/scale_o2, pressure/scale_p) from testPoints of the complete tests; convexHull (engine/src/geometry.ts:25); inside if hullContains (geometry.ts:70, with EPS = 1e-9, geometry.ts:10) or hullNearBox (geometry.ts:88) with half-widths 0.005 × |value| / scale. HullCheck.viaTolerance marks the tolerance case. Degenerate hulls (one point, one segment) use the same code; the zero-width case is why a tolerance exists (all records of one investigation at exactly 1 atm).

APPLICABLE needs at least one pairable point (pts.length > 0); testPoints returns null when two stated axes each have several values (pairing unknown).

Extrapolation

Extrapolation means the investigation was tested in your regime, but at least one number you set is outside the tested range, or your oxygen and pressure together are outside the tested region.

It is the engine's way of saying "close in kind, not in measurement". It never says "this will behave like that experiment". Combustion can change abruptly near limits (extinction is the classic example), so even a condition just outside the tested data is an extrapolation and must be treated as one.

An Extrapolation verdict always comes with a level that says how far outside you are, and with the receipt: which axis is outside, by how much, and which records define the nearest bound.

The distance shown to specialists is the straight-line distance, after scaling each axis by its range across PSI, to the nearest measured point. For people it is replaced by the level.

## For engineers

Condition: outside || outsideHull in judgeCluster after the regime checks, where outside is any axis with status below or above (beyond tolerance) and outsideHull is hasPoints && !(hullContains || hullNearBox).

Reasons produced: outside_range ("Oxygen: your 45 % is above the tested 17 % to 30 % (15 points higher).", with technicalNote carrying the fraction of the axis scale), outside_hull ("Oxygen and pressure together are outside the region covered by N tested conditions.", technicalNote with the normalized distance), extrapolation_level (informational) and nearest_point (informational, nearest measured point and its test).

Numbers in sentences: oxygen as % with at most one decimal (percentText), pressure in kPa with psia at 3 significant figures, other axes 3 significant figures (humanValue, humanGap, engine/src/labels.ts).

The investigation-level level is the lowest among the investigation's EXTRAPOLATION clusters (bestLevel, engine/src/levels.ts), only when the investigation's best verdict is EXTRAPOLATION.

Extrapolation and its four levels

The word "extrapolation" alone would say little, because at some oxygen and pressure almost every condition is an extrapolation for some investigation. So the verdict carries one of four levels:

• Inside each tested range, but this combination was not tested. Every number is within the range tested, but the pairing (oxygen, pressure) was never tested. Shown with a hatch on the map.
• Just outside the tested data. The worst axis is beyond the tested range by up to 10 % of the nearest tested value.
• Outside the tested data. Up to 30 %.
• Far outside the tested data. More than 30 %.

Example with an investigation tested only at exactly 1 atm (101.325 kPa): 101.3 kPa is Applicable (inside the tolerance); 110 kPa is 8.6 % beyond, so just outside; 125 kPa is 23 %, so outside; 140 kPa is 38 %, so far outside.

The note shown with every level is part of the meaning: "PYRION convention: these levels measure distance from the tested data, not how reliable or safe the condition is; combustion can change abruptly near limits (e.g. extinction), so even "just outside" is an extrapolation."

The 10 % and 30 % cuts are conventions chosen by PYRION. They are not NASA values. Their purpose is to make the word informative, not to define a safety margin.

## For engineers

Constants (engine/src/levels.ts):

• EXTRAPOLATION_LEVELS = { just_outside: 0.1, outside: 0.3 } (line 14);
• EXTRAPOLATION_AXIS_FLOOR = 0.05 (line 17);
• EXTRAPOLATION_LEVEL_ORDER = ['combination', 'just_outside', 'outside', 'far_outside'];
• EXTRAPOLATION_LEVEL_NOTE (line 19), the note quoted above.

Rule: for each continuous axis outside its range (beyond the 0.5 % tolerance), relativeGap = gap / max(|nearest tested value|, 0.05 × axisScale) (relativeGap, line 32), where nearest tested value is the range bound that was crossed and axisScale is AxisScale.scale of the corpus normalization. The worst axis decides (levelFromRelativeGaps, line 37): ≤ 0.1 just_outside, ≤ 0.3 outside, otherwise far_outside. No axis outside (so the cause is the hull): combination. The floor keeps the quotient finite when the nearest tested value is 0 or tiny.

Sentences: levelSentence in engine/src/labels.ts ("Inside each tested range, but this combination was not tested", "Just outside the tested data", "Outside the tested data", "Far outside the tested data"). The reason extrapolation_level is informational; its technicalNote names the worst axis and the percentage to one decimal and carries the convention note.

The map: EvidenceCell.extrapolationLevel is the closest level among the cell's extrapolating investigations (engine/src/navigator.ts, evidenceMap), equal to evaluate() cell by cell (tested on 200+ random cells).

Source cited for the microgravity cut that the levels sit next to: NTRS 20260001966, PDF p. 17 (slide 16), flammability chart with 1e-4 g and 1e-2 g on one continuous axis.

Insufficient evidence

Insufficient evidence means that PSI's extracted records for this investigation do not say enough to place your condition. It is a legitimate result, not a failure, and never a hidden "no".

It happens when:

• an axis you set (a regime axis like fuel phase, or a number like pressure) was not recorded for the investigation;
• it was recorded but flagged in the extraction as insufficient (such values are never counted as evidence);
• the records disagree with each other on a regime;
• the investigation recorded your axes, but never together in one test, so no tested condition can be named;
• oxygen and pressure were listed as several values without saying which go together.

Each of these has a fixed code and a plain sentence (see "Why an investigation is not comparable: the blocker codes"). When a safe action exists (for example "leave fuel phase open"), it is offered; when it would mean ignoring something you asked about, it is not.

Insufficient evidence has no distance and is never ranked.

## For engineers

Triggers in judgeCluster: regimeUnknown (stated regime axis missing or conflicting, or the informational gravity_not_covered), missingAxis (a stated continuous axis has no usable value in any test), complete.length === 0 (no test records all stated axes), or hullUnknown (no pairable points) without any axis outside.

distance = null, distance note 'not defined: insufficient evidence to place the target' (the word "undefined" never appears in text shown to a reader; checked by engine/test/wording.test.ts).

Excluded records: status insufficient_evidence is never counted; the reason says "N records exist but are not counted (flagged as insufficient in the extraction)" (excludedWhy, engine/src/labels.ts; with minimumStatus: 'verified' the text also says "not verified").

When the target states a gravity regime that no investigation was tested in, evaluation.regimeUntested = { axis: 'gravity_regime', value, testedValues } (regimeUntestedOf, engine/src/verdict.ts) so the interface can say "No PSI test in this gravity regime".

What the four verdicts mean

Each investigation gets one verdict for your condition.

Applicable: the investigation tested the same regime, and your oxygen and pressure fall inside what it measured.

Extrapolation: same regime, but your condition lies outside the measured range. Any value would have to be extended beyond the measurements.

Insufficient evidence: the extracted records do not state enough to compare. PYRION does not guess.

Not comparable: different gravity, fuel or atmosphere: gravity, fuel phase, diluent or flame type differ. This is a barrier, not a worse match, so no distance is computed across it.

Why an investigation is not comparable: the blocker codes

For every investigation whose verdict is Insufficient evidence or Not comparable, the engine attaches one or more blockers. A blocker has a fixed code, a plain sentence and, sometimes, an action. The codes:

• AXIS_NOT_RECORDED. The investigation did not record something you set. Example: "PSI-9401 did not record fuel phase." Action offered only for fuel phase, diluent and flame type: "Leave fuel phase open." For pressure, oxygen or gravity there is no action: leaving them open would ignore your question.
• NO_USABLE_VALUE. Records exist but cannot be used as evidence. Example: "PSI-9403 has records for fuel phase, but none can be used as evidence (flagged as insufficient in the extraction)."
• REGIME_NOT_TESTED. The investigation was tested only in other regimes. Example: "PSI-9402 was tested only in gaseous fuel, not in solid fuel (fuel phase)." The action is a switch and says so: "Switch fuel phase to gaseous fuel: another regime, not a small step."
• RECORDS_DISAGREE. Records of the investigation disagree on a regime. Example: "The records of PSI-9404 disagree on fuel phase (liquid fuel / solid fuel)."
• AXES_NOT_RECORDED_TOGETHER. Example: "No single test of PSI-9406 records all the axes you set together."
• VALUES_NOT_PAIRED. Example: "PSI-xx lists several oxygen and pressure values without saying which go together."

(The investigation numbers in the examples are the synthetic ones used by the tests. The first three codes are the ones most often met.)

In the answer from TARS, blockers are grouped by code and axis with the number of investigations affected, always worded "in PSI".

## For engineers

Blocker { code, axis, testedValues?, sentence, action? } and BlockerCode in engine/src/types.ts; produced by blockersOf (engine/src/verdict.ts:100) from the non-informational reasons of the deciding cluster of the investigation; attached to InvestigationVerdict.blockers only when the investigation verdict is INSUFFICIENT_EVIDENCE or REGIME_BARRIER.

Mapping from reason code to blocker:

| Reason | Blocker |
|---|---|
| regime_barrier (axis) | REGIME_NOT_TESTED, testedValues = the values of that axis the investigation's clusters state; action { kind: 'switch_regime', axis, to: tested[0] } |
| regime_missing or axis_missing with an axis, no excluded records | AXIS_NOT_RECORDED |
| same, with excluded records (reason citations non-empty) | NO_USABLE_VALUE |
| regime_conflicting | RECORDS_DISAGREE, testedValues = the recorded values |
| axis_missing without an axis | AXES_NOT_RECORDED_TOGETHER |
| unpaired_values (non-informational) | VALUES_NOT_PAIRED |

Actions: leave_open only if axis is a member of REGIME_AXES and not gravity_regime; none for continuous axes. Tests: engine/test/blockers.test.ts.

Summaries for TARS: threePartAnswer groups barrier blockers by axis (kind regime), insufficient blockers by code|axis (kind insufficient) with count and accessions (engine/src/answer.ts).

Not comparable: the regime barrier

Four things in your question are regimes, not numbers: the gravity regime (microgravity, partial gravity, normal gravity), the fuel phase (solid, liquid, gas), the diluent gas (nitrogen, helium, carbon dioxide, argon, mixed) and the flame type (normal, inverse). If you set one of them and an investigation was tested in a different one, the verdict is Not comparable: different gravity, fuel or atmosphere.

The key idea is that infinity is not a big number. A flame in microgravity burns without buoyancy; a flame on the Moon has a small but real buoyancy; the two are not near each other on a scale, they are different situations. So PYRION does not compute a distance across a regime, never ranks such an investigation, and never presents the switch as a small step. Its distance is "not defined", and the rest of the numbers are shown only as context.

A regime barrier decides alone: if the gravity differs, the verdict is the barrier even if other things are also missing. In the interface the barrier investigations are folded away until you open them, with their DOIs.

If you leave a regime axis open (not stated), it is not compared at all; the result says which axes you left open.

## For engineers

REGIME_AXES and REGIME_VALUES (engine/src/types.ts): gravity_regime ∈ {microgravity, partial_gravity, normal_gravity}; fuel_phase ∈ {solid, liquid, gas}; diluent ∈ {N2, He, CO2, Ar, mixed}; flame_type ∈ {normal, inverse}.

In judgeCluster, section "1. Regime axes: barriers, never distances": for each axis, target value t:

• t === undefined: not compared; reason target_regime_unstated (informational);
• cluster state missing: regimeUnknown;
• !state.values.includes(t): barrier = true, reason regime_barrier ("<Axis>: you set X, the evidence is Y. Not comparable: different gravity, fuel or atmosphere: no distance is defined across it.");
• cluster state conflicting: regimeUnknown;
• else regime_match.

A barrier overrides: missing/conflicting reasons of the other axes are marked informational. Axes and distances after a barrier are context only (decided). ClusterVerdict.distance is null and distanceNote is 'not defined: the target is across a regime barrier from this evidence'.

Clusters and the verdict of an investigation

An investigation in PSI is often several experiments (tests). Different tests of the same investigation can have been run in different regimes (for example some in air and some in a helium mix). PYRION groups the tests of one investigation that share the same regime values into a cluster and judges each cluster on its own.

The verdict of the investigation is the best verdict among its clusters (Applicable beats Extrapolation, which beats Insufficient evidence, which beats Not comparable); ties are broken by the smaller distance. So an investigation is Applicable if at least one of its regime groups is.

This matters for honesty: a cluster that happens to be inside your condition cannot be hidden by another cluster that is not, and a cluster is never merged with a different regime just to make the ranges wider.

A test marked "*" in the records applies to all tests of that investigation unless a test has its own record for the same variable.

## For engineers

buildCorpus (engine/src/evidence.ts:170): records sorted by compareRecords (a total order); normalization scales per axis; per accession (numeric order): tests named by test_id (or one test * if none), with * records resolved per variable (a test's own records win, even if all of them are excluded); regimeKey groups tests with equal regime states; clusters sorted by key.

TestEvidence holds, per regime axis, a RegimeState (known, missing, conflicting) with its values; per continuous axis, the distinct numeric values (ranges lo..hi count as both ends); descriptors (fuel, material, geometry, flow configuration, platform).

Investigation verdict (evaluate, engine/src/verdict.ts:523): clusters sorted by compareRanked; the first is the decidingCluster. counts (investigations, clusters, recordsUsed, recordsFlaggedInsufficient, recordsBelowMinimumStatus) summarize.

Axis scale: AxisScale.scale = max - min of counted values over all PSI (scaleRule: 'range'); if max = min ≠ 0, |min| (abs_value); else 1 (unit).

The 0.5 % measurement tolerance

People type "101.3 kPa" or "14.7 psia" or "760 mmHg" for the same pressure. If an investigation was tested at exactly 101.325 kPa, treating those as different would make the same physical condition Applicable or Extrapolation depending on which digits you typed. So "inside the tested data" allows a tolerance of 0.5 % of your own value, on every axis, and in the oxygen-pressure region.

When the tolerance is what puts you inside, the result says so: "Pressure: your 101.3 kPa (14.69 psia) is within the 0.5 % measurement tolerance of the tested 101.3 kPa (14.70 psia)..." and marks it, so nobody mistakes it for an exact hit.

Why 0.5 %: it is the worst-case rounding of a value written with three significant figures (1.00 can hide up to ±0.5 %) and it sits inside the usual accuracy of pressure transducers (about 0.25 to 1 % of reading). That is PYRION's own reasoning, a convention and not a NASA value, and the note travels with the result.

It is deliberately small: 110 kPa against a test at 101.325 kPa is 8.6 % away and is an extrapolation.

## For engineers

MEASUREMENT_TOLERANCE_REL = 0.005 (engine/src/types.ts:175) and MEASUREMENT_TOLERANCE_NOTE (same file): "PYRION convention, not a NASA value: a target within ±0.5 % of its own value of a measured range or tested region counts as inside it (rounding of typed values and typical instrument accuracy)."

Used in three places, with the same constant:

1. per-axis range check in judgeCluster (tol = REL × |target|);
2. the (O2, pressure) region: hullNearBox(hull, target, REL × |o2| / scale_o2, REL × |p| / scale_p) (engine/src/geometry.ts:88, Liang-Barsky segment clipping against the box padded by EPS);
3. the chart geometry locateTarget (engine/src/envelope.ts) and the evidence map (evidenceMap), so the chart can never show a point outside a region that the verdict calls inside.

Flags: AxisCheck.viaTolerance, HullCheck.viaTolerance, TargetLocation.viaTolerance (present only when true).

The tolerance is relative to the target's own value: a target of 0 has tolerance 0. Tests: engine/test/judge.test.ts (101.3, 101.325, 101.33, 760 mmHg and 14.7 psia agree; 110 kPa does not).

Gravity conventions: below 0.01 g, 0.9 to 1.1 g, and above

A gravity regime is a name, but people type numbers ("0.165 g", "1e-4 g"). PYRION turns a level into a regime with three cuts. All three cuts are PYRION conventions, not NASA values, and the notes say so with every result.

• Below 0.01 g: microgravity. "0 g" and "1e-4 g" are microgravity. NASA's own flammability chart puts 1e-4 g and 1e-2 g on one continuous axis, so this cut is a modelling choice.
• 0.01 g up to 0.9 g: partial gravity. The Moon (0.165 g in the FM2 plan; 0.16 g in a lunar-gravity presentation) and Mars (0.38 g, NASA's Mars fact sheet) are in this range.
• 0.9 g to 1.1 g: normal gravity. A band, not the single value 1: 0.998 g and 1.003 g are both ground gravity.
• Above 1.1 g: not covered by this dataset. No regime exists there. Every investigation is then Insufficient evidence with the reason "above 1 g: not covered by this dataset". It is never treated as an open axis.

Anything below 0 g or above 3 g is rejected as a mistake.

The gravity level you type is only shown. The regime it selects is what is compared, because no condition record carries a gravity level. Naming a regime ("microgravity", "freefall", "Moon") sets the regime directly; "microgravity" asserts no level at all.

## For engineers

engine/src/quantity.ts: MICROGRAVITY_BELOW_G = 0.01 (line 385), NORMAL_GRAVITY_BAND = { lo: 0.9, hi: 1.1 } (line 392), regimeOfLevel (line 399): 0 ≤ g < 0.01 microgravity; 0.01 ≤ g < 0.9 partial; 0.9 ≤ g ≤ 1.1 normal; otherwise no regime. Bounds gravity_level: [0.0, 3.0] (BOUNDS, line 125). Notes: MICROGRAVITY_CONVENTION_NOTE, NORMAL_GRAVITY_CONVENTION_NOTE, ABOVE_NORMAL_GRAVITY_MESSAGE (line 396).

A numeric level goes to Target.informational.gravity_level (never to continuous); informational.gravity_not_covered is set above 1.1 g and makes judgeCluster return regime_missing ("Gravity regime: above 1 g: not covered by this dataset...") for every cluster. The name "microgravity" (and its aliases: freefall, free fall, weightless, in orbit, ISS, zero-g, microgravedad, caída libre, ...) sets the regime and no level (targetFromQuantities).

Named gravities (GRAVITY_TARGETS, engine/src/transfer.ts:61): Moon 0.165 g (NTRS 20260001966, PDF p. 13, slide 12, "Lunar-g = 0.165 gE"; 0.16 g from NTRS 20210020446 p. 3), Mars 0.38 g (NASA GSFC NSSDC Mars Fact Sheet, "Surface gravity (mean) (m/s2) 3.73 9.82 0.380"; NTRS 20010074003 PDF p. 2 lists 0.38 g only as one of the partial-gravity levels used in combustion studies), Earth 1 g.

Source of the cut context: NTRS 20260001966, PDF p. 17 (slide 16).

Determinism and the SHA-256 fingerprint

The engine has no randomness, no clock, no network and no language model inside. Given the same records and the same condition, it produces exactly the same result, byte for byte, on any machine. Records are put in a fixed order before anything is computed, so the order of the files does not matter.

That makes a result checkable. TARS shows a fingerprint: a 64-character code computed from the whole evaluation (every verdict, every reason, every number). If someone re-runs the same question on the same data and gets a different fingerprint, something changed: the data, the condition or the engine. If the fingerprint matches, the result is identical.

A fingerprint does not say the result is right; it says the result is reproducible. The correctness of a verdict rests on the rules in this encyclopedia and on the records and their sources.

Swapping the language model that writes the explanation does not change the verdict or the fingerprint, because the model never decides.

## For engineers

canonicalJson (engine/src/json.ts:4): keys sorted, two-space indent, trailing newline, undefined dropped, non-finite numbers rejected with a TypeError (undefined distances are null by contract).

sha256Hex(text) (engine/src/sha256.ts:34): pure TypeScript SHA-256 of the UTF-8 text, no dependencies and no platform API; tested against standard vectors and Node's crypto (engine/test/answer.test.ts).

threePartAnswer (engine/src/answer.ts:87): fingerprint = sha256Hex(canonicalJson(evaluate(records, target, options))), where target is normalized (continuous.gravity_level moved to informational). The fingerprint is identical in easy and advanced mode and independent of record order (tested).

Ordering that makes this true: compareRecords (total order over record fields), compareAccession (numeric), compareNatural (test ids: "T2" before "T10", locale-free), sorted keys in output, deterministic tie-breaks in compareRanked, compareRoutes. Tests use fixed-seed linear-congruential generators, never Math.random.

Engine version in every evaluation: ENGINE_VERSION = '0.2.0' (engine/src/types.ts:301), part of the hashed output.

Verdict panel

What it is. The top card of the right column.

What it shows. "Result for ..." the headline and its detail, a compare button and the verdict ring.

How to use it. Read it first after changing a condition.

Example. Look for "Inside the tested range".

What it does not do. It summarizes PSI coverage; it is not a safety rating.

Fuel phase left open

What it is. A note shown when your condition does not state a fuel phase.

What it shows. That liquid droplet and gas-flame investigations are then compared alongside solid materials, because an axis you leave open is not compared.

How to use it. For cabin materials such as fabrics and plastics, set the fuel phase to solid in the condition panel; the list then keeps the solid-fuel investigations.

Example. ISS cabin air leaves the fuel phase open, so FLEX droplets can rank first.

What it does not do. It does not change any verdict by itself; the engine still compares only the axes you set.

Headline

What it is. The large coloured sentence.

What it shows. One of: Inside the tested range, Outside the tested range, Undetermined, or No PSI test in this gravity regime.

How to use it. Read it first.

Example. "No PSI test in this gravity regime" for the Moon.

What it does not do. It is computed by the engine; no model writes it.

Verdict ring

What it is. The circular counter.

What it shows. The number of investigations with extracted records, split by verdict.

How to use it. Hover a row for the split by extrapolation level.

Example. Read how many are applicable.

What it does not do. Six investigations have no extracted values yet and are not in the ring.

Ring caption

What it is. The small line under the ring.

What it shows. "of 24 PSI combustion investigations, N have no extracted values yet".

How to use it. Read it to see coverage.

Example. See that 6 have no extracted values.

What it does not do. It is not a statement about PSI at large (the PSI catalogue is bigger than the 24 combustion ones).

Result cards section

What it is. The long list under the dashboard.

What it shows. One card per investigation with its verdict, reasons and receipts.

How to use it. Scroll through it or open a card from the chart.

Example. Open PSI-26's card.

What it does not do. Verdicts are identical to the panel above; this is the detail.

Result card

What it is. The card of one investigation.

What it shows. Its verdict badge, a one-sentence result, title, DOI, the reasons and the receipt.

How to use it. Click it, or open it from the chart.

Example. Read the card for PSI-69.

What it does not do. It states what was extracted; it does not re-judge the experiment.

Result sentence

What it is. The plain sentence of a card.

What it shows. Where your condition stands relative to this investigation.

How to use it. Read it first.

Example. "Inside the tested range: ...".

What it does not do. It is written by the engine.

Reasons list

What it is. The list under a card.

What it shows. One reason per checked axis, with receipts as numbered references.

How to use it. Click a [n] reference to see the source value.

Example. Open the references of an extrapolation.

What it does not do. Context-only reasons are marked and did not decide the verdict.

Technical line

What it is. The small line on a card.

What it shows. Normalized distance and, for extrapolation, the convention note.

How to use it. Read it if you want the figures.

Example. "Normalized distance 0.04".

What it does not do. It is for people who want numbers; the sentence says the same thing in words.

Receipt

What it is. A collapsible list on a card.

What it shows. Every source value used: its file, location and the quoted text.

How to use it. Click to open it.

Example. Open a receipt of PSI-26.

What it does not do. A receipt shows what was extracted, not the whole document.

Receipt reference [n]

What it is. A small numbered button in a reason.

What it shows. The source value behind that sentence.

How to use it. Click it to jump to that row of the receipt.

Example. Click [1].

What it does not do. It does not open the NASA document; use the DOI for that.

More receipt references

What it is. A "+n" button.

What it shows. The remaining references of a reason.

How to use it. Click it.

Example. Click +2.

What it does not do. It jumps to the first hidden reference.

Show all receipts

What it is. A link in the receipt.

What it shows. The remaining citations.

How to use it. Click to show all or fewer.

Example. Show all.

What it does not do. It does not change the verdict.

Card DOI (header)

What it is. A link in the card header.

What it shows. The investigation's accession, version and DOI.

How to use it. Click it to open the dataset.

Example. Check the version.

What it does not do. It opens PSI's DOI page.

Card DOI (citation line)

What it is. A link in the card.

What it shows. The DOI at doi.org.

How to use it. Click it.

Example. Cite the dataset.

What it does not do. It is the dataset DOI, not a paper.

Blocker action button

What it is. A button inside a card that is insufficient or not comparable.

What it shows. The change that would resolve it: leave an axis open, or switch regime.

How to use it. Click it to apply the change.

Example. Leave diluent open.

What it does not do. A regime switch is shown as another regime, never as a small step.

Show or hide different-regime cards

What it is. A link above the lowest group of cards.

What it shows. The cards of investigations in a different regime.

How to use it. Click to show or hide.

Example. Show them to read why they are not comparable.

What it does not do. They are never ranked with the comparable ones.

Different-regime DOI link

What it is. A link in that group.

What it shows. The dataset DOI.

How to use it. Click it.

Example. Open the DOI.

What it does not do. It does not compare the regime.