Semantic Compression

The common-basis annotations contain 133 locally explicit facts across 808 lexical tokens. Their ratio is 0.16460396 facts per token; min–max scaling produces 100.00.

For the integer-narrowing probe F10.P1, the worker counted 5 locally explicit facts in 9 tokens. Its recorded fragment is: int32 small = int32(big) return small. This concrete declaration/conversion form contributes to the fact-per-token ratio; the overall number also includes the other common probes.

The mean of log2(B) is 0 bits across 31 common probes, where B is the worker's count of compatible interpretations. Min–max inversion produces 100.00.

Every common-basis probe was annotated B = 1, so the mean log2 branching is zero.

Worker reasoning for F05.P1: Bare f(x) call: Quidra's grammar requires an explicit & at BOTH the call site and the parameter declaration for any writable or aliasing access ('Reference markers cannot be omitted or supplied to ordinary parameters', architecture.md). Absence of & at the call site alone is sufficient, without consulting f's signature, to fix that x is passed as an independent value with copy/value semantics and no retained alias -- collapsing the outcome set the spec 6.1.4.B probe is designed to expose to a single interpretation for this language.

The submitted lookup values sum to 17 across 31 common probes. Dividing by 31 gives 0.548387097; min–max inversion produces 34.45.

Examples of nonzero recorded contributions: F01.P1 (Immutable local binding of an integer): 1; F03.P2 (In-place element mutation of a growable sequence through a name): 1; F04.P3 (Two independently obtained handles observed to denote the same heap object): 1; F07.P1 (Fused multiply-add expression on fixed-width signed integers): 1.

The worker assigns F01.P1 one lookup for: function/statement return-type context outside the measured fragment (R5: excluded supporting context still counts as a lookup when a fact depends on it) determines the numeric literal's concrete type.

The worker assigns F17.P1 one lookup for: standard-namespace file module documentation needed to know the automatic release/cleanup contract of file.Handle, not evident from the local call syntax alone.

The hidden-behavior counts sum to 11 across 31 common probes. Dividing by 31 gives 0.35483871; min–max inversion produces 81.48.

Examples of nonzero recorded contributions: F02.P2 (Explicitly uninitialized fixed-size buffer): 1; F03.P1 (In-place increment of a scalar variable): 1; F03.P2 (In-place element mutation of a growable sequence through a name): 1; F05.P1 (REQUIRED spec-6.1.4.B probe — ordinary bare call site f(x)): 1.

Worker reasoning for F10.P1, recorded count 1: implicit_exception_or_failure_propagation: explicit int32(big) narrowing is range-checked and fails deterministically at runtime without a locally visible error type on the cast expression itself.

Worker reasoning for F06.P1, recorded count 1: implicit_exception_or_failure_propagation: element access inside the callee can fail on bounds without that being visible in the signature.

The worker recorded 132 semantic complexity units. The final support ledger awards 72 capability points, so the raw value is 132 ÷ 72 = 1.833333333 units per point. Min–max inversion produces 36.46.

For F17.P1 (Scoped file handle released on every exit path), the worker counted 2 syntax forms + 0 contextual rules + 1 implicit rules + 0 semantic exceptions = 3 complexity units. Its cited basis/fragment is: language.md file.Handle: 'closes its native file deterministically when the handle leaves its lifetime, including ... error propagation; no defer or manual cleanup is required'.

For F19.P1 (Two concurrent computations joined into one result), the worker counted 2 syntax forms + 0 contextual rules + 1 implicit rules + 1 semantic exceptions = 4 complexity units. Its cited basis/fragment is: language.md 'task.all' bounded structured concurrency, ordered int[] results.

The final ledger records 35 FULL, 2 PARTIAL and 7 NONE probes. That awards 72 of 88 capability points: 100 × 72 ÷ 88 = 81.82.

Recorded NONE probes: F05.P3: Constructing a function value that captures an enclosing local, and passing it as an argument; F09.P2: Descending sort of a sequence, plus a scalar ordering comparison; F11.P2: Sub-range of a sequence — copy or shared storage?; F14.P3: Adding a third alternative from a separate unit without editing the original; F15.P3: Heterogeneous sequence behind one abstract element type, dispatched at runtime; F17.P2: User-defined type with a deterministic end-of-lifetime cleanup hook; F20.P2: Exporting a function with C ABI and a stable unmangled symbol.

Recorded PARTIAL probes: F12.P2: Optional-preserving transformation by a locally declared function, without an explicit conditional; F18.P2: A code unit with one exported and one private item, used from outside.