#U.Flow.ConstraintValidity — Eulerian

Pattern A.20 · Stable Part A - Kernel Architecture Cluster

Tech‑name. U.Flow.ConstraintValidity (U.Flow genus) Plain‑name. Flow constraint validity (Eulerian interpretation) Type / Status. Architectural pattern — normative for flows hosted by E.TGA (E.18) under the Eulerian operational interpretation

One‑liner Defines cross‑cutting ConstraintValidity rules for all U.Flow instances. U.TransductionFlow inherits these rules and may refine CV class specializations for transduction‑specific semantics (species‑binding only; genus rules remain unchanged). The CV core is kind‑agnostic and assumes an open‑world catalogue of node species; the enumeration of node kinds in E.TGA is a minimal roles baseline. Operational interpretation. Eulerian stance: flow = valuation over U.Transfer; CV is attached to transformations (steps) and evaluated before any GateFit; edges carry assurance‑only operations; no token‑passing semantics are assumed.

#Keywords

• flow
• ConstraintValidity
• Eulerian
• TransductionFlow
• GateFit
• MVPK
• SquareLaw
• Sentinel
• PathSlice.

#Relations

#Content

#Intention

One‑liner Defines cross‑cutting ConstraintValidity rules for all U.Flow instances. U.TransductionFlow inherits these rules and may refine CV class specializations for transduction‑specific semantics (species‑binding only; genus rules remain unchanged). The CV core is kind‑agnostic and assumes an open‑world catalogue of node species; the enumeration of node kinds in E.TGA is a minimal roles baseline. Operational interpretation. Eulerian stance: flow = valuation over U.Transfer; CV is attached to transformations (steps) and evaluated before any GateFit; edges carry assurance‑only operations; no token‑passing semantics are assumed.

#Problem frame

E.TGA makes nodes = morphisms and enforces a single edge kind (U.Transfer). GateFit checks aggregate only in OperationalGate(profile) with the activation predicate CV ⇒ GF: until aggregated ConstraintValidity = pass, all GateFit checks return abstain. Equivalently, while ConstraintValidity ≠ pass, any GateFit‑oriented explanation does not apply. To keep flows comparable and auditable, this pattern delimits internal step constraints (CV) from external gate fit (GF), preventing any second ladder of processes beside the graph.

#Problem

Without a clear CV core:

• internal step laws (domains/ranges, invariants, units coherence, Lipschitz/stability) bleed into gate profile;
• plane or comparator declarations sneak into mechanisms;
• freshness and design/run concerns appear inside mechanisms;
• reproducibility suffers because transfers start carrying hidden semantics beyond ⟨L,P,E⃗,D⟩.

Under this pattern, CV is evaluated inside transformations. If a check declares planes/units/comparators or depends on an active GateProfile, then it is treated as GateFit at gates and the CV explanation does not apply.

#Forces

• Separation of concerns. Internal mechanism laws vs. external profile fit.
• Auditability. MVPK faces include pins/references only; no new numeric claims; editions and Γ are pinned where applicable.
• Graph discipline. One edge kind; all crossings mediated by gates; SquareLaw on every crossing.
• Reproducible valuation. Flow = valuation over U.Transfer, with slice‑local refresh bounded by sentinels.
• LEX hygiene. ASCII Tech labels, twin Tech/Plain registers, registered tokens.

#Solution

#Intent & Scope

Intent. Establish the ConstraintValidity core for the U.Flow genus: the normative set of internal step constraints and how they are surfaced and aggregated, independent of GateFit profiles (publication follows MVPK without adding new numeric claims). Where CV speaks about admissibility, phrase criteria counterfactually: “If the admissibility conditions hold, then the CV explanation applies; otherwise this explanation does not apply.” Avoid duty verbs unless stating the normative CC minima.

Scope (genus). CV covers intra‑step properties checkable from the transformation’s own signature/mechanism. The canonical CV classes are genus‑level and non‑exhaustive: MechanismUnitsCoherence, LawSetInvariants, AdmissibilityConditionsSatisfaction, LipschitzBounds, TypeDomainRange, and—only for StructuralReinterpretation—ReinterpretationEquivalence (correspondence/reversibility witness).

Species binding (U.TransductionFlow). The above classes bind to U.Transduction(kind ∈ {Signature, Mechanism, Work, Check, StructuralReinterpretation}) with OperationalGate = kind=Check; no additional CV classes are introduced here (species‑specific semantics reside in A.31 and A.45).

Out‑of‑scope (CV): declaring/translating ReferencePlane/Units/ComparatorSet; CSLC comparability; Freshness; Role/Channel; Regulated‑X; DesignRunTagConsistency — all reside in GateFit (A.21).

#Intensional object(s)

Genus. U.Flow leaves step‑kinds abstract; CV/GF separation applies to any lawful instantiation. Species (U.TransductionFlow). U.Transduction(kind) ∈ {Signature, Mechanism, Work, Check, StructuralReinterpretation}; this set of kinds is a minimum roles baseline defined in E.TGA. The species space (e.g., UNM.Authoring/Usage, SelectionAndTuning, WorkPlanning, EvaluatingAndRefreshing, …) is open‑world and non‑exhaustive. OperationalGate = U.Transduction(kind=Check). StructuralReinterpretation is projection‑preserving (no mutation of ⟨L,P,E⃗,D⟩) and may retarget describedEntity under CC‑TGA‑06‑EX; see also A.45.

AdmissibilityConditionsSatisfaction — If the declared admissibility conditions hold on the step’s inputs and context, then the CV explanation applies; otherwise this explanation does not apply. LipschitzBounds — If inputs vary within the stated domain (X) and perturbations/noise (≤ ε), then the step’s estimate remains within δ of the reference; otherwise this explanation does not apply. MechanismUnitsCoherence / TypeDomainRange — If units/types/domains match the mechanism’s signature and closed‑world assumptions for the step, then the CV explanation applies; otherwise this explanation does not apply.

Terminology & bindings (normative)

• Status/witness lexicon (E.10 discipline). In CV scope, publications use Status/Witness terminology; GateDecision… lexemes belong to GateFit (A.21) and do not apply to CV.
• describedEntity = KindBridge. Any CV mention of “describedEntity” SHALL be read via KindBridge (CL^k) on UTS (A.27 / C.3.3). CV does not declare or translate planes/units/comparators.
• retargeting/witness binding. For U.Transduction(kind=StructuralReinterpretation), the CV class ReinterpretationEquivalence SHALL surface CV.WitnessRef := ReinterpWitness over the addressed PathSliceId; the UTS SquareLaw‑retargeting witness is referenced from MVPK/UTS and linked from the CV witness without duplication.
• ReinterpWitness record (normative).
  ReinterpWitness := { PathSliceId, PublicationScopeId, mapping:{kind: iso|optic, laws: PutGet/GetPut}, commutingSquares:[TransferId], definedOn: PathSliceId, properties:{invertible?:bool, idempotent?:bool}, UTS.RowId, NoHiddenScalarization:true }.

#MVPK Faces (PlainView - TechCard - InteropCard - AssuranceLane)

Minimum pins on faces that surface CV outcomes (Lean surfacing allowed by profile but without weakening checks):

• CtxState pins. ⟨L,P,E⃗,D⟩ on ports/tokens; raw U.Transfer preserves them.
• Path pins. PathId and PathSliceId appear where slice‑local refresh or reinterpretation witnesses are relevant (valuation semantics per A.22).
• CV pins. CV.Status ∈ {abstain, pass, degrade, block}, CV.WitnessRef? (refs only).
• Edition pins. If a face cites CG‑Spec, ComparatorSet, or UNM.TransportRegistryΦ, the face includes the compatibility surface as per A.27 (BridgeCard + UTS row, with CL/CL^plane) for downstream consumption. A.20 references this requirement; it does not introduce or modify Bridge/UTS formats.
• Face scope. Each face includes PublicationScopeId with an MVPK profile (Min/Lite/SetReady/Max) — no new surface kinds.
• Register discipline. Tech names ASCII; twin labels; required LEX tokens follow E.10 (e.g., SentinelId, PathSliceId, SliceRefresh).

No new numeric claims. Faces add pins and references; they do not introduce fresh computed scalars beyond what the mechanism already entails (MVPK functoriality).

Publication lexeme (per‑check). Each surfaced CV check is referenced as
GateCheckRef := { aspect=ConstraintValidity, kind, edition, scope } with scope ∈ {lane|locus|subflow|profile}. This adds no execution steps and introduces no numeric claims on faces; it records what CV classes were considered and under which editions.

#GateChecks (table) — CV only

Activation predicate (in E.TGA). Until aggregated CV = pass, all GateFit checks return abstain (CV⇒GF). Role/Channel Fit guard (GateFit scope). GateFit checks that involve roles SHALL use Kernel U.Role tokens (domain = U.System) and SHALL NOT consume TypicalEnactorRoleName strings from alias tables.

CV must not declare/translate Units/ReferencePlane/ComparatorSet; crossings and CSLC comparability live only in A.21.

#SWP matrix (single‑writer discipline)

• Writes (faces). CV.Status (and optional CV.WitnessRef) only.
• Reads (ref‑only). Any CG‑Spec/ComparatorSet/TransportRegistryΦ editions (when referenced); UNM remains single writer as per CC‑TGA‑24.

#CtxState & GateCrossing

• Crossings only at OperationalGate(profile) (plane/unit/context) with a strict exception for StructuralReinterpretation: a projection‑only retargeting MAY occur without a gate iff ⟨L,P,E⃗,D⟩ is preserved, KindBridge (CL^k) and a SquareLaw‑retargeting witness are present on MVPK/UTS, and the action is PathSlice‑local (PathSliceId pinned).
• Projection vs describedEntity (normative reduction). “Projection” denotes a change of MVPK published view that is point‑wise identity on the intensional transformation; “describedEntity” is the Kind‑channel on UTS evidenced by a CL^k row. “No unit/plane change” holds iff P is equal on both sides and no CL^plane is emitted for the step.
• Projection/describedEntity normalization (normative). In the context of StructuralReinterpretation, the terms projection and describedEntity are read via UTS: projection = change of published view coordinates only; describedEntity = Kind‑channel change under CL^k. A “no unit/plane change” test SHALL verify that ReferencePlane(src)=ReferencePlane(tgt) and CL^plane is absent (or = ⊤), otherwise the step is a gated crossing.
• Assurance operations on edges. ConstrainTo/CalibrateTo/CiteEvidence/AttributeTo reside on U.Transfer and do not alter ⟨L,P,E⃗,D⟩; plane/unit changes occur only at gates; Φ/CL^plane penalties route in R‑lane. describedEntity/kind transitions are surfaced as KindBridge (CL^k) on UTS (see A.27 / C.3.3). describedEntity/kind transitions use KindBridge (CL^k) (A.27/E.TGA); under CC‑TGA‑06‑EX this appears without a gate and remains PathSlice‑local.

Terminology binding (TGA‑specific, normative)

• Status/witness lexicon (E.10 discipline). In CV scope, publications use Status/Witness terminology; GateDecision… lexemes belong to GateFit (A.21) and do not apply to CV.
• describedEntity = KindBridge. Any CV mention of “describedEntity” SHALL be read via KindBridge (CL^k) on UTS (A.27 / C.3.3). CV does not declare or translate planes/units/comparators.
• retargeting/witness binding. For U.Transduction(kind=StructuralReinterpretation), the CV class ReinterpretationEquivalence SHALL surface CV.WitnessRef := ReinterpWitness over the addressed PathSliceId; the UTS SquareLaw‑retargeting witness is referenced from MVPK/UTS and linked from the CV witness without duplication.
• ReinterpWitness record (normative).
  ReinterpWitness := { PathSliceId, PublicationScopeId, mapping:{kind: iso|optic, laws: PutGet/GetPut}, commutingSquares:[TransferId], definedOn: PathSliceId, properties:{invertible?:bool, idempotent?:bool}, UTS.RowId, NoHiddenScalarization:true }.

#SquareLaw

For any gate‑mediated crossing adjacent to CV‑checked steps: gate_out ∘ transfer = transfer' ∘ gate_in. For projection retargetings under StructuralReinterpretation, a SquareLaw‑retargeting witness shows that the view retargeting commutes with transfers on the PathSlice. Inconsistencies lead to degrade/block per active profile (GateFit decision).

retargeting witness shape (normative, UTS‑level). A SquareLaw‑retargeting witness is an artifact that demonstrates commutativity of a published‑projection retargeting over the addressed PathSliceId:

1. identifies PathSliceId and PublicationScopeId;
2. presents a bidirectional view mapping between projections either as an iso or as a profunctor optic (get : A→B, put : (B×A)→A) satisfying Put‑Get / Get‑Put laws;
3. enumerates the commuting squares for the cut‑set edges considered (ids of transfers before/after the retargeting);
4. declares properties (invertible?, idempotent?) and the definedness area;
5. cites the UTS.RowId and links the DecisionLog entries that rely on this witness.
   Realizations via profunctor optics (post‑2017) are permitted; the optic/lens laws serve as the proof template of commutativity.

CV witness for reinterpretation (normative, CV‑level). CV.ReinterpretationEquivalence SHALL surface a ReinterpretationEquivalenceWitness distinct from the UTS retargeting witness and scoped to the mechanism state over the same PathSliceId: — PathSliceId, PublicationScopeId, and definedness region (domain constraints);
— a pair of internal transformations (or an optic) with Put‑Get / Get‑Put obligations over mechanism state (not faces);
— a list of commuting squares for the adjacent raw transfers (before/after reinterpretation) showing SquareLaw at CV boundary;
— an explicit NoHiddenScalarization assertion (see §4.9) for any comparable return shape;
— edition neutrality: no new editions are authored; only refs/pins appear.
This CV witness links to the UTS SquareLaw‑retargeting witness when present, but does not duplicate UTS fields.

CV witness binding (normative). For the CV class ReinterpretationEquivalence, the witness SHALL be a ReinterpWitness record: ReinterpWitness := { PathSliceId, PublicationScopeId, mapping: {kind: iso|optic, laws: PutGet/GetPut}, commutingSquares: [TransferId], definedOn: PathSliceId, properties: {invertible?: bool, idempotent?: bool}, UTS.RowId, NoHiddenScalarization: true }. The record is PathSlice‑local and does not declare or translate planes/units or comparators.

#Sentinel & PathSlice (path‑local refresh)

• Flows are valuations over U.Transfer, re‑emitting slice‑locally under sentinel rules or edition bumps (A.22/A.25). CV contributes to the prepare/refresh conditions but does not expand scope beyond the addressed PathSliceId.

• Delimitation & planning (normative). A PathSlice closes on: (i) any pinned edition change, (ii) Γ‑window boundary relevant to the face, (iii) GateProfile change along the path, or (iv) an explicit sentinel rule. Concurrency: at most one active recompute per {PathSliceId}; parallel recomputes are permitted across distinct PathSliceIds.

• CV‑triggered refresh (minimum list). Re‑emit the addressed PathSliceId when any holds: (a) CV.Status changes across the lattice; (b) ReinterpWitness is added/updated/withdrawn; (c) AdmissibilityDecl.edition or LipschitzBoundRef.edition changes; (d) updates arrive from A.27 (Bridge) or A.28 (ComparatorSet/UNM.TransportRegistryΦ); (e) error/timeout transitions to a resolved pass for a previously abstain|degrade CV class.

• CV‑to‑refresh triggers (normative). A SliceRefresh(PathSliceId) SHALL be scheduled when any of the following occurs:
  (T1) a CV status flip on the slice (pass↔degrade, pass↔block, or error/timeout→{degrade|block} under profile rules);
  (T2) arrival of a new ReinterpretationEquivalenceWitness or a change in its definedness region;
  (T3) updates to adjacent UTS/Bridge facts for the slice (e.g., CL^k, BridgeId, Φ/Ψ policy‑ids) coming from A.27;
  (T4) edition changes referenced by CSLC (A.28) on the slice (ComparatorSetRef.edition, DescriptorMapRef.edition, DistanceDefRef.edition, …);
  (T5) FreshnessTicket lifecycle changes impacting the slice window (A.40);
  (T6) sentinel rules explicitly attached to the PathSliceId.
  Scheduling is slice‑local; recompute does not fan‑out beyond the addressed PathSliceId.

  Id‑scheme: PathSliceId := PathId × Γ_time selector × ReferencePlane × SentinelFingerprint × IterationCounter.
  Locking for replay: within a recompute, the effective E⃗ is frozen; outputs carry a replay fingerprint resolvable via DecisionLog.

#ReturnShape & CSLC (comparability discipline)

When the mechanism yields comparable artifacts, the return surface is set‑valued / partially ordered; no hidden scalarization. Any comparator citation is ref‑only and (if editions are cited) requires Bridge+UTS per CSLC (A.28). Actual CSLC checks are GateFit (A.21).

Under StructuralReinterpretation, projection changes MUST NOT introduce hidden scalarization; set‑return semantics remain intact; comparator cites stay ref‑only with UTS discipline.

Detectable signs of hidden scalarization (normative checklist). A face SHALL be flagged when any holds:
(H1) introduction of a new scalar not entailed by the mechanism, or any cardinality‑reducing fold of a set return (e.g., argmax/best‑of) without a cited ComparatorSetRef;
(H2) omission of a required ComparatorSetRef or its edition pins where comparison is implied;
(H3) presence of an order‑imposing coordinate without a CoordinatePolicy and legality annotations (scale/units/illegal ops);
(H4) cross‑plane/units numeric combination without a Bridge+UTS row;
(H5) for StructuralReinterpretation, any change of return plane/units (violates “projection‑only”).
Failing (H1–H5) degrades or blocks per GateProfile (§4.4/CC‑TGA‑21a).

#Γ‑windows / Freshness

• No implicit latest. Any face expected to be consumed at compare/launch pins Γ_time; Freshness enforcement occurs at gates; CV neither issues Freshness tickets nor evaluates staleness (see A.33/A.40).
• Granularity of Γ (normative). Γ SHALL be one of: snapshot (effective_at=t) or interval ([t₀,t₁) with a named folding policy). Faces SHALL surface which selector is used.
• CV time‑stamping. Each CV computation surfaces t_cv and the Γ selector it assumed; replay binds t_cv to PathSliceId.
• Temporal policy types (binding). Γ‑pins refer to the canonical selectors of §22 (effective_at, latest_effective_before, windowed(W, policy)) and to folding policies that are IDEM/MONO/WLNK‑safe. Units/time scales SHALL be explicit. Overrides of the default weakest‑link fold SHALL cite CAL proofs of monotonicity and boundary behavior.

#Unknown/Timeout/Error policy

Each CV class yields abstain | pass | degrade | block. Errors/timeouts at CV stage imply CV ≠ pass; therefore GateFit abstains by the global activation predicate and any GateFit‑oriented explanation does not apply. The aggregated CV decision uses the join on abstain ≤ pass ≤ degrade ≤ block (neutral = abstain; absorbing = block).
Minimal default (profile‑bound, normative): Lean/Core ⇒ error|timeout → degrade, SafetyCritical/RegulatedX ⇒ error|timeout → block; unknown folds per GateCheck policy (safety‑default: degrade). (Consistent with CC‑TGA‑22.)

#Idempotency / congruence discipline

Any surface influencing gate decisions references A.41 for equivalence of inputs and idempotency witness; A.20 does not introduce keys, hashes, or cache policies. Minimal lexeme set for CV‑adjacent equivalence (normative). Where CV outcomes influence a gate decision, the equivalence witness SHALL identify at least: {PathSliceId, GateProfileId, Γ selector (+window bounds if interval), E⃗ editions vector for cited registries, ReturnShape kind (if comparable), CV class/kind set considered}. Changing any of these breaks equivalence and requires re‑aggregation.

#Archetypal Grounding (Tell–Show–Show) ✱

Show‑1 (compiler build → run). A typed module M exposes f : State_d → Artifact_d under a declared LawSet (e.g., determinism under fixed toolchain) and TypeDomainRange. CV checks: (i) MechanismUnitsCoherence (toolchain/flags units coherent), (ii) LawSetInvariants (reproducible outputs under same E⃗), (iii) Admissibility (inputs well‑typed), (iv) optional Lipschitz/stability surrogate (bounded perturbation in sandbox). CtxState is preserved along raw transfers. Entering U.Work(run) requires LaunchGate with FreshnessUpToDate and DesignRunTagConsistency — GateFit, not CV.

Show‑2 (selection archive in QD/AutoML). A mechanism emits a set (front/portfolio/archive). CV ensures only: valid descriptor ranges, internal metric continuity bounds, archive invariants (idempotent insert). No ranking or acceptance thresholds are introduced at CV; comparators and acceptance policies bind at gates via CSLC and profiles (A.21/A.28). Edition‑aware pins on faces carry DescriptorMapRef.edition only with Bridge+UTS.

Anchors. Algebraic effects & handlers separate signatures from handlers (Koka/Effekt, 2015+); reproducible pipelines isolate mechanism constraints from deployment profiles (Bazel/Nix); optics/profunctors and open/hypergraph categories motivate composition on open graphs without adding facts on faces; QD/MAP‑Elites/CMA‑ME/DQD motivate set‑return + lawful orders (2015–2022).

#Bias‑Annotation

The pattern constrains how internal constraints are surfaced; it does not encode profile‑bound thresholds or Role/Channel fit — those sit in GateFit. This separation reduces leakage of profile concerns into mechanism semantics.

#Conformance Checklist ✱

Static lint (graph & surfaces)

• CC‑TGA‑01: only U.Transfer edges; crossings appear only on gates.
• CC‑TGA‑05: ⟨L,P,E⃗,D⟩ unchanged across raw transfers.
• CC‑TGA‑09: MVPK faces present; edition & Γ pins where expected; no new numeric claims on faces (E.17).

CV discipline

• CV classes present exactly as {UnitsCoherence, LawSetInvariants, Admissibility, LipschitzBounds, TypeDomainRange}; plus ReinterpretationEquivalence when the node kind is StructuralReinterpretation. None declare/translate planes/comparators.
• Open‑world species. Any node species binds to one of the minimal kinds; adding a new kind is out of scope for A.20 and requires an E.TGA update.
• Aggregated CV.Status computed; errors/timeouts ⇒ CV ≠ pass.

Gate coupling

• CC‑TGA‑07: when CV ≠ pass, all GateFit checks report abstain.
• CC‑TGA‑23: SquareLaw witnesses present on crossings adjacent to CV‑checked steps.
• Any edition citation on faces includes Bridge+UTS (A.27; CSLC in A.28).

UNM single‑writer

• CC‑TGA‑24: UNM.Authoring is the sole writer for CG‑Spec/ComparatorSet/TransportRegistryΦ; CV is ref‑only.

Valuation & refresh

• CC‑TGA‑18/19: Flow publishes valuation with PublicationScopeId/PathSliceId; Γ pinned at compare/launch surfaces; sentinel triggers slice‑local refresh.

#Consequences

Benefits. Clarity & composability. Mechanisms remain pure carriers of internal laws; gates are the sole policy junction. Replayability. With valuation + MVPK pins, re‑runs under fixed E⃗ are comparable and slice‑scoped (A.22/A.25). Didactic hygiene. Readers can see what is mechanism truth vs. gate policy.

Trade‑offs.

• Two places to look (CV vs. GF) impose author discipline; mitigated by the activation predicate and MVPK links.

#Rationale

E.TGA hosts A.20 and A.21 as orthogonal cores: CV inside transformations; GF at gates with join‑aggregation and DecisionLog. This mirrors effects/handlers (signature vs. handler), and reproducible build vs. deployment‑profile separation.

#SoTA‑Echoing (post‑2015)

• Algebraic effects & handlers (Koka, Effekt): signatures vs. handlers as a model for CV vs. GF.
• Reproducible pipelines (Bazel, Nix): hermetic builds ≈ CV; release/deploy gates ≈ GF.
• Optics/profunctors; open/hypergraph categories (2017–2019+): composition over open graphs without extra face semantics.
• Quality‑Diversity / MAP‑Elites / CMA‑ME / DQD (2015–2022): set‑return with lawful partial orders; no hidden scalarization. These anchors justify the separation and the set‑return discipline (CSLC) embedded in the flow family.

#Relations

• Hosted by E.TGA. Nodes are morphisms; only U.Transfer edges; open‑world species over a minimal kind set; CV⇒GF activation; MVPK faces; SquareLaw on crossings; CC‑TGA‑06‑EX for StructuralReinterpretation.
• A.21 (GateProfilization). Sole point for GateFit checks and profile‑bound folds.
• A.22 (FlowSpec—valuation). Declares valuation and slice‑refresh semantics used by this flow family.
• A.27 (Bridge+UTS). Boundary‑surface requirement whenever faces cite editions.
• A.28 (CSLC). Comparability discipline; CV does not compare; it only ensures internal readiness for lawful comparison.
• A.41 (DecisionLog & Idempotency). Equivalence witness binding for any surfaces affecting gate decisions.
• E.10 (LEX). Token classes and ASCII Tech names; twin labels and aliasing for Γ/CL/Φ as per LEX‑BUNDLE.

#A.20:Appendix A — CV Class Gloss (normative)

• MechanismUnitsCoherence. Internal unit/scale coherence within the step; no declarations or translations of units/planes (GateFit scope).
• LawSetInvariants. Mechanism‑declared invariants hold (e.g., mass/energy balance in a model, determinism under fixed editions).
• AdmissibilityConditionsSatisfaction. Inputs lie within admissible windows/guards declared by the mechanism’s AdmissibilityConditions; failure yields degrade or abstain per class policy. Minimum declaration (normative): AdmissibilityDecl := { domains: {name: set/poset}+, guards: [predicate_id]*, windows: {Γ_time: snapshot|interval|policy}, observables: [signal_id]*, edition: EditionId }. The declaration is surfaced on MVPK as references only; it introduces no arithmetic on faces.
• LipschitzBounds / stability. Bounded sensitivity to perturbations as declared by mechanism; optional where meaningful. Method binding (normative): LipschitzBoundRef := { method ∈ {spectral_norm|CROWN|IBP|rand_smoothing|other}, metric_space: {X: norm_id, Y: norm_id}, bound: value_or_interval, units/plane: P, validity_window: Γ_time(basis), edition: EditionId }. The bound is edition‑pinned and plane/units‑declared; proofs/witness artefacts are referenced (no new numeric claims on faces). Minimal declaration template (normative):
  AdmissibilityConditions := { Domains[]{var, type, range, units, plane}, Guards[]{predicate, editionRefs}, ObservationWindows[]{Γ selector, freshness window}, ObservableSigns[]{name, detection rule}, Editions{… } }
  — No authoring of units/planes here; only references. — Γ selectors must be explicit.
• TypeDomainRange. Type/domain/range compliance of inputs/outputs (ref‑only to definitions).
• ReinterpretationEquivalence. Mechanism’s reinterpretation preserves internal meaning on a PathSlice.
  Witness (normative): ReinterpretationEquivalenceWitness (see §4.7) with: (i) PathSliceId, PublicationScopeId, (ii) bidirectional mapping (iso/optic) with Put‑Get/Get‑Put obligations, (iii) commuting squares for adjacent raw transfers, (iv) NoHiddenScalarization assertion (if comparable), (v) definedness region.
  — No plane/unit change; any describedEntity change must have KindBridge (CL^k) on UTS.
• LipschitzBounds / stability. Bounded sensitivity of the mechanism under a declared metric.
  Certificate (normative): LipschitzCertificate := { metricId (with units/plane), bound L, methodId, methodRef (e.g., spectral estimate / cert. robustness bound), validity region (inputs/state), proof sketch/ref }.
  — The method MUST be cited; units/plane of the metric MUST be explicit; bounds are ref‑only at CV; any acceptance action remains GateFit.
• TypeDomainRange. Well‑typedness and domain/range consistency for the transformation signature. (Enumeration mandated by A.20; GF matters excluded).
• ReinterpretationEquivalence (StructuralReinterpretation). Existence of a correspondence/reversibility witness between source and retarget projections; preservation of ⟨L,P,E⃗,D⟩; no comparator/plane/unit declaration or translation at CV. The witness is PathSlice‑local and supports idempotence & reversibility within the addressed slice. The normative record is ReinterpWitness (see §4.7).

#A.20:Appendix B — LEX discipline (summary)

Register token classes (Tech) include: U.TransductionFlow, U.TransductionGraph, OperationalGate, GateProfile, GateCheckKind, GateCheckRef, DecisionLog, FreshnessTicket, FinalizeLaunchValues, SubflowRef, FlowEmbed, SentinelId, PathSliceId, SliceRefresh, VALATA; discriminators use Base__P2W, Base__EvaluatingAndRefreshing; Tech names are ASCII; aliases GammaTimeRule/Plane, CLPlane, Phi follow E.10. A.20 references these tokens; it does not introduce additional LEX classes. For each surfaced CV check, GateCheckRef.aspect is fixed to ConstraintValidity. MVPK minima for CV faces also include PathId/PathSliceId where slice‑local refresh applies (A.22).

#A.20:End