#CHR Authoring: Characteristics - Scales - Levels - Coordinates

Pattern G.3 · Stable Part G - Discipline SoTA Patterns Kit

Tag. Architectural pattern (CHR kit; publishes lawful measurement primitives; constrains CAL authoring and selector/dispatch use) Stage. design‑time (authoring & publication; enables lawful run‑time consumption by G.4 / G.5) Primary output. CHR Pack@CG‑Frame — a notation‑independent, UTS‑published CHR bundle that provides: typed Characteristics/Scales/Levels/Coordinates, legality + guard surfaces, aggregation/comparison specs, RSCR hooks/tests, and provenance pins. Primary hooks. G.1 (CG‑FrameContext), G.2 (SoTA synthesis inputs), A.19.CHR (CHRMechanismSuite boundary + pins), A.15.3 (SlotFillingsPlanItem baseline), A.18/C.16 (MM‑CHR legality), F.1–F.9 (Contexts/UTS/Bridges), B.3 / B.3.4 (trust, freshness/decay), A.10 (provenance anchors/carriers), G.6 (EvidenceGraph/Path citation), optional C.18/C.19 (QD/OEE wiring), G.11 (refresh orchestration). Non‑duplication note. Universal Part‑G invariants (bridge‑only crossings, tri‑state semantics, penalties→R_eff‑only, set‑return semantics, P2W split, typed RSCR triggers + alias docking, single‑owner defaults, linkage discipline) are owned by G.Core. This pattern cites them via G.3:4.1 and delegates where needed.

A team is defining or evolving a CG‑Frame (via G.1) and has plural, competing SoTA traditions and constructs (via G.2). The team needs a lawful characterization layer that makes downstream work possible without hidden semantic drift:

#Keywords

• CHR authoring
• characteristics
• scales
• levels
• coordinates
• CSLC legality
• typed measurement
• CHR Pack@CG-Frame
• ReferencePlane
• Φ/CL policy pins
• edition pins
• RSCRTriggerKindId.

#Relations

#Content

#Problem frame

A team is defining or evolving a CG‑Frame (via G.1) and has plural, competing SoTA traditions and constructs (via G.2). The team needs a lawful characterization layer that makes downstream work possible without hidden semantic drift:

• CAL authoring (G.4) needs typed, lawful operands and guard/legality surfaces to build admissibility and acceptance rules (thresholds and policy cut‑offs remain CAL‑owned).
• Selector/dispatch (G.5) needs CHR‑typed quantities and explicit provenance pins so selection can remain set‑returning and auditable under lawful orders.
• Cross‑context reuse must be explicit (bridges + loss accounting + pinned policy ids), and refresh must be tractable by typed RSCR causes rather than prose.

The deliverable is a CHR Pack that is CG‑Frame‑scoped, notation‑independent, and UTS‑published, with explicit edition/policy pins sufficient for reproducibility and RSCR.

#Problem

Without a disciplined CHR authoring layer, teams repeatedly produce “measurable slots” that are numerically manipulable but semantically unlawful:

• Meaning leaks across contexts (same token, different referent/sense).
• Illicit arithmetic (e.g., averaging ordinals, mixing units, laundering polarity).
• Hidden normalizations that silently change scale type, polarity, or admissible transforms.
• Unreproducible comparisons (missing edition pins for methods/distances/policies; unclear reference plane).
• Unscoped reuse (no explicit bridge/loss notes; unclear describedEntity changes).
• Un-auditable aggregation (no explicit legality/guard surface; no proof hooks; unclear Γ‑fold ownership).
• Refresh chaos (changes in names/editions/policies do not map to typed RSCR causes).

#Forces

#Solution — CHR authoring kit and publication surface

#G.Core linkage (normative)

Builds on: G.Core (Part‑G core invariants; routing/delegation hub)

GCoreLinkageManifest (normative; size‑controlled).

`GCoreLinkageManifest := ⟨ CoreConformanceProfileIds := { GCoreConformanceProfileId.PartG.AuthoringBase, GCoreConformanceProfileId.PartG.TriStateGuard, GCoreConformanceProfileId.PartG.UTSWhenPublicIdsMinted }, CorePinSetIds := { GCorePinSetId.PartG.AuthoringMinimal, GCorePinSetId.PartG.CrossingVisibilityPins },

// Pins strengthened for CHR authoring (delta over PinSets) CorePinsRequired := { // NOTE: CG-FrameContext, describedEntity, CNSpecRef.edition, CGSpecRef.edition are already required // by GCorePinSetId.PartG.AuthoringMinimal (cite, don’t restate here). UTSRowId[], // required: CHR terms are public ids (Name Cards + lifecycle) PathId[]/PathSliceId[], // required: worked examples/tests and refresh anchoring cite paths ReferencePlane, // required: definitional claims are plane-scoped Φ/Ψ/Φ_plane policy-ids?, // iff crossings/plane moves are exercised in examples or imports ΓFoldRef.edition? // iff an explicit Γ-fold artefact is pinned (otherwise use DefaultId) // NOTE: method-/discipline-specific pins (e.g., DescriptorMapRef/DistanceDefRef/DHCMethodRef/InsertionPolicyRef) // are declared only inside Extensions (e.g., G.3:Ext.QD_OEE_Wiring) to keep core linkage universal. },

// consumed iff any published CHR.AggregationSpec relies on default Γ-fold (no explicit override pinned) DefaultsConsumed := { DefaultId.GammaFoldForR_eff },

RSCRTriggerKindIds := { RSCRTriggerKindId.EvidenceSurfaceEdit, RSCRTriggerKindId.TokenizationOrNameChange, RSCRTriggerKindId.CrossingBundleEdit, RSCRTriggerKindId.ReferencePlaneEdit, RSCRTriggerKindId.EditionPinChange, RSCRTriggerKindId.PolicyPinChange, RSCRTriggerKindId.DefaultOwnerChange, RSCRTriggerKindId.FreshnessOrDecayEvent, RSCRTriggerKindId.LegalitySurfaceEdit, RSCRTriggerKindId.BaselineBindingEdit } ⟩`

(Nil‑elision + expansion rule are per G.Core:4.2. This pattern does not redefine the semantics of core conformance ids, trigger kinds, or defaults; it only declares applicability and required pins.)

#Output surface: CHR Pack@CG‑Frame (normative)

CHR Pack@CG‑Frame is the CHR kit payload that downstream patterns cite and pin (it is not a “shadow spec” for CN/CG).

Minimum exported objects (kit surface):

• CHR.Characteristic[]
• CHR.Scale[]
• CHR.Level[] (when the scale type requires explicit level sets / order structure)
• CHR.Coordinate[] (encodings + legality annotations; never an implicit “upgrade” of measurement structure)
• CHR.Guards (guard macro surface; semantics routed to owners; see G.Core + A.18)
• CHR.LegalityMatrix (admissible operations per scale type / unit / polarity regimes)
• CHR.AggregationSpecs (typed aggregators/comparators + proof hooks + edition pins where applicable)
• UTS publication bundle: Name Cards (twin labels), lifecycle notes, and (when applicable) bridge/loss notes
• RSCR artefacts: RSCRTestId[] + worked examples + provenance pins (ReferencePlane, Path/PathSlice, policy ids)

Mandatory provenance pins (conceptual, notation‑independent):

• ReferencePlane
• PathId/PathSliceId citations for worked examples/tests
• R‑anchors (conceptual; KD‑CAL lanes when used) realised via PathId/PathSliceId and, where applicable, A.10 anchor/carrier refs
• policy pins used by crossings or plane moves (when exercised)
• edition pins for any referenced method or metric definitions that affect interpretation

#Authoring workflow: CHR authoring chassis (S1–S8)

S1 — Charter the measurement scope (scope anchor). Declare the CHR home context/scope for the CG‑Frame, including: describedEntity boundaries, ReferencePlane, freshness/decay expectations, and the list of contested terms likely to require bridging. Output a design‑time MeasurementCharter and KindMap@Context. If freshness/decay expectations are anything beyond an explicit “non‑decaying” declaration, wire them via G.3:Ext.DecayWiring (semantic owner: B.3.4) rather than encoding decay semantics in CHR prose. If assurance‑subtype lane tags are used (e.g., TA/VA/LA), declare the lane regime here so downstream evidence discipline can remain lane‑pure (taxonomy/semantics owned by B.3; evidence‑path representation & audit owned by G.6; this pattern only records wiring). Lane docking (wiring‑only; normative). If EvidenceLanes are used, the charter MUST:

• enumerate the lane tags used (e.g., TA/VA/LA) and cite their semantic owner taxonomy (owner: B.3), plus the upstream provenance for their use when available (e.g., SoTAPaletteDescriptionId via G.3:Ext.SoTAPackInputs);
• expose any lane‑dependent tolerances / proof requirements via explicit pins (policy‑id and/or edition‑pinned refs), not prose;
• treat lane tags as provenance metadata (not Contexts): they MUST NOT be “bridged away” or silently mixed;
• if any cross‑lane comparison/aggregation is claimed, it MUST be explicit and pinned to the owning acceptance/evidence policy (typically G.4) and auditable via evidence paths (G.6); otherwise downstream consumers treat it as illegal. Crossing semantics and penalty routing are cited via G.Core (do not restate).

S2 — Mint or reuse terms (UTS‑first). For each candidate characteristic/scale/level/coordinate term: attempt reuse; otherwise mint via UTS Name Cards with twin labels and lifecycle notes. When a term is imported across contexts, the import must be explicit and auditable (bridge/loss notes live with the crossing artefacts; CHR only cites them).

S3 — Define CharacteristicCard (the CHR unit of meaning). A CharacteristicCard is the minimum unit CHR publishes for downstream legality. It SHOULD include (field names are indicative; semantics routed to owners):

CharacteristicCard := ⟨ UTSRowId, Context, ReferencePlane, ObjectKind, Intent, Definition (typed), ObservableOf := ⟨instrument/protocol (A.10 anchors/carriers), uncertainty model, validity window⟩, EvidenceLanes? (KD‑CAL lanes; wiring only; semantics owned by G.4/G.6), ScaleRef, Polarity ∈ {↑, ↓, ⊥}, Domain/Range, UnitSet, Bounds / zero semantics (as applicable), Freshness / half‑life (or explicit NonDecayingDecl; freshness/decay semantics owned by B.3.4), Missingness semantics (typed; include a classification/mapping when non‑trivial; downstream tri‑state handling is per G.Core), Stability/Reliability notes, RoleDecls? := RoleDecl[] (wiring‑only; each role declaration names its semantic owner + required pins; see G.3:4.5), QD.Role? ∈ {Q, D, QD-score} (interop alias for RoleDeclwithSemanticOwnerPatternId = C.18; see G.3:Ext.QD_OEE_Wiring), Micro‑examples (R‑anchors: Path/PathSlice cited; lane tags where applicable) ⟩

Where RoleDecl := ⟨ roleLabel, SemanticOwnerPatternId, EditionPins?, PolicyPins? ⟩ (wiring‑only; semantics owned by SemanticOwnerPatternId).

Rules (CHR‑owned intent, semantics routed where indicated):

• Scale/unit/polarity legality obligations are routed to MM‑CHR owners (A.18/C.16) and must be checkable by downstream patterns.
• Missingness must be typed so downstream can apply tri‑state outcomes without silent coercion (tri‑state semantics are owned by G.Core).
• If EvidenceLanes are recorded, they are only lane tags for downstream evidence discipline (taxonomy owner: B.3; audit surface: G.6; any cross‑lane policy is owned by G.4); this pattern does not introduce lane semantics or invent bridge‑like constructs.
• If RoleDecls are used, each declaration MUST cite its semantic owner pattern (e.g., C.18/C.19) and surface the edition/policy pins required by that owner; CHR does not define role semantics locally.
• Role docking (normative, wiring-only): if any RoleDecl is present with SemanticOwnerPatternId = X, then G.3 MUST include (or explicitly cite) a corresponding GPatternExtension block whose owner is X (or whose Uses includes X) and that surfaces the required pins for that role family. Otherwise the role declaration is non-conformant (it is an undocked semantic fragment).
• Freshness docking (normative, wiring-only): if a characteristic’s freshness/half-life is defined via a named decay model/policy (rather than a pure local statement), the relevant policy/ref MUST be pinned and routed to B.3.4 via G.3:Ext.DecayWiring.
• If a characteristic is intended to be promoted into CG‑Spec, the linkage is explicit and edition‑pinned (wiring lives in an Extension; semantics owned by G.0).

S4 — Define ScaleCard and LevelCard (lawful measurement). Publish the scale type and admissible transforms, plus levels/orders when applicable. CHR does not invent new legality semantics; it cites MM‑CHR owners and makes the legality surface concrete for the frame’s characteristics.

Typical distinctions that must be representable:

• Nominal / categorical: equality + counting; transforms are permutations.
• Ordinal: order‑preserving transforms; no arithmetic that presupposes intervals.
• Interval: affine transforms; differences meaningful; means may be lawful if justified.
• Ratio: positive scalar transforms; ratios meaningful; products/sums subject to unit discipline.
• Count / rates: explicit exposure/timebase requirements; rate conversions must be explicit.
• Cyclic: wrap‑around discipline + principal interval declaration.

S5 — Define CoordinatePolicy (encodings without hidden cardinalization). When a numeric coordinate/embedding is used for convenience or tooling, CHR MUST publish:

• what invariants are preserved (order only / ratios / topology / wrap‑around),
• what remains illegal,
• what proof hooks are required if a stronger structure is claimed.

A coordinate never silently upgrades a scale type; if an upgrade is claimed, the proof burden is explicit and routed to MM‑CHR owners.

S6 — Publish legality + guard surfaces (Guard Macros + LegalityMatrix). CHR publishes a CHR.LegalityMatrix and a CHR.Guards surface that downstream operators can reference.

Guard macro names are allowed as authoring ergonomics, but their semantics MUST be routed (no “shadow semantics” in this pattern). Examples of macro intents (owners in parentheses):

• CSLC_PROOF_REQUIRED(x) (MM‑CHR legality owners: A.18/C.16)
• UNKNOWN_TRI_STATE(x) (tri‑state semantics owner: G.Core)
• UNIT_CHECK(x) (MM‑CHR legality owners)
• RETURN_SET_FOR_PARTIAL_ORDERS() (set‑return semantics owner: G.Core)
• METRIC_EDITION_REF(...) (edition‑pin discipline owner: G.Core; metric semantics owner: C.18/C.21 as applicable)

S7 — Publish AggregationSpecs (typed, lawful, reproducible). CHR may publish typed aggregation/comparison specs that are safe by construction and usable as building blocks by G.4 and G.5. For any published spec:

• The legality regime is explicit (scale/unit/polarity constraints + required proof hooks).
• If a contributor folding policy (Γ‑fold) is used and not explicitly overridden, it is referenced via DefaultId.GammaFoldForR_eff (single‑owner routing is via G.Core.DefaultOwnershipIndex; do not restate defaults here).
• If method‑role declarations imply metric‑driven comparisons (e.g., QD roles), the relevant edition/policy pins are surfaced (wiring lives in an Extension; semantics owned by the referenced patterns).

S8 — Publish, test, and evolve (UTS + RSCR readiness). Publish the CHR pack and associated Name Cards to UTS. Attach:

• RSCR tests that check legality/guard coverage and reject illegal ops,
• worked examples with Path/PathSlice provenance,
• refresh/decay notes and deprecations with lexical continuity.

This step prepares the RSCR loop but does not own orchestration (owner: G.11).

#Interfaces (normative)

#Extensions (pattern‑scoped; non‑core)

All blocks below are GPatternExtension modules (PatternScopeId‑scoped; not new PatternIds). They store wiring only and cite semantic owners.

GPatternExtension: SuiteBoundaryLinkage

• PatternScopeId: G.3:Ext.SuiteBoundaryLinkage

• GPatternExtensionId: SuiteBoundaryLinkage

• GPatternExtensionKind: InteropSpecific

• SemanticOwnerPatternId: A.19.CHR

• Uses: {A.19.CHR, A.15.3}

• ⊑/⊑⁺: ∅

• RequiredPins/EditionPins/PolicyPins (minimum):

  • CHRMechanismSuiteDescriptionRef.edition? (when the suite description is cited as a reproducibility baseline)
  • CHRMechanismSuiteSlotFillingsPlanItem refs (when planned baseline binds CHR artefacts into WorkPlanning)

• RSCRTriggerKindIds: {RSCRTriggerKindId.BaselineBindingEdit, RSCRTriggerKindId.EditionPinChange}

• Notes (wiring‑only): This module binds CHR authoring outputs to the P2W seam (SlotFillingsPlanItem); suite semantics and membership are owned by A.19.CHR.

GPatternExtension: SoTAPackInputs

• PatternScopeId: G.3:Ext.SoTAPackInputs

• GPatternExtensionId: SoTAPackInputs

• GPatternExtensionKind: DisciplineSpecific

• SemanticOwnerPatternId: G.2

• Uses: {G.2}

• ⊑/⊑⁺: ∅

• RequiredPins/EditionPins/PolicyPins (minimum):

  • ClaimSheetId[] / operator & object inventory refs (as cited inputs)
  • SoTAPaletteDescriptionId? (when palette/traces are cited; used to dock contested‑term inventory and (if present) lane tags/tolerances)
  • BridgeMatrixId? (when terms/constructs are imported across traditions)
  • UTSRowId[] drafts/aliases from synthesis

• RSCRTriggerKindIds: {RSCRTriggerKindId.EvidenceSurfaceEdit, RSCRTriggerKindId.TokenizationOrNameChange, RSCRTriggerKindId.CrossingBundleEdit}

• Notes (wiring‑only): SoTA pluralism inputs are owned by G.2; this module only specifies which synthesis artefacts are cited while authoring CHR.

GPatternExtension: CGSpecPromotionWiring

• PatternScopeId: G.3:Ext.CGSpecPromotionWiring

• GPatternExtensionId: CGSpecPromotionWiring

• GPatternExtensionKind: InteropSpecific

• SemanticOwnerPatternId: G.0

• Uses: {G.0}

• ⊑/⊑⁺: ∅

• RequiredPins/EditionPins/PolicyPins (minimum):

  • CGSpecRef.edition (when a characteristic is promoted/linked into CG‑Spec)
  • CHR.Characteristic.id pointers included in CG‑Spec.Characteristics := [...] (no shadow ids; CG‑Spec stores pointers, see G.0)

• RSCRTriggerKindIds: {RSCRTriggerKindId.LegalitySurfaceEdit, RSCRTriggerKindId.EditionPinChange, RSCRTriggerKindId.PolicyPinChange}

• Notes (wiring‑only): Promotion semantics and legality gate ownership stay with G.0; CHR only pins and cites.

GPatternExtension: MMCHRLegalityWiring

• PatternScopeId: G.3:Ext.MMCHRLegalityWiring

• GPatternExtensionId: MMCHRLegalityWiring

• GPatternExtensionKind: DisciplineSpecific

• SemanticOwnerPatternId: A.18

• Uses: {A.17, A.18, C.16}

• ⊑/⊑⁺: ∅

• RequiredPins/EditionPins/PolicyPins (minimum):

  • CSLC legality proof anchors/carriers (ids/refs as defined by MM‑CHR owners; cite A.18/C.16)
  • Unit coherence references (where units exist)

• RSCRTriggerKindIds: {RSCRTriggerKindId.LegalitySurfaceEdit, RSCRTriggerKindId.ReferencePlaneEdit}

• Notes (wiring‑only): This module wires CHR artefacts to MM‑CHR legality proof obligations; legality semantics are owned by the referenced patterns.

GPatternExtension: DecayWiring

• PatternScopeId: G.3:Ext.DecayWiring

• GPatternExtensionId: DecayWiring

• GPatternExtensionKind: DisciplineSpecific

• SemanticOwnerPatternId: B.3.4 (freshness/decay semantics)

• Uses: {B.3.4, G.6}

• ⊑/⊑⁺: ∅

• RequiredPins/EditionPins/PolicyPins (minimum):

  • FreshnessWindowDeclRef (or equivalent window pin, as defined by the owner)
  • DecayPolicyIdRef? (policy-bound; if decay model is referenced by id)
  • PathSliceId[] (affected evidence carriers / examples that witness drift)

• RSCRTriggerKindIds: {RSCRTriggerKindId.FreshnessOrDecayEvent, RSCRTriggerKindId.EvidenceSurfaceEdit, RSCRTriggerKindId.PolicyPinChange, RSCRTriggerKindId.BaselineBindingEdit}

• Notes (wiring‑only): CHR does not define decay semantics; it only pins the owner-defined window/policy and ensures refresh can be triggered on decay events.

GPatternExtension: QD_OEE_Wiring

• PatternScopeId: G.3:Ext.QD_OEE_Wiring

• GPatternExtensionId: QD_OEE_Wiring

• GPatternExtensionKind: MethodSpecific

• SemanticOwnerPatternId: C.18

• Uses: {C.18, C.19}

• ⊑/⊑⁺: ∅

• RequiredPins/EditionPins/PolicyPins (minimum):

  • DescriptorMapRef.edition (if any Characteristic declares descriptor roles)
  • DistanceDefRef.edition (if any Characteristic declares distance roles)
  • DHCMethodRef.edition (if any Characteristic is used as Q / QD-score)
  • InsertionPolicyRef? (when archive insertion semantics are declared for reproducibility)

• RSCRTriggerKindIds: {RSCRTriggerKindId.EditionPinChange, RSCRTriggerKindId.PolicyPinChange, RSCRTriggerKindId.TelemetryDelta, RSCRTriggerKindId.FreshnessOrDecayEvent}

• Notes (wiring‑only): QD/OEE semantics are owned by C.18/C.19. CHR only surfaces method‑role declarations (via RoleDecls or the interop alias QD.Role) and the edition/policy pins required for reproducible archive/front interpretation.

#Archetypal Grounding

AG‑1 — ML fairness auditing (post‑2015 selective and set‑valued practice). System: a CG‑Frame for evaluating deployed classifiers across cohorts with explicit abstention/defer behavior. CHR authoring: publish DemographicParityGap and EqualizedOddsGap as Characteristics with:

• explicit ReferencePlane (deployment population + sampling regime),
• ObservableOf (audit protocol + uncertainty model + window),
• interval scale (bounded; zero semantics explicit),
• missingness semantics (cohort sparsity and label noise are typed),
• legality/guard surfaces that forbid illicit cohort mixing and require explicit proof hooks for aggregation across cohorts.

Downstream: CAL acceptance binds thresholds and failure behavior; selector remains set‑returning under partial orders and may treat “defer/abstain” as a first‑class outcome (tri‑state semantics routed via G.Core).

AG‑2 — Clinical diagnostics (post‑2015 evidence‑aware evaluation). System: a CG‑Frame for comparing diagnostic pipelines under evolving datasets and protocols. CHR authoring: publish Sensitivity and Specificity as ratio‑scale, dimensionless Characteristics on [0,1], with:

• explicit ObservableOf (trial protocol, inclusion criteria, uncertainty model),
• freshness/decay expectations (protocol drift is modelled as decay),
• legality surfaces that forbid averaging incompatible ordinal labels (e.g., severity grades) and require explicit unit/exposure constraints for any derived rate.

Downstream: CAL acceptance owns thresholds and guard‑bands; evidence wiring is cited via Path/PathSlice to make refresh triggers actionable.

AG‑3 — Quality‑Diversity / Illumination (post‑2015 MAP‑Elites/CMA‑ME lineage). System: a CG‑Frame where selection returns archives/fronts rather than a single winner. CHR authoring: declare which Characteristics play Q/D/QD‑score roles and pin the metric definitions (descriptor map, distance definition, method editions) so archives are reproducible across runs and refresh can be triggered on edition changes. CHR does not scalarize partial orders; set‑return semantics are routed via G.Core.

#Bias‑Annotation

CHR authoring is where many biases become “baked in” as measurement choices. Typical risks:

• Proxy bias: a convenient observable substitutes for the intended construct. Mitigation: require ObservableOf + ReferencePlane + micro‑examples; force explicit “what is being measured” rather than relying on labels.
• Population and protocol shift: a characteristic’s meaning changes when the sampling regime or protocol changes. Mitigation: explicit validity windows and freshness/decay expectations; edition pins for protocol definitions; RSCR triggers on freshness/decay events and evidence surface edits.
• Ordinal misuse bias: ordinal ratings treated as interval/ratio by convenience. Mitigation: publish scale type + admissible transforms; legality matrix + guard macros; reject coordinate upgrades without proof hooks.
• Cross‑tradition/cross‑context bias: imported terms erase local meaning. Mitigation: require explicit imports and loss notes; downstream penalties route to R_eff only (routed via G.Core), making loss visible rather than silently altering F/G semantics.
• Metric gaming bias (QD and evaluation): changing descriptors/distances changes what “diverse” means. Mitigation: edition‑pin metric definitions and make role declarations explicit (wiring via C.18/C.19).

#Conformance Checklist (normative)

#Common Anti‑Patterns and How to Avoid Them

• Hidden cardinalization. Don’t treat ordinal encodings as interval/ratio; do publish coordinate policies that explicitly preserve order‑only invariants and forbid arithmetic upgrades.
• Unit laundering. Don’t add or average quantities with incompatible units; do force explicit unit discipline and legality checks via MM‑CHR owners.
• Polarity drift. Don’t rely on “higher is better” implicitly; do publish polarity explicitly and make downstream use auditable.
• Threshold leakage into CHR. Don’t embed policy cut‑offs in CHR; do keep thresholds in CAL acceptance artefacts.
• Unpinned semantics. Don’t cite “the metric” or “the distance” without edition pins; do require edition‑pinned references when semantics affect interpretation.
• Unscoped reuse. Don’t reuse CHR terms across contexts without explicit import and loss notes; do keep crossings explicit and auditable (routed via G.Core).

#Consequences

• Legality becomes checkable. Downstream patterns can reject illegal operations and rely on explicit legality surfaces rather than implicit conventions.
• Comparability without semantic flattening. Plural traditions remain representable because CHR preserves local meaning while making lawful relations explicit.
• Reproducible downstream behavior. Edition/policy pins make “why did this change?” answerable and RSCR actionable.
• Authoring overhead. The pattern shifts effort to up‑front authoring: explicit cards, pins, and tests are non‑optional when CHR becomes a public kit surface.

#Rationale

CHR is the point where “numbers start moving” only if measurement semantics are stable enough to support lawful downstream reasoning. By making scale/unit/polarity explicit, publishing legality and guard surfaces, and requiring provenance pins, CHR authoring prevents downstream mechanisms from silently inventing their own legality assumptions.

Separating core invariants into G.Core prevents drift and ensures Part‑G‑wide properties (tri‑state, penalty routing, set‑return semantics, RSCR typing, default ownership) are single‑owner, while CHR remains responsible for CHR‑specific kit surfaces.

#SoTA‑Echoing

This pattern aligns with post‑2015 best practice by:

• treating abstention/defer and set‑valued outcomes as first‑class design objects (consistent with modern selective prediction and set‑valued reporting practice),
• keeping multiobjective and archive‑based reasoning set‑returning rather than silently scalarizing (consistent with QD/illumination and open‑ended evaluation practice after 2015),
• making evaluation semantics reproducible through explicit edition/policy pinning (aligned with the modern emphasis on reproducibility and “specifying the evaluation surface” rather than only reporting metrics),
• modularizing method‑family specifics (QD/OEE, explore‑exploit) via explicit wiring and ownership rather than embedding method semantics into universal measurement legality.

#Relations

Builds on: G.Core, G.1, G.2, G.6 (EvidenceGraph / Path citation), A.19.CHR, A.15.3, A.17–A.18/C.16 (MM‑CHR), F.1–F.9 (Contexts/UTS/Bridges), B.3 / B.3.4, A.10, E.10, E.5.1–E.5.3. Uses (via Extensions): G.0 (promotion/linkage to CG‑Spec), optional C.18/C.19 (QD/OEE wiring). Publishes to: G.4 (admissible operators + legality/guard macros + freshness routing), G.5 (role declarations + pins for reproducibility), UTS (Name Cards + lifecycle), RSCR tests/hooks. Constrains: any CAL/LOG/selector usage that consumes CHR (must treat CHR artefacts as typed/legal surfaces, not as prose hints).

#G.3:End