Jump to text
On this page
Copy and source
Published source confirmed at last check

Source changed 2026-11-18 21:11:39 UTC · snapshot created 2026-11-18 21:12:35 UTC · last check 2026-11-18 22:00:10 UTC

A.19.USCM - Scoring Mechanism

Type: Architectural (A) Status: Stable Normativity: Normative (unless marked informative)

Use this when admitted values need a declared valuation for comparison or selection. Select the scoring rule and recover its input basis, output meanings and permitted use before calculating. If the receiving comparison can use the admitted values directly, scoring is unnecessary.

USCM.IntensionRef identifies the U.Mechanism declaration in §4.1 under A.6.1. CHR resolves its score stage to the local Score operation; the declaration supplies the meanings and application/binding rules below.

A.19.USCM:0 - At a glance — didactic, informative

  • Suite stage: score (ordering lives only in A.19.CHR:4.5 / suite_protocols; suite membership is a set in A.19.CHR:4.2).
  • Inputs, conceptual: an admitted measure profile for the evaluated bearer, plus CNSpecRef, CGSpecRef, and ScoringMethodDescriptionRef; their editions name the criteria, comparison or reference basis, evidence policy, intended result use, and any claim scope, selected slices or qualification window that qualify that use. MinimalEvidenceRef may override the CG-Spec minimum.
  • Output: ScoreProfileSlot = a set of score measures (vector scores are first‑class; a scalar score is allowed only if declared).
  • Non‑goals: does not normalize (UNM), aggregate (ULSAM), compare (CPM), select (SelectorMechanism), issue a gate decision, publish, or emit telemetry; it is a scoring step with explicit admissibility and evidence surfaces.
  • P2W seam: an A.15.2 baseline selects editions and policies, including ScoringMethodDescriptionRef when USCM is used. A.15.3 typed filling applies only to independently declared receiving positions under A.19.CHR:4.7.2. Score bindings obtain under §4.1; Audit makes the effective refs and pins recoverable.
  • Failure mode: tri‑state guard (pass|degrade|abstain); unknown never coerces to pass, and MUST NOT be coerced to 0/false.
  • Quick rule of thumb: if CGSpecSlot.SCP is missing → ScoreEligibility = abstain (fail‑closed); if ScoringMethodDescriptionSlot is missing → ScoreEligibility = abstain (no implicit scoring method); if CN‑Spec.comparability requires normalization‑based comparability → normalization MUST be explicit in choreography (Uses/pins), never hidden inside Score.

A.19.USCM:1 - Problem frame

FPF’s Characterization (CHR) suite treats scoring as a mechanism boundary (authoritative membership: A.19.CHR:4.2). Suite membership is a set (order has no semantics); any intended ordering is expressed only via suite_protocols (A.19.CHR:4.5), under the suite obligations (A.19.CHR:4.3).

Within the canonical suite-closed protocol, USCM appears as the score stage (after normalize and indicatorize, before comparison and selection). USCM’s surface is admissibility-first: it produces score measures from admitted profiles while remaining constrained by the ScaleComplianceProfile (CG-Spec.SCP) and by scale-lawfulness (CSLC).

USCM exists to keep a distinction between:

  • normalization (UNM),
  • indicatorization (UINDM),
  • scoring (USCM),
  • aggregation/folding (ULSAM), and
  • comparison/ordering/selection (CPM + SelectorMechanism),

so that each commitment has a single place to live, can be audited, and can evolve without smuggling extra semantics into adjacent steps.

A.19.USCM:2 - Problem

Engineering teams often need to convert an admitted (indicator or NCV) profile into one or more score measures for downstream comparison and selection. When the scoring rule, scale constraints or input basis remain implicit, the following failures can occur:

  • Illicit arithmetic by convenience: teams apply weighted sums, averages, or nonlinear transforms across mixed scale kinds without an explicit admissibility profile, creating scores that are not CSLC‑lawful.
  • Hidden normalization: scoring implementations silently normalize, align, or flip polarities, collapsing the distinction between “normalize” and “score” and making downstream reasoning non‑reproducible.
  • Silent scalarization: multi‑criteria realities (vector scores, partial‑order comparability) are reduced to a single scalar via hidden tie‑breakers, producing an apparent total order that is not justified.
  • Unknown coercion: missing or insufficient evidence is coerced into 0/false or treated as “good enough,” yielding scores that look precise while being epistemically unsafe.
  • Drift and non-auditability: differences between teams’ scores for the same admitted target cannot be explained or replayed when the effective admissibility constraints and policies (editions, evidence rules, used relations) are not recoverable.

A.19.USCM:3 - Forces

  1. Admissibility discipline vs operational pressure. Admissibility must remain explicit and checkable under operational pressure: SCP and CSLC constraints must bound permissible transforms.

  2. Method diversity vs stable mechanism boundary. Scoring methods evolve rapidly; USCM’s signature must remain stable so method families can be wired through SoTA packs and extensions without mutating the mechanism boundary.

  3. Vector reality vs scalar simplicity. Many situations require multiple score dimensions. A single scalar score may be convenient but must be a declared commitment, not a hidden reduction.

  4. Uncertainty vs decisiveness. Teams need decisions under uncertainty; the framework must prevent epistemic overconfidence. Tri-state admissibility guards state whether the declared conditions pass, permit degraded use or require abstention; their correctness depends on the rule and evidence.

  5. Distinction across CHR steps. USCM must not absorb UNM, ULSAM, or CPM semantics “for convenience,” or the suite becomes opaque and non‑teachable.

  6. Evolvability vs didactic usability. Interfaces must remain evolvable (stable SlotKind surface; method semantics externalized), while the spec remains teachable: a reader must find USCM’s purpose, boundary, laws, guard behavior, and audit minimum in one place.

  7. P2W separation and gate/guard separation. On a P2W path, selection of planned editions and policy ids belongs to WorkPlanning plan items; gate decisions belong under gate patterns and work‑enactment logs belong with WorkEnactment. USCM must expose eligibility and audit pins without turning into a gate or a planner.

A.19.USCM:4 - Solution

USCM is the canonical scoring mechanism in the CHR suite. It defines:

  • a stable mechanism boundary (score is its own stage with a canonical Score operation and a tri‑state eligibility predicate),
  • a stable SlotKind surface (via the suite lexicon),
  • an admissibility‑first LawSet anchored in CG‑Spec.SCP and CSLC,
  • an anti‑smuggling rule (no implicit normalization), and
  • an audit minimum (the evaluated bearer and input profile, editions, criteria, comparison basis, evidence used, effective evidence policy, result use, any scope or window that qualifies that use, and any relation used).

USCM does not embed GateDecision/GateLog or perform publish/telemetry steps. It cites relation pins only when the score or its receiving use depends on an obtaining relation; assess loss under the applicable receiving-use rule.

Scoring-method semantics remain outside the suite core. The selected ScoringMethodDescription supplies them; G.2 packs can provide method choices, while wiring-only GPatternExtension modules cite the corresponding governing content and required pins.

A.19.USCM:4.1 - Operation declaration

USCM.IntensionRef cites the A.6.1 U.Mechanism declaration episteme here. The CHR score stage resolves to its local Score operation. Selecting a changed argument, scoring law or guard requires selecting that changed declaration explicitly; another realizer of the same declaration changes no suite member.

  • Scope note: A.6.1 governs the operation and its argument/result bindings below. The planned baseline selects method and specification editions; independently declared receiving positions may use A.15.3 typed filling. Score returns a score profile, while eligibility and Audit retain their own meanings. GateDecision/GateLog remain outside this declaration.

  • IntensionHeader: id = USCM, version = 1.0.0, status = stable.

  • IntensionRef: USCM.IntensionRef (canonical target for the suite member named in A.19.CHR:4.2).

  • SignatureManifest (optional; importability): if a USCM publication is intended to be imported/reused, it SHOULD publish a SignatureManifest (A.6.0:4.5 and A.6.1; A.6.0 checklist item 10 with SM-1 through SM-4) consistent with IntensionHeader/Imports, exposing the stable SlotKind surface (including ScoringMethodDescriptionSlot) and any declared scalarization commitment.

  • Purpose: SCP‑first scoring: produce score measures from admitted profiles without violating CSLC / scale lawfulness.

  • Imports: G.0 (CG‑Spec.SCP, CG‑Spec.MinimalEvidence), A.18 (CSLC), C.16 (measurement constitution and scale-lawful operations when measurement is claimed), A.19.CN (comparability.mode + normalization routing), A.19.CHR:4.2.1 (CHR SlotKind Lexicon).

  • SubjectBlock:

    • SubjectKind: ReadingContent, supplied by the reading contents in InputProfileSlot; each retains its bearer, Characteristic and Scale.
    • RangedValueKind: ReadingContent; Score transforms the admitted profile under the selected method, and ScoreEligibility assesses that proposed transformation.
    • SliceBasis: any declared U.ClaimScope, selected U.ContextSlice members or qualification window that qualify the scoring result or its intended use.
    • Input qualification: scoring ranges over the admitted indicator or NCV profile for the evaluated bearer, criteria, comparison or reference basis and intended result use, under any scope, slice or window conditions required by that use; CN-Spec.comparability routes comparison and CG-Spec.SCP constrains the permitted scoring transformations.
    • Results are declared per operation: the score-measure profile and the eligibility judgment.

Reading range. ReadingContent and profile interpretation come from C.16:5.5.1. Resolve each component’s subject, Characteristic, Scale, attribution and conditions before using its values. A content member can be conditional or insufficiently supported; this operation’s eligibility and evidence rules still decide whether it may be used. Profiles retain the positions or contributor identities, ordering and multiplicity required by their declared basis. An independently materialized result episteme is distinct from the calculated Coordinate and the bound reading content.

Operation-local argument and result declarations

Each input meaning is declared separately for Score and ScoreEligibility. ByRef inputs resolve to the stated value and edition. Cardinalities shown are for Score.

ScoreEligibility may assess an incomplete proposal: each required input then has cardinality 0..1, and an absent value has no binding and triggers the corresponding missing-input rule.

DirectionLocal designatorMeaning and ValueKindDesignation; cardinality
ArgumentInputProfileSlotAdmitted profile of ReadingContent components to score; each UINDM-derived value retains its basis position, Characteristic and ScaleByValue; 1 profile
ArgumentCNSpecSlotCN-Spec used for the bearer, basis, intended use and comparability routing, including any scope/slices or qualification window required by that useCNSpecRef; 1
ArgumentCGSpecSlotCG-Spec supplying the SCP restrictions and default evidence requirement for this scoring useCGSpecRef; 1
ArgumentScoringMethodDescriptionSlotScoringMethodDescription supplying the selected Coordinate→Score rule, domain, codomain, Scale, polarity and use-required propertiesScoringMethodDescriptionRef; 1
ArgumentMinimalEvidenceSlotMinimalEvidence override used in place of CGSpecSlot.MinimalEvidenceMinimalEvidenceRef; 0..1
Score resultScoreProfileSlotProfile of ReadingContent components returned by the declared scoring ruleByValue; 1 profile on completed admitted scoring, 0 on abstain or termination without a result
ScoreEligibility resultGuardDecisionEligibility judgment under the predicates below: pass, degrade or abstainByValue; 1 on completed evaluation

An argument’s bindingPredicate holds when this Score or ScoreEligibility application uses the resolved value for that row’s purpose: the profile supplies the operands, the method supplies the transformation, CN-Spec delimits its use and routing, and CG-Spec plus any override supplies its admission and evidence conditions. Mere inclusion in an Audit record is insufficient.

The ScoreProfileSlot bindingPredicate holds when that Score application returns the profile obtained by applying the bound method lawfully to those operands, with the declared scalar/vector cardinality. The guard’s result binding holds when that ScoreEligibility application returns its evaluated judgment. Each binding follows A.6.1 identity and continuous extent within the application; the result begins to bind at return.

SlotIndex (derived projection). Project this table’s local designators, ValueKinds, designation modes and cardinalities. Its historical Slot names permit CHR lookup and introduce no separate meanings; A.6.5 relation SlotSpecs do not govern these operation positions. A repeated Characteristic name alone cannot select a profile value whose basis position and Scale matter.

  • OperationAlgebra (suite stage = score, per A.19.CHR:4.5; canonical stage‑op = Score):

    • Score(InputProfileSlot, CNSpecSlot, CGSpecSlot, ScoringMethodDescriptionSlot, MinimalEvidenceSlot?) → ScoreProfileSlot; the cited inputs supply the evaluated bearer and use qualifications.

ApplicationPredicate. Score obtains when a calculation applies the bound scoring method to the bound input profile under the CN-Spec/CG-Spec conditions. It proceeds on pass or on an explicitly permitted degrade branch and returns the lawful score profile; abstain starts no Score calculation. ScoreEligibility obtains when an evaluation assesses the proposal under the eligibility predicates and returns the corresponding judgment. A passing guard or a cached compatible profile does not establish a new Score calculation.

ApplicationIdentityRule. One application is one scoring calculation or eligibility evaluation at its calculation locus, from taking up the chosen operands/rules until return or termination. Reidentifying that same invocation preserves identity. A second invocation with identical profile, method, specifications, qualification point and output is a distinct application; changing those arguments for another calculation also makes another application. A record identifier designates an established invocation and cannot create it.

ApplicationExtentRule. Score extends from use of the input profile under the selected method to the return of its score profile or termination; ScoreEligibility extends from proposal assessment to judgment or termination. An unfinished invocation has an open extent and no unreturned result binding. The qualification point or input window identifies what is scored, not when the scoring occurs. Ordinary use of a scoring function does not by itself assert dated U.Work.

For the Celsius example in §4.2, two separate calculations of (20−0)/(40−0) each return 0.5 under the same declared method. Their operand-to-return episodes and result bindings differ. A saved 0.5 can refer to the earlier result when that return is established; numerical agreement and the same method pins cannot establish a second return. The example retains its specified Celsius input and interval endpoints.

  • LawSet (minimum; admissibility‑first, no hidden scalarization):

    1. SCP+CSLC lawfulness: any numeric transform used to produce ScoreProfileSlot MUST be admissible under CGSpecSlot.SCP and CSLC‑lawful (cites G.0 + A.18).
    2. ScoringMethod is explicit (no hidden defaults): Score MUST cite ScoringMethodDescriptionSlot (with its edition resolved for this use and recorded in the P2W baseline when applicable; see A.19.CHR:4.7.2). Disclose the scoring method 𝒢 (Coordinate→Score), its domain, codomain, Scale, polarity and the properties required by the declared scoring use. Apply C.16 when measurement is claimed and enforce the SCP/CSLC restrictions. Boundedness or monotonicity is required only when the selected method or use requires it. USCM MUST NOT rely on an implicit default scoring method.
    3. No implicit normalization: Score MUST NOT silently perform UNM; if CNSpecSlot.comparability requires normalization‑based comparability, the normalization step MUST be explicit in choreography (Uses/pins), not hidden in Score.
    4. Vector scores allowed; scalarization must be explicit: producing a single scalar score is allowed only if declared (e.g., by fixing ScoreProfileSlot cardinality to 1 and citing the lawful transform); partial‑order semantics MUST NOT be silently reduced to a scalar “tie‑breaker”.
    5. Unknown is not coerced: unknown / insufficient evidence MUST NOT be mapped to 0/false; use tri‑state guards and explicit failure behavior.
  • AdmissibilityConditions (tri‑state guard; fail‑closed on missing admissibility/evidence):

    • ScoreEligibility(InputProfileSlot, CNSpecSlot, CGSpecSlot, ScoringMethodDescriptionSlot, MinimalEvidenceSlot?) → GuardDecision ∈ {pass|degrade|abstain}.
    • pass requires: (i) CGSpecSlot.SCP is present, (ii) the scoring method and edition are explicit, (iii) the input profile is admitted for the bearer and criteria, (iv) the cited specs apply to the comparison or reference basis and intended result use, including any required claim-scope, slice or window qualifications, (v) the evidence supporting the admitted profile passes the effective minimum, (vi) CN-Spec.comparability routing is satisfied, including explicit UNM when needed, and (vii) the declared transformation is defined on the input profile and satisfies the applicable SCP/CSLC restrictions.
    • If MinimalEvidenceSlot is absent, the guard MUST evaluate evidence against CGSpecSlot.MinimalEvidence, and MUST NOT return pass when evidence is missing/unknown.
    • If ScoringMethodDescriptionSlot is missing or unresolved or ambiguous under the selected use baseline, the guard MUST return abstain (fail‑closed), not “assume a default”.
    • degrade requires every non-evidence condition above and an effective failure policy that permits the stated degraded result when evidence is insufficient. abstain applies otherwise, including an undefined transformation or missing required input. A degrade policy supplies no undefined value.
  • Applicability:

    • Score is intended to be used after indicatorization (when indicator profiles are used) and before comparison/selection.
    • Score is applicable only when admissibility/evidence surfaces are present via CGSpecSlot (fail-closed otherwise).
    • Score is applicable only when a scoring method is declared via ScoringMethodDescriptionSlot (edition-pinned when reproducibility matters). A “do nothing / identity scoring” intent (if needed) MUST still be declared as a scoring method description, not as an implicit default.
  • Relation boundary: scoring creates no transfer relation. If the input profile or receiving use relies on an F.9 Bridge, kind relation, or plane relation, cite that obtaining relation, its direction and loss. Establish the bounded-use and reliance grounds required for that proposed use, and assess loss against its receiving rule and tolerance. Apply a numerical assurance penalty only when a named assurance use consumes it and an applicable B.3 domain model warrants it under its declared assumptions.

  • Γ_timePolicy: when a temporal qualification is needed, point by default (no implicit “latest”).

  • PlaneRegime: each admitted input and score keeps its declared reference plane; USCM introduces no plane crossing. When a conclusion depends on a relation between planes, cite that relation, its direction and loss, and keep the receiving use separate.

  • Audit: Make the application basis below recoverable from the specifications, inputs, evidence and results used. For ScoreEligibility, identify missing or unresolved required inputs and policies, and apply the following requirements to the values supplied or resolved. Retain a separate record when the receiving use requires one.

    • MUST make recoverable: the evaluated bearer, input profile and its admission status; CNSpecRef.edition, CGSpecRef.edition, and ScoringMethodDescriptionRef.edition; criteria, comparison or reference basis and intended result use; and any claim scope, selected slices or qualification window that qualify that use.
    • MUST make recoverable the evidence refs used for input admission or the ScoreEligibility evaluation.
    • MUST make the effective evidence policy recoverable:
      • if MinimalEvidenceSlot? is present → identify MinimalEvidenceRef as effective;
      • otherwise → identify CGSpecSlot.MinimalEvidence as effective.
    • SHOULD make recoverable the realized GuardDecision for ScoreEligibility, and (when degrade/abstain) the referenced failure behavior / downstream handling policy id (e.g., SoS-LOG branch id) when such a policy is in scope.
    • SHOULD make recoverable: a stable description of ScoreProfileSlot; any F.9 Bridge, kind relation, or plane relation only when the score or receiving use relies on it; and, when normalization-based comparability was required, the upstream UNM ref or pin.

A.19.USCM:4.2 - Interpretation notes — informative

  • Selected-input basis. Consume the UINDM S and space declaration when an indicator profile is used. For CS7 in A.19.UINDM §5.4, the Celsius policy selects i1 and the declared Celsius scoring rule reads 20, giving 0.5. It cannot read the kelvin position’s 293.15 under that rule. After a basis change, resolve the selected positions and the scoring method’s input requirements again; keep any projection in the original basis order.

  • A score profile retains its component meanings. ScoreProfileSlot is a declared profile of ReadingContent components, with each component’s score Characteristic and Scale recoverable. An ordered vector rendering retains the correspondence between positions and those components. Several score dimensions are different from uncertainty expressed by an interval or set for one component. A scalar score, or an interval-valued result, requires its own declared meaning and admissible operations.

  • USCM does not order; it scores. USCM produces score measures. Any ordering, dominance, or set‑valued comparison is performed by CPM and SelectorMechanism (and any optional aggregation is made explicit via ULSAM). Treating the score as “the decision” is a category error in CHR terms.

  • ScoringMethod is explicit (no hidden defaults). USCM requires ScoringMethodDescriptionSlot with its selected edition. A formal A.3.2 U.MethodDescription claim requires an independently admitted A.3.1 Method as EntityOfConcern and substantive content about that Method as a way of doing. This keeps “how we score” evolvable (wired via method packs) without making it implicit or accidental.

  • No implicit UNM is a boundary guard. This discourages convenience implementations that “just normalize inside scoring.” USCM forbids that: if comparability requires normalization‑based routing, the UNM step is explicit in choreography (Uses/pins) and visible in audit surfaces.

  • Evidence policy is explicit and auditable. MinimalEvidenceSlot? is an optional override; otherwise the effective policy is CGSpecSlot.MinimalEvidence. Failures do not disappear; they must show up as degrade/abstain and be traceable.

  • Relations are explicit; loss is judged for the receiving use. When a score or receiving conclusion depends on another source-local meaning, bearer kind, or reference plane, cite the obtaining relation and supported loss. Apply the receiving rule and tolerance; a numerical assurance penalty needs the applicable B.3 domain model. A changed bearer, scope, method, basis, or use is not by itself a crossing.

A.19.USCM:5 - Archetypal Grounding — informative

A.19.USCM:5.1 - Tell

Think of USCM as admissibility‑gated scoring:

  • Input: “an admitted profile of measures for this bearer, criteria, comparison basis, evidence policy and result use, with any scope or window that qualifies that use, plus the CN-Spec and CG-Spec editions that declare those bounds”
  • Output: “a set of score measures that downstream steps may compare/select on”

USCM is allowed to transform measures only within the admissibility surface (SCP+CSLC), and it must not hide normalization, aggregation, or ordering.

A.19.USCM:5.2 - Show — rollout-plan evaluation

A program manager evaluates competing rollout plans for a product launch.

  • The admitted profile includes measures like {Cost, LeadTime, Reliability, RiskExposure, CarbonPerUnit}.
  • The CG-Spec’s SCP states the allowed transforms and their output meanings. A rescaling that preserves a ratio chart uses a positive factor; an interval-chart conversion uses its admissible affine rule. A different scoring function declares its score Scale and valuation instead of claiming that any monotone function preserves the original quantity.
  • USCM runs Score(...) and outputs a score profile such as {UtilityScore, RiskScore} rather than forcing a single number.
  • A plan lacks sufficient evidence for RiskExposure. In this constructed case the declared method can return a bounded risk-score interval from the available inputs, and the effective failure policy permits that qualified output. ScoreEligibility returns degrade only if the non-evidence conditions still hold. Audit retains the interval meaning, limitation and CN/CG editions. If the method has no defined result on the available inputs, the result is abstain instead.

A downstream comparison can use that interval only under a rule that accepts its meaning and uncertainty. The audit identifies the grounds; it does not supply a missing comparison rule.

A.19.USCM:5.3 - Show — U.Episteme

A research lead compares several model families for deployment across heterogeneous environments.

  • Indicators include calibration and robustness metrics; scoring is done using a calibrated probabilistic score plus uncertainty‑aware score dimensions.
  • A chosen scoring method may require monotonicity or interpretability, as in the additive and lattice examples below. A separate prediction-uncertainty account may supply an interval under its own method and conditions; its interval is not another name for a vector of score dimensions.
  • The declared score profile retains each score dimension and any justified uncertainty representation. Unknown input is not replaced by a point score. Downstream comparison explicitly handles the scalar, vector or interval meanings it consumes.

A.19.USCM:6 - Bias-Annotation — informative

  • Gov (governance). Bias toward explicit admissibility and evidence surfaces (CGSpecRef, SCP, MinimalEvidence) rather than “standard practice” arithmetic. Risk: perceived overhead. Mitigation: keep the shared signature small; use the selected ScoringMethodDescription for method-specific rules and wiring modules for their references and pins.

  • Arch (architecture). Bias toward stable interfaces and strict step boundaries (no implicit UNM; no hidden scalarization). Risk: reduced room for ad‑hoc shortcuts. Mitigation: allow richer scoring method families via wiring, without mutating the USCM intension.

  • Onto/Epist. Bias toward treating scores as measures with declared semantics, not as “the truth.” Risk: teams accustomed to one‑number rankings may resist. Mitigation: treat scalarization as an explicit, auditable commitment, not as the default.

  • Prag (pragmatics). Bias toward fail‑closed guards and traceability under uncertainty. Risk: more degrade/abstain outcomes early. Mitigation: couple degrade with explicit downstream behavior policies, rather than silent coercion.

  • Did (didactics). Bias toward “one place to learn the mechanism”: the problem/forces/solution narrative is co‑located with the canonical Mechanism.Intension.

A.19.USCM:7 - Conformance Checklist

A USCM publication or use is conformant if it satisfies:

  1. Mechanism declaration completeness. The A.6.1 operation-local arguments/results, application predicates, identity/extent rules and laws in §4.1 are recoverable, together with the declared imports, subject, admissibility, applicability, transport, time, plane and Audit conditions. SlotIndex projects the argument/result declarations; eligibility retains its tri-state result.

  2. SlotKind discipline. SlotKind tokens match the CHR SlotKind lexicon for the roles used (InputProfileSlot, CNSpecSlot, CGSpecSlot, MinimalEvidenceSlot, ScoringMethodDescriptionSlot, ScoreProfileSlot); no generic ContextSlot is introduced. If a required token is missing, suite-dock it rather than introducing it ad hoc in the mechanism.

  3. SCP+CSLC admissibility is enforced. Any numeric transform used to produce score measures is admissible under CGSpecSlot.SCP and CSLC-lawful; illicit operations (especially “convenient arithmetic” over non-lawful scales) are excluded.

  4. ScoringMethod is explicit and auditable. Score cites ScoringMethodDescriptionSlot (edition-pinned when reproducibility matters). Its domain, codomain, Scale, polarity and use-required properties are disclosed and satisfy the applicable SCP/CSLC restrictions. Apply C.16 for any measurement claim.

  5. No implicit normalization. Score does not silently perform UNM. If CN‑Spec.comparability requires normalization‑based routing, the normalization step is explicit in choreography (Uses/pins) and auditable.

  6. No hidden scalarization. Vector scores are permitted. A scalar score is produced only when declared, and partial‑order semantics are not reduced to a scalar tie‑breaker.

  7. Unknown and evidence handling is explicit. Unknown / insufficient evidence is not coerced to 0/false. Eligibility uses GuardDecision ∈ {pass|degrade|abstain} and evaluates evidence against the effective policy (MinimalEvidenceSlot override or CGSpecSlot.MinimalEvidence).

  8. Planning and actual binding remain separate. On a P2W path, A.15.2 carries the intended edition/policy baseline; A.15.3 governs typed filling only for independently declared positions. The application uses its effective bindings under §4.1, and Audit makes their refs and pins recoverable. Planned selection alone does not establish actual use.

  9. Relation and plane discipline. Another bearer, scope and window, basis, method, plane, or result use gets a fresh eligibility decision. Any F.9 Bridge, kind relation, or plane relation is cited only when the score or conclusion relies on that obtaining relation. Judge loss under the receiving-use rule; a numerical assurance penalty requires an applicable B.3 domain model.

  10. Specialization discipline, if extended. Retain inherited operation-position meanings, add no mandatory input to the inherited Score operation, and declare extra outputs or operations using the local extension notation ⊑⁺. A claimed refinement, conservative extension or equivalence additionally needs its A.6.1 §4.8 predicate, endpoint facts and applicable preservation test; ⊑/⊑⁺ alone establishes none of them.

A.19.USCM:8 - Common Anti‑Patterns and How to Avoid Them

  • Hidden normalization inside scoring. Scoring silently normalizes or aligns measures. Avoid by making UNM explicit in choreography and keeping Score as the declared scoring transformation under its admission conditions.

  • Weighted sum across mixed or non-admissible scales. Treating “weights + sum” as universal. Avoid by requiring SCP+CSLC admissibility.

  • Silent scalarization. Collapsing vector scores or partial orders into a single “overall score” via an untracked tie‑breaker. Avoid by leaving vector scores intact, and making scalarization a declared commitment.

  • Implicit scoring method (“we just use the standard formula”). The scoring method is assumed rather than declared and pinned. Avoid by requiring ScoringMethodDescriptionSlot and resolving its edition, recorded in a planned baseline on P2W paths; treat “identity scoring” (if needed) as an explicit method description, not a hidden default.

  • Unknown → 0 coercion. Treating missing evidence as zero, false, or “good enough.” Avoid by tri‑state guards and explicit failure behavior, with auditable effective evidence policy.

  • Shadow CG‑Spec. Copying governing CG conditions into a competing local specification creates drift. Cite CGSpecSlot.SCP and retain the scoring method’s own domain, law and restrictions; method-specific conditions are substantive content, not merely wiring.

  • Telemetry or publish leakage. Treating scoring as a reporting step. Avoid by keeping publish/telemetry outside suite closure and using the appropriate post-suite mechanisms.

  • SlotKind drift. Renaming or re‑purposing slots across specializations or across mechanisms. Avoid by using the suite SlotKind lexicon and the ⊑/⊑⁺ discipline.

A.19.USCM:9 - Consequences

Benefits

  • Makes scoring a first‑class, admissibility‑gated CHR step, reducing illicit arithmetic and silent assumptions.
  • Improves auditability and reproducibility via edition pins and explicit evidence policy selection (override vs default).
  • Preserves evolvability: scoring method families can change via SoTA wiring without changing the USCM intension.
  • Makes uncertainty disposition explicit through the guard result and its effective failure policy.

Costs / trade‑offs

  • Requires explicit CG‑Spec admissibility surfaces (SCP) and explicit evidence policies to achieve pass; this can feel slower than “just compute a score.”
  • Vector scores can be less immediately comfortable than a single number; downstream comparison/selection must be explicit about how vector scores are used.

A.19.USCM:10 - Rationale

Scoring can lose semantic precision through hidden normalization, illegal arithmetic, implicit thresholds or uncertainty coercion. USCM requires the following commitments to remain explicit:

  • Admissibility first: transformations satisfy the restrictions in CG‑Spec.SCP and CSLC.
  • No hidden steps: normalization is explicit (UNM), aggregation is explicit (ULSAM), ordering is explicit (CPM/SelectorMechanism).
  • Uncertainty is visible: admissibility is tri‑state; unknown is not coerced.
  • Recoverable audit basis: effective editions and the effective evidence policy remain traceable.

A.19.USCM:11 - SoTA-Echoing

The following research and architecture-description lines inform distinct choices. A receiving task selects its method and verifies the conditions it needs; none of these examples establishes a universal scoring policy.

A.19.USCM:11.1 - SoTA alignment map

Practice contributionSource examplesWhere it connects to USCMAdoption status
Prefer monotone and interpretable scoring surfaces where appropriateExplainable additive and monotone model lines, e.g., Nori et al. 2019; monotone deep lattice style models, e.g., You et al. 2017Expressed as admissibility‑bounded transform freedom via CGSpecSlot.SCP and explicit scalarization rules; method details stay out of the kernelAdapt
Assess calibration when interpreting probability estimates as correctness likelihoodsGuo et al. (2017), On Calibration of Modern Neural Networks, including temperature scalingExpressed as “score is a measure on an explicit scale,” bounded by SCP+CSLC and evidence gating; calibration itself is wired as method semantics, not kernel lawAdapt
Keep prediction uncertainty distinct from multiple score dimensionsRomano, Patterson and Candès (2019), Conformalized Quantile Regression, constructs prediction intervals under its stated conditionsRetain the interval’s declared meaning and conditions when a receiving score or comparison uses it. Vector cardinality alone does not establish uncertainty semanticsAdapt
Keep architectural commitments traceable to one governing patternISO/IEC/IEEE 42010:2022 architecture description disciplineFPF adapts architecture-description distinctions to explicit governing-pattern references; that local assignment is not a rule claimed from the standardAdapt

Notes per row

  1. USCM does not “implement a particular scoring model”; it preserves a stable, admissibility‑gated surface on which such models can be wired.
  2. A calibration transform must satisfy SCP+CSLC; USCM does not mandate a specific calibration method.
  3. A prediction interval and a vector of score measures carry different meanings. A downstream CPM/SelectorMechanism use needs a declared comparator for whichever result it consumes; neither form supplies an ordering automatically.

A.19.USCM:12 - Relations

  • Builds on

    • A.6.1 (operation declarations and application/binding rules).
    • A.19.CHR:4.2.1 (CHR SlotKind lexicon).
    • G.0 (CG‑Spec, specifically SCP and MinimalEvidence).
    • A.18 (CSLC lawfulness discipline).
    • C.16 (measurement constitution and scale-lawful operations when measurement is claimed).
    • A.15.2 for the planned edition/policy baseline on P2W paths; A.15.3 plus A.19.CHR:4.7.2 for typed filling of independently declared positions.
    • A.19.CN (CN‑Spec, specifically comparability routing and normalization‑based comparability expectations).
  • Used by

    • A.19.CHR (suite membership and suite protocols; USCM is the score stage).
    • Downstream CHR stages that require score measures as inputs (e.g., CPM, SelectorMechanism).
    • E.18 when USCM instances are used as nodes in a selected TransformationFlowStructure; the selected ScoringMethodDescriptionRef@edition(…) and other pins live in planned baselines (P2W), while executions surface effective refs/pins via Audit.
  • Coordinates with

    • UNM when CN‑Spec.comparability requires normalization‑based comparability (explicit choreography, no hidden UNM).
    • ULSAM when folding/aggregation is needed as a distinct, explicit step.
    • G.2 for scoring-method choices and GPatternExtension modules for their wiring, without mutating the USCM kernel.
    • E.20 (governing-pattern discipline) and F.18 (alias docking) for governing-source references and designation continuity.

A.19.USCM:End

Referenced in the corpus

9 literal mentions in other sections. Read their context to establish the relation.