{
  "$defs": {
    "boundary/BoundaryEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1ExternalEffect"
        },
        {
          "properties": {
            "effectBoundary": {
              "$ref": "#/$defs/boundary~1IOBoundary"
            },
            "isIdempotent": {
              "type": "boolean"
            }
          },
          "required": [
            "effectBoundary",
            "isIdempotent"
          ],
          "type": "object"
        }
      ],
      "description": "An effect that crosses the kernel/external boundary. Specializes effect:ExternalEffect with explicit source or sink binding.",
      "title": "BoundaryEffect"
    },
    "boundary/BoundaryProtocol": {
      "description": "A specification of the data shape, ordering, and framing constraints for data crossing a boundary.",
      "properties": {
        "protocolOrdering": {
          "$ref": "#/$defs/type~1CompositeConstraint"
        },
        "protocolType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        }
      },
      "required": [
        "protocolType",
        "protocolOrdering"
      ],
      "title": "BoundaryProtocol",
      "type": "object"
    },
    "boundary/BoundarySession": {
      "allOf": [
        {
          "$ref": "#/$defs/state~1Session"
        },
        {
          "properties": {
            "crossingCount": {
              "minimum": 0,
              "type": "integer"
            },
            "sessionBoundaries": {
              "items": {
                "$ref": "#/$defs/boundary~1IOBoundary"
              },
              "type": "array"
            }
          },
          "required": [
            "crossingCount"
          ],
          "type": "object"
        }
      ],
      "description": "A Session that includes BoundaryEffects. Extends the session model to track which boundaries were crossed.",
      "title": "BoundarySession"
    },
    "boundary/EmitEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/boundary~1BoundaryEffect"
        },
        {
          "properties": {
            "emitSink": {
              "$ref": "#/$defs/boundary~1Sink"
            }
          },
          "required": [
            "emitSink"
          ],
          "type": "object"
        }
      ],
      "description": "A BoundaryEffect that writes a ring datum to a Sink.",
      "title": "EmitEffect"
    },
    "boundary/IOBoundary": {
      "description": "A typed interface point between the kernel and the external world. Every data flow into or out of the ring crosses exactly one IOBoundary.",
      "title": "IOBoundary",
      "type": "object"
    },
    "boundary/IngestEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/boundary~1BoundaryEffect"
        },
        {
          "properties": {
            "ingestSource": {
              "$ref": "#/$defs/boundary~1Source"
            }
          },
          "required": [
            "ingestSource"
          ],
          "type": "object"
        }
      ],
      "description": "A BoundaryEffect that reads from a Source and produces a datum in the ring.",
      "title": "IngestEffect"
    },
    "boundary/Sink": {
      "allOf": [
        {
          "$ref": "#/$defs/boundary~1IOBoundary"
        },
        {
          "properties": {
            "sinkProjection": {
              "$ref": "#/$defs/morphism~1ProjectionMap"
            },
            "sinkType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            }
          },
          "required": [
            "sinkType",
            "sinkProjection"
          ],
          "type": "object"
        }
      ],
      "description": "A typed destination for data leaving the ring. Carries an expected TypeDefinition describing the shape of outgoing data.",
      "title": "Sink"
    },
    "boundary/Source": {
      "allOf": [
        {
          "$ref": "#/$defs/boundary~1IOBoundary"
        },
        {
          "properties": {
            "sourceGrounding": {
              "$ref": "#/$defs/morphism~1GroundingMap"
            },
            "sourceType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            }
          },
          "required": [
            "sourceType",
            "sourceGrounding"
          ],
          "type": "object"
        }
      ],
      "description": "A typed source of external data entering the ring. Carries an expected TypeDefinition describing the shape of incoming data.",
      "title": "Source"
    },
    "carry/CarryChain": {
      "description": "The Boolean function chain c_{k+1} = or(and(x_k, y_k), and(xor(x_k, y_k), c_k)). The carry chain is the algebraic mechanism behind the incompatibility metric d_Δ.",
      "properties": {
        "chainLength": {
          "minimum": 0,
          "type": "integer"
        },
        "generateMask": {
          "minimum": 0,
          "type": "integer"
        },
        "killMask": {
          "minimum": 0,
          "type": "integer"
        },
        "propagateMask": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "chainLength",
        "generateMask",
        "propagateMask",
        "killMask"
      ],
      "title": "CarryChain",
      "type": "object"
    },
    "carry/CarryEvent": {
      "description": "A single carry event at site k. Three kinds: Generate (and(x_k, y_k) = 1), Propagate (xor(x_k, y_k) = 1 and c_k = 1), Kill (neither generate nor propagate).",
      "properties": {
        "eventKind": {
          "minimum": 0,
          "type": "integer"
        },
        "sitePosition": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "eventKind",
        "sitePosition"
      ],
      "title": "CarryEvent",
      "type": "object"
    },
    "carry/CarryProfile": {
      "description": "The complete carry pattern for an addition x + y. Aggregates carry events across all sites into counts and position masks.",
      "properties": {
        "carryCount": {
          "minimum": 0,
          "type": "integer"
        },
        "maxPropagationLength": {
          "minimum": 0,
          "type": "integer"
        },
        "profileChain": {
          "$ref": "#/$defs/carry~1CarryChain"
        }
      },
      "required": [
        "carryCount",
        "maxPropagationLength",
        "profileChain"
      ],
      "title": "CarryProfile",
      "type": "object"
    },
    "carry/EncodingConfiguration": {
      "description": "A mapping from a finite symbol set S to Z/(2^k)Z where 2^k ≥ |S|. Determines how domain values are represented as ring elements.",
      "properties": {
        "encodingMap": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "quantizationBits": {
          "minimum": 1,
          "type": "integer"
        },
        "symbolSetSize": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "symbolSetSize",
        "quantizationBits",
        "encodingMap"
      ],
      "title": "EncodingConfiguration",
      "type": "object"
    },
    "carry/EncodingQuality": {
      "description": "The d_Δ quality metric for an encoding over observed data. Measures how well an encoding minimizes carry-induced metric incompatibility.",
      "properties": {
        "discriminationRatio": {
          "type": "number"
        },
        "isOptimalEncoding": {
          "type": "boolean"
        },
        "meanDelta": {
          "type": "number"
        }
      },
      "required": [
        "meanDelta",
        "discriminationRatio",
        "isOptimalEncoding"
      ],
      "title": "EncodingQuality",
      "type": "object"
    },
    "cert/BornRuleVerification": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "bornRuleVerified": {
              "type": "boolean"
            }
          },
          "required": [
            "bornRuleVerified"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a MeasurementEvent outcome probability matches the Born rule: P(outcome k) = |α_k|² (QM_5). Linked from MeasurementCertificate to provide probability distribution verification.",
      "title": "BornRuleVerification"
    },
    "cert/Certificate": {
      "description": "A kernel-produced attestation. The root class for all certificate types.",
      "properties": {
        "certifies": {
          "format": "iri",
          "type": "string"
        },
        "method": {
          "$ref": "#/$defs/proof~1ProofStrategy"
        },
        "timestamp": {
          "format": "date-time",
          "type": "string"
        },
        "verified": {
          "type": "boolean"
        },
        "wittLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "method",
        "verified",
        "wittLength",
        "timestamp",
        "certifies"
      ],
      "title": "Certificate",
      "type": "object"
    },
    "cert/ChainAuditTrail": {
      "description": "An ordered collection of per-step evidence records for a LiftChainCertificate.",
      "properties": {
        "chainStepCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "chainStepCount"
      ],
      "title": "ChainAuditTrail",
      "type": "object"
    },
    "cert/CompletenessAuditTrail": {
      "description": "An ordered collection of CompletenessWitness records belonging to a CompletenessCertificate. Provides full provenance of the certification process: every constraint applied, every site closed, in sequence.",
      "properties": {
        "witnessCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "witnessCount"
      ],
      "title": "CompletenessAuditTrail",
      "type": "object"
    },
    "cert/CompletenessCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "auditTrail": {
              "$ref": "#/$defs/cert~1CompletenessAuditTrail"
            },
            "certifiedType": {
              "$ref": "#/$defs/type~1CompleteType"
            }
          },
          "required": [
            "certifiedType",
            "auditTrail"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a type:CompleteType satisfies IT_7d: its constraint nerve has χ = n and all Betti numbers β_k = 0. Issued by the kernel after running the full ψ pipeline on the type's constraint set.",
      "title": "CompletenessCertificate"
    },
    "cert/GeodesicCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "certifiedGeodesic": {
              "$ref": "#/$defs/trace~1GeodesicTrace"
            },
            "evidenceBundle": {
              "$ref": "#/$defs/cert~1GeodesicEvidenceBundle"
            },
            "geodesicTrace": {
              "$ref": "#/$defs/trace~1GeodesicTrace"
            }
          },
          "required": [
            "certifiedGeodesic",
            "geodesicTrace",
            "evidenceBundle"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a trace:GeodesicTrace satisfies both GD_1 conditions: AR_1-ordered and DC_10-selected. Transforms ComputationTrace from descriptive to normative.",
      "title": "GeodesicCertificate"
    },
    "cert/GeodesicEvidenceBundle": {
      "description": "A structured evidence bundle attesting that each sub-predicate of the geodesic condition (GD_6) holds independently: isAR1Ordered and isDC10Selected. Linked from GeodesicCertificate via evidenceBundle.",
      "properties": {
        "isAR1Ordered": {
          "type": "boolean"
        },
        "isDC10Selected": {
          "type": "boolean"
        }
      },
      "required": [
        "isAR1Ordered",
        "isDC10Selected"
      ],
      "title": "GeodesicEvidenceBundle",
      "type": "object"
    },
    "cert/GroundingCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "certifiedGrounding": {
              "$ref": "#/$defs/state~1GroundedContext"
            },
            "groundingWitness": {
              "$ref": "#/$defs/state~1GroundingWitness"
            }
          },
          "required": [
            "certifiedGrounding",
            "groundingWitness"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a state:GroundedContext has reached full saturation (σ = 1, freeRank = 0, S = 0, T_ctx = 0) per SC_4. The session-layer dual of CompletenessCertificate.",
      "title": "GroundingCertificate"
    },
    "cert/InvolutionCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "operation": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "operation"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that an operation is an involution: f(f(x)) = x for all x in R_n.",
      "title": "InvolutionCertificate"
    },
    "cert/IsometryCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a morphism:Isometry preserves metric distances. Certifies the transform is a metric isometry with respect to the specified metric.",
      "title": "IsometryCertificate"
    },
    "cert/LiftChainCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "certifiedChain": {
              "$ref": "#/$defs/type~1LiftChain"
            },
            "chainAuditTrail": {
              "$ref": "#/$defs/cert~1ChainAuditTrail"
            },
            "sourceLevel": {
              "$ref": "#/$defs/schema~1WittLevel"
            },
            "targetLevel": {
              "$ref": "#/$defs/schema~1WittLevel"
            }
          },
          "required": [
            "certifiedChain",
            "chainAuditTrail",
            "targetLevel",
            "sourceLevel"
          ],
          "type": "object"
        }
      ],
      "description": "A kernel-issued certificate attesting that a LiftChain from liftSourceLevel to liftTargetLevel is complete.",
      "title": "LiftChainCertificate"
    },
    "cert/MeasurementCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "certifiedMeasurement": {
              "$ref": "#/$defs/trace~1MeasurementEvent"
            },
            "landauerCost": {
              "type": "number"
            },
            "vonNeumannEntropy": {
              "type": "number"
            }
          },
          "required": [
            "certifiedMeasurement",
            "vonNeumannEntropy",
            "landauerCost"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a trace:MeasurementEvent respected the von Neumann–Landauer bridge (QM_1): preCollapseEntropy = postCollapseLandauerCost at β* = ln 2.",
      "title": "MeasurementCertificate"
    },
    "cert/TransformCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "transformType": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "transformType"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting to the properties of a morphism:Transform. Certifies that the transform maps source to target correctly.",
      "title": "TransformCertificate"
    },
    "cohomology/CoboundaryOperator": {
      "description": "The coboundary operator δ^k: C^k → C^{k+1}. Satisfies δ² = 0.",
      "properties": {
        "coboundarySource": {
          "$ref": "#/$defs/cohomology~1CochainGroup"
        },
        "coboundaryTarget": {
          "$ref": "#/$defs/cohomology~1CochainGroup"
        },
        "satisfiesCoboundarySquaredZero": {
          "type": "boolean"
        }
      },
      "required": [
        "coboundarySource",
        "coboundaryTarget",
        "satisfiesCoboundarySquaredZero"
      ],
      "title": "CoboundaryOperator",
      "type": "object"
    },
    "cohomology/CochainComplex": {
      "description": "A cochain complex: a sequence of cochain groups connected by coboundary operators.",
      "properties": {
        "hasCoboundary": {
          "items": {
            "$ref": "#/$defs/cohomology~1CoboundaryOperator"
          },
          "type": "array"
        },
        "hasCochainGroup": {
          "items": {
            "$ref": "#/$defs/cohomology~1CochainGroup"
          },
          "type": "array"
        }
      },
      "title": "CochainComplex",
      "type": "object"
    },
    "cohomology/CochainGroup": {
      "description": "A cochain group: the dual of a chain group, maps chains to coefficients.",
      "properties": {
        "cochainDegree": {
          "type": "integer"
        },
        "cochainRank": {
          "minimum": 0,
          "type": "integer"
        },
        "dualOf": {
          "$ref": "#/$defs/homology~1ChainGroup"
        }
      },
      "required": [
        "cochainDegree",
        "cochainRank",
        "dualOf"
      ],
      "title": "CochainGroup",
      "type": "object"
    },
    "cohomology/CohomologyGroup": {
      "description": "The k-th cohomology group H^k = ker(δ^k) / im(δ^{k-1}). Measures k-dimensional obstructions.",
      "properties": {
        "cohomologyDegree": {
          "type": "integer"
        },
        "cohomologyRank": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "cohomologyDegree",
        "cohomologyRank"
      ],
      "title": "CohomologyGroup",
      "type": "object"
    },
    "cohomology/GluingObstruction": {
      "description": "A gluing obstruction: a cohomology class that detects when local sections fail to glue.",
      "properties": {
        "addressesSuggestion": {
          "items": {
            "$ref": "#/$defs/resolver~1RefinementSuggestion"
          },
          "type": "array"
        },
        "obstructionClass": {
          "$ref": "#/$defs/cohomology~1CohomologyGroup"
        }
      },
      "required": [
        "obstructionClass"
      ],
      "title": "GluingObstruction",
      "type": "object"
    },
    "cohomology/LocalSection": {
      "allOf": [
        {
          "$ref": "#/$defs/cohomology~1Section"
        },
        {
          "type": "object"
        }
      ],
      "description": "A local section: a consistent choice of data over a subcomplex.",
      "title": "LocalSection"
    },
    "cohomology/RestrictionMap": {
      "description": "A restriction map ρ_{σ,τ}: maps data from a simplex to a face.",
      "properties": {
        "restrictsFrom": {
          "$ref": "#/$defs/homology~1Simplex"
        },
        "restrictsTo": {
          "$ref": "#/$defs/homology~1Simplex"
        }
      },
      "required": [
        "restrictsFrom",
        "restrictsTo"
      ],
      "title": "RestrictionMap",
      "type": "object"
    },
    "cohomology/Section": {
      "description": "A global section of a sheaf: a consistent choice of local data across all simplices.",
      "title": "Section",
      "type": "object"
    },
    "cohomology/Sheaf": {
      "description": "A sheaf F over a simplicial complex: assigns data to each simplex with restriction maps.",
      "properties": {
        "coefficientIn": {
          "$ref": "#/$defs/schema~1Ring"
        },
        "hasGlobalSection": {
          "items": {
            "$ref": "#/$defs/cohomology~1Section"
          },
          "type": "array"
        },
        "hasStalks": {
          "items": {
            "$ref": "#/$defs/cohomology~1Stalk"
          },
          "type": "array"
        },
        "sheafOver": {
          "$ref": "#/$defs/homology~1SimplicialComplex"
        }
      },
      "required": [
        "sheafOver",
        "coefficientIn"
      ],
      "title": "Sheaf",
      "type": "object"
    },
    "cohomology/Stalk": {
      "description": "A stalk F_σ: the local data of a sheaf at a simplex σ.",
      "properties": {
        "stalkAt": {
          "$ref": "#/$defs/homology~1Simplex"
        }
      },
      "required": [
        "stalkAt"
      ],
      "title": "Stalk",
      "type": "object"
    },
    "conformance/CompileUnitBuilder": {
      "description": "Builder for CompileUnit admission. Collects rootTerm, quantumLevelCeiling, thermodynamicBudget, and targetDomains. Validates against CompileUnitShape.",
      "properties": {
        "builderRootTerm": {
          "$ref": "#/$defs/schema~1Term"
        },
        "builderTargetDomains": {
          "items": {
            "$ref": "#/$defs/op~1VerificationDomain"
          },
          "type": "array"
        },
        "builderThermodynamicBudget": {
          "type": "number"
        },
        "builderWittLevelCeiling": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "builderRootTerm",
        "builderWittLevelCeiling",
        "builderThermodynamicBudget"
      ],
      "title": "CompileUnitBuilder",
      "type": "object"
    },
    "conformance/DispatchDeclaration": {
      "description": "Builder for DispatchShape. Collects predicate, target resolver, and dispatch priority.",
      "properties": {
        "dispatchPredicate": {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        "dispatchPriority": {
          "minimum": 0,
          "type": "integer"
        },
        "targetResolver": {
          "$ref": "#/$defs/resolver~1Resolver"
        }
      },
      "required": [
        "dispatchPredicate",
        "targetResolver",
        "dispatchPriority"
      ],
      "title": "DispatchDeclaration",
      "type": "object"
    },
    "conformance/DispatchShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring a new DispatchRule in a DispatchTable.",
      "title": "DispatchShape"
    },
    "conformance/EffectDeclaration": {
      "description": "Builder for EffectShape. Collects effect name, target sites, budget delta, and commutation flag.",
      "properties": {
        "budgetDelta": {
          "type": "integer"
        },
        "commutationFlag": {
          "type": "boolean"
        },
        "effectName": {
          "type": "string"
        },
        "targetSites": {
          "items": {
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        }
      },
      "required": [
        "effectName",
        "budgetDelta",
        "commutationFlag"
      ],
      "title": "EffectDeclaration",
      "type": "object"
    },
    "conformance/EffectShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring an ExternalEffect.",
      "title": "EffectShape"
    },
    "conformance/GroundedCoordinate": {
      "description": "Boundary crossing intermediate for a single grounded coordinate value. Not a WitnessDatum — must be validated and minted by the foundation.",
      "properties": {
        "coordinateLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "coordinateLevel"
      ],
      "title": "GroundedCoordinate",
      "type": "object"
    },
    "conformance/GroundedTuple": {
      "description": "Boundary crossing intermediate for a fixed-size array of GroundedCoordinate values. Stack-resident, no heap allocation.",
      "title": "GroundedTuple",
      "type": "object"
    },
    "conformance/GroundedValueMarker": {
      "description": "Sealed marker trait class. Implemented only for GroundedCoordinate and GroundedTuple. Prevents downstream crates from substituting arbitrary types.",
      "title": "GroundedValueMarker",
      "type": "object"
    },
    "conformance/GroundingDeclaration": {
      "description": "Builder for GroundingShape. Collects source type, ring mapping, and invertibility contract.",
      "properties": {
        "groundingSourceType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        "invertibilityContract": {
          "type": "boolean"
        },
        "ringMapping": {
          "type": "string"
        }
      },
      "required": [
        "groundingSourceType",
        "ringMapping",
        "invertibilityContract"
      ],
      "title": "GroundingDeclaration",
      "type": "object"
    },
    "conformance/GroundingShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring a GroundingMap from surface data to the ring.",
      "title": "GroundingShape"
    },
    "conformance/LeaseDeclaration": {
      "description": "Builder for LeaseShape. Collects linear site and lease scope.",
      "properties": {
        "leaseScope": {
          "type": "string"
        },
        "linearSite": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "linearSite",
        "leaseScope"
      ],
      "title": "LeaseDeclaration",
      "type": "object"
    },
    "conformance/LeaseShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring a Lease with LinearSite allocation.",
      "title": "LeaseShape"
    },
    "conformance/MintingSession": {
      "description": "Boundary session state tracker. Records crossing count and idempotency flag for the two-phase minting boundary.",
      "properties": {
        "sessionCrossingCount": {
          "minimum": 0,
          "type": "integer"
        },
        "sessionIsIdempotent": {
          "type": "boolean"
        }
      },
      "required": [
        "sessionCrossingCount",
        "sessionIsIdempotent"
      ],
      "title": "MintingSession",
      "type": "object"
    },
    "conformance/ParallelDeclaration": {
      "description": "Builder for ParallelShape. Collects site partition and disjointness witness.",
      "properties": {
        "disjointnessWitness": {
          "type": "string"
        },
        "sitePartition": {
          "$ref": "#/$defs/partition~1Partition"
        }
      },
      "required": [
        "sitePartition",
        "disjointnessWitness"
      ],
      "title": "ParallelDeclaration",
      "type": "object"
    },
    "conformance/ParallelShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring a ParallelProduct.",
      "title": "ParallelShape"
    },
    "conformance/PredicateDeclaration": {
      "description": "Builder for PredicateShape. Collects input type, evaluator term, and termination witness.",
      "properties": {
        "evaluatorTerm": {
          "$ref": "#/$defs/schema~1Term"
        },
        "predicateInputType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        "terminationWitness": {
          "type": "string"
        }
      },
      "required": [
        "predicateInputType",
        "evaluatorTerm",
        "terminationWitness"
      ],
      "title": "PredicateDeclaration",
      "type": "object"
    },
    "conformance/PredicateShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for user-declared predicates. Requires a bounded evaluator (termination witness) and input type declaration.",
      "title": "PredicateShape"
    },
    "conformance/PropertyConstraint": {
      "description": "A single required property within a shape: the property URI, its expected range, minimum and maximum cardinality.",
      "properties": {
        "constraintProperty": {
          "format": "iri",
          "type": "string"
        },
        "constraintRange": {
          "format": "iri",
          "type": "string"
        },
        "maxCount": {
          "minimum": 0,
          "type": "integer"
        },
        "minCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "constraintProperty",
        "constraintRange",
        "minCount",
        "maxCount"
      ],
      "title": "PropertyConstraint",
      "type": "object"
    },
    "conformance/Shape": {
      "description": "A constraint shape that a Prism-declared extension must satisfy. Analogous to sh:NodeShape in SHACL.",
      "properties": {
        "requiredProperty": {
          "items": {
            "$ref": "#/$defs/conformance~1PropertyConstraint"
          },
          "type": "array"
        },
        "targetClass": {
          "format": "iri",
          "type": "string"
        }
      },
      "required": [
        "targetClass"
      ],
      "title": "Shape",
      "type": "object"
    },
    "conformance/ShapeViolationReport": {
      "description": "Structured violation diagnostic carrying the shape IRI, constraint IRI, property IRI, expected range, cardinality bounds, and violation kind.",
      "properties": {
        "constraintIri": {
          "type": "string"
        },
        "expectedRange": {
          "type": "string"
        },
        "propertyIri": {
          "type": "string"
        },
        "shapeIri": {
          "type": "string"
        },
        "violationKind": {
          "$ref": "#/$defs/conformance~1ViolationKind"
        },
        "violationMaxCount": {
          "minimum": 0,
          "type": "integer"
        },
        "violationMinCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "shapeIri",
        "constraintIri",
        "propertyIri",
        "expectedRange",
        "violationMinCount",
        "violationMaxCount",
        "violationKind"
      ],
      "title": "ShapeViolationReport",
      "type": "object"
    },
    "conformance/StreamDeclaration": {
      "description": "Builder for StreamShape. Collects unfold seed, step term, and productivity witness.",
      "properties": {
        "productivityWitness": {
          "type": "string"
        },
        "stepTerm": {
          "$ref": "#/$defs/schema~1Term"
        },
        "unfoldSeed": {
          "$ref": "#/$defs/schema~1Term"
        }
      },
      "required": [
        "unfoldSeed",
        "stepTerm",
        "productivityWitness"
      ],
      "title": "StreamDeclaration",
      "type": "object"
    },
    "conformance/StreamShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring a ProductiveStream (targets stream:Unfold, the coinductive constructor).",
      "title": "StreamShape"
    },
    "conformance/ValidatedWrapper": {
      "description": "Generic validation-proof wrapper. Proves that the inner value was produced by the conformance checker, not fabricated by Prism code.",
      "properties": {
        "validatedInner": {
          "format": "iri",
          "type": "string"
        }
      },
      "required": [
        "validatedInner"
      ],
      "title": "ValidatedWrapper",
      "type": "object"
    },
    "conformance/ValidationResult": {
      "description": "The result of validating an extension against a shape: conforms (boolean), and violation details if non-conformant.",
      "properties": {
        "conforms": {
          "type": "boolean"
        },
        "validationShape": {
          "$ref": "#/$defs/conformance~1Shape"
        },
        "validationTarget": {
          "format": "iri",
          "type": "string"
        }
      },
      "required": [
        "validationShape",
        "validationTarget",
        "conforms"
      ],
      "title": "ValidationResult",
      "type": "object"
    },
    "conformance/ViolationKind": {
      "description": "The kind of shape violation: Missing, TypeMismatch, CardinalityViolation, ValueCheck, or LevelMismatch.",
      "enum": [
        "Missing",
        "TypeMismatch",
        "CardinalityViolation",
        "ValueCheck",
        "LevelMismatch"
      ],
      "title": "ViolationKind"
    },
    "conformance/WitnessDatum": {
      "description": "Opaque ring element witness. Cannot be constructed outside the foundation crate — only produced by reduction evaluation or the two-phase minting boundary.",
      "properties": {
        "witnessBytes": {
          "pattern": "^[0-9a-fA-F]*$",
          "type": "string"
        },
        "witnessLevel": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "witnessLevel",
        "witnessBytes"
      ],
      "title": "WitnessDatum",
      "type": "object"
    },
    "conformance/WitnessDerivation": {
      "description": "Opaque derivation trace that can only be extended by the rewrite engine. Records rewrite step count and root term content address.",
      "title": "WitnessDerivation",
      "type": "object"
    },
    "conformance/WitnessSiteBudget": {
      "description": "Opaque site budget that can only be decremented by PinningEffect and incremented by UnbindingEffect — never by direct mutation.",
      "title": "WitnessSiteBudget",
      "type": "object"
    },
    "conformance/WittLevelDeclaration": {
      "description": "Builder for WittLevelShape. Collects declared bit width, cycle size, and predecessor level.",
      "properties": {
        "declaredBitWidth": {
          "minimum": 1,
          "type": "integer"
        },
        "declaredCycleSize": {
          "minimum": 0,
          "type": "integer"
        },
        "predecessorLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "declaredBitWidth",
        "declaredCycleSize",
        "predecessorLevel"
      ],
      "title": "WittLevelDeclaration",
      "type": "object"
    },
    "conformance/WittLevelShape": {
      "allOf": [
        {
          "$ref": "#/$defs/conformance~1Shape"
        },
        {
          "type": "object"
        }
      ],
      "description": "Shape for declaring a new WittLevel beyond Q3.",
      "title": "WittLevelShape"
    },
    "convergence/AssociativeSubalgebra": {
      "description": "The subspace H ⊂ O selected when triple interaction converges.",
      "properties": {
        "associatorRef": {
          "$ref": "#/$defs/interaction~1AssociatorTriple"
        },
        "subalgebraRef": {
          "$ref": "#/$defs/convergence~1AssociativeSubalgebra"
        }
      },
      "required": [
        "subalgebraRef",
        "associatorRef"
      ],
      "title": "AssociativeSubalgebra",
      "type": "object"
    },
    "convergence/CommutativeSubspace": {
      "description": "The subspace U(1) ⊂ SU(2) selected when pairwise interaction converges.",
      "properties": {
        "commutatorRef": {
          "$ref": "#/$defs/observable~1Commutator"
        },
        "subspaceRef": {
          "$ref": "#/$defs/convergence~1CommutativeSubspace"
        }
      },
      "required": [
        "subspaceRef",
        "commutatorRef"
      ],
      "title": "CommutativeSubspace",
      "type": "object"
    },
    "convergence/ConvergenceLevel": {
      "description": "A level in the convergence tower. Four instances: R (dim 1), C (dim 2), H (dim 4), O (dim 8).",
      "properties": {
        "algebraDimension": {
          "minimum": 0,
          "type": "integer"
        },
        "bettiSignature": {
          "type": "string"
        },
        "characteristicIdentity": {
          "type": "string"
        },
        "fiberType": {
          "$ref": "#/$defs/convergence~1HopfFiber"
        },
        "levelName": {
          "type": "string"
        }
      },
      "required": [
        "algebraDimension",
        "bettiSignature",
        "fiberType",
        "characteristicIdentity",
        "levelName"
      ],
      "title": "ConvergenceLevel",
      "type": "object"
    },
    "convergence/ConvergenceResidual": {
      "description": "The unresolved structure at a convergence level. The β_{2^k−1} = 1 Betti number that persists.",
      "properties": {
        "residualBetti": {
          "minimum": 0,
          "type": "integer"
        },
        "residualDimension": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "residualBetti",
        "residualDimension"
      ],
      "title": "ConvergenceResidual",
      "type": "object"
    },
    "convergence/HopfFiber": {
      "description": "The fiber of the Hopf fibration at a convergence level. Four instances: S⁰, S¹, S³, S⁷.",
      "properties": {
        "baseSpace": {
          "type": "string"
        },
        "fiberDimension": {
          "minimum": 0,
          "type": "integer"
        },
        "fiberSphere": {
          "type": "string"
        },
        "totalSpace": {
          "type": "string"
        }
      },
      "required": [
        "fiberDimension",
        "totalSpace",
        "baseSpace",
        "fiberSphere"
      ],
      "title": "HopfFiber",
      "type": "object"
    },
    "derivation/Derivation": {
      "description": "A complete term rewriting witness: the full sequence of rewrite steps transforming an original term into its canonical form.",
      "properties": {
        "canonicalTerm": {
          "$ref": "#/$defs/schema~1Term"
        },
        "originalTerm": {
          "$ref": "#/$defs/schema~1Term"
        },
        "result": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "step": {
          "items": {
            "$ref": "#/$defs/derivation~1RewriteStep"
          },
          "type": "array"
        },
        "termMetrics": {
          "$ref": "#/$defs/derivation~1TermMetrics"
        }
      },
      "required": [
        "originalTerm",
        "canonicalTerm",
        "result",
        "termMetrics"
      ],
      "title": "Derivation",
      "type": "object"
    },
    "derivation/DerivationStep": {
      "description": "An abstract step in a derivation. Concrete subclasses are RewriteStep (term-level rewriting) and RefinementStep (type-level refinement).",
      "title": "DerivationStep",
      "type": "object"
    },
    "derivation/RefinementStep": {
      "allOf": [
        {
          "$ref": "#/$defs/derivation~1DerivationStep"
        },
        {
          "properties": {
            "appliedConstraint": {
              "$ref": "#/$defs/type~1Constraint"
            },
            "previousType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            },
            "refinedType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            },
            "sitesClosed": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "previousType",
            "appliedConstraint",
            "refinedType",
            "sitesClosed"
          ],
          "type": "object"
        }
      ],
      "description": "A type-level refinement step: the application of a constraint to narrow a type, pinning additional site coordinates. Complements RewriteStep (term-level) in the derivation hierarchy.",
      "title": "RefinementStep"
    },
    "derivation/RewriteRule": {
      "description": "A named rewrite rule that can be applied in a derivation step. Each RewriteRule individual represents a specific algebraic law or normalization strategy used during term rewriting.",
      "enum": [
        "CriticalIdentityRule",
        "InvolutionRule",
        "AssociativityRule",
        "CommutativityRule",
        "IdentityElementRule",
        "NormalizationRule"
      ],
      "title": "RewriteRule"
    },
    "derivation/RewriteStep": {
      "allOf": [
        {
          "$ref": "#/$defs/derivation~1DerivationStep"
        },
        {
          "properties": {
            "from": {
              "$ref": "#/$defs/schema~1Term"
            },
            "hasRewriteRule": {
              "$ref": "#/$defs/derivation~1RewriteRule"
            },
            "to": {
              "$ref": "#/$defs/schema~1Term"
            }
          },
          "required": [
            "from",
            "to",
            "hasRewriteRule"
          ],
          "type": "object"
        }
      ],
      "description": "A single rewrite step in a derivation: the application of one rewrite rule to transform a term.",
      "title": "RewriteStep"
    },
    "derivation/SynthesisCheckpoint": {
      "description": "A persistent snapshot of a ConstraintSearchState at a specific SynthesisStep, allowing a TypeSynthesisResolver to resume exploration after interruption. Essential at Q1+ scale where exhaustive synthesis is computationally significant.",
      "properties": {
        "checkpointState": {
          "$ref": "#/$defs/resolver~1ConstraintSearchState"
        },
        "checkpointStep": {
          "$ref": "#/$defs/derivation~1SynthesisStep"
        }
      },
      "required": [
        "checkpointStep",
        "checkpointState"
      ],
      "title": "SynthesisCheckpoint",
      "type": "object"
    },
    "derivation/SynthesisStep": {
      "description": "A single step in the construction of a SynthesizedType: one constraint added to the synthesis candidate and the resulting change in the constraint nerve's topological signature. Ordered by derivation:stepIndex. Analogous to derivation:RewriteStep in the forward pipeline.",
      "properties": {
        "addedConstraint": {
          "$ref": "#/$defs/type~1Constraint"
        },
        "signatureAfter": {
          "$ref": "#/$defs/observable~1SynthesisSignature"
        },
        "signatureBefore": {
          "$ref": "#/$defs/observable~1SynthesisSignature"
        },
        "stepIndex": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "stepIndex",
        "addedConstraint",
        "signatureBefore",
        "signatureAfter"
      ],
      "title": "SynthesisStep",
      "type": "object"
    },
    "derivation/TermMetrics": {
      "description": "Metrics describing the size and complexity of a term.",
      "properties": {
        "stepCount": {
          "minimum": 0,
          "type": "integer"
        },
        "termSize": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "stepCount",
        "termSize"
      ],
      "title": "TermMetrics",
      "type": "object"
    },
    "division/AlgebraAssociator": {
      "description": "The associator [a,b,c] = (ab)c − a(bc). Zero for R, C, H; non-zero for O.",
      "title": "AlgebraAssociator",
      "type": "object"
    },
    "division/AlgebraCommutator": {
      "description": "The commutator [a,b] = ab − ba. Zero for R and C; non-zero for H and O.",
      "title": "AlgebraCommutator",
      "type": "object"
    },
    "division/CayleyDicksonConstruction": {
      "description": "The doubling construction that builds each division algebra from the previous: R → C → H → O.",
      "properties": {
        "adjoinedElement": {
          "type": "string"
        },
        "cayleyDicksonSource": {
          "$ref": "#/$defs/division~1NormedDivisionAlgebra"
        },
        "cayleyDicksonTarget": {
          "$ref": "#/$defs/division~1NormedDivisionAlgebra"
        },
        "conjugationRule": {
          "type": "string"
        }
      },
      "required": [
        "cayleyDicksonSource",
        "cayleyDicksonTarget",
        "adjoinedElement",
        "conjugationRule"
      ],
      "title": "CayleyDicksonConstruction",
      "type": "object"
    },
    "division/MultiplicationTable": {
      "description": "The explicit product rules for a division algebra’s basis elements.",
      "title": "MultiplicationTable",
      "type": "object"
    },
    "division/NormedDivisionAlgebra": {
      "description": "An algebra over R that is a division ring with multiplicative norm. Exactly four exist (Hurwitz theorem): R, C, H, O.",
      "properties": {
        "algebraDimension": {
          "minimum": 0,
          "type": "integer"
        },
        "algebraMultiplicationTable": {
          "$ref": "#/$defs/division~1MultiplicationTable"
        },
        "basisElements": {
          "type": "string"
        },
        "isAssociative": {
          "type": "boolean"
        },
        "isCommutative": {
          "type": "boolean"
        }
      },
      "required": [
        "algebraDimension",
        "isCommutative",
        "isAssociative",
        "basisElements",
        "algebraMultiplicationTable"
      ],
      "title": "NormedDivisionAlgebra",
      "type": "object"
    },
    "effect/CompositeEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1Effect"
        },
        {
          "properties": {
            "compositeHead": {
              "$ref": "#/$defs/effect~1Effect"
            },
            "compositeTail": {
              "items": {
                "$ref": "#/$defs/effect~1Effect"
              },
              "type": "array"
            }
          },
          "required": [
            "compositeHead"
          ],
          "type": "object"
        }
      ],
      "description": "An ordered sequence of effects applied atomically. The composition E₁ ; E₂ applies E₁ then E₂.",
      "title": "CompositeEffect"
    },
    "effect/DisjointnessWitness": {
      "description": "A certificate that two EffectTargets have empty intersection, enabling commutative reordering.",
      "properties": {
        "disjointnessLeft": {
          "$ref": "#/$defs/effect~1EffectTarget"
        },
        "disjointnessRight": {
          "$ref": "#/$defs/effect~1EffectTarget"
        }
      },
      "required": [
        "disjointnessLeft",
        "disjointnessRight"
      ],
      "title": "DisjointnessWitness",
      "type": "object"
    },
    "effect/Effect": {
      "description": "A typed endomorphism on state:Context. Maps one site-budget configuration to another. The atomic unit of state mutation in the kernel.",
      "properties": {
        "compositeIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "effectTarget": {
          "$ref": "#/$defs/effect~1EffectTarget"
        },
        "freeRankDelta": {
          "type": "integer"
        },
        "isCommutativeWith": {
          "type": "boolean"
        },
        "postContext": {
          "$ref": "#/$defs/state~1Context"
        },
        "preContext": {
          "$ref": "#/$defs/state~1Context"
        }
      },
      "required": [
        "effectTarget",
        "preContext",
        "postContext",
        "freeRankDelta",
        "compositeIndex",
        "isCommutativeWith"
      ],
      "title": "Effect",
      "type": "object"
    },
    "effect/EffectTarget": {
      "description": "The set of site coordinates that an effect reads or writes. Determines commutation.",
      "properties": {
        "targetCardinality": {
          "minimum": 0,
          "type": "integer"
        },
        "targetSites": {
          "items": {
            "$ref": "#/$defs/partition~1SiteIndex"
          },
          "type": "array"
        }
      },
      "required": [
        "targetCardinality"
      ],
      "title": "EffectTarget",
      "type": "object"
    },
    "effect/ExternalEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1Effect"
        },
        {
          "properties": {
            "externalEffectShape": {
              "$ref": "#/$defs/conformance~1EffectShape"
            }
          },
          "required": [
            "externalEffectShape"
          ],
          "type": "object"
        }
      ],
      "description": "An opaque effect declared by a Prism implementation. The kernel treats it as a site-budget transformation satisfying the declared commutation contract. Must carry an effect:externalEffectShape linking to a conformance:EffectShape.",
      "title": "ExternalEffect"
    },
    "effect/PhaseEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1ReversibleEffect"
        },
        {
          "properties": {
            "phaseAngleDelta": {
              "type": "number"
            }
          },
          "required": [
            "phaseAngleDelta"
          ],
          "type": "object"
        }
      ],
      "description": "Rotates the reduction phase angle by Ω^k. Does not alter the site budget. The effect produced by reduction step transitions.",
      "title": "PhaseEffect"
    },
    "effect/PinningEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1ReversibleEffect"
        },
        {
          "type": "object"
        }
      ],
      "description": "Pins a single free site to a definite value. Decrements freeRank by exactly 1. The effect produced by constraint resolution.",
      "title": "PinningEffect"
    },
    "effect/ReversibleEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1Effect"
        },
        {
          "type": "object"
        }
      ],
      "description": "An effect that has a well-defined inverse. PinningEffect and PhaseEffect are reversible; ExternalEffect and CompositeEffect are not in general.",
      "title": "ReversibleEffect"
    },
    "effect/UnbindingEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1Effect"
        },
        {
          "type": "object"
        }
      ],
      "description": "Releases a pinned site back to free state. Increments freeRank by exactly 1. The effect produced by session boundary reset.",
      "title": "UnbindingEffect"
    },
    "failure/ComputationResult": {
      "description": "The outcome of a computation that may fail: either a Success carrying a datum, or a Failure carrying a typed reason. The coproduct of the success and failure cases.",
      "title": "ComputationResult",
      "type": "object"
    },
    "failure/ConstraintContradiction": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1FailureReason"
        },
        {
          "type": "object"
        }
      ],
      "description": "Two constraints in the type’s constraint set are jointly unsatisfiable.",
      "title": "ConstraintContradiction"
    },
    "failure/Failure": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1ComputationResult"
        },
        {
          "properties": {
            "failureDepth": {
              "minimum": 0,
              "type": "integer"
            },
            "failureReason": {
              "$ref": "#/$defs/failure~1FailureReason"
            },
            "failureStage": {
              "$ref": "#/$defs/reduction~1ReductionStep"
            },
            "failureState": {
              "$ref": "#/$defs/reduction~1ReductionState"
            },
            "recoveryStrategy": {
              "items": {
                "$ref": "#/$defs/failure~1Recovery"
              },
              "type": "array"
            }
          },
          "required": [
            "failureReason",
            "failureState",
            "failureStage",
            "failureDepth"
          ],
          "type": "object"
        }
      ],
      "description": "A computation that could not reach convergence. Carries a typed FailureReason and the reduction state at the point of failure.",
      "title": "Failure"
    },
    "failure/FailurePropagation": {
      "description": "The rule for how failures compose under monoidal and parallel products.",
      "properties": {
        "propagationRule": {
          "items": {
            "$ref": "#/$defs/failure~1FailureReason"
          },
          "type": "array"
        }
      },
      "title": "FailurePropagation",
      "type": "object"
    },
    "failure/FailureReason": {
      "description": "A typed classification of why a computation failed.",
      "title": "FailureReason",
      "type": "object"
    },
    "failure/GuardFailure": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1FailureReason"
        },
        {
          "type": "object"
        }
      ],
      "description": "A reduction step guard evaluated to false and no alternative transition exists.",
      "title": "GuardFailure"
    },
    "failure/LiftObstructionFailure": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1FailureReason"
        },
        {
          "type": "object"
        }
      ],
      "description": "A WittLift encountered a non-trivial obstruction that could not be resolved.",
      "title": "LiftObstructionFailure"
    },
    "failure/PartialComputation": {
      "description": "A computation that produces a ComputationResult rather than a guaranteed datum. The general case of all computations.",
      "properties": {
        "isTotal": {
          "type": "boolean"
        }
      },
      "required": [
        "isTotal"
      ],
      "title": "PartialComputation",
      "type": "object"
    },
    "failure/Recovery": {
      "description": "A strategy for converting a Failure into a Success by modifying the computation path.",
      "properties": {
        "recoveryEffect": {
          "$ref": "#/$defs/effect~1Effect"
        },
        "recoveryTarget": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        }
      },
      "required": [
        "recoveryEffect",
        "recoveryTarget"
      ],
      "title": "Recovery",
      "type": "object"
    },
    "failure/SiteExhaustion": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1FailureReason"
        },
        {
          "type": "object"
        }
      ],
      "description": "The linear budget was exhausted before resolution completed.",
      "title": "SiteExhaustion"
    },
    "failure/Success": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1ComputationResult"
        },
        {
          "properties": {
            "resultCertificate": {
              "$ref": "#/$defs/proof~1ComputationCertificate"
            },
            "resultDatum": {
              "$ref": "#/$defs/schema~1Datum"
            }
          },
          "required": [
            "resultDatum",
            "resultCertificate"
          ],
          "type": "object"
        }
      ],
      "description": "A computation that reached convergence and produced a valid datum. Carries the output datum and the computation certificate.",
      "title": "Success"
    },
    "failure/TotalComputation": {
      "allOf": [
        {
          "$ref": "#/$defs/failure~1PartialComputation"
        },
        {
          "type": "object"
        }
      ],
      "description": "A computation where the FailureReason type is empty — failure is structurally impossible.",
      "title": "TotalComputation"
    },
    "homology/BoundaryOperator": {
      "description": "The boundary operator ∂_k: C_k → C_{k-1}. Satisfies ∂² = 0.",
      "properties": {
        "satisfiesBoundarySquaredZero": {
          "type": "boolean"
        },
        "sourceGroup": {
          "$ref": "#/$defs/homology~1ChainGroup"
        },
        "targetGroup": {
          "$ref": "#/$defs/homology~1ChainGroup"
        }
      },
      "required": [
        "sourceGroup",
        "targetGroup",
        "satisfiesBoundarySquaredZero"
      ],
      "title": "BoundaryOperator",
      "type": "object"
    },
    "homology/ChainComplex": {
      "description": "A chain complex: a sequence of chain groups connected by boundary operators.",
      "properties": {
        "hasBoundary": {
          "items": {
            "$ref": "#/$defs/homology~1BoundaryOperator"
          },
          "type": "array"
        },
        "hasChainGroup": {
          "items": {
            "$ref": "#/$defs/homology~1ChainGroup"
          },
          "type": "array"
        }
      },
      "title": "ChainComplex",
      "type": "object"
    },
    "homology/ChainFunctor": {
      "description": "The chain functor C: maps a simplicial complex to a chain complex.",
      "title": "ChainFunctor",
      "type": "object"
    },
    "homology/ChainGroup": {
      "description": "A free abelian group generated by k-simplices (the k-th chain group C_k).",
      "properties": {
        "degree": {
          "type": "integer"
        },
        "generatedBy": {
          "items": {
            "$ref": "#/$defs/homology~1Simplex"
          },
          "type": "array"
        }
      },
      "required": [
        "degree"
      ],
      "title": "ChainGroup",
      "type": "object"
    },
    "homology/DeformationComplex": {
      "allOf": [
        {
          "$ref": "#/$defs/homology~1ChainComplex"
        },
        {
          "properties": {
            "deformationBase": {
              "$ref": "#/$defs/type~1CompleteType"
            },
            "obstructionDimension": {
              "minimum": 0,
              "type": "integer"
            },
            "tangentDimension": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "deformationBase",
            "tangentDimension",
            "obstructionDimension"
          ],
          "type": "object"
        }
      ],
      "description": "The deformation complex of a CompleteType T: a chain complex whose H⁰ = automorphisms, H¹ = first-order deformations, H² = obstructions to extending deformations.",
      "title": "DeformationComplex"
    },
    "homology/FaceMap": {
      "description": "A face map d_i: removes vertex i from a simplex, producing a face.",
      "properties": {
        "removesVertex": {
          "minimum": 0,
          "type": "integer"
        },
        "sourceSimplex": {
          "$ref": "#/$defs/homology~1Simplex"
        },
        "targetFace": {
          "$ref": "#/$defs/homology~1Simplex"
        }
      },
      "required": [
        "removesVertex",
        "sourceSimplex",
        "targetFace"
      ],
      "title": "FaceMap",
      "type": "object"
    },
    "homology/HomologyGroup": {
      "description": "The k-th homology group H_k = ker(∂_k) / im(∂_{k+1}). Measures k-dimensional holes.",
      "properties": {
        "bettiNumber": {
          "minimum": 0,
          "type": "integer"
        },
        "homologyDegree": {
          "type": "integer"
        }
      },
      "required": [
        "homologyDegree",
        "bettiNumber"
      ],
      "title": "HomologyGroup",
      "type": "object"
    },
    "homology/HornFiller": {
      "description": "A witness that a given horn (an incomplete simplex boundary) can be filled, certifying the Kan condition at a specific dimension and position.",
      "properties": {
        "hornDimension": {
          "minimum": 0,
          "type": "integer"
        },
        "hornPosition": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "hornDimension",
        "hornPosition"
      ],
      "title": "HornFiller",
      "type": "object"
    },
    "homology/KInvariant": {
      "description": "The k-invariant κk that classifies the extension from the (k−1)-truncation to the k-truncation of the Postnikov tower. Trivial κk means the truncation splits as a product.",
      "properties": {
        "kInvariantTrivial": {
          "type": "boolean"
        }
      },
      "required": [
        "kInvariantTrivial"
      ],
      "title": "KInvariant",
      "type": "object"
    },
    "homology/KanComplex": {
      "allOf": [
        {
          "$ref": "#/$defs/homology~1SimplicialComplex"
        },
        {
          "properties": {
            "kanWitness": {
              "items": {
                "$ref": "#/$defs/homology~1HornFiller"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "A simplicial set satisfying the Kan extension condition. The constraint nerve, when promoted from a SimplicialComplex to a KanComplex, carries a full homotopy type — not just its homology groups.",
      "title": "KanComplex"
    },
    "homology/NerveFunctor": {
      "description": "The nerve functor N: maps a set of constraints to a simplicial complex.",
      "title": "NerveFunctor",
      "type": "object"
    },
    "homology/PostnikovTruncation": {
      "description": "The k-th Postnikov truncation τ≤k of the constraint nerve: a KanComplex whose homotopy groups πj vanish for j > k.",
      "properties": {
        "kInvariant": {
          "$ref": "#/$defs/homology~1KInvariant"
        },
        "truncationLevel": {
          "minimum": 0,
          "type": "integer"
        },
        "truncationSource": {
          "$ref": "#/$defs/homology~1KanComplex"
        }
      },
      "required": [
        "truncationLevel",
        "truncationSource",
        "kInvariant"
      ],
      "title": "PostnikovTruncation",
      "type": "object"
    },
    "homology/Simplex": {
      "description": "A k-simplex: a finite set of k+1 vertices drawn from constraint objects.",
      "properties": {
        "dimension": {
          "type": "integer"
        },
        "isFaceOf": {
          "items": {
            "$ref": "#/$defs/homology~1Simplex"
          },
          "type": "array"
        },
        "pinIntersection": {
          "items": {
            "$ref": "#/$defs/partition~1SiteIndex"
          },
          "type": "array"
        },
        "vertex": {
          "items": {
            "$ref": "#/$defs/type~1Constraint"
          },
          "type": "array"
        },
        "vertexCount": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "dimension",
        "vertexCount"
      ],
      "title": "Simplex",
      "type": "object"
    },
    "homology/SimplicialComplex": {
      "description": "A simplicial complex: a set of simplices closed under taking faces.",
      "properties": {
        "eulerCharacteristic": {
          "type": "integer"
        },
        "hasSimplex": {
          "items": {
            "$ref": "#/$defs/homology~1Simplex"
          },
          "type": "array"
        },
        "maxDimension": {
          "type": "integer"
        },
        "simplicialVertexCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "maxDimension",
        "eulerCharacteristic",
        "simplicialVertexCount"
      ],
      "title": "SimplicialComplex",
      "type": "object"
    },
    "interaction/AssociatorState": {
      "description": "The norm of the three-way associator on shared sites.",
      "properties": {
        "associatorNorm": {
          "type": "number"
        }
      },
      "required": [
        "associatorNorm"
      ],
      "title": "AssociatorState",
      "type": "object"
    },
    "interaction/AssociatorTriple": {
      "description": "Three entities whose interaction exhibits non-associativity due to read-write interleaving.",
      "properties": {
        "associatorNormValue": {
          "type": "number"
        },
        "associatorProfileRef": {
          "$ref": "#/$defs/observable~1Observable"
        },
        "tripleComponentA": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "tripleComponentB": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "tripleComponentC": {
          "$ref": "#/$defs/schema~1Datum"
        }
      },
      "required": [
        "tripleComponentA",
        "tripleComponentB",
        "tripleComponentC",
        "associatorProfileRef",
        "associatorNormValue"
      ],
      "title": "AssociatorTriple",
      "type": "object"
    },
    "interaction/CommutatorState": {
      "description": "The norm ‖[δ_A, ι_B]‖ on shared sites. Zero iff operators commute on the shared domain.",
      "properties": {
        "commutatorValue": {
          "type": "number"
        }
      },
      "required": [
        "commutatorValue"
      ],
      "title": "CommutatorState",
      "type": "object"
    },
    "interaction/InteractionComposition": {
      "description": "IC(A,B) = κ(session(A,B)). Combined interaction-composition operator.",
      "properties": {
        "reificationDepth": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "reificationDepth"
      ],
      "title": "InteractionComposition",
      "type": "object"
    },
    "interaction/InteractionContext": {
      "description": "Two entities sharing sites through composed operations. Properties: entityA, entityB, sharedSiteMask, commutatorNorm.",
      "properties": {
        "commutatorNorm": {
          "type": "number"
        },
        "entityA": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "entityB": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "sharedSiteMask": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "entityA",
        "entityB",
        "sharedSiteMask",
        "commutatorNorm"
      ],
      "title": "InteractionContext",
      "type": "object"
    },
    "interaction/InteractionNerve": {
      "description": "Simplicial complex of N-entity coupling.",
      "properties": {
        "nerveBettiNumbers": {
          "minimum": 0,
          "type": "integer"
        },
        "nerveDimension": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "nerveDimension",
        "nerveBettiNumbers"
      ],
      "title": "InteractionNerve",
      "type": "object"
    },
    "interaction/MutualModelTrace": {
      "description": "Sequence of AssociatorStates across interaction steps.",
      "properties": {
        "modelConvergent": {
          "type": "boolean"
        }
      },
      "required": [
        "modelConvergent"
      ],
      "title": "MutualModelTrace",
      "type": "object"
    },
    "interaction/NegotiationTrace": {
      "description": "Sequence of CommutatorStates across interaction steps.",
      "properties": {
        "convergenceRate": {
          "type": "number"
        },
        "isConvergent": {
          "type": "boolean"
        },
        "negotiationSteps": {
          "minimum": 0,
          "type": "integer"
        },
        "terminalValue": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "traceLength": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "negotiationSteps",
        "isConvergent",
        "traceLength",
        "convergenceRate",
        "terminalValue"
      ],
      "title": "NegotiationTrace",
      "type": "object"
    },
    "interaction/ThreeWaySite": {
      "description": "A site shared by all three entities in an AssociatorTriple.",
      "properties": {
        "isPinned": {
          "type": "boolean"
        },
        "leftGroupingValue": {
          "type": "number"
        },
        "pinningPair": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "rightGroupingValue": {
          "type": "number"
        },
        "sitePosition": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "sitePosition",
        "leftGroupingValue",
        "rightGroupingValue",
        "isPinned",
        "pinningPair"
      ],
      "title": "ThreeWaySite",
      "type": "object"
    },
    "linear/AffineSite": {
      "allOf": [
        {
          "$ref": "#/$defs/partition~1SiteIndex"
        },
        {
          "type": "object"
        }
      ],
      "description": "A site that may be pinned at most once (but need not be pinned). Relaxation of LinearSite for incomplete resolution paths.",
      "title": "AffineSite"
    },
    "linear/LeaseAllocation": {
      "description": "A binding between a state:ContextLease and a subset of LinearSites. Formalizes what resources a lease claims.",
      "properties": {
        "leaseCardinality": {
          "minimum": 1,
          "type": "integer"
        },
        "leaseSource": {
          "$ref": "#/$defs/state~1ContextLease"
        },
        "leaseTarget": {
          "items": {
            "$ref": "#/$defs/linear~1LinearSite"
          },
          "type": "array"
        }
      },
      "required": [
        "leaseSource",
        "leaseCardinality"
      ],
      "title": "LeaseAllocation",
      "type": "object"
    },
    "linear/LinearBudget": {
      "description": "The multiset of LinearSites available at a given point in resolution. Starts as the full site budget; each LinearEffect removes exactly one element.",
      "properties": {
        "budgetContext": {
          "$ref": "#/$defs/state~1Context"
        },
        "budgetSites": {
          "items": {
            "$ref": "#/$defs/linear~1LinearSite"
          },
          "type": "array"
        },
        "remainingCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "budgetContext",
        "remainingCount"
      ],
      "title": "LinearBudget",
      "type": "object"
    },
    "linear/LinearEffect": {
      "allOf": [
        {
          "$ref": "#/$defs/effect~1PinningEffect"
        },
        {
          "properties": {
            "linearTarget": {
              "$ref": "#/$defs/linear~1LinearSite"
            }
          },
          "required": [
            "linearTarget"
          ],
          "type": "object"
        }
      ],
      "description": "A PinningEffect that consumes its target LinearSite. After application, the site is no longer available for pinning by any subsequent effect.",
      "title": "LinearEffect"
    },
    "linear/LinearSite": {
      "allOf": [
        {
          "$ref": "#/$defs/partition~1SiteIndex"
        },
        {
          "type": "object"
        }
      ],
      "description": "A site index annotated with a linearity constraint: must be pinned exactly once in any complete resolution path.",
      "title": "LinearSite"
    },
    "linear/LinearTrace": {
      "allOf": [
        {
          "$ref": "#/$defs/trace~1ComputationTrace"
        },
        {
          "type": "object"
        }
      ],
      "description": "A computation trace where every site in the budget is targeted by exactly one LinearEffect.",
      "title": "LinearTrace"
    },
    "monoidal/MonoidalAssociator": {
      "description": "The witness that (A⊗B)⊗C ≅ A⊗(B⊗C). The associativity isomorphism.",
      "properties": {
        "associatorLeft": {
          "$ref": "#/$defs/monoidal~1MonoidalProduct"
        },
        "associatorRight": {
          "$ref": "#/$defs/monoidal~1MonoidalProduct"
        },
        "associatorWitnessRef": {
          "$ref": "#/$defs/cert~1Certificate"
        }
      },
      "required": [
        "associatorLeft",
        "associatorRight",
        "associatorWitnessRef"
      ],
      "title": "MonoidalAssociator",
      "type": "object"
    },
    "monoidal/MonoidalProduct": {
      "description": "A ⊗ B: the sequential composition of two computations. Output of A feeds input of B.",
      "properties": {
        "composedResult": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "leftOperand": {
          "$ref": "#/$defs/morphism~1ComputationDatum"
        },
        "rightOperand": {
          "$ref": "#/$defs/morphism~1ComputationDatum"
        },
        "saturationValue": {
          "type": "number"
        }
      },
      "required": [
        "leftOperand",
        "rightOperand",
        "composedResult",
        "saturationValue"
      ],
      "title": "MonoidalProduct",
      "type": "object"
    },
    "monoidal/MonoidalUnit": {
      "description": "The identity computation I: passes input through unchanged. I ⊗ A ≅ A ≅ A ⊗ I.",
      "properties": {
        "unitWitnessRef": {
          "$ref": "#/$defs/cert~1Certificate"
        }
      },
      "required": [
        "unitWitnessRef"
      ],
      "title": "MonoidalUnit",
      "type": "object"
    },
    "morphism/Action": {
      "description": "The mechanism by which a group applies transforms systematically to a set. Each group element induces a transform of the set. The dihedral action on type space is an action by isometries — every element of D_{2^n} produces an isometric transform of 𝒯_n.",
      "properties": {
        "actingOn": {
          "format": "iri",
          "type": "string"
        },
        "actionIsometry": {
          "type": "boolean"
        },
        "group": {
          "$ref": "#/$defs/op~1Group"
        }
      },
      "required": [
        "group",
        "actingOn",
        "actionIsometry"
      ],
      "title": "Action",
      "type": "object"
    },
    "morphism/ApplicationMorphism": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "applicationInput": {
              "$ref": "#/$defs/schema~1Datum"
            },
            "applicationTarget": {
              "$ref": "#/$defs/morphism~1ComputationDatum"
            }
          },
          "required": [
            "applicationTarget",
            "applicationInput"
          ],
          "type": "object"
        }
      ],
      "description": "A transform that applies a ComputationDatum to an input datum, producing an output datum. The output inherits the certificate of the ComputationDatum.",
      "title": "ApplicationMorphism"
    },
    "morphism/Composition": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "compositionComponents": {
              "items": {
                "$ref": "#/$defs/morphism~1Transform"
              },
              "type": "array"
            },
            "compositionResult": {
              "$ref": "#/$defs/morphism~1Transform"
            }
          },
          "required": [
            "compositionResult"
          ],
          "type": "object"
        }
      ],
      "description": "A transform formed by composing two or more transforms sequentially. The categorical composition operation that turns transforms into a category.",
      "title": "Composition"
    },
    "morphism/CompositionLaw": {
      "description": "A law governing how operations compose. Records whether the composition is associative, commutative, and what the result operation is. The critical composition law (neg ∘ bnot = succ) is the foundational instance.",
      "properties": {
        "isAssociative": {
          "type": "boolean"
        },
        "isCommutative": {
          "type": "boolean"
        },
        "lawComponents": {
          "items": {
            "$ref": "#/$defs/op~1Operation"
          },
          "type": "array"
        },
        "lawResult": {
          "$ref": "#/$defs/op~1Operation"
        }
      },
      "required": [
        "isAssociative",
        "isCommutative",
        "lawResult"
      ],
      "title": "CompositionLaw",
      "type": "object"
    },
    "morphism/ComputationDatum": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1Datum"
        },
        {
          "properties": {
            "computationAddress": {
              "$ref": "#/$defs/u~1Element"
            },
            "referencedCertificate": {
              "$ref": "#/$defs/cert~1TransformCertificate"
            }
          },
          "required": [
            "referencedCertificate",
            "computationAddress"
          ],
          "type": "object"
        }
      ],
      "description": "A datum whose ring value is the content address of a cert:TransformCertificate. Represents a certified computation as a first-class value within the ring.",
      "title": "ComputationDatum"
    },
    "morphism/Embedding": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "addressCoherence": {
              "$ref": "#/$defs/op~1Identity"
            },
            "sourceQuantum": {
              "minimum": 1,
              "type": "integer"
            },
            "targetQuantum": {
              "minimum": 1,
              "type": "integer"
            }
          },
          "required": [
            "sourceQuantum",
            "targetQuantum",
            "addressCoherence"
          ],
          "type": "object"
        }
      ],
      "description": "An injective, structure-preserving transform across quantum levels. The canonical instance is the level embedding ι : R_n → R_{n'} (n < n'), which preserves addition, multiplication, and content addressing.",
      "title": "Embedding"
    },
    "morphism/GroundingCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "groundingCertAddress": {
              "$ref": "#/$defs/u~1Element"
            },
            "groundingCertMap": {
              "$ref": "#/$defs/morphism~1GroundingMap"
            },
            "groundingCertProjection": {
              "$ref": "#/$defs/morphism~1ProjectionMap"
            },
            "groundingCertSourceSymbol": {
              "$ref": "#/$defs/schema~1Literal"
            }
          },
          "required": [
            "groundingCertMap",
            "groundingCertProjection",
            "groundingCertSourceSymbol",
            "groundingCertAddress"
          ],
          "type": "object"
        }
      ],
      "description": "A certificate attesting that a specific grounding round-trip (P∘Π∘G) satisfied the shared-frame condition and landed in the type-equivalent neighbourhood of the source symbol. Witnesses the Surface Symmetry Theorem (op:surfaceSymmetry) for one specific symbol instance.",
      "title": "GroundingCertificate"
    },
    "morphism/GroundingMap": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "groundingDerivation": {
              "$ref": "#/$defs/derivation~1Derivation"
            },
            "symbolConstraints": {
              "items": {
                "$ref": "#/$defs/type~1Constraint"
              },
              "type": "array"
            }
          },
          "required": [
            "groundingDerivation"
          ],
          "type": "object"
        }
      ],
      "description": "A Transform mapping a surface symbol (any schema:Literal) to its ring datum (a schema:Datum) via the content-addressing bijection. Typed, derivation-witnessed, constraint-preserving map from surface to coordinate. Applies identically across NLP tokens, ARC-AGI grid cells, MIDI notes, pixels, sensor readings, and logical propositions.",
      "title": "GroundingMap"
    },
    "morphism/GroundingWitness": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Witness"
        },
        {
          "properties": {
            "groundedAddress": {
              "$ref": "#/$defs/u~1Element"
            },
            "surfaceSymbol": {
              "$ref": "#/$defs/schema~1SurfaceSymbol"
            }
          },
          "required": [
            "surfaceSymbol",
            "groundedAddress"
          ],
          "type": "object"
        }
      ],
      "description": "One specific surface symbol mapped to one specific grounded address by some GroundingMap.",
      "title": "GroundingWitness"
    },
    "morphism/Identity": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "identityOn": {
              "$ref": "#/$defs/type~1TypeDefinition"
            }
          },
          "required": [
            "identityOn"
          ],
          "type": "object"
        }
      ],
      "description": "The identity transform on a type: maps every element to itself. The categorical identity morphism.",
      "title": "Identity"
    },
    "morphism/Isometry": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "preservesMetric": {
              "items": {
                "$ref": "#/$defs/observable~1MetricObservable"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "A transform that preserves metric structure with respect to a specified metric. In UOR, isometry is metric-relative: neg is a ring isometry, bnot is a Hamming isometry. A transform can be an isometry with respect to one metric but not the other. This is what cert:IsometryCertificate certifies.",
      "title": "Isometry"
    },
    "morphism/PartialApplication": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1ComputationDatum"
        },
        {
          "properties": {
            "boundArguments": {
              "items": {
                "$ref": "#/$defs/schema~1Datum"
              },
              "type": "array"
            },
            "partialBase": {
              "$ref": "#/$defs/morphism~1ComputationDatum"
            },
            "remainingArity": {
              "minimum": 1,
              "type": "integer"
            }
          },
          "required": [
            "partialBase",
            "remainingArity"
          ],
          "type": "object"
        }
      ],
      "description": "A ComputationDatum formed by fixing some but not all inputs of a multi-argument transform.",
      "title": "PartialApplication"
    },
    "morphism/ProjectionMap": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "outputElementClass": {
              "format": "iri",
              "type": "string"
            },
            "projectionFrame": {
              "$ref": "#/$defs/state~1Frame"
            },
            "projectionOrder": {
              "$ref": "#/$defs/type~1CompositeConstraint"
            },
            "roundTripCoherence": {
              "type": "boolean"
            }
          },
          "required": [
            "projectionFrame",
            "projectionOrder",
            "roundTripCoherence",
            "outputElementClass"
          ],
          "type": "object"
        }
      ],
      "description": "A Transform mapping a resolved partition:Partition (address neighbourhood) to an ordered sequence of surface symbols. Output ordering determined by the active state:Frame — the same constraint frame that decomposed the input symbol sequence.",
      "title": "ProjectionMap"
    },
    "morphism/ProjectionWitness": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Witness"
        },
        {
          "properties": {
            "projectionOutput": {
              "$ref": "#/$defs/morphism~1SymbolSequence"
            },
            "projectionSource": {
              "$ref": "#/$defs/partition~1Partition"
            }
          },
          "required": [
            "projectionSource",
            "projectionOutput"
          ],
          "type": "object"
        }
      ],
      "description": "One specific input partition mapped to one specific surface symbol sequence by some ProjectionMap.",
      "title": "ProjectionWitness"
    },
    "morphism/SequenceElement": {
      "description": "One position in a SymbolSequence: a reified (value, index) pair.",
      "properties": {
        "elementIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "elementValue": {
          "$ref": "#/$defs/schema~1SurfaceSymbol"
        }
      },
      "required": [
        "elementValue",
        "elementIndex"
      ],
      "title": "SequenceElement",
      "type": "object"
    },
    "morphism/SymbolSequence": {
      "description": "An ordered sequence of surface symbols. Elements are reified as SequenceElement individuals with explicit position indices.",
      "properties": {
        "hasElement": {
          "items": {
            "$ref": "#/$defs/morphism~1SequenceElement"
          },
          "type": "array"
        }
      },
      "title": "SymbolSequence",
      "type": "object"
    },
    "morphism/TopologicalDelta": {
      "description": "A topological delta: records changes in topological invariants (Betti numbers, Euler characteristic, nerve structure) before and after a morphism.",
      "properties": {
        "bettisAfter": {
          "$ref": "#/$defs/observable~1BettiNumber"
        },
        "bettisBefore": {
          "$ref": "#/$defs/observable~1BettiNumber"
        },
        "eulerAfter": {
          "type": "integer"
        },
        "eulerBefore": {
          "type": "integer"
        },
        "nerveAfter": {
          "$ref": "#/$defs/homology~1SimplicialComplex"
        },
        "nerveBefore": {
          "$ref": "#/$defs/homology~1SimplicialComplex"
        }
      },
      "required": [
        "bettisBefore",
        "bettisAfter",
        "eulerBefore",
        "eulerAfter",
        "nerveBefore",
        "nerveAfter"
      ],
      "title": "TopologicalDelta",
      "type": "object"
    },
    "morphism/Transform": {
      "description": "A map between UOR objects. The root abstraction: source, target, and optionally what structure (if any) is preserved. This is what cert:TransformCertificate certifies.",
      "properties": {
        "composesWith": {
          "items": {
            "$ref": "#/$defs/morphism~1Transform"
          },
          "type": "array"
        },
        "hasWitness": {
          "items": {
            "$ref": "#/$defs/morphism~1Witness"
          },
          "type": "array"
        },
        "inputClass": {
          "format": "iri",
          "type": "string"
        },
        "outputClass": {
          "format": "iri",
          "type": "string"
        },
        "preservedInvariant": {
          "$ref": "#/$defs/op~1Identity"
        },
        "preserves": {
          "items": {
            "format": "iri",
            "type": "string"
          },
          "type": "array"
        },
        "source": {
          "format": "iri",
          "type": "string"
        },
        "target": {
          "format": "iri",
          "type": "string"
        },
        "trace": {
          "$ref": "#/$defs/trace~1ComputationTrace"
        }
      },
      "required": [
        "source",
        "target",
        "trace",
        "preservedInvariant",
        "inputClass",
        "outputClass"
      ],
      "title": "Transform",
      "type": "object"
    },
    "morphism/TransformComposition": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1ComputationDatum"
        },
        {
          "properties": {
            "compositionLeft": {
              "$ref": "#/$defs/morphism~1ComputationDatum"
            },
            "compositionRight": {
              "$ref": "#/$defs/morphism~1ComputationDatum"
            }
          },
          "required": [
            "compositionLeft",
            "compositionRight"
          ],
          "type": "object"
        }
      ],
      "description": "A ComputationDatum representing the composition f ∘ g of two ComputationDatums. Certified iff both components are certified and range(g) = domain(f).",
      "title": "TransformComposition"
    },
    "morphism/Witness": {
      "description": "Abstract supertype for one specific input/output pair witnessing a Transform.",
      "title": "Witness",
      "type": "object"
    },
    "observable/AchievabilityStatus": {
      "description": "The achievability classification of a topological signature in the morphospace. Either Achievable or Forbidden (witnessed by ImpossibilityWitness).",
      "enum": [
        "Achievable",
        "Forbidden"
      ],
      "title": "AchievabilityStatus"
    },
    "observable/BaseMetric": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "properties": {
            "metricBound": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "metricComposition": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "metricComputationCost": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "metricDecomposition": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "metricDomain": {
              "type": "string"
            },
            "metricMonotonicity": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "metricPrecision": {
              "minimum": 0,
              "type": "integer"
            },
            "metricRange": {
              "type": "string"
            },
            "metricTowerPosition": {
              "minimum": 0,
              "type": "integer"
            },
            "metricUnit": {
              "$ref": "#/$defs/observable~1MeasurementUnit"
            },
            "referencesClass": {
              "$ref": "#/$defs/observable~1Observable"
            },
            "referencesIdentity": {
              "$ref": "#/$defs/op~1Identity"
            }
          },
          "required": [
            "metricDomain",
            "metricRange",
            "metricComposition",
            "referencesClass",
            "referencesIdentity",
            "metricUnit",
            "metricPrecision",
            "metricMonotonicity",
            "metricDecomposition",
            "metricTowerPosition",
            "metricComputationCost",
            "metricBound"
          ],
          "type": "object"
        }
      ],
      "description": "Superclass for the six universal measurements. Every computation on the ring produces these six quantities: d_Δ, σ, J_k, β_k, χ, r.",
      "title": "BaseMetric"
    },
    "observable/BettiNumber": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1TopologicalObservable"
        },
        {
          "properties": {
            "groundedIn": {
              "$ref": "#/$defs/homology~1HomologyGroup"
            }
          },
          "required": [
            "groundedIn"
          ],
          "type": "object"
        }
      ],
      "description": "The rank of a homology group of the constraint nerve. β_k = rank(H_k(N(C))) counts the k-dimensional holes in the constraint configuration.",
      "title": "BettiNumber"
    },
    "observable/CatastropheCount": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1CatastropheObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The number of catastrophe events (qualitative partition changes) in a computation.",
      "title": "CatastropheCount"
    },
    "observable/CatastropheObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "properties": {
            "onResonanceLine": {
              "type": "boolean"
            },
            "phaseBoundaryType": {
              "$ref": "#/$defs/observable~1PhaseBoundaryType"
            },
            "phaseG": {
              "minimum": 1,
              "type": "integer"
            },
            "phaseN": {
              "minimum": 1,
              "type": "integer"
            }
          },
          "required": [
            "phaseN",
            "phaseG",
            "onResonanceLine",
            "phaseBoundaryType"
          ],
          "type": "object"
        }
      ],
      "description": "An observable measuring catastrophe-theoretic properties: thresholds at which qualitative changes occur in the partition.",
      "title": "CatastropheObservable"
    },
    "observable/CatastropheThreshold": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1CatastropheObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "A critical value at which a qualitative change occurs in the partition structure.",
      "title": "CatastropheThreshold"
    },
    "observable/ClosedConstraintPath": {
      "description": "A sequence of constraint applications forming a closed loop in the constraint nerve — beginning and ending at the same site assignment. The Monodromy of the loop is the net DihedralElement accumulated when traversing it.",
      "properties": {
        "pathConstraints": {
          "items": {
            "$ref": "#/$defs/type~1Constraint"
          },
          "type": "array"
        },
        "pathLength": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "pathLength"
      ],
      "title": "ClosedConstraintPath",
      "type": "object"
    },
    "observable/Commutator": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1CurvatureObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The commutator [f, g](x) = f(g(x)) - g(f(x)) of two operations, measuring their non-commutativity.",
      "title": "Commutator"
    },
    "observable/CurvatureFlux": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1CurvatureObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The integrated curvature over a region of type space: the total metric incompatibility accumulated.",
      "title": "CurvatureFlux"
    },
    "observable/CurvatureObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "type": "object"
        }
      ],
      "description": "An observable measuring the curvature of the UOR geometry: the gap between ring-isometry and Hamming-isometry for a given transform.",
      "title": "CurvatureObservable"
    },
    "observable/DihedralElement": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1HolonomyObservable"
        },
        {
          "properties": {
            "dihedralElementValue": {
              "items": {
                "$ref": "#/$defs/op~1Operation"
              },
              "type": "array"
            },
            "elementOrder": {
              "minimum": 1,
              "type": "integer"
            },
            "isIdentityElement": {
              "type": "boolean"
            },
            "reflectionBit": {
              "type": "boolean"
            },
            "rotationExponent": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "isIdentityElement",
            "elementOrder",
            "rotationExponent",
            "reflectionBit"
          ],
          "type": "object"
        }
      ],
      "description": "An element of the dihedral group D_{2^n} acting on the type space. Each dihedral element induces an isometry of 𝒯_n.",
      "title": "DihedralElement"
    },
    "observable/EulerCharacteristicObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "properties": {
            "alternatingSum": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "alternatingSum"
          ],
          "type": "object"
        }
      ],
      "description": "The Euler characteristic χ = Σ(−1)^k β_k of the constraint nerve. An integer-valued topological invariant.",
      "title": "EulerCharacteristicObservable"
    },
    "observable/GroundingObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "properties": {
            "saturationDenominator": {
              "minimum": 1,
              "type": "integer"
            },
            "saturationNumerator": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "saturationNumerator",
            "saturationDenominator"
          ],
          "type": "object"
        }
      ],
      "description": "The grounding metric σ = pinned sites / total sites. Ranges from 0 (no sites pinned) to 1 (fully grounded).",
      "title": "GroundingObservable"
    },
    "observable/HammingMetric": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1MetricObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "Distance between two ring elements under the Hamming metric: the number of bit positions where they differ.",
      "title": "HammingMetric"
    },
    "observable/HigherMonodromy": {
      "description": "The image of πk(N(C)) → Aut(sitek) for k > 1. Generalises the MN_6 monodromy homomorphism.",
      "properties": {
        "higherMonodromyDimension": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "higherMonodromyDimension"
      ],
      "title": "HigherMonodromy",
      "type": "object"
    },
    "observable/HolonomyGroup": {
      "description": "The holonomy group of a ConstrainedType: the group of all Monodromy elements achievable by closed paths in the constraint nerve. Always a subgroup of D_{2^n}. Trivial iff the type has trivial monodromy everywhere; equals D_{2^n} iff paths involving both neg and bnot involutions are present.",
      "properties": {
        "holonomyGroup": {
          "items": {
            "$ref": "#/$defs/observable~1DihedralElement"
          },
          "type": "array"
        },
        "holonomyGroupOrder": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "holonomyGroupOrder"
      ],
      "title": "HolonomyGroup",
      "type": "object"
    },
    "observable/HolonomyObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "type": "object"
        }
      ],
      "description": "An observable measuring holonomy: the accumulated transformation when traversing a closed path in the ring.",
      "title": "HolonomyObservable"
    },
    "observable/HomotopyGroup": {
      "description": "The k-th homotopy group πk(N(C), v) of the constraint nerve based at vertex v.",
      "properties": {
        "homotopyBasepoint": {
          "$ref": "#/$defs/type~1Constraint"
        },
        "homotopyDimension": {
          "minimum": 0,
          "type": "integer"
        },
        "homotopyRank": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "homotopyDimension",
        "homotopyRank",
        "homotopyBasepoint"
      ],
      "title": "HomotopyGroup",
      "type": "object"
    },
    "observable/IncompatibilityMetric": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1MetricObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The metric incompatibility between two ring elements: the divergence between their ring-metric and Hamming-metric distances, measuring geometric curvature.",
      "title": "IncompatibilityMetric"
    },
    "observable/Jacobian": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1CurvatureObservable"
        },
        {
          "properties": {
            "derivativeValue": {
              "type": "number"
            },
            "sitePosition": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "sitePosition",
            "derivativeValue"
          ],
          "type": "object"
        }
      ],
      "description": "Site-by-site curvature decomposition. J_k measures the discrete derivative of the incompatibility metric at site position k: J_k = |d_R(x, succ(x)) - d_H(x, succ(x))| restricted to position k.",
      "title": "Jacobian"
    },
    "observable/LandauerCost": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1ThermoObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The minimum thermodynamic cost (in units of k_B T ln 2) of erasing one bit of site uncertainty. The UOR ring operates at β* = ln 2 — the Landauer temperature.",
      "title": "LandauerCost"
    },
    "observable/LiftObstructionClass": {
      "description": "The cohomology class in H^2(N(C(T))) representing the LiftObstruction for a specific WittLift. The class is zero iff the obstruction is trivial. When non-zero, it indexes the specific site pair at Q_{n+1} that cannot be closed by the lifted constraint set alone.",
      "properties": {
        "obstructionClass": {
          "$ref": "#/$defs/cohomology~1CohomologyGroup"
        }
      },
      "required": [
        "obstructionClass"
      ],
      "title": "LiftObstructionClass",
      "type": "object"
    },
    "observable/MeasurementUnit": {
      "description": "A unit of measurement for observable quantities. Each MeasurementUnit individual names a specific unit (bits, ring steps, dimensionless) replacing the string-valued observable:unit property.",
      "enum": [
        "Bits",
        "RingSteps",
        "Dimensionless",
        "Nats"
      ],
      "title": "MeasurementUnit"
    },
    "observable/MetricObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "type": "object"
        }
      ],
      "description": "An observable measuring geometric distance between ring elements under a specific metric.",
      "title": "MetricObservable"
    },
    "observable/Monodromy": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1HolonomyObservable"
        },
        {
          "properties": {
            "isTrivialMonodromy": {
              "type": "boolean"
            },
            "monodromyElement": {
              "$ref": "#/$defs/observable~1DihedralElement"
            },
            "monodromyLoop": {
              "$ref": "#/$defs/observable~1ClosedConstraintPath"
            }
          },
          "required": [
            "monodromyLoop",
            "monodromyElement",
            "isTrivialMonodromy"
          ],
          "type": "object"
        }
      ],
      "description": "The monodromy of a closed path: the net transformation accumulated when traversing a loop in the type space.",
      "title": "Monodromy"
    },
    "observable/MonodromyClass": {
      "description": "A classification of a type's holonomy: the subgroup of D_{2^n} generated by all Monodromy observables computed over closed paths in the type's constraint nerve. Trivial iff every closed constraint path returns to its starting site assignment without net dihedral transformation.",
      "title": "MonodromyClass",
      "type": "object"
    },
    "observable/Observable": {
      "description": "A measurable quantity in the UOR Framework. All observables are kernel-computed and user-consumed.",
      "properties": {
        "hasUnit": {
          "$ref": "#/$defs/observable~1MeasurementUnit"
        },
        "source": {
          "format": "iri",
          "type": "string"
        },
        "target": {
          "format": "iri",
          "type": "string"
        },
        "value": {
          "type": "number"
        }
      },
      "required": [
        "value",
        "source",
        "target",
        "hasUnit"
      ],
      "title": "Observable",
      "type": "object"
    },
    "observable/ParallelTransport": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1HolonomyObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The parallel transport of a vector along a path: the canonical lift of the path to the tangent bundle of the ring.",
      "title": "ParallelTransport"
    },
    "observable/PathLength": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1PathObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The length of a path through the ring, measured in operation steps.",
      "title": "PathLength"
    },
    "observable/PathObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "type": "object"
        }
      ],
      "description": "An observable measuring properties of paths through the ring: path length, total variation, winding number.",
      "title": "PathObservable"
    },
    "observable/PhaseBoundaryType": {
      "description": "A classification of phase boundary in the catastrophe diagram: period boundary (g divides 2^n − 1) or power-of-two boundary (g = 2^k).",
      "enum": [
        "PeriodBoundary",
        "PowerOfTwoBoundary"
      ],
      "title": "PhaseBoundaryType"
    },
    "observable/ReductionCount": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1ReductionObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The number of distinct reduction sequences in a computation.",
      "title": "ReductionCount"
    },
    "observable/ReductionEntropy": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1ThermoObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The Shannon entropy of the reduction distribution P(j) = 2^{−j}. At the Landauer temperature, this equals ln 2 per reduction step — each step erases exactly one bit of site uncertainty.",
      "title": "ReductionEntropy"
    },
    "observable/ReductionLength": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1ReductionObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The number of operation applications in a reduction sequence.",
      "title": "ReductionLength"
    },
    "observable/ReductionObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "type": "object"
        }
      ],
      "description": "An observable measuring reduction properties: the length and count of operation sequences.",
      "title": "ReductionObservable"
    },
    "observable/ResidualEntropy": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1ThermoObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "S_residual: the residual Shannon entropy of the site distribution after partial resolution. Computed as S = (Σ κ_k − χ(N(C))) × ln 2 (IT_7b). Unit: Nats.",
      "title": "ResidualEntropy"
    },
    "observable/RingMetric": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1MetricObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "Distance between two ring elements under the ring metric: d_R(x, y) = |x - y| mod 2^n.",
      "title": "RingMetric"
    },
    "observable/SpectralGap": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1TopologicalObservable"
        },
        {
          "properties": {
            "laplacianOf": {
              "$ref": "#/$defs/homology~1ChainComplex"
            }
          },
          "required": [
            "laplacianOf"
          ],
          "type": "object"
        }
      ],
      "description": "The smallest positive eigenvalue of the constraint nerve Laplacian. Controls the convergence rate of iterative resolution: larger gap = faster convergence.",
      "title": "SpectralGap"
    },
    "observable/SpectralSequencePage": {
      "description": "A single page E_r of the quantum level spectral sequence. Carries the page index r and the differential d_r. The sequence converges when all differentials vanish — typically by E_3 for simple constraint configurations.",
      "properties": {
        "convergedAt": {
          "minimum": 0,
          "type": "integer"
        },
        "differentialIsZero": {
          "type": "boolean"
        },
        "pageIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "postnikovTruncation": {
          "$ref": "#/$defs/homology~1PostnikovTruncation"
        }
      },
      "required": [
        "pageIndex",
        "differentialIsZero",
        "convergedAt",
        "postnikovTruncation"
      ],
      "title": "SpectralSequencePage",
      "type": "object"
    },
    "observable/StratificationRecord": {
      "description": "A record of the holonomy stratification of the moduli space at a given quantum level: the list of HolonomyStrata, their codimensions, and their relationship to the MorphospaceBoundary.",
      "properties": {
        "stratificationLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        },
        "stratificationStratum": {
          "items": {
            "$ref": "#/$defs/type~1HolonomyStratum"
          },
          "type": "array"
        }
      },
      "required": [
        "stratificationLevel"
      ],
      "title": "StratificationRecord",
      "type": "object"
    },
    "observable/StratumDelta": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1StratumObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The difference in stratum between two ring elements.",
      "title": "StratumDelta"
    },
    "observable/StratumObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "type": "object"
        }
      ],
      "description": "An observable measuring stratum-level properties: position within the ring's layer structure.",
      "title": "StratumObservable"
    },
    "observable/StratumTrajectory": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1StratumObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The sequence of strata traversed by a path through the ring.",
      "title": "StratumTrajectory"
    },
    "observable/StratumValue": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1StratumObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The stratum index of a ring element.",
      "title": "StratumValue"
    },
    "observable/SynthesisSignature": {
      "description": "A named topological signature: a pair (realised Euler characteristic, realised Betti profile). Linked from TypeSynthesisResult. Allows comparison between the goal signature and the actually achieved signature.",
      "properties": {
        "achievabilityStatus": {
          "$ref": "#/$defs/observable~1AchievabilityStatus"
        },
        "achievabilityWitness": {
          "$ref": "#/$defs/proof~1Proof"
        },
        "isAchievable": {
          "type": "boolean"
        },
        "isForbidden": {
          "type": "boolean"
        },
        "realisedBetti": {
          "items": {
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        },
        "realisedEuler": {
          "type": "integer"
        }
      },
      "required": [
        "realisedEuler",
        "achievabilityStatus",
        "isAchievable",
        "isForbidden",
        "achievabilityWitness"
      ],
      "title": "SynthesisSignature",
      "type": "object"
    },
    "observable/ThermoObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "properties": {
            "hardnessEstimate": {
              "type": "number"
            }
          },
          "required": [
            "hardnessEstimate"
          ],
          "type": "object"
        }
      ],
      "description": "An observable measuring thermodynamic properties of the resolution process: residual entropy, Landauer cost, and reduction distribution statistics.",
      "title": "ThermoObservable"
    },
    "observable/TopologicalObservable": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1Observable"
        },
        {
          "properties": {
            "dimension": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "dimension"
          ],
          "type": "object"
        }
      ],
      "description": "An observable measuring a topological invariant of the resolution space. Topological observables are invariant under continuous deformations of the constraint configuration.",
      "title": "TopologicalObservable"
    },
    "observable/TotalVariation": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1PathObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The total variation of a path: the sum of metric distances between consecutive elements.",
      "title": "TotalVariation"
    },
    "observable/WhiteheadProduct": {
      "description": "The Whitehead product [α, β] ∈ πp+q−1 for α ∈ πp, β ∈ πq.",
      "properties": {
        "whiteheadTrivial": {
          "type": "boolean"
        }
      },
      "required": [
        "whiteheadTrivial"
      ],
      "title": "WhiteheadProduct",
      "type": "object"
    },
    "observable/WindingNumber": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1PathObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "The winding number of a closed path: the number of times the path wraps around the ring.",
      "title": "WindingNumber"
    },
    "op/AccumulationOperation": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1ComposedOperation"
        },
        {
          "properties": {
            "accumulationBase": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "accumulationBinding": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "accumulationBase",
            "accumulationBinding"
          ],
          "type": "object"
        }
      ],
      "description": "α: Binding × Context → Context. Non-commutative, associative at convergence (SR_10), arity 2.",
      "title": "AccumulationOperation"
    },
    "op/BinaryOp": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1Operation"
        },
        {
          "properties": {
            "associative": {
              "type": "boolean"
            },
            "commutative": {
              "type": "boolean"
            },
            "identity": {
              "type": "integer"
            }
          },
          "required": [
            "commutative",
            "associative",
            "identity"
          ],
          "type": "object"
        }
      ],
      "description": "A binary operation on the ring: takes two datums and produces one datum.",
      "title": "BinaryOp"
    },
    "op/ComposedOperation": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1Operation"
        },
        {
          "$ref": "#/$defs/morphism~1Composition"
        },
        {
          "properties": {
            "composedOfOps": {
              "items": {
                "$ref": "#/$defs/op~1Operation"
              },
              "type": "array"
            },
            "composedOperatorCount": {
              "minimum": 0,
              "type": "integer"
            },
            "convergenceGuarantee": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "isInvolutory": {
              "type": "boolean"
            },
            "operatorComplexity": {
              "type": "string"
            },
            "operatorDomainType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            },
            "operatorIdempotent": {
              "type": "boolean"
            },
            "operatorRangeType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            }
          },
          "required": [
            "operatorDomainType",
            "operatorRangeType",
            "operatorComplexity",
            "operatorIdempotent",
            "composedOperatorCount",
            "isInvolutory",
            "convergenceGuarantee"
          ],
          "type": "object"
        }
      ],
      "description": "An operation formed by composing ring operations, witnessed by op:composedOf and morphism/CompositionLaw.",
      "title": "ComposedOperation"
    },
    "op/DihedralGroup": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1Group"
        },
        {
          "type": "object"
        }
      ],
      "description": "The dihedral group D_{2^n} of order 2^(n+1), generated by the ring reflection (neg) and the hypercube reflection (bnot). This group governs the symmetry of the UOR type space.",
      "title": "DihedralGroup"
    },
    "op/DispatchOperation": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1ComposedOperation"
        },
        {
          "properties": {
            "dispatchSource": {
              "$ref": "#/$defs/op~1Operation"
            },
            "dispatchTarget": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "dispatchSource",
            "dispatchTarget"
          ],
          "type": "object"
        }
      ],
      "description": "δ: Query × ResolverRegistry → Resolver. Non-commutative, non-associative, arity 2.",
      "title": "DispatchOperation"
    },
    "op/GeometricCharacter": {
      "description": "The geometric role of a ring operation in the UOR dual-geometry (ring + hypercube). Every op:Operation individual references exactly one GeometricCharacter via op:hasGeometricCharacter. The nine canonical individuals correspond to the action types of the dihedral group D_{2^n}.",
      "enum": [
        "RingReflection",
        "HypercubeReflection",
        "Rotation",
        "RotationInverse",
        "Translation",
        "Scaling",
        "HypercubeTranslation",
        "HypercubeProjection",
        "HypercubeJoin",
        "ConstraintSelection",
        "ResolutionTraversal",
        "SiteBinding",
        "SitePartition",
        "SessionMerge"
      ],
      "title": "GeometricCharacter"
    },
    "op/Group": {
      "description": "A group: a set with an associative binary operation, an identity element, and inverses for every element.",
      "properties": {
        "generatedBy": {
          "items": {
            "$ref": "#/$defs/op~1Operation"
          },
          "type": "array"
        },
        "order": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "order"
      ],
      "title": "Group",
      "type": "object"
    },
    "op/GroupPresentation": {
      "description": "A structured group presentation: generators and relations as typed data rather than prose strings.",
      "title": "GroupPresentation",
      "type": "object"
    },
    "op/Identity": {
      "description": "An algebraic identity: a statement that two expressions are equal for all inputs. The critical identity is neg(bnot(x)) = succ(x) for all x in R_n.",
      "properties": {
        "forAll": {
          "$ref": "#/$defs/schema~1ForAllDeclaration"
        },
        "lhs": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "rhs": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "universallyValid": {
          "type": "boolean"
        },
        "validKMax": {
          "minimum": 0,
          "type": "integer"
        },
        "validKMin": {
          "minimum": 0,
          "type": "integer"
        },
        "validityKind": {
          "$ref": "#/$defs/op~1ValidityScopeKind"
        },
        "verificationDomain": {
          "items": {
            "$ref": "#/$defs/op~1VerificationDomain"
          },
          "type": "array"
        },
        "verifiedAtLevel": {
          "items": {
            "$ref": "#/$defs/op~1WittLevelBinding"
          },
          "type": "array"
        }
      },
      "required": [
        "lhs",
        "rhs",
        "forAll",
        "universallyValid",
        "validityKind",
        "validKMin",
        "validKMax"
      ],
      "title": "Identity",
      "type": "object"
    },
    "op/InferenceOperation": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1ComposedOperation"
        },
        {
          "properties": {
            "inferencePipeline": {
              "$ref": "#/$defs/op~1Operation"
            },
            "inferenceSource": {
              "$ref": "#/$defs/op~1Operation"
            },
            "inferenceTarget": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "inferenceSource",
            "inferenceTarget",
            "inferencePipeline"
          ],
          "type": "object"
        }
      ],
      "description": "ι = P ∘ Π ∘ G (the φ-pipeline composed). Non-commutative, non-associative, arity 2.",
      "title": "InferenceOperation"
    },
    "op/Involution": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1UnaryOp"
        },
        {
          "type": "object"
        }
      ],
      "description": "A unary operation f such that f(f(x)) = x for all x in R_n. The two UOR involutions are neg (ring reflection) and bnot (hypercube reflection).",
      "title": "Involution"
    },
    "op/LeasePartitionOperation": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1ComposedOperation"
        },
        {
          "properties": {
            "leaseFactor": {
              "$ref": "#/$defs/op~1Operation"
            },
            "leasePartitionCount": {
              "minimum": 0,
              "type": "integer"
            },
            "leaseSource": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "leaseSource",
            "leaseFactor",
            "leasePartitionCount"
          ],
          "type": "object"
        }
      ],
      "description": "λ: SharedContext × ℕ → ContextLease^k. Non-commutative, non-associative, arity 2.",
      "title": "LeasePartitionOperation"
    },
    "op/Operation": {
      "description": "An operation on the ring Z/(2^n)Z. The root class for all UOR kernel operations.",
      "properties": {
        "affectsAxis": {
          "items": {
            "$ref": "#/$defs/type~1MetricAxis"
          },
          "type": "array"
        },
        "arity": {
          "minimum": 0,
          "type": "integer"
        },
        "composedOf": {
          "items": {
            "format": "iri",
            "type": "string"
          },
          "type": "array"
        },
        "hasGeometricCharacter": {
          "$ref": "#/$defs/op~1GeometricCharacter"
        },
        "inverse": {
          "$ref": "#/$defs/op~1Operation"
        }
      },
      "required": [
        "arity",
        "hasGeometricCharacter",
        "inverse",
        "composedOf"
      ],
      "title": "Operation",
      "type": "object"
    },
    "op/QuantumThermodynamicDomain": {
      "description": "A verification domain at the intersection of quantum superposition and classical thermodynamics. Identities in this domain require both SuperpositionDomain and Thermodynamic reasoning simultaneously.",
      "title": "QuantumThermodynamicDomain",
      "type": "object"
    },
    "op/SessionCompositionOperation": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1ComposedOperation"
        },
        {
          "properties": {
            "compositionLeftSession": {
              "$ref": "#/$defs/op~1Operation"
            },
            "compositionRightSession": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "compositionLeftSession",
            "compositionRightSession"
          ],
          "type": "object"
        }
      ],
      "description": "κ: Session × Session → Session. Commutative (disjoint leases), associative (SR_8), arity 2.",
      "title": "SessionCompositionOperation"
    },
    "op/UnaryOp": {
      "allOf": [
        {
          "$ref": "#/$defs/op~1Operation"
        },
        {
          "type": "object"
        }
      ],
      "description": "A unary operation on the ring: takes one datum and produces one datum.",
      "title": "UnaryOp"
    },
    "op/ValidityScopeKind": {
      "description": "Root class for validity scope individuals. Instances are the four named scope kinds: Universal, ParametricLower, ParametricRange, and LevelSpecific.",
      "enum": [
        "Universal",
        "ParametricLower",
        "ParametricRange",
        "LevelSpecific"
      ],
      "title": "ValidityScopeKind"
    },
    "op/VerificationDomain": {
      "description": "A named mathematical discipline through which an algebraic identity is established and grounded. Every op:Identity individual references at least one VerificationDomain via op:verificationDomain. The nine canonical domain individuals are kernel-level constants defined in op/.",
      "enum": [
        "Enumerative",
        "Algebraic",
        "Geometric",
        "Analytical",
        "Thermodynamic",
        "Topological",
        "Pipeline",
        "IndexTheoretic",
        "SuperpositionDomain",
        "QuantumThermodynamic",
        "ArithmeticValuation",
        "ComposedAlgebraic"
      ],
      "title": "VerificationDomain"
    },
    "op/WittLevelBinding": {
      "description": "A record linking an op:Identity individual to a specific quantum level at which it has been verified. Non-functional: one WittLevelBinding per (Identity, WittLevel) pair verified.",
      "properties": {
        "bindingLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "bindingLevel"
      ],
      "title": "WittLevelBinding",
      "type": "object"
    },
    "operad/OperadComposition": {
      "description": "A specific nesting: outer type F applied to inner type G.",
      "properties": {
        "composedGrounding": {
          "$ref": "#/$defs/morphism~1GroundingMap"
        },
        "composedSiteCount": {
          "minimum": 0,
          "type": "integer"
        },
        "composedType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        "innerType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        "outerType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        }
      },
      "required": [
        "outerType",
        "innerType",
        "composedType",
        "composedSiteCount",
        "composedGrounding"
      ],
      "title": "OperadComposition",
      "type": "object"
    },
    "operad/StructuralOperad": {
      "description": "The composition structure on the eight structural types. Governs how types nest.",
      "properties": {
        "operadStructure": {
          "$ref": "#/$defs/operad~1StructuralOperad"
        },
        "positionVariance": {
          "$ref": "#/$defs/type~1VarianceAnnotation"
        }
      },
      "required": [
        "positionVariance",
        "operadStructure"
      ],
      "title": "StructuralOperad",
      "type": "object"
    },
    "parallel/DisjointnessCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/cert~1Certificate"
        },
        {
          "properties": {
            "certLeftTarget": {
              "$ref": "#/$defs/effect~1EffectTarget"
            },
            "certRightTarget": {
              "$ref": "#/$defs/effect~1EffectTarget"
            }
          },
          "required": [
            "certLeftTarget",
            "certRightTarget"
          ],
          "type": "object"
        }
      ],
      "description": "A kernel-produced certificate attesting that the site targets of two computations are disjoint.",
      "title": "DisjointnessCertificate"
    },
    "parallel/ParallelProduct": {
      "description": "A ∥ B: two computations with provably disjoint site targets. Execution order does not affect the result.",
      "properties": {
        "disjointnessCert": {
          "$ref": "#/$defs/parallel~1DisjointnessCertificate"
        },
        "disjointnessCommutation": {
          "type": "boolean"
        },
        "isFullyDisjoint": {
          "type": "boolean"
        },
        "leftComputation": {
          "$ref": "#/$defs/monoidal~1MonoidalProduct"
        },
        "rightComputation": {
          "$ref": "#/$defs/monoidal~1MonoidalProduct"
        }
      },
      "required": [
        "leftComputation",
        "rightComputation",
        "disjointnessCert",
        "isFullyDisjoint",
        "disjointnessCommutation"
      ],
      "title": "ParallelProduct",
      "type": "object"
    },
    "parallel/ParallelTrace": {
      "allOf": [
        {
          "$ref": "#/$defs/trace~1ComputationTrace"
        },
        {
          "type": "object"
        }
      ],
      "description": "A computation trace recording interleaved steps from two parallel computations. Valid iff every interleaving produces the same final context.",
      "title": "ParallelTrace"
    },
    "parallel/SitePartitioning": {
      "description": "A partition of the total site budget into disjoint subsets, one per parallel component. The sum of subset cardinalities equals the total site budget.",
      "properties": {
        "componentCount": {
          "minimum": 1,
          "type": "integer"
        },
        "partitionComponents": {
          "items": {
            "$ref": "#/$defs/effect~1EffectTarget"
          },
          "type": "array"
        }
      },
      "required": [
        "componentCount"
      ],
      "title": "SitePartitioning",
      "type": "object"
    },
    "parallel/SynchronizationPoint": {
      "description": "A point where two parallel computations must agree on shared state before proceeding. Only applicable when parallelism is partial.",
      "properties": {
        "syncSites": {
          "items": {
            "$ref": "#/$defs/partition~1SiteIndex"
          },
          "type": "array"
        }
      },
      "title": "SynchronizationPoint",
      "type": "object"
    },
    "partition/Complement": {
      "allOf": [
        {
          "$ref": "#/$defs/partition~1Component"
        },
        {
          "properties": {
            "exteriorCriteria": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "exteriorCriteria"
          ],
          "type": "object"
        }
      ],
      "description": "Elements of R_n that fall outside the active carrier — i.e., outside the type's domain. These are ring elements that do not participate in the current type resolution.",
      "title": "Complement"
    },
    "partition/Component": {
      "description": "A single component of a partition: a set of datum values belonging to one of the four categories.",
      "properties": {
        "cardinality": {
          "minimum": 0,
          "type": "integer"
        },
        "member": {
          "items": {
            "$ref": "#/$defs/schema~1Datum"
          },
          "type": "array"
        }
      },
      "required": [
        "cardinality"
      ],
      "title": "Component",
      "type": "object"
    },
    "partition/FreeRank": {
      "description": "The site budget for a partition: an accounting of how many sites are pinned (determined by constraints) versus free (still available for further refinement). A closed budget means all sites are pinned and the type is fully resolved.",
      "properties": {
        "freeRank": {
          "minimum": 0,
          "type": "integer"
        },
        "hasBinding": {
          "items": {
            "$ref": "#/$defs/partition~1SiteBinding"
          },
          "type": "array"
        },
        "hasSite": {
          "items": {
            "$ref": "#/$defs/partition~1SiteIndex"
          },
          "type": "array"
        },
        "isClosed": {
          "type": "boolean"
        },
        "pinnedCount": {
          "minimum": 0,
          "type": "integer"
        },
        "reversibleStrategy": {
          "type": "boolean"
        },
        "totalSites": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "totalSites",
        "pinnedCount",
        "freeRank",
        "isClosed",
        "reversibleStrategy"
      ],
      "title": "FreeRank",
      "type": "object"
    },
    "partition/IrreducibleSet": {
      "allOf": [
        {
          "$ref": "#/$defs/partition~1Component"
        },
        {
          "type": "object"
        }
      ],
      "description": "The set of irreducible elements under the active type: elements whose only factorizations involve units or themselves. Analogous to prime elements in a ring.",
      "title": "IrreducibleSet"
    },
    "partition/Partition": {
      "description": "A four-component partition of R_n produced by resolving a type declaration. The four components — Irreducible, Reducible, Units, Exterior — are mutually disjoint and exhaustive over the carrier.",
      "properties": {
        "density": {
          "type": "number"
        },
        "exterior": {
          "$ref": "#/$defs/partition~1Complement"
        },
        "irreducibles": {
          "$ref": "#/$defs/partition~1IrreducibleSet"
        },
        "isExhaustive": {
          "type": "boolean"
        },
        "reducibles": {
          "$ref": "#/$defs/partition~1ReducibleSet"
        },
        "siteBudget": {
          "$ref": "#/$defs/partition~1FreeRank"
        },
        "sourceType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        "units": {
          "$ref": "#/$defs/partition~1UnitGroup"
        },
        "wittLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "irreducibles",
        "reducibles",
        "units",
        "exterior",
        "density",
        "sourceType",
        "wittLength",
        "siteBudget",
        "isExhaustive"
      ],
      "title": "Partition",
      "type": "object"
    },
    "partition/PartitionCoproduct": {
      "description": "The coproduct (disjoint union) of two partitions: partition(A + B) = partition(A) ⊕ partition(B). The four-component structure combines via disjoint union under the sum type construction (PT_2b). Carries leftSummand and rightSummand links to the operand partitions.",
      "properties": {
        "leftSummand": {
          "$ref": "#/$defs/partition~1Partition"
        },
        "rightSummand": {
          "$ref": "#/$defs/partition~1Partition"
        }
      },
      "required": [
        "leftSummand",
        "rightSummand"
      ],
      "title": "PartitionCoproduct",
      "type": "object"
    },
    "partition/PartitionProduct": {
      "description": "The tensor product of two partitions: partition(A × B) = partition(A) ⊗ partition(B). The four-component structure combines component-wise under the product type construction (PT_2a). Carries leftFactor and rightFactor links to the operand partitions.",
      "properties": {
        "leftFactor": {
          "$ref": "#/$defs/partition~1Partition"
        },
        "rightFactor": {
          "$ref": "#/$defs/partition~1Partition"
        }
      },
      "required": [
        "leftFactor",
        "rightFactor"
      ],
      "title": "PartitionProduct",
      "type": "object"
    },
    "partition/ReducibleSet": {
      "allOf": [
        {
          "$ref": "#/$defs/partition~1Component"
        },
        {
          "type": "object"
        }
      ],
      "description": "The set of reducible non-unit elements: elements that can be expressed as a product of two or more non-unit elements.",
      "title": "ReducibleSet"
    },
    "partition/SiteBinding": {
      "description": "A record of a single site being pinned by a constraint. Links a specific site coordinate to the constraint that determined its value.",
      "properties": {
        "pinnedBy": {
          "$ref": "#/$defs/type~1Constraint"
        },
        "pinsCoordinate": {
          "$ref": "#/$defs/partition~1SiteIndex"
        }
      },
      "required": [
        "pinnedBy",
        "pinsCoordinate"
      ],
      "title": "SiteBinding",
      "type": "object"
    },
    "partition/SiteIndex": {
      "description": "A single site coordinate in the iterated Z/2Z fibration. Each site represents one binary degree of freedom in the ring's structure. The total number of sites equals the quantum level n.",
      "properties": {
        "ancillaSite": {
          "$ref": "#/$defs/partition~1SiteIndex"
        },
        "sitePosition": {
          "minimum": 0,
          "type": "integer"
        },
        "siteState": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "sitePosition",
        "siteState",
        "ancillaSite"
      ],
      "title": "SiteIndex",
      "type": "object"
    },
    "partition/UnitGroup": {
      "allOf": [
        {
          "$ref": "#/$defs/partition~1Component"
        },
        {
          "type": "object"
        }
      ],
      "description": "The set of invertible elements (units) in the carrier: elements with a multiplicative inverse. In Z/(2^n)Z, the units are the odd integers.",
      "title": "UnitGroup"
    },
    "predicate/DispatchRule": {
      "description": "A pair (Predicate, Target) where Target is a resolver:Resolver class. The kernel evaluates the predicate; if true, the target resolver is selected.",
      "properties": {
        "dispatchIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "dispatchPredicate": {
          "$ref": "#/$defs/predicate~1Predicate"
        },
        "dispatchTarget": {
          "$ref": "#/$defs/resolver~1Resolver"
        }
      },
      "required": [
        "dispatchPredicate",
        "dispatchTarget",
        "dispatchIndex"
      ],
      "title": "DispatchRule",
      "type": "object"
    },
    "predicate/DispatchTable": {
      "description": "An ordered set of DispatchRules for a single dispatch point. Must satisfy exhaustiveness and mutual exclusion.",
      "properties": {
        "dispatchRules": {
          "items": {
            "$ref": "#/$defs/predicate~1DispatchRule"
          },
          "type": "array"
        },
        "isExhaustive": {
          "type": "boolean"
        },
        "isMutuallyExclusive": {
          "type": "boolean"
        }
      },
      "required": [
        "isExhaustive",
        "isMutuallyExclusive"
      ],
      "title": "DispatchTable",
      "type": "object"
    },
    "predicate/GuardedTransition": {
      "description": "A triple (StatePredicate, effect:Effect, reduction:ReductionStep). The guard is a StatePredicate; if true, the effect is applied and the reduction advances to the target step.",
      "properties": {
        "guardEffect": {
          "$ref": "#/$defs/effect~1Effect"
        },
        "guardPredicate": {
          "$ref": "#/$defs/predicate~1StatePredicate"
        },
        "guardTarget": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        }
      },
      "required": [
        "guardPredicate",
        "guardEffect",
        "guardTarget"
      ],
      "title": "GuardedTransition",
      "type": "object"
    },
    "predicate/MatchArm": {
      "description": "A single case in a pattern match: a Predicate and a result Term. The match evaluates predicates in order and returns the result of the first matching arm.",
      "properties": {
        "armIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "armPredicate": {
          "$ref": "#/$defs/predicate~1Predicate"
        },
        "armResult": {
          "$ref": "#/$defs/schema~1Term"
        }
      },
      "required": [
        "armPredicate",
        "armResult",
        "armIndex"
      ],
      "title": "MatchArm",
      "type": "object"
    },
    "predicate/MatchExpression": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1Term"
        },
        {
          "properties": {
            "matchArms": {
              "items": {
                "$ref": "#/$defs/predicate~1MatchArm"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "A term formed by evaluating a sequence of MatchArms. Extends the term language with deterministic conditional evaluation.",
      "title": "MatchExpression"
    },
    "predicate/Predicate": {
      "description": "A total, pure, boolean-valued function on a kernel object. Evaluation terminates for all inputs and produces no side effects.",
      "properties": {
        "boundedEvaluator": {
          "items": {
            "$ref": "#/$defs/recursion~1DescentMeasure"
          },
          "type": "array"
        },
        "evaluatesOver": {
          "format": "iri",
          "type": "string"
        }
      },
      "required": [
        "evaluatesOver"
      ],
      "title": "Predicate",
      "type": "object"
    },
    "predicate/SitePredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/predicate~1Predicate"
        },
        {
          "type": "object"
        }
      ],
      "description": "A predicate over partition:SiteIndex. Used for site-level selection in geodesic resolution.",
      "title": "SitePredicate"
    },
    "predicate/StatePredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/predicate~1Predicate"
        },
        {
          "type": "object"
        }
      ],
      "description": "A predicate over state:Context or reduction:ReductionState. Used for reduction step guards.",
      "title": "StatePredicate"
    },
    "predicate/TypePredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/predicate~1Predicate"
        },
        {
          "type": "object"
        }
      ],
      "description": "A predicate over type:TypeDefinition. Used for resolver dispatch.",
      "title": "TypePredicate"
    },
    "proof/AxiomaticDerivation": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1Proof"
        },
        {
          "properties": {
            "derivationWitness": {
              "items": {
                "$ref": "#/$defs/derivation~1Derivation"
              },
              "type": "array"
            },
            "universalScope": {
              "type": "boolean"
            }
          },
          "required": [
            "universalScope"
          ],
          "type": "object"
        }
      ],
      "description": "A proof that follows from previously established axioms or definitions by equational, structural, or topological reasoning. The proof:derivationWitness property links to a derivation:Derivation individual recording the rewrite chain. All pipeline, constraint, observable, and topological identities are AxiomaticDerivations.",
      "title": "AxiomaticDerivation"
    },
    "proof/CoherenceProof": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1Proof"
        },
        {
          "type": "object"
        }
      ],
      "description": "A proof of coherence: the type system and ring structure are mutually consistent at a given quantum level.",
      "title": "CoherenceProof"
    },
    "proof/ComputationCertificate": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1Proof"
        },
        {
          "properties": {
            "atWittLevel": {
              "$ref": "#/$defs/schema~1WittLevel"
            }
          },
          "required": [
            "atWittLevel"
          ],
          "type": "object"
        }
      ],
      "description": "A proof confirmed by exhaustive execution over R_n at a specific quantum level. The kernel ran the identity against all 2^n inputs and observed that it holds. The proof:atWittLevel property records the level; proof:witness links to the WitnessData. CriticalIdentityProof is a subclass of ComputationCertificate.",
      "title": "ComputationCertificate"
    },
    "proof/ComputationStep": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1DerivationTerm"
        },
        {
          "type": "object"
        }
      ],
      "description": "A proof step performing exhaustive computation at a specific quantum level as verification witness.",
      "title": "ComputationStep"
    },
    "proof/CriticalIdentityProof": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1ComputationCertificate"
        },
        {
          "type": "object"
        }
      ],
      "description": "A proof of the critical identity: neg(bnot(x)) = succ(x) for all x in R_n. This is the foundational theorem of the UOR kernel.",
      "title": "CriticalIdentityProof"
    },
    "proof/DerivationTerm": {
      "description": "Root AST node for proof construction terms. Distinct from schema:TermExpression which represents mathematical terms; DerivationTerm represents proof constructions (tactic applications, lemma invocations, induction scaffolding).",
      "title": "DerivationTerm",
      "type": "object"
    },
    "proof/ImpossibilityWitness": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1Proof"
        },
        {
          "properties": {
            "achievabilityStatus": {
              "$ref": "#/$defs/observable~1AchievabilityStatus"
            },
            "impossibilityDomain": {
              "$ref": "#/$defs/op~1VerificationDomain"
            },
            "impossibilityReason": {
              "type": "string"
            }
          },
          "required": [
            "impossibilityReason",
            "impossibilityDomain",
            "achievabilityStatus"
          ],
          "type": "object"
        }
      ],
      "description": "A formal witness that a topological signature (χ, β_k) is impossible to achieve for any ConstrainedType. Carries the algebraic reason and the verification domain grounding the impossibility.",
      "title": "ImpossibilityWitness"
    },
    "proof/InductionStep": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1DerivationTerm"
        },
        {
          "type": "object"
        }
      ],
      "description": "A proof step performing structural induction: base case derivation, inductive hypothesis, and step derivation.",
      "title": "InductionStep"
    },
    "proof/InductiveProof": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1Proof"
        },
        {
          "properties": {
            "baseCase": {
              "$ref": "#/$defs/proof~1Proof"
            },
            "inductiveStep": {
              "$ref": "#/$defs/proof~1Proof"
            },
            "validForKAtLeast": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "baseCase",
            "inductiveStep",
            "validForKAtLeast"
          ],
          "type": "object"
        }
      ],
      "description": "A proof by structural induction on the quantum level index k. Carries a base case proof, an inductive step proof, and the minimum k for which the induction holds.",
      "title": "InductiveProof"
    },
    "proof/LemmaInvocation": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1DerivationTerm"
        },
        {
          "type": "object"
        }
      ],
      "description": "A proof step invoking a previously proved identity as a lemma. References the identity via proof:dependsOn.",
      "title": "LemmaInvocation"
    },
    "proof/MorphospaceBoundary": {
      "description": "An aggregate of ImpossibilityWitness instances forming the queryable morphospace map. SPARQL over this structure answers achievability queries in O(1).",
      "properties": {
        "morphospaceRecord": {
          "items": {
            "$ref": "#/$defs/proof~1MorphospaceRecord"
          },
          "type": "array"
        }
      },
      "title": "MorphospaceBoundary",
      "type": "object"
    },
    "proof/MorphospaceRecord": {
      "description": "A formal record of a morphospace boundary point — either an achievable or forbidden topological signature. Aggregated by MorphospaceBoundary to form the queryable morphospace map.",
      "properties": {
        "boundaryType": {
          "$ref": "#/$defs/observable~1AchievabilityStatus"
        }
      },
      "required": [
        "boundaryType"
      ],
      "title": "MorphospaceRecord",
      "type": "object"
    },
    "proof/Proof": {
      "description": "A kernel-produced attestation that a given algebraic property holds. The root class for all proof types.",
      "properties": {
        "dependsOn": {
          "items": {
            "$ref": "#/$defs/op~1Identity"
          },
          "type": "array"
        },
        "formalDerivation": {
          "$ref": "#/$defs/proof~1DerivationTerm"
        },
        "provesIdentity": {
          "$ref": "#/$defs/op~1Identity"
        },
        "strategy": {
          "$ref": "#/$defs/proof~1ProofStrategy"
        },
        "timestamp": {
          "format": "date-time",
          "type": "string"
        },
        "verified": {
          "type": "boolean"
        },
        "verifiedAtLevel": {
          "items": {
            "$ref": "#/$defs/schema~1WittLevel"
          },
          "type": "array"
        },
        "witness": {
          "items": {
            "$ref": "#/$defs/proof~1WitnessData"
          },
          "type": "array"
        }
      },
      "required": [
        "verified",
        "timestamp",
        "provesIdentity",
        "strategy",
        "formalDerivation"
      ],
      "title": "Proof",
      "type": "object"
    },
    "proof/ProofStrategy": {
      "description": "A controlled vocabulary of proof methods. Each proof individual carries exactly one strategy from this vocabulary, enabling compilation to verified theorem provers.",
      "enum": [
        "RingAxiom",
        "DecideQ0",
        "BitwiseInduction",
        "GroupPresentation",
        "Simplification",
        "ChineseRemainder",
        "EulerPoincare",
        "ProductFormula",
        "Composition",
        "Contradiction",
        "Computation"
      ],
      "title": "ProofStrategy"
    },
    "proof/TacticApplication": {
      "allOf": [
        {
          "$ref": "#/$defs/proof~1DerivationTerm"
        },
        {
          "type": "object"
        }
      ],
      "description": "A proof step applying a named tactic (from ProofStrategy) with arguments. Maps to a Lean4 tactic invocation.",
      "title": "TacticApplication"
    },
    "proof/WitnessData": {
      "description": "Supporting data for a proof: specific examples, counter-examples checked, or intermediate computation results.",
      "properties": {
        "bnot_x": {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        "holds": {
          "items": {
            "type": "boolean"
          },
          "type": "array"
        },
        "neg_bnot_x": {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        "succ_x": {
          "items": {
            "type": "integer"
          },
          "type": "array"
        },
        "x": {
          "items": {
            "type": "integer"
          },
          "type": "array"
        }
      },
      "title": "WitnessData",
      "type": "object"
    },
    "query/CoordinateQuery": {
      "allOf": [
        {
          "$ref": "#/$defs/query~1Query"
        },
        {
          "properties": {
            "hasTriadProjection": {
              "$ref": "#/$defs/query~1TriadProjection"
            }
          },
          "required": [
            "hasTriadProjection"
          ],
          "type": "object"
        }
      ],
      "description": "A query for the ring-coordinate position of a datum: its stratum, spectrum, and address within the ring geometry.",
      "title": "CoordinateQuery"
    },
    "query/MetricQuery": {
      "allOf": [
        {
          "$ref": "#/$defs/query~1Query"
        },
        {
          "type": "object"
        }
      ],
      "description": "A query for a metric value between two datums: ring distance, Hamming distance, or their divergence (curvature).",
      "title": "MetricQuery"
    },
    "query/Query": {
      "description": "A request for information from the UOR kernel. The root abstraction for all query types.",
      "properties": {
        "inputType": {
          "format": "iri",
          "type": "string"
        },
        "outputType": {
          "format": "iri",
          "type": "string"
        }
      },
      "required": [
        "inputType",
        "outputType"
      ],
      "title": "Query",
      "type": "object"
    },
    "query/RelationQuery": {
      "allOf": [
        {
          "$ref": "#/$defs/query~1Query"
        },
        {
          "properties": {
            "groundingMap": {
              "$ref": "#/$defs/morphism~1GroundingMap"
            },
            "projectionMap": {
              "$ref": "#/$defs/morphism~1ProjectionMap"
            },
            "relationType": {
              "$ref": "#/$defs/type~1Constraint"
            },
            "sessionContext": {
              "$ref": "#/$defs/state~1Context"
            },
            "sourceAddress": {
              "$ref": "#/$defs/u~1Element"
            },
            "targetSite": {
              "$ref": "#/$defs/partition~1FreeRank"
            }
          },
          "required": [
            "sourceAddress",
            "relationType",
            "targetSite",
            "groundingMap",
            "projectionMap",
            "sessionContext"
          ],
          "type": "object"
        }
      ],
      "description": "A Query with a known source address, a typed relation constraint, and an open target partition:FreeRank. Represents any question of the form: given this source symbol and relation type, what is the target? The relation type is read from the observable coordinate triple (d_R, d_H, d_I) — not externally supplied. Applies across NLP, ARC-AGI grids, music, images, sensor streams, and logical formulae.",
      "title": "RelationQuery"
    },
    "query/RepresentationQuery": {
      "allOf": [
        {
          "$ref": "#/$defs/query~1Query"
        },
        {
          "type": "object"
        }
      ],
      "description": "A query for the canonical representation of a datum or term: its normal form under the active resolver strategy.",
      "title": "RepresentationQuery"
    },
    "query/SessionQuery": {
      "allOf": [
        {
          "$ref": "#/$defs/query~1RelationQuery"
        },
        {
          "properties": {
            "sessionMembership": {
              "$ref": "#/$defs/state~1Session"
            }
          },
          "required": [
            "sessionMembership"
          ],
          "type": "object"
        }
      ],
      "description": "A RelationQuery that explicitly declares its session membership, allowing the conformance suite to validate session-scoped site reduction across multi-turn Prism deployments.",
      "title": "SessionQuery"
    },
    "query/TriadProjection": {
      "description": "A classification of coordinate types that a CoordinateQuery can extract. Each TriadProjection individual names a specific coordinate system (stratum, spectrum, address) replacing the string-valued query:coordinate property.",
      "enum": [
        "TwoAdicValuation",
        "WalshHadamardImage",
        "RingElement"
      ],
      "title": "TriadProjection"
    },
    "recursion/BaseCase": {
      "allOf": [
        {
          "$ref": "#/$defs/predicate~1MatchArm"
        },
        {
          "type": "object"
        }
      ],
      "description": "The match arm selected when the descent measure reaches zero or the base predicate is satisfied. Produces a direct result without further recursion.",
      "title": "BaseCase"
    },
    "recursion/BoundedRecursion": {
      "description": "A self-referential computation parameterized by a descent measure. Each recursive step strictly decreases the measure; the computation terminates when the base case predicate is satisfied.",
      "properties": {
        "baseCase": {
          "$ref": "#/$defs/recursion~1BaseCase"
        },
        "basePredicate": {
          "$ref": "#/$defs/predicate~1Predicate"
        },
        "initialMeasure": {
          "minimum": 0,
          "type": "integer"
        },
        "measure": {
          "$ref": "#/$defs/recursion~1DescentMeasure"
        },
        "recursionBody": {
          "$ref": "#/$defs/morphism~1ComputationDatum"
        },
        "recursiveCase": {
          "$ref": "#/$defs/recursion~1RecursiveCase"
        }
      },
      "required": [
        "measure",
        "baseCase",
        "recursiveCase",
        "basePredicate",
        "recursionBody",
        "initialMeasure"
      ],
      "title": "BoundedRecursion",
      "type": "object"
    },
    "recursion/DescentMeasure": {
      "description": "A well-founded function from computation state to xsd:nonNegativeInteger. Strictly decreases on every recursive step.",
      "properties": {
        "measureValue": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "measureValue"
      ],
      "title": "DescentMeasure",
      "type": "object"
    },
    "recursion/RecursionTrace": {
      "allOf": [
        {
          "$ref": "#/$defs/trace~1ComputationTrace"
        },
        {
          "type": "object"
        }
      ],
      "description": "A computation trace recording the sequence of recursive steps, measure values, and the base case result. The trace length is bounded by the initial measure value.",
      "title": "RecursionTrace"
    },
    "recursion/RecursiveCase": {
      "allOf": [
        {
          "$ref": "#/$defs/predicate~1MatchArm"
        },
        {
          "type": "object"
        }
      ],
      "description": "The match arm selected when the descent measure is positive. Applies a decomposition step, decreases the measure, and invokes the recursion.",
      "title": "RecursiveCase"
    },
    "recursion/RecursiveStep": {
      "description": "A single step in a bounded recursion: the decomposition applied before the recursive invocation. Must strictly decrease the DescentMeasure.",
      "properties": {
        "stepDecomposition": {
          "$ref": "#/$defs/morphism~1Transform"
        },
        "stepMeasurePost": {
          "$ref": "#/$defs/recursion~1DescentMeasure"
        },
        "stepMeasurePre": {
          "$ref": "#/$defs/recursion~1DescentMeasure"
        }
      },
      "required": [
        "stepDecomposition",
        "stepMeasurePre",
        "stepMeasurePost"
      ],
      "title": "RecursiveStep",
      "type": "object"
    },
    "recursion/StructuralRecursion": {
      "allOf": [
        {
          "$ref": "#/$defs/recursion~1BoundedRecursion"
        },
        {
          "type": "object"
        }
      ],
      "description": "A bounded recursion where the descent measure is the structural size of the input type (site count, constraint count, or operad nesting depth).",
      "title": "StructuralRecursion"
    },
    "reduction/BackPressureSignal": {
      "description": "Flow control when reduction produces faster than downstream can consume.",
      "properties": {
        "pressureLevel": {
          "type": "string"
        },
        "pressureThreshold": {
          "type": "number"
        },
        "sourceStage": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "targetStage": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "pressureLevel",
        "pressureThreshold",
        "sourceStage",
        "targetStage"
      ],
      "title": "BackPressureSignal",
      "type": "object"
    },
    "reduction/ComparisonPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "comparisonField": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "comparisonOperator": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "comparisonValue": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "comparisonField",
            "comparisonOperator",
            "comparisonValue"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate comparing a state field against a value.",
      "title": "ComparisonPredicate"
    },
    "reduction/CompileUnit": {
      "description": "The typed input graph submitted to the reduction pipeline. Packages a root Term, target quantum level, verification domains, and thermodynamic budget. Stage 0 accepts exactly one CompileUnit and initializes the reduction state vector from it.",
      "properties": {
        "rootTerm": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "targetDomains": {
          "items": {
            "$ref": "#/$defs/op~1VerificationDomain"
          },
          "type": "array"
        },
        "thermodynamicBudget": {
          "type": "number"
        },
        "unitAddress": {
          "$ref": "#/$defs/u~1Element"
        },
        "unitWittLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "rootTerm",
        "unitWittLevel",
        "thermodynamicBudget",
        "unitAddress"
      ],
      "title": "CompileUnit",
      "type": "object"
    },
    "reduction/ComplexConjugateRollback": {
      "description": "Recovery operation when a phase gate fails: z → z̄. Involutory: applying twice yields the original value.",
      "properties": {
        "rollbackTarget": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        }
      },
      "required": [
        "rollbackTarget"
      ],
      "title": "ComplexConjugateRollback",
      "type": "object"
    },
    "reduction/ConjunctionPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "conjuncts": {
              "items": {
                "$ref": "#/$defs/schema~1TermExpression"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "Conjunction (AND) of multiple predicates.",
      "title": "ConjunctionPredicate"
    },
    "reduction/DeferredQuerySet": {
      "description": "Queries postponed to a future epoch.",
      "properties": {
        "deferralEpoch": {
          "minimum": 0,
          "type": "integer"
        },
        "deferralReason": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "deferredCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "deferredCount",
        "deferralEpoch",
        "deferralReason"
      ],
      "title": "DeferredQuerySet",
      "type": "object"
    },
    "reduction/DisjunctionPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "disjuncts": {
              "items": {
                "$ref": "#/$defs/schema~1TermExpression"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "Disjunction (OR) of multiple predicates.",
      "title": "DisjunctionPredicate"
    },
    "reduction/Epoch": {
      "description": "Temporal segment of reduction execution. Each epoch represents one complete pass through the reduction stages.",
      "properties": {
        "epochDatum": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "epochIndex": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "epochIndex",
        "epochDatum"
      ],
      "title": "Epoch",
      "type": "object"
    },
    "reduction/EpochBoundary": {
      "description": "Transition between epochs. Carries metadata about the epoch boundary crossing.",
      "properties": {
        "epochBoundaryType": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "preservedGrounding": {
          "type": "boolean"
        }
      },
      "required": [
        "epochBoundaryType",
        "preservedGrounding"
      ],
      "title": "EpochBoundary",
      "type": "object"
    },
    "reduction/EqualsPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "equalityLeft": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "equalityRight": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "equalityLeft",
            "equalityRight"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate testing equality of two expressions.",
      "title": "EqualsPredicate"
    },
    "reduction/EulerReduction": {
      "description": "The composite endofunctor ψ = ψ_9 ∘ … ∘ ψ_1, parameterized by Ω = e^{iπ/6}.",
      "properties": {
        "composedOfMaps": {
          "items": {
            "$ref": "#/$defs/schema~1TermExpression"
          },
          "type": "array"
        },
        "convergenceAngle": {
          "type": "number"
        },
        "phaseParameter": {
          "type": "number"
        },
        "stageCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "phaseParameter",
        "stageCount",
        "convergenceAngle"
      ],
      "title": "EulerReduction",
      "type": "object"
    },
    "reduction/FeasibilityResult": {
      "description": "Result of a preflight check: feasibility witness or infeasibility witness.",
      "properties": {
        "feasibilityKind": {
          "type": "string"
        },
        "feasibilityWitness": {
          "type": "string"
        },
        "infeasibilityKind": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "feasibilityKind",
        "feasibilityWitness",
        "infeasibilityKind"
      ],
      "title": "FeasibilityResult",
      "type": "object"
    },
    "reduction/GroundingPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "groundingThreshold": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "groundingThreshold"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate testing whether grounding exceeds a threshold.",
      "title": "GroundingPredicate"
    },
    "reduction/GuardExpression": {
      "description": "A conjunction of PredicateExpressions that must hold for a transition to fire.",
      "properties": {
        "guardPredicates": {
          "items": {
            "$ref": "#/$defs/reduction~1PredicateExpression"
          },
          "type": "array"
        }
      },
      "title": "GuardExpression",
      "type": "object"
    },
    "reduction/LeaseCheckpoint": {
      "description": "Snapshot of lease state at a point in time.",
      "properties": {
        "checkpointEpoch": {
          "minimum": 0,
          "type": "integer"
        },
        "checkpointState": {
          "$ref": "#/$defs/reduction~1ReductionState"
        },
        "leaseRemainingBudget": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "checkpointEpoch",
        "checkpointState",
        "leaseRemainingBudget"
      ],
      "title": "LeaseCheckpoint",
      "type": "object"
    },
    "reduction/LeaseState": {
      "description": "Lifecycle of a partitioned context lease: Pending → Active → Released/Expired/Suspended.",
      "properties": {
        "leasePhase": {
          "type": "string"
        }
      },
      "required": [
        "leasePhase"
      ],
      "title": "LeaseState",
      "type": "object"
    },
    "reduction/ManagedLease": {
      "description": "A context lease with lifecycle tracking.",
      "properties": {
        "expiryEpoch": {
          "minimum": 0,
          "type": "integer"
        },
        "leaseBudget": {
          "minimum": 0,
          "type": "integer"
        },
        "leaseLifecycle": {
          "$ref": "#/$defs/reduction~1LeaseState"
        },
        "managedLeaseId": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "managedLeaseId",
        "leaseLifecycle",
        "expiryEpoch",
        "leaseBudget"
      ],
      "title": "ManagedLease",
      "type": "object"
    },
    "reduction/MembershipPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "membershipElement": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "membershipSet": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "membershipSet",
            "membershipElement"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate testing membership of an element in a set.",
      "title": "MembershipPredicate"
    },
    "reduction/NegationPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "negatedPredicate": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "negatedPredicate"
          ],
          "type": "object"
        }
      ],
      "description": "Negation (NOT) of a single predicate.",
      "title": "NegationPredicate"
    },
    "reduction/NonNullPredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "nonNullField": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "nonNullField"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate testing that a field is non-null.",
      "title": "NonNullPredicate"
    },
    "reduction/PhaseGateAttestation": {
      "description": "Validation at each stage boundary checking that the accumulated phase angle matches the expected Ω^k.",
      "properties": {
        "gateExpectedPhase": {
          "type": "number"
        },
        "gateResult": {
          "type": "boolean"
        },
        "gateStage": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        }
      },
      "required": [
        "gateStage",
        "gateExpectedPhase",
        "gateResult"
      ],
      "title": "PhaseGateAttestation",
      "type": "object"
    },
    "reduction/PhaseRotationScheduler": {
      "description": "Schedule Ω⁰, Ω¹, …, Ω⁵ assigning a phase angle to each stage of the reduction.",
      "properties": {
        "baseAngle": {
          "type": "number"
        },
        "rotationSchedule": {
          "type": "number"
        }
      },
      "required": [
        "rotationSchedule",
        "baseAngle"
      ],
      "title": "PhaseRotationScheduler",
      "type": "object"
    },
    "reduction/PipelineFailureReason": {
      "description": "Typed failure: DispatchMiss, GroundingFailure, ConvergenceStall, etc.",
      "properties": {
        "failureKind": {
          "type": "string"
        },
        "failureStage": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "failureKind",
        "failureStage"
      ],
      "title": "PipelineFailureReason",
      "type": "object"
    },
    "reduction/PipelineSuccess": {
      "description": "Successful termination (FullGrounding).",
      "properties": {
        "finalGrounding": {
          "type": "number"
        },
        "groundingReached": {
          "type": "boolean"
        }
      },
      "required": [
        "groundingReached",
        "finalGrounding"
      ],
      "title": "PipelineSuccess",
      "type": "object"
    },
    "reduction/PredicateExpression": {
      "description": "A Boolean expression over the reduction state. The atomic guard unit.",
      "properties": {
        "predicateField": {
          "type": "string"
        },
        "predicateOperator": {
          "type": "string"
        },
        "predicateValue": {
          "type": "string"
        }
      },
      "required": [
        "predicateField",
        "predicateOperator",
        "predicateValue"
      ],
      "title": "PredicateExpression",
      "type": "object"
    },
    "reduction/PreflightCheck": {
      "description": "A pre-execution validation: feasibility, dispatch coverage, coherence.",
      "properties": {
        "preflightKind": {
          "type": "string"
        },
        "preflightOrder": {
          "minimum": 0,
          "type": "integer"
        },
        "preflightResult": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "preflightKind",
        "preflightResult",
        "preflightOrder"
      ],
      "title": "PreflightCheck",
      "type": "object"
    },
    "reduction/PropertyBind": {
      "description": "A single site pinning: target site + value.",
      "properties": {
        "bindTarget": {
          "type": "string"
        },
        "bindValue": {
          "type": "string"
        }
      },
      "required": [
        "bindTarget",
        "bindValue"
      ],
      "title": "PropertyBind",
      "type": "object"
    },
    "reduction/QuerySubtypePredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "queryTypeRef": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "queryTypeRef"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate testing whether a query is a subtype of a given type.",
      "title": "QuerySubtypePredicate"
    },
    "reduction/ReductionAdvance": {
      "description": "Advancement from one ReductionStep to the next.",
      "properties": {
        "advanceFrom": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        },
        "advanceTo": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        }
      },
      "required": [
        "advanceFrom",
        "advanceTo"
      ],
      "title": "ReductionAdvance",
      "type": "object"
    },
    "reduction/ReductionRule": {
      "description": "Guard-effect pair governing stage transitions in the reduction. The guard must be satisfied before the effect is applied.",
      "properties": {
        "transitionAdvance": {
          "type": "boolean"
        },
        "transitionEffect": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "transitionGuard": {
          "$ref": "#/$defs/predicate~1GuardedTransition"
        }
      },
      "required": [
        "transitionGuard",
        "transitionEffect",
        "transitionAdvance"
      ],
      "title": "ReductionRule",
      "type": "object"
    },
    "reduction/ReductionState": {
      "description": "State of reduction execution at a specific point, including the current stage, phase angle, and pinned mask.",
      "properties": {
        "currentStage": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        },
        "freeRank": {
          "minimum": 0,
          "type": "integer"
        },
        "phaseAngle": {
          "type": "number"
        },
        "pinnedMask": {
          "minimum": 0,
          "type": "integer"
        },
        "siteState": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "currentStage",
        "phaseAngle",
        "pinnedMask",
        "freeRank",
        "siteState"
      ],
      "title": "ReductionState",
      "type": "object"
    },
    "reduction/ReductionStep": {
      "description": "A named stage of the reduction. The standard reduction has six stages (Initialization through Convergence).",
      "properties": {
        "entryGuard": {
          "$ref": "#/$defs/predicate~1StatePredicate"
        },
        "exitGuard": {
          "$ref": "#/$defs/predicate~1StatePredicate"
        },
        "expectedPhase": {
          "type": "number"
        },
        "stageEffect": {
          "$ref": "#/$defs/effect~1Effect"
        },
        "stageIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "stageName": {
          "type": "string"
        }
      },
      "required": [
        "stageIndex",
        "stageName",
        "expectedPhase",
        "entryGuard",
        "exitGuard",
        "stageEffect"
      ],
      "title": "ReductionStep",
      "type": "object"
    },
    "reduction/ReductionTransaction": {
      "description": "An atomic group of state changes within the reduction.",
      "properties": {
        "transactionOutcome": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "transactionPolicy": {
          "type": "string"
        },
        "transactionScope": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "transactionStatus": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "transactionPolicy",
        "transactionOutcome",
        "transactionScope",
        "transactionStatus"
      ],
      "title": "ReductionTransaction",
      "type": "object"
    },
    "reduction/ServiceWindow": {
      "description": "A sliding window over recent epochs providing BaseContext.",
      "properties": {
        "baseContextRef": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "windowOffset": {
          "minimum": 0,
          "type": "integer"
        },
        "windowSize": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "windowSize",
        "windowOffset",
        "baseContextRef"
      ],
      "title": "ServiceWindow",
      "type": "object"
    },
    "reduction/SiteCoveragePredicate": {
      "allOf": [
        {
          "$ref": "#/$defs/reduction~1PredicateExpression"
        },
        {
          "properties": {
            "coverageTarget": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "coverageTarget"
          ],
          "type": "object"
        }
      ],
      "description": "Predicate testing whether a site coverage target is met.",
      "title": "SiteCoveragePredicate"
    },
    "reduction/SubleaseTransfer": {
      "description": "Transfer of a lease from one computation to another.",
      "properties": {
        "sourceLeaseRef": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "targetLeaseRef": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "transferCompleted": {
          "type": "boolean"
        },
        "transferredBudget": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "sourceLeaseRef",
        "targetLeaseRef",
        "transferredBudget",
        "transferCompleted"
      ],
      "title": "SubleaseTransfer",
      "type": "object"
    },
    "reduction/TargetConvergenceAngle": {
      "description": "The angle at which the reduction terminates (default: π).",
      "properties": {
        "targetAngle": {
          "type": "number"
        }
      },
      "required": [
        "targetAngle"
      ],
      "title": "TargetConvergenceAngle",
      "type": "object"
    },
    "reduction/TransitionEffect": {
      "description": "State changes applied when a transition fires. Contains PropertyBind steps.",
      "properties": {
        "effectBindings": {
          "items": {
            "$ref": "#/$defs/reduction~1PropertyBind"
          },
          "type": "array"
        }
      },
      "title": "TransitionEffect",
      "type": "object"
    },
    "region/AddressRegion": {
      "description": "A contiguous range of u:Element values accessible during a single reduction step. Defines the resolver’s working set.",
      "properties": {
        "localityMetric": {
          "$ref": "#/$defs/region~1LocalityMetric"
        },
        "regionBound": {
          "$ref": "#/$defs/region~1RegionBound"
        },
        "regionCardinality": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "regionBound",
        "localityMetric",
        "regionCardinality"
      ],
      "title": "AddressRegion",
      "type": "object"
    },
    "region/LocalityMetric": {
      "allOf": [
        {
          "$ref": "#/$defs/observable~1MetricObservable"
        },
        {
          "type": "object"
        }
      ],
      "description": "A metric on u:Element values determining which addresses are near each other for resolution purposes.",
      "title": "LocalityMetric"
    },
    "region/RegionAllocation": {
      "description": "An assignment of AddressRegions to reduction steps for a given computation. Enables Prism to pre-compute memory layout.",
      "properties": {
        "allocationStage": {
          "items": {
            "$ref": "#/$defs/reduction~1ReductionStep"
          },
          "type": "array"
        },
        "allocationWorkingSet": {
          "items": {
            "$ref": "#/$defs/region~1WorkingSet"
          },
          "type": "array"
        }
      },
      "title": "RegionAllocation",
      "type": "object"
    },
    "region/RegionBound": {
      "description": "The boundary of an AddressRegion: a pair (lowerAddress, upperAddress) in the content-address ordering.",
      "properties": {
        "regionLower": {
          "$ref": "#/$defs/u~1Element"
        },
        "regionUpper": {
          "$ref": "#/$defs/u~1Element"
        }
      },
      "required": [
        "regionLower",
        "regionUpper"
      ],
      "title": "RegionBound",
      "type": "object"
    },
    "region/WorkingSet": {
      "description": "The set of AddressRegions needed by a resolver at a specific reduction step for a specific type. Computable from the type’s constraint nerve.",
      "properties": {
        "workingSetRegions": {
          "items": {
            "$ref": "#/$defs/region~1AddressRegion"
          },
          "type": "array"
        },
        "workingSetSize": {
          "minimum": 0,
          "type": "integer"
        },
        "workingSetStage": {
          "$ref": "#/$defs/reduction~1ReductionStep"
        },
        "workingSetType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        }
      },
      "required": [
        "workingSetStage",
        "workingSetType",
        "workingSetSize"
      ],
      "title": "WorkingSet",
      "type": "object"
    },
    "resolver/CanonicalFormResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "type": "object"
        }
      ],
      "description": "Resolves types by computing canonical forms via term rewriting. Applies the critical identity and normalization rules to reduce terms to unique canonical representatives.",
      "title": "CanonicalFormResolver"
    },
    "resolver/CechNerve": {
      "allOf": [
        {
          "$ref": "#/$defs/homology~1SimplicialComplex"
        },
        {
          "$ref": "#/$defs/homology~1KanComplex"
        },
        {
          "type": "object"
        }
      ],
      "description": "The simplicial complex whose vertices are constraints and where a k-simplex exists iff the corresponding k+1 constraints have nonempty intersection. The nerve's topology governs resolution convergence: trivial homology ↔ smooth convergence, non-trivial homology ↔ potential stalls.",
      "title": "CechNerve"
    },
    "resolver/CompletenessResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "completenessTarget": {
              "$ref": "#/$defs/type~1CompletenessCandidate"
            }
          },
          "required": [
            "completenessTarget"
          ],
          "type": "object"
        }
      ],
      "description": "A specialisation of Resolver driving the completeness certification loop. Accepts a CompletenessCandidate, runs the ψ-pipeline (reading nerveEulerCharacteristic from ResolutionState), and either issues a CompletenessCertificate or produces a RefinementSuggestion.",
      "title": "CompletenessResolver"
    },
    "resolver/ComplexityClass": {
      "description": "A computational complexity classification for resolvers. Each resolver's asymptotic runtime is typed as a named ComplexityClass individual rather than a free string.",
      "enum": [
        "ConstantTime",
        "LogarithmicTime",
        "LinearTime",
        "ExponentialTime"
      ],
      "title": "ComplexityClass"
    },
    "resolver/ConstraintSearchState": {
      "description": "Internal resolver state tracking the boundary of explored constraint combinations during synthesis. Carries exploredCount, currentCandidate, and a link to the best SynthesisSignature achieved so far.",
      "properties": {
        "currentCandidate": {
          "$ref": "#/$defs/type~1ConstrainedType"
        },
        "exploredCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "exploredCount",
        "currentCandidate"
      ],
      "title": "ConstraintSearchState",
      "type": "object"
    },
    "resolver/DihedralFactorizationResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "type": "object"
        }
      ],
      "description": "Resolves types by factoring the ring under dihedral group action. Identifies orbits under D_{2^n} to determine irreducibility boundaries.",
      "title": "DihedralFactorizationResolver"
    },
    "resolver/EvaluationResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "type": "object"
        }
      ],
      "description": "Resolves types by direct evaluation: applies operations to enumerate ring elements and classify them as irreducible, reducible, unit, or exterior.",
      "title": "EvaluationResolver"
    },
    "resolver/ExecutionPolicy": {
      "description": "A strategy class that defines how a SessionResolver orders pending RelationQuery instances for dispatch. The policy reads the targetSite.freeRank of each pending query and applies an ordering function.",
      "title": "ExecutionPolicy",
      "type": "object"
    },
    "resolver/ExecutionPolicyKind": {
      "description": "A typed controlled vocabulary for ExecutionPolicy individuals. Follows the SessionBoundaryType pattern: a single class with named individuals rather than a subclass hierarchy.",
      "enum": [
        "FifoPolicy",
        "MinFreeCountFirst",
        "MaxFreeCountFirst",
        "DisjointFirst"
      ],
      "title": "ExecutionPolicyKind"
    },
    "resolver/GeodesicValidator": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "validateGeodesic": {
              "$ref": "#/$defs/trace~1GeodesicTrace"
            }
          },
          "required": [
            "validateGeodesic"
          ],
          "type": "object"
        }
      ],
      "description": "A resolver that validates whether a ComputationTrace satisfies the dual geodesic condition (AR_1-ordered and DC_10-selected). Produces GeodesicViolation individuals on failure.",
      "title": "GeodesicValidator"
    },
    "resolver/GroundingAwareResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "usedGrounding": {
              "type": "boolean"
            }
          },
          "required": [
            "usedGrounding"
          ],
          "type": "object"
        }
      ],
      "description": "A resolver that exploits accumulated session bindings at full saturation (σ = 1) to provide O(1) resolution via direct coordinate reads (SC_5).",
      "title": "GroundingAwareResolver"
    },
    "resolver/HomotopyResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "homotopyResult": {
              "items": {
                "$ref": "#/$defs/observable~1HomotopyGroup"
              },
              "type": "array"
            },
            "homotopyTarget": {
              "$ref": "#/$defs/resolver~1CechNerve"
            }
          },
          "required": [
            "homotopyTarget"
          ],
          "type": "object"
        }
      ],
      "description": "A resolver that runs the extended ψ-pipeline (ψ_7–ψ_9) to compute the full homotopy type of a CechNerve. Returns HomotopyGroup observables and PostnikovTruncation records.",
      "title": "HomotopyResolver"
    },
    "resolver/IncrementalCompletenessResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "liftTarget": {
              "$ref": "#/$defs/type~1WittLift"
            }
          },
          "required": [
            "liftTarget"
          ],
          "type": "object"
        }
      ],
      "description": "A Resolver that determines whether a CompleteType T at Q_n lifts to a CompleteType at Q_{n+1} without re-running the full ψ-pipeline from scratch. It computes the SpectralSequencePage sequence, reads the LiftObstruction, and either confirms the lift or returns a LiftRefinementSuggestion.",
      "title": "IncrementalCompletenessResolver"
    },
    "resolver/JacobianGuidedResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "type": "object"
        }
      ],
      "description": "A resolver that uses the Jacobian matrix to guide constraint selection, implementing DC_10: select the constraint that maximises total curvature reduction.",
      "title": "JacobianGuidedResolver"
    },
    "resolver/LiftRefinementSuggestion": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1RefinementSuggestion"
        },
        {
          "properties": {
            "liftSitePosition": {
              "$ref": "#/$defs/partition~1SiteIndex"
            },
            "obstructionClass": {
              "$ref": "#/$defs/observable~1LiftObstructionClass"
            }
          },
          "required": [
            "liftSitePosition",
            "obstructionClass"
          ],
          "type": "object"
        }
      ],
      "description": "A RefinementSuggestion produced when a WittLift has a non-trivial LiftObstruction. Specialises RefinementSuggestion with liftSitePosition (the new bit position n+1) and obstructionClass.",
      "title": "LiftRefinementSuggestion"
    },
    "resolver/MeasurementResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "collapseAmplitude": {
              "type": "number"
            },
            "collapsedSite": {
              "minimum": 0,
              "type": "integer"
            },
            "measurementOutcome": {
              "minimum": 0,
              "type": "integer"
            },
            "priorAmplitudeVector": {
              "type": "number"
            }
          },
          "required": [
            "collapseAmplitude",
            "collapsedSite",
            "measurementOutcome",
            "priorAmplitudeVector"
          ],
          "type": "object"
        }
      ],
      "description": "A resolver that handles projective collapse of SuperposedSiteState components. Issues MeasurementCertificate upon successful collapse with QM_1 verification.",
      "title": "MeasurementResolver"
    },
    "resolver/ModuliResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "moduliDeformation": {
              "$ref": "#/$defs/homology~1DeformationComplex"
            },
            "moduliTarget": {
              "$ref": "#/$defs/type~1CompleteType"
            }
          },
          "required": [
            "moduliTarget",
            "moduliDeformation"
          ],
          "type": "object"
        }
      ],
      "description": "A resolver that computes the local structure of the moduli space at a given CompleteType: constructs the DeformationComplex, determines the HolonomyStratum, and computes tangent/obstruction dimensions.",
      "title": "ModuliResolver"
    },
    "resolver/MonodromyResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "holonomyResult": {
              "$ref": "#/$defs/observable~1HolonomyGroup"
            },
            "monodromyTarget": {
              "$ref": "#/$defs/type~1ConstrainedType"
            }
          },
          "required": [
            "monodromyTarget",
            "holonomyResult"
          ],
          "type": "object"
        }
      ],
      "description": "A Resolver that computes the HolonomyGroup of a ConstrainedType by enumerating closed paths in the constraint nerve and accumulating DihedralElement values. Outputs a MonodromyClass and classifies the type as FlatType or TwistedType.",
      "title": "MonodromyResolver"
    },
    "resolver/RefinementSuggestion": {
      "description": "A suggestion from the resolver for how to refine an incomplete resolution: which metric axis to explore, which class to narrow to, and which sites to target.",
      "properties": {
        "suggestedAxis": {
          "$ref": "#/$defs/type~1MetricAxis"
        },
        "suggestedClass": {
          "format": "iri",
          "type": "string"
        },
        "targetSites": {
          "items": {
            "$ref": "#/$defs/partition~1SiteIndex"
          },
          "type": "array"
        }
      },
      "required": [
        "suggestedAxis",
        "suggestedClass"
      ],
      "title": "RefinementSuggestion",
      "type": "object"
    },
    "resolver/ResolutionState": {
      "description": "The current state of an iterative resolution: tracks how many iterations have been performed, whether the resolution is complete, and the current site deficit.",
      "properties": {
        "cechNerve": {
          "$ref": "#/$defs/resolver~1CechNerve"
        },
        "convergenceRate": {
          "type": "number"
        },
        "guidingJacobian": {
          "$ref": "#/$defs/observable~1Jacobian"
        },
        "homologicalAnalysis": {
          "$ref": "#/$defs/homology~1ChainComplex"
        },
        "isComplete": {
          "type": "boolean"
        },
        "iterationCount": {
          "minimum": 0,
          "type": "integer"
        },
        "nerveEulerCharacteristic": {
          "type": "integer"
        },
        "residualEntropy": {
          "type": "number"
        },
        "sheafAnalysis": {
          "$ref": "#/$defs/cohomology~1Sheaf"
        },
        "siteDeficit": {
          "$ref": "#/$defs/partition~1FreeRank"
        },
        "suggestion": {
          "items": {
            "$ref": "#/$defs/resolver~1RefinementSuggestion"
          },
          "type": "array"
        },
        "topologicallyComplete": {
          "type": "boolean"
        }
      },
      "required": [
        "isComplete",
        "iterationCount",
        "siteDeficit",
        "convergenceRate",
        "cechNerve",
        "residualEntropy",
        "topologicallyComplete",
        "nerveEulerCharacteristic",
        "guidingJacobian",
        "homologicalAnalysis",
        "sheafAnalysis"
      ],
      "title": "ResolutionState",
      "type": "object"
    },
    "resolver/Resolver": {
      "description": "A strategy for resolving a type declaration into a partition of the ring. The kernel dispatches to a specific resolver based on the type's structure.",
      "properties": {
        "dispatchTable": {
          "$ref": "#/$defs/predicate~1DispatchTable"
        },
        "hasComplexityClass": {
          "$ref": "#/$defs/resolver~1ComplexityClass"
        },
        "inputType": {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        "outputType": {
          "$ref": "#/$defs/partition~1Partition"
        },
        "resolutionState": {
          "$ref": "#/$defs/resolver~1ResolutionState"
        },
        "resolverPredicate": {
          "$ref": "#/$defs/predicate~1TypePredicate"
        },
        "strategy": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "inputType",
        "outputType",
        "strategy",
        "resolutionState",
        "hasComplexityClass",
        "dispatchTable",
        "resolverPredicate"
      ],
      "title": "Resolver",
      "type": "object"
    },
    "resolver/SessionResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "executionPolicy": {
              "$ref": "#/$defs/resolver~1ExecutionPolicy"
            },
            "sessionAccumulator": {
              "$ref": "#/$defs/state~1BindingAccumulator"
            }
          },
          "required": [
            "sessionAccumulator",
            "executionPolicy"
          ],
          "type": "object"
        }
      ],
      "description": "A Resolver that maintains a BindingAccumulator across multiple RelationQuery evaluations. The top-level resolver for multi-turn Prism deployments.",
      "title": "SessionResolver"
    },
    "resolver/SuperpositionResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "amplitudeVector": {
              "type": "number"
            }
          },
          "required": [
            "amplitudeVector"
          ],
          "type": "object"
        }
      ],
      "description": "A resolver that handles superposed site states, computing amplitudes and determining when superposition collapses to a classical site assignment (Amendment 32).",
      "title": "SuperpositionResolver"
    },
    "resolver/TowerCompletenessResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "currentChain": {
              "$ref": "#/$defs/type~1LiftChain"
            },
            "towerCheckpoint": {
              "items": {
                "$ref": "#/$defs/derivation~1SynthesisCheckpoint"
              },
              "type": "array"
            },
            "towerSourceLevel": {
              "$ref": "#/$defs/schema~1WittLevel"
            },
            "towerStepResolver": {
              "$ref": "#/$defs/resolver~1IncrementalCompletenessResolver"
            },
            "towerTargetLevel": {
              "$ref": "#/$defs/schema~1WittLevel"
            }
          },
          "required": [
            "towerSourceLevel",
            "towerTargetLevel",
            "currentChain",
            "towerStepResolver"
          ],
          "type": "object"
        }
      ],
      "description": "A Resolver that constructs a LiftChain from liftSourceLevel to an arbitrary liftTargetLevel Q_k by iterating IncrementalCompletenessResolver step by step.",
      "title": "TowerCompletenessResolver"
    },
    "resolver/TypeSynthesisResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "synthesisGoal": {
              "$ref": "#/$defs/type~1TypeSynthesisGoal"
            }
          },
          "required": [
            "synthesisGoal"
          ],
          "type": "object"
        }
      ],
      "description": "A Resolver that runs the ψ-pipeline in inverse mode. Accepts a TypeSynthesisGoal and returns a TypeSynthesisResult. Internally maintains a ConstraintSearchState tracking which constraint combinations have been explored and which Betti profiles they realise.",
      "title": "TypeSynthesisResolver"
    },
    "resolver/WittLevelResolver": {
      "allOf": [
        {
          "$ref": "#/$defs/resolver~1Resolver"
        },
        {
          "properties": {
            "quantumLevel": {
              "$ref": "#/$defs/schema~1WittLevel"
            }
          },
          "required": [
            "quantumLevel"
          ],
          "type": "object"
        }
      ],
      "description": "A Resolver parameterised by quantum level. The same resolver strategy runs at any quantum level n ≥ 1 by substituting the appropriate R_n ring.",
      "title": "WittLevelResolver"
    },
    "schema/Application": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1Term"
        },
        {
          "properties": {
            "argument": {
              "items": {
                "$ref": "#/$defs/schema~1Term"
              },
              "type": "array"
            },
            "operator": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "operator"
          ],
          "type": "object"
        }
      ],
      "description": "A term formed by applying an operation to one or more argument terms. The application's value is the result of evaluating the operator on the evaluated arguments.",
      "title": "Application"
    },
    "schema/ApplicationExpression": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        {
          "properties": {
            "arguments": {
              "items": {
                "$ref": "#/$defs/schema~1TermExpression"
              },
              "type": "array"
            },
            "expressionOperator": {
              "$ref": "#/$defs/op~1Operation"
            }
          },
          "required": [
            "expressionOperator"
          ],
          "type": "object"
        }
      ],
      "description": "An AST node representing operator application: an operator applied to an argument list (e.g., add(x, y)).",
      "title": "ApplicationExpression"
    },
    "schema/CompositionExpression": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        {
          "type": "object"
        }
      ],
      "description": "An AST node for function composition (f compose g).",
      "title": "CompositionExpression"
    },
    "schema/Datum": {
      "description": "An element of the ring Z/(2^n)Z at a specific Witt level n. The primary semantic value type. Disjoint from Term: datums are values, terms are syntactic expressions that evaluate to datums.",
      "properties": {
        "element": {
          "$ref": "#/$defs/u~1Element"
        },
        "spectrum": {
          "minimum": 0,
          "type": "integer"
        },
        "stratum": {
          "minimum": 0,
          "type": "integer"
        },
        "value": {
          "minimum": 0,
          "type": "integer"
        },
        "wittLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "value",
        "wittLength",
        "stratum",
        "spectrum",
        "element"
      ],
      "title": "Datum",
      "type": "object"
    },
    "schema/ForAllDeclaration": {
      "description": "A structured quantifier binding: typed variable declarations with a domain and quantifier kind (universal or existential). Replaces the string-valued op:forAll property.",
      "properties": {
        "boundVariables": {
          "items": {
            "$ref": "#/$defs/schema~1VariableBinding"
          },
          "type": "array"
        },
        "quantifierKind": {
          "$ref": "#/$defs/schema~1QuantifierKind"
        }
      },
      "required": [
        "quantifierKind"
      ],
      "title": "ForAllDeclaration",
      "type": "object"
    },
    "schema/HostBooleanLiteral": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1HostValue"
        },
        {
          "properties": {
            "hostBoolean": {
              "type": "boolean"
            }
          },
          "required": [
            "hostBoolean"
          ],
          "type": "object"
        }
      ],
      "description": "A host boolean literal carrying an xsd:boolean value.",
      "title": "HostBooleanLiteral"
    },
    "schema/HostStringLiteral": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1HostValue"
        },
        {
          "properties": {
            "hostString": {
              "type": "string"
            }
          },
          "required": [
            "hostString"
          ],
          "type": "object"
        }
      ],
      "description": "A host string literal carrying an xsd:string value.",
      "title": "HostStringLiteral"
    },
    "schema/HostValue": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1SurfaceSymbol"
        },
        {
          "type": "object"
        }
      ],
      "description": "An xsd-typed value that denotes a host datatype rather than a ring datum. Used in property-position slots whose range is xsd and as the host-side input of a grounding map.",
      "title": "HostValue"
    },
    "schema/InfixExpression": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        {
          "properties": {
            "infixOperator": {
              "type": "string"
            },
            "leftOperand": {
              "$ref": "#/$defs/schema~1TermExpression"
            },
            "rightOperand": {
              "$ref": "#/$defs/schema~1TermExpression"
            }
          },
          "required": [
            "leftOperand",
            "rightOperand",
            "infixOperator"
          ],
          "type": "object"
        }
      ],
      "description": "An AST node for infix relations and logical connectives (e.g., x <= y, P -> Q, a = b).",
      "title": "InfixExpression"
    },
    "schema/Literal": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1Term"
        },
        {
          "$ref": "#/$defs/schema~1SurfaceSymbol"
        },
        {
          "properties": {
            "denotes": {
              "$ref": "#/$defs/schema~1Datum"
            }
          },
          "required": [
            "denotes"
          ],
          "type": "object"
        }
      ],
      "description": "A term that directly denotes a datum value. A Literal is a leaf node in the term language — it refers to a concrete Datum via schema:denotes without being a Datum itself.",
      "title": "Literal"
    },
    "schema/LiteralExpression": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        {
          "properties": {
            "literalValue": {
              "type": "string"
            }
          },
          "required": [
            "literalValue"
          ],
          "type": "object"
        }
      ],
      "description": "A leaf AST node: an integer literal, variable reference, or named constant.",
      "title": "LiteralExpression"
    },
    "schema/QuantifierKind": {
      "description": "The kind of quantifier: Universal (forall) or Existential (exists). Controlled vocabulary with exactly 2 individuals.",
      "enum": [
        "Universal",
        "Existential"
      ],
      "title": "QuantifierKind"
    },
    "schema/Ring": {
      "description": "The ambient ring Z/(2^n)Z at a specific Witt level n. The Ring is the primary data structure of the UOR kernel. Its two generators (negation and complement) produce the dihedral group D_{2^n} that governs the invariance frame.",
      "properties": {
        "atWittLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        },
        "complement": {
          "$ref": "#/$defs/op~1Involution"
        },
        "generator": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "modulus": {
          "minimum": 1,
          "type": "integer"
        },
        "negation": {
          "$ref": "#/$defs/op~1Involution"
        },
        "ringWittLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "ringWittLength",
        "modulus",
        "generator",
        "negation",
        "complement",
        "atWittLevel"
      ],
      "title": "Ring",
      "type": "object"
    },
    "schema/SetExpression": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        {
          "type": "object"
        }
      ],
      "description": "An AST node for set-builder notation (e.g., {x : P(x)}).",
      "title": "SetExpression"
    },
    "schema/SurfaceSymbol": {
      "description": "An abstract leaf value that a grounding map can accept as surface input. Has no direct instances: every SurfaceSymbol is either a Datum-denoting schema:Literal or an xsd-typed schema:HostValue, and the two cases are disjoint.",
      "title": "SurfaceSymbol",
      "type": "object"
    },
    "schema/Term": {
      "description": "A syntactic expression in the UOR term language. Terms are evaluated to produce Datums. Disjoint from Datum.",
      "title": "Term",
      "type": "object"
    },
    "schema/TermExpression": {
      "description": "Root AST node for parsed EBNF term expressions. Identity lhs/rhs values are instances of TermExpression subtypes. Maps to the `term` production in the EBNF grammar.",
      "title": "TermExpression",
      "type": "object"
    },
    "schema/Triad": {
      "description": "A three-component structure encoding an element's position in the UOR address space: stratum (ring layer), spectrum (bit pattern), and glyph (Braille address).",
      "title": "Triad",
      "type": "object"
    },
    "schema/VariableBinding": {
      "description": "A single variable binding: a variable name bound to a domain type (e.g., x in R_n).",
      "properties": {
        "variableDomain": {
          "format": "iri",
          "type": "string"
        },
        "variableName": {
          "type": "string"
        }
      },
      "required": [
        "variableDomain",
        "variableName"
      ],
      "title": "VariableBinding",
      "type": "object"
    },
    "schema/W16Ring": {
      "allOf": [
        {
          "$ref": "#/$defs/schema~1Ring"
        },
        {
          "properties": {
            "W16bitWidth": {
              "minimum": 1,
              "type": "integer"
            },
            "W16capacity": {
              "minimum": 1,
              "type": "integer"
            }
          },
          "required": [
            "W16bitWidth",
            "W16capacity"
          ],
          "type": "object"
        }
      ],
      "description": "The concrete ring Z/(2^16)Z at Witt level 16. Subclass of schema:Ring. Carries 65,536 elements. W16Ring is the first extension of the default Q0 ring and is the target of Amendment 26's universality proofs.",
      "title": "W16Ring"
    },
    "schema/WittLevel": {
      "description": "A named Witt level Q_k at which the UOR ring operates. Level Q_k uses 8*(k+1) bits, 2^(8*(k+1)) states, and modulus 2^(8*(k+1)). The named individuals Q0-Q3 are the spec-defined reference levels. The class is open: Prism implementations operating at higher levels declare their own WittLevel individuals. The nextWittLevel property forms an unbounded chain Q0 -> Q1 -> Q2 -> ...",
      "enum": [
        "W8",
        "W16",
        "W24",
        "W32"
      ],
      "title": "WittLevel"
    },
    "state/Binding": {
      "description": "The association of a datum value with an address in a context. The write primitive: creating a binding populates an address.",
      "properties": {
        "address": {
          "$ref": "#/$defs/u~1Element"
        },
        "boundType": {
          "items": {
            "$ref": "#/$defs/type~1TypeDefinition"
          },
          "type": "array"
        },
        "content": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "timestamp": {
          "format": "date-time",
          "type": "string"
        }
      },
      "required": [
        "address",
        "content",
        "timestamp"
      ],
      "title": "Binding",
      "type": "object"
    },
    "state/BindingAccumulator": {
      "description": "The mutable accumulator that appends state:Binding instances to a state:Context as each RelationQuery resolves. Tracks monotonic reduction of aggregate free site space.",
      "properties": {
        "accumulatedBindings": {
          "items": {
            "$ref": "#/$defs/state~1Binding"
          },
          "type": "array"
        },
        "aggregateSiteDeficit": {
          "$ref": "#/$defs/partition~1FreeRank"
        }
      },
      "required": [
        "aggregateSiteDeficit"
      ],
      "title": "BindingAccumulator",
      "type": "object"
    },
    "state/Context": {
      "description": "A bounded set of populated UOR addresses. The parameter space for a resolution cycle. Contexts hold bindings that map addresses to datum values.",
      "properties": {
        "binding": {
          "items": {
            "$ref": "#/$defs/state~1Binding"
          },
          "type": "array"
        },
        "capacity": {
          "minimum": 1,
          "type": "integer"
        },
        "contentAddress": {
          "type": "string"
        },
        "contextTemperature": {
          "type": "number"
        },
        "groundingDegree": {
          "type": "number"
        },
        "groundingPhase": {
          "$ref": "#/$defs/state~1GroundingPhase"
        },
        "isGrounded": {
          "type": "boolean"
        },
        "residualFreeCount": {
          "minimum": 0,
          "type": "integer"
        },
        "wittLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "capacity",
        "contentAddress",
        "wittLength",
        "groundingDegree",
        "contextTemperature",
        "isGrounded",
        "groundingPhase",
        "residualFreeCount"
      ],
      "title": "Context",
      "type": "object"
    },
    "state/ContextLease": {
      "description": "A bounded, exclusive claim on a set of site coordinates within a SharedContext, held by exactly one Session. When the session closes or hits a SessionBoundary, the lease is released and its sites become available for re-leasing.",
      "properties": {
        "leaseAllocation": {
          "$ref": "#/$defs/linear~1LeaseAllocation"
        },
        "leaseHolder": {
          "$ref": "#/$defs/state~1Session"
        },
        "leasedSites": {
          "$ref": "#/$defs/partition~1FreeRank"
        }
      },
      "required": [
        "leasedSites",
        "leaseHolder",
        "leaseAllocation"
      ],
      "title": "ContextLease",
      "type": "object"
    },
    "state/DomainGroundingRecord": {
      "description": "An informational/monitoring record tracking the saturation progress of a specific domain within a context. Carries no formal authority — purely observational.",
      "properties": {
        "domainFreeCount": {
          "minimum": 0,
          "type": "integer"
        },
        "groundedContext": {
          "$ref": "#/$defs/state~1GroundedContext"
        },
        "groundedDomain": {
          "$ref": "#/$defs/type~1TypeDefinition"
        }
      },
      "required": [
        "groundedContext",
        "groundedDomain",
        "domainFreeCount"
      ],
      "title": "DomainGroundingRecord",
      "type": "object"
    },
    "state/Frame": {
      "description": "The visibility boundary determining which bindings are in scope for a given resolution. A frame is a view into a context: it selects which bindings the resolver sees.",
      "properties": {
        "activeBindings": {
          "items": {
            "$ref": "#/$defs/state~1Binding"
          },
          "type": "array"
        },
        "constraint": {
          "$ref": "#/$defs/type~1Constraint"
        },
        "context": {
          "$ref": "#/$defs/state~1Context"
        }
      },
      "required": [
        "context",
        "constraint"
      ],
      "title": "Frame",
      "type": "object"
    },
    "state/GroundedContext": {
      "allOf": [
        {
          "$ref": "#/$defs/state~1Context"
        },
        {
          "properties": {
            "groundingCertificate": {
              "$ref": "#/$defs/cert~1GroundingCertificate"
            }
          },
          "required": [
            "groundingCertificate"
          ],
          "type": "object"
        }
      ],
      "description": "A context that has reached full saturation: σ = 1, freeRank = 0, S = 0, T_ctx = 0 (SC_4). The ground state of the type system. All subsequent queries resolve in O(1) via SC_5.",
      "title": "GroundedContext"
    },
    "state/GroundingPhase": {
      "description": "A typed controlled vocabulary for the three phases of context saturation: Open (σ = 0), PartialGrounding (0 < σ < 1), and FullGrounding (σ = 1).",
      "enum": [
        "Open",
        "PartialGrounding",
        "FullGrounding"
      ],
      "title": "GroundingPhase"
    },
    "state/GroundingWitness": {
      "description": "Step-by-step evidence of the saturation process: records which bindings were applied, in what order, to reach full saturation.",
      "properties": {
        "witnessBinding": {
          "items": {
            "$ref": "#/$defs/state~1Binding"
          },
          "type": "array"
        },
        "witnessStep": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "witnessStep"
      ],
      "title": "GroundingWitness",
      "type": "object"
    },
    "state/Session": {
      "description": "A bounded sequence of RelationQuery/response pairs sharing a common state:Context. Sessions are the unit of coherent multi-turn reasoning in Prism.",
      "properties": {
        "sessionBindings": {
          "$ref": "#/$defs/state~1Context"
        },
        "sessionQueries": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "sessionBindings",
        "sessionQueries"
      ],
      "title": "Session",
      "type": "object"
    },
    "state/SessionBoundary": {
      "description": "Marks a context-reset event within a session stream. Records why the context was reset and provides a clean state:Context for subsequent queries.",
      "properties": {
        "boundaryReason": {
          "type": "string"
        },
        "boundaryType": {
          "$ref": "#/$defs/state~1SessionBoundaryType"
        },
        "freshContext": {
          "$ref": "#/$defs/state~1Context"
        },
        "priorContext": {
          "$ref": "#/$defs/state~1Context"
        }
      },
      "required": [
        "boundaryReason",
        "boundaryType",
        "priorContext",
        "freshContext"
      ],
      "title": "SessionBoundary",
      "type": "object"
    },
    "state/SessionBoundaryType": {
      "description": "A typed controlled vocabulary for session boundary reasons. Each individual names a specific reason a context-reset boundary was triggered during a multi-turn session.",
      "enum": [
        "ExplicitReset",
        "ConvergenceBoundary",
        "ContradictionBoundary"
      ],
      "title": "SessionBoundaryType"
    },
    "state/SessionComposition": {
      "description": "Records that a Session was formed by merging the binding sets of two or more predecessor sessions. Valid only if all predecessor binding sets pass the cross-session consistency check (SR_8). An invalid composition attempt produces a ContradictionBoundary on the target session.",
      "properties": {
        "composedFrom": {
          "items": {
            "$ref": "#/$defs/state~1Session"
          },
          "type": "array"
        },
        "compositionCompatible": {
          "type": "boolean"
        },
        "compositionResult": {
          "$ref": "#/$defs/state~1Context"
        },
        "towerConsistencyVerified": {
          "type": "boolean"
        }
      },
      "required": [
        "compositionCompatible",
        "compositionResult",
        "towerConsistencyVerified"
      ],
      "title": "SessionComposition",
      "type": "object"
    },
    "state/SharedContext": {
      "allOf": [
        {
          "$ref": "#/$defs/state~1Context"
        },
        {
          "properties": {
            "leaseSet": {
              "items": {
                "$ref": "#/$defs/state~1ContextLease"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "A Context visible to more than one Session simultaneously. Holds a set of ContextLease instances that partition its site coordinates among active sessions. Lease disjointness (SR_9) prevents concurrent write conflicts.",
      "title": "SharedContext"
    },
    "state/Transition": {
      "description": "A state change: the transformation of one context into another through binding or unbinding. The sequence of transitions is the application's computation history.",
      "properties": {
        "addedBindings": {
          "items": {
            "$ref": "#/$defs/state~1Binding"
          },
          "type": "array"
        },
        "from": {
          "$ref": "#/$defs/state~1Context"
        },
        "removedBindings": {
          "items": {
            "$ref": "#/$defs/state~1Binding"
          },
          "type": "array"
        },
        "to": {
          "$ref": "#/$defs/state~1Context"
        },
        "topologicalSnapshot": {
          "$ref": "#/$defs/morphism~1TopologicalDelta"
        },
        "trace": {
          "$ref": "#/$defs/trace~1ComputationTrace"
        }
      },
      "required": [
        "from",
        "to",
        "trace",
        "topologicalSnapshot"
      ],
      "title": "Transition",
      "type": "object"
    },
    "stream/Epoch": {
      "description": "A single bounded iteration within a productive stream. Each epoch is a complete reduction execution from Initialization through Convergence.",
      "properties": {
        "epochContext": {
          "$ref": "#/$defs/state~1Context"
        },
        "epochIndex": {
          "minimum": 0,
          "type": "integer"
        },
        "epochOutput": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "epochReduction": {
          "$ref": "#/$defs/reduction~1EulerReduction"
        }
      },
      "required": [
        "epochReduction",
        "epochOutput",
        "epochContext",
        "epochIndex"
      ],
      "title": "Epoch",
      "type": "object"
    },
    "stream/EpochBoundary": {
      "description": "The transition point between consecutive epochs. Carries the continuation context and the epoch output.",
      "properties": {
        "boundaryFrom": {
          "$ref": "#/$defs/stream~1Epoch"
        },
        "boundaryTo": {
          "$ref": "#/$defs/stream~1Epoch"
        },
        "continuationContext": {
          "$ref": "#/$defs/state~1Context"
        }
      },
      "required": [
        "boundaryFrom",
        "boundaryTo",
        "continuationContext"
      ],
      "title": "EpochBoundary",
      "type": "object"
    },
    "stream/ProductiveStream": {
      "description": "An unbounded sequence of reduction epochs where each epoch terminates and produces a well-typed output. The coinductive dual of a finite computation.",
      "properties": {
        "isProductive": {
          "type": "boolean"
        }
      },
      "required": [
        "isProductive"
      ],
      "title": "ProductiveStream",
      "type": "object"
    },
    "stream/StreamMorphism": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "type": "object"
        }
      ],
      "description": "A transform between productive streams: maps each epoch of the source to an epoch of the target while preserving the productive property.",
      "title": "StreamMorphism"
    },
    "stream/StreamPrefix": {
      "description": "A finite prefix of a productive stream: the first k epochs and their outputs. Every finite prefix is computable in finite time.",
      "properties": {
        "prefixEpochs": {
          "items": {
            "$ref": "#/$defs/stream~1Epoch"
          },
          "type": "array"
        },
        "prefixLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "prefixLength"
      ],
      "title": "StreamPrefix",
      "type": "object"
    },
    "stream/Unfold": {
      "description": "The coinductive constructor: given an initial context and a step function (a morphism:ComputationDatum), produces a ProductiveStream. The step function must be certified to always reach reduction convergence.",
      "properties": {
        "unfoldResult": {
          "$ref": "#/$defs/stream~1ProductiveStream"
        },
        "unfoldSeed": {
          "$ref": "#/$defs/state~1Context"
        },
        "unfoldStep": {
          "$ref": "#/$defs/morphism~1ComputationDatum"
        }
      },
      "required": [
        "unfoldSeed",
        "unfoldStep",
        "unfoldResult"
      ],
      "title": "Unfold",
      "type": "object"
    },
    "trace/ComputationStep": {
      "description": "A single step in a computation trace: one operation applied to produce one output from one or more inputs.",
      "properties": {
        "from": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "index": {
          "minimum": 0,
          "type": "integer"
        },
        "jacobianAtStep": {
          "type": "number"
        },
        "operation": {
          "$ref": "#/$defs/op~1Operation"
        },
        "stepEntropyCost": {
          "type": "number"
        },
        "to": {
          "$ref": "#/$defs/schema~1Datum"
        }
      },
      "required": [
        "from",
        "to",
        "operation",
        "index",
        "stepEntropyCost",
        "jacobianAtStep"
      ],
      "title": "ComputationStep",
      "type": "object"
    },
    "trace/ComputationTrace": {
      "description": "A complete record of a kernel computation: the input, output, every operation step, and accumulated metrics.",
      "properties": {
        "adiabaticallyOrdered": {
          "type": "boolean"
        },
        "certifiedBy": {
          "$ref": "#/$defs/cert~1Certificate"
        },
        "cumulativeEntropyCost": {
          "type": "number"
        },
        "geodesicViolation": {
          "items": {
            "$ref": "#/$defs/trace~1GeodesicViolation"
          },
          "type": "array"
        },
        "input": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "isAR1Ordered": {
          "type": "boolean"
        },
        "isDC10Selected": {
          "type": "boolean"
        },
        "isGeodesic": {
          "type": "boolean"
        },
        "measurementEvent": {
          "items": {
            "$ref": "#/$defs/trace~1MeasurementEvent"
          },
          "type": "array"
        },
        "monodromy": {
          "$ref": "#/$defs/observable~1DihedralElement"
        },
        "output": {
          "$ref": "#/$defs/schema~1Datum"
        },
        "residualEntropy": {
          "$ref": "#/$defs/observable~1ResidualEntropy"
        },
        "step": {
          "items": {
            "$ref": "#/$defs/trace~1ComputationStep"
          },
          "type": "array"
        }
      },
      "required": [
        "input",
        "output",
        "monodromy",
        "certifiedBy",
        "residualEntropy",
        "isGeodesic",
        "cumulativeEntropyCost",
        "adiabaticallyOrdered",
        "isAR1Ordered",
        "isDC10Selected"
      ],
      "title": "ComputationTrace",
      "type": "object"
    },
    "trace/GeodesicTrace": {
      "allOf": [
        {
          "$ref": "#/$defs/trace~1ComputationTrace"
        },
        {
          "properties": {
            "geodesicCertificate": {
              "$ref": "#/$defs/cert~1GeodesicCertificate"
            }
          },
          "required": [
            "geodesicCertificate"
          ],
          "type": "object"
        }
      ],
      "description": "A computation trace that satisfies the dual geodesic condition (GD_1): AR_1-ordered and DC_10-selected. The path of least dissipation through the resolution landscape.",
      "title": "GeodesicTrace"
    },
    "trace/GeodesicViolation": {
      "description": "A record of a geodesic condition violation at a specific step of a computation trace. Produced by GeodesicValidator when J_k(step_i) < max_\\{free\\} J_k(state_i).",
      "properties": {
        "violationReason": {
          "type": "string"
        }
      },
      "required": [
        "violationReason"
      ],
      "title": "GeodesicViolation",
      "type": "object"
    },
    "trace/MeasurementEvent": {
      "allOf": [
        {
          "$ref": "#/$defs/trace~1ComputationStep"
        },
        {
          "properties": {
            "amplitudeVector": {
              "type": "number"
            },
            "collapseStep": {
              "minimum": 0,
              "type": "integer"
            },
            "postCollapseLandauerCost": {
              "type": "number"
            },
            "preCollapseEntropy": {
              "type": "number"
            }
          },
          "required": [
            "preCollapseEntropy",
            "postCollapseLandauerCost",
            "collapseStep",
            "amplitudeVector"
          ],
          "type": "object"
        }
      ],
      "description": "A specialized computation step recording a single projective collapse of a SuperposedSiteState. Carries pre-collapse entropy and post-collapse Landauer cost (QM_1).",
      "title": "MeasurementEvent"
    },
    "trace/MeasurementOutcome": {
      "description": "A single outcome of a projective measurement on a SuperposedSiteState, recording the classical site index (outcomeValue) and its Born-rule probability |α_k|² (outcomeProbability). Multiple outcomes form the probability distribution of a measurement.",
      "properties": {
        "outcomeProbability": {
          "type": "number"
        },
        "outcomeValue": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "outcomeValue",
        "outcomeProbability"
      ],
      "title": "MeasurementOutcome",
      "type": "object"
    },
    "trace/TraceMetrics": {
      "description": "Summary metrics for a computation trace: total steps, accumulated ring distance, and accumulated Hamming distance.",
      "properties": {
        "stepCount": {
          "minimum": 0,
          "type": "integer"
        },
        "totalHammingDistance": {
          "minimum": 0,
          "type": "integer"
        },
        "totalRingDistance": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "stepCount",
        "totalRingDistance",
        "totalHammingDistance"
      ],
      "title": "TraceMetrics",
      "type": "object"
    },
    "type/AffineConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "affineGenerator": {
              "items": {
                "$ref": "#/$defs/schema~1Datum"
              },
              "type": "array"
            },
            "affineOffset": {
              "$ref": "#/$defs/schema~1Datum"
            }
          },
          "required": [
            "affineOffset"
          ],
          "type": "object"
        }
      ],
      "description": "Pins the Datum to an affine subspace specified by an offset and a set of generators.",
      "title": "AffineConstraint"
    },
    "type/CarryConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "carryPattern": {
              "$ref": "#/$defs/schema~1Datum"
            }
          },
          "required": [
            "carryPattern"
          ],
          "type": "object"
        }
      ],
      "description": "A constraint based on carry propagation patterns in ring arithmetic. Pins sites corresponding to carry positions.",
      "title": "CarryConstraint"
    },
    "type/CollapsedSiteState": {
      "description": "A site state that has undergone projective collapse from a SuperposedSiteState to a definitive classical value. Topologically equivalent to a classically pinned site (QM_2).",
      "properties": {
        "collapsedFrom": {
          "$ref": "#/$defs/type~1SuperposedSiteState"
        },
        "survivingAmplitude": {
          "type": "number"
        }
      },
      "required": [
        "collapsedFrom",
        "survivingAmplitude"
      ],
      "title": "CollapsedSiteState",
      "type": "object"
    },
    "type/CompleteType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        {
          "type": "object"
        }
      ],
      "description": "A TypeDefinition certified to satisfy the UOR completeness criterion (IT_7d): its constraint nerve N(C) has Euler characteristic χ = n and all Betti numbers β_k = 0. A CompleteType guarantees that resolution closes the site budget in O(1) — no iterative refinement is required. Completeness is attested by a cert:CompletenessCertificate linked via cert:certifiedType. This class is not addressable from a type-expr position in the term language; references from term-language positions are rejected by the resolver.",
      "title": "CompleteType"
    },
    "type/CompletenessCandidate": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1ConstrainedType"
        },
        {
          "properties": {
            "candidateNerve": {
              "$ref": "#/$defs/resolver~1CechNerve"
            },
            "completenessCandidate": {
              "items": {
                "$ref": "#/$defs/type~1ConstrainedType"
              },
              "type": "array"
            }
          },
          "required": [
            "candidateNerve"
          ],
          "type": "object"
        }
      ],
      "description": "A ConstrainedType actively undergoing the completeness certification pipeline. Links to the resolver:ResolutionState tracking the current iteration and to the resolver:CechNerve being computed. Disjoint from CompleteType (which is already certified). This class is not addressable from a type-expr position in the term language; references from term-language positions are rejected by the resolver.",
      "title": "CompletenessCandidate"
    },
    "type/CompletenessWitness": {
      "description": "A record of a single site-closing event: one constraint application that reduced the FreeRank deficit. Carries the applied constraint and the sitesClosed count. Forms the ordered audit trail between ConstrainedType and CompleteType.",
      "properties": {
        "sitesClosed": {
          "minimum": 0,
          "type": "integer"
        },
        "witnessConstraint": {
          "$ref": "#/$defs/type~1Constraint"
        }
      },
      "required": [
        "witnessConstraint",
        "sitesClosed"
      ],
      "title": "CompletenessWitness",
      "type": "object"
    },
    "type/CompositeConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "composedFrom": {
              "items": {
                "$ref": "#/$defs/type~1Constraint"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "A constraint formed by composing two or more simpler constraints. The composite pins the union of sites pinned by its components.",
      "title": "CompositeConstraint"
    },
    "type/ConstrainedType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        {
          "properties": {
            "baseType": {
              "$ref": "#/$defs/type~1TypeDefinition"
            },
            "hasConstraint": {
              "items": {
                "$ref": "#/$defs/type~1Constraint"
              },
              "type": "array"
            },
            "holonomyClassified": {
              "type": "boolean"
            },
            "holonomyGroup": {
              "$ref": "#/$defs/observable~1HolonomyGroup"
            },
            "monodromyClass": {
              "$ref": "#/$defs/observable~1MonodromyClass"
            }
          },
          "required": [
            "baseType",
            "holonomyGroup",
            "monodromyClass",
            "holonomyClassified"
          ],
          "type": "object"
        }
      ],
      "description": "A type formed by constraining a base type with a predicate. The carrier is the subset of the base carrier satisfying the constraint.",
      "title": "ConstrainedType"
    },
    "type/Constraint": {
      "description": "A composable predicate that refines a type by pinning one or more site coordinates. Constraints are the parameterization mechanism for ConstrainedType.",
      "properties": {
        "crossingCost": {
          "minimum": 0,
          "type": "integer"
        },
        "metricAxis": {
          "$ref": "#/$defs/type~1MetricAxis"
        },
        "pinsSites": {
          "items": {
            "$ref": "#/$defs/partition~1SiteIndex"
          },
          "type": "array"
        }
      },
      "required": [
        "metricAxis",
        "crossingCost"
      ],
      "title": "Constraint",
      "type": "object"
    },
    "type/DeformationFamily": {
      "description": "A one-parameter family of constraint configurations parameterizing a path.",
      "properties": {
        "familyParameter": {
          "items": {
            "$ref": "#/$defs/type~1CompleteType"
          },
          "type": "array"
        },
        "familyPreservesCompleteness": {
          "type": "boolean"
        }
      },
      "required": [
        "familyPreservesCompleteness"
      ],
      "title": "DeformationFamily",
      "type": "object"
    },
    "type/DepthConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "maxDepth": {
              "minimum": 0,
              "type": "integer"
            },
            "minDepth": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "minDepth",
            "maxDepth"
          ],
          "type": "object"
        }
      ],
      "description": "A constraint on factorization depth: the minimum and maximum number of irreducible factors. Pins sites by bounding the factorization tree depth.",
      "title": "DepthConstraint"
    },
    "type/FlatType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1ConstrainedType"
        },
        {
          "type": "object"
        }
      ],
      "description": "A ConstrainedType whose HolonomyGroup is trivial — all closed constraint paths have identity monodromy. The constraint configuration is topologically flat: resolution is path-independent. This class is not addressable from a type-expr position in the term language; references from term-language positions are rejected by the resolver.",
      "title": "FlatType"
    },
    "type/ForbiddenSignature": {
      "description": "A topological signature (χ, β_k) that is formally impossible to achieve for any ConstrainedType. Witnessed by an ImpossibilityWitness in proof/.",
      "title": "ForbiddenSignature",
      "type": "object"
    },
    "type/GaloisConnection": {
      "description": "The adjunction between the type lattice and the site lattice. The upper adjoint is type closure; the lower adjoint is site interior. σ = lower adjoint evaluation; r = complement of upper adjoint image.",
      "properties": {
        "fixpointCondition": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "galoisClosureProperty": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "galoisInteriorProperty": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "lowerAdjoint": {
          "$ref": "#/$defs/schema~1TermExpression"
        },
        "refinementDirection": {
          "minimum": 0,
          "type": "integer"
        },
        "upperAdjoint": {
          "$ref": "#/$defs/schema~1TermExpression"
        }
      },
      "required": [
        "upperAdjoint",
        "lowerAdjoint",
        "fixpointCondition",
        "refinementDirection",
        "galoisClosureProperty",
        "galoisInteriorProperty"
      ],
      "title": "GaloisConnection",
      "type": "object"
    },
    "type/HammingConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "hammingBound": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "hammingBound"
          ],
          "type": "object"
        }
      ],
      "description": "Pins the Hamming weight of the Datum to at most the bound. The horizontal axis of the tri-metric.",
      "title": "HammingConstraint"
    },
    "type/HolonomyStratum": {
      "description": "A stratum indexed by a conjugacy class of subgroups of D_{2^n}.",
      "properties": {
        "stratumCodimension": {
          "minimum": 0,
          "type": "integer"
        },
        "stratumHolonomyClass": {
          "$ref": "#/$defs/observable~1MonodromyClass"
        },
        "stratumModuli": {
          "$ref": "#/$defs/type~1ModuliSpace"
        }
      },
      "required": [
        "stratumHolonomyClass",
        "stratumCodimension",
        "stratumModuli"
      ],
      "title": "HolonomyStratum",
      "type": "object"
    },
    "type/LiftChain": {
      "description": "An ordered composition of WittLift steps from liftSourceLevel (Q_j) to liftTargetLevel (Q_k) for any j < k. The canonical object certifying type completeness at arbitrary Q_k.",
      "properties": {
        "chainLength": {
          "minimum": 0,
          "type": "integer"
        },
        "chainObstructionProfile": {
          "$ref": "#/$defs/type~1ObstructionChain"
        },
        "chainStep": {
          "items": {
            "$ref": "#/$defs/type~1WittLift"
          },
          "type": "array"
        },
        "liftSourceLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        },
        "resolvedBasisSize": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "liftSourceLevel",
        "chainLength",
        "chainObstructionProfile",
        "resolvedBasisSize"
      ],
      "title": "LiftChain",
      "type": "object"
    },
    "type/LiftObstruction": {
      "description": "The algebraic obstruction to a WittLift inheriting the completeness of its base type. Computed as the image of the spectral sequence differential d_2. If trivial (zero), the base type's completeness lifts. If non-trivial, at least one additional constraint is needed at the new quantum level.",
      "properties": {
        "obstructionSite": {
          "$ref": "#/$defs/partition~1SiteIndex"
        },
        "obstructionTrivial": {
          "type": "boolean"
        }
      },
      "required": [
        "obstructionTrivial",
        "obstructionSite"
      ],
      "title": "LiftObstruction",
      "type": "object"
    },
    "type/MetricAxis": {
      "description": "A classification axis for constraints by their geometric effect. The three axes — vertical (ring/additive), horizontal (Hamming/bitwise), diagonal (incompatibility) — form the tri-metric coordinate system of UOR.",
      "enum": [
        "verticalAxis",
        "horizontalAxis",
        "diagonalAxis"
      ],
      "title": "MetricAxis"
    },
    "type/MinimalConstraintBasis": {
      "description": "The minimal set of constraints in the SynthesizedType's constraint set that is sufficient to realise the target topological signature. The minimality criterion is that removing any single member changes the realised signature.",
      "properties": {
        "basisConstraint": {
          "items": {
            "$ref": "#/$defs/type~1Constraint"
          },
          "type": "array"
        },
        "basisSize": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "basisSize"
      ],
      "title": "MinimalConstraintBasis",
      "type": "object"
    },
    "type/ModuliSpace": {
      "description": "The space of all CompleteTypes over R_n at a given quantum level.",
      "properties": {
        "moduliDimension": {
          "minimum": 0,
          "type": "integer"
        },
        "moduliPoint": {
          "items": {
            "$ref": "#/$defs/type~1CompleteType"
          },
          "type": "array"
        },
        "moduliWittLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "moduliWittLevel",
        "moduliDimension"
      ],
      "title": "ModuliSpace",
      "type": "object"
    },
    "type/ModuliTowerMap": {
      "description": "The map induced by WittLift from one moduli space to the next.",
      "properties": {
        "towerMapSource": {
          "$ref": "#/$defs/type~1ModuliSpace"
        }
      },
      "required": [
        "towerMapSource"
      ],
      "title": "ModuliTowerMap",
      "type": "object"
    },
    "type/ObstructionChain": {
      "description": "The complete ordered sequence of LiftObstruction records encountered and resolved along a LiftChain. An empty ObstructionChain means the tower is flat.",
      "properties": {
        "isFlat": {
          "type": "boolean"
        },
        "obstructionAt": {
          "items": {
            "$ref": "#/$defs/type~1LiftObstruction"
          },
          "type": "array"
        },
        "obstructionCount": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "obstructionCount",
        "isFlat"
      ],
      "title": "ObstructionChain",
      "type": "object"
    },
    "type/PrimitiveType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        {
          "properties": {
            "bitWidth": {
              "minimum": 1,
              "type": "integer"
            }
          },
          "required": [
            "bitWidth"
          ],
          "type": "object"
        }
      ],
      "description": "A primitive type defined by a fixed bit width. The carrier is the entire ring Z/(2^n)Z at the specified quantum level.",
      "title": "PrimitiveType"
    },
    "type/ProductType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        {
          "properties": {
            "component": {
              "items": {
                "$ref": "#/$defs/type~1TypeDefinition"
              },
              "type": "array"
            }
          },
          "type": "object"
        }
      ],
      "description": "A product (Cartesian) type formed from multiple component types. The carrier is the product of the component carriers.",
      "title": "ProductType"
    },
    "type/ResidueConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "modulus": {
              "minimum": 1,
              "type": "integer"
            },
            "residue": {
              "minimum": 0,
              "type": "integer"
            }
          },
          "required": [
            "modulus",
            "residue"
          ],
          "type": "object"
        }
      ],
      "description": "A constraint based on residue class membership: x ≡ r (mod m). Pins sites corresponding to the residue pattern.",
      "title": "ResidueConstraint"
    },
    "type/SiteConstraint": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1Constraint"
        },
        {
          "properties": {
            "siteIndex": {
              "minimum": 0,
              "type": "integer"
            },
            "siteValue": {
              "$ref": "#/$defs/schema~1Datum"
            }
          },
          "required": [
            "siteIndex",
            "siteValue"
          ],
          "type": "object"
        }
      ],
      "description": "Pins a single site coordinate to 0 or 1. The atomic unit of the site budget.",
      "title": "SiteConstraint"
    },
    "type/SubtypingLattice": {
      "description": "The partial order on types induced by TypeInclusion. The top element is PrimitiveType (no constraints); the bottom elements are CompleteTypes (all sites pinned).",
      "properties": {
        "latticeDepth": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "latticeDepth"
      ],
      "title": "SubtypingLattice",
      "type": "object"
    },
    "type/SumType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        {
          "type": "object"
        }
      ],
      "description": "A sum (disjoint union) type formed from multiple variant types. The carrier is the disjoint union of the variant carriers.",
      "title": "SumType"
    },
    "type/SuperposedSiteState": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1TypeDefinition"
        },
        {
          "properties": {
            "amplitude": {
              "type": "number"
            },
            "normalizationVerified": {
              "type": "boolean"
            }
          },
          "required": [
            "amplitude",
            "normalizationVerified"
          ],
          "type": "object"
        }
      ],
      "description": "A type representing a superposition of site states where sites carry complex amplitudes rather than binary pinned/free assignments. Ontological realisation of RC_5 (Amendment 32). This class is not addressable from a type-expr position in the term language; references from term-language positions are rejected by the resolver.",
      "title": "SuperposedSiteState"
    },
    "type/SynthesizedType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1ConstrainedType"
        },
        {
          "properties": {
            "synthesisResult": {
              "$ref": "#/$defs/type~1TypeSynthesisResult"
            }
          },
          "required": [
            "synthesisResult"
          ],
          "type": "object"
        }
      ],
      "description": "A ConstrainedType produced by the TypeSynthesisResolver. Distinguished from a hand-authored ConstrainedType by the presence of a type:synthesisResult link. May or may not be a CompleteType, depending on the synthesis goal. This class is not addressable from a type-expr position in the term language; references from term-language positions are rejected by the resolver.",
      "title": "SynthesizedType"
    },
    "type/TwistedType": {
      "allOf": [
        {
          "$ref": "#/$defs/type~1ConstrainedType"
        },
        {
          "type": "object"
        }
      ],
      "description": "A ConstrainedType whose HolonomyGroup is non-trivial — at least one closed constraint path produces a non-identity dihedral element. A TwistedType may still be a CompleteType (IT_7d is a homological, not holonomic, criterion), but its resolution paths require tracking dihedral accumulation. This class is not addressable from a type-expr position in the term language; references from term-language positions are rejected by the resolver.",
      "title": "TwistedType"
    },
    "type/TypeDefinition": {
      "description": "A runtime type declaration. The root class for all UOR types. Each TypeDefinition, when resolved, produces a partition of the ring at the specified quantum level.",
      "properties": {
        "contentAddress": {
          "$ref": "#/$defs/u~1Element"
        }
      },
      "required": [
        "contentAddress"
      ],
      "title": "TypeDefinition",
      "type": "object"
    },
    "type/TypeInclusion": {
      "allOf": [
        {
          "$ref": "#/$defs/morphism~1Transform"
        },
        {
          "properties": {
            "inclusionSource": {
              "$ref": "#/$defs/type~1ConstrainedType"
            },
            "inclusionTarget": {
              "$ref": "#/$defs/type~1ConstrainedType"
            },
            "inclusionWitness": {
              "type": "boolean"
            }
          },
          "required": [
            "inclusionSource",
            "inclusionTarget",
            "inclusionWitness"
          ],
          "type": "object"
        }
      ],
      "description": "A morphism T₁ → T₂ witnessing that T₁ is a subtype of T₂: the constraint set of T₁ is a superset of the constraint set of T₂.",
      "title": "TypeInclusion"
    },
    "type/TypeSynthesisGoal": {
      "description": "A specification of the desired topological properties of a type to be synthesised. Carries a target Euler characteristic (targetEulerCharacteristic) and a target Betti profile (zero or more targetBettiNumber assertions). The minimal goal for O(1) resolution is: targetEulerCharacteristic = n and all targetBettiNumber = 0 — the IT_7d profile.",
      "properties": {
        "targetBettiNumber": {
          "items": {
            "minimum": 0,
            "type": "integer"
          },
          "type": "array"
        },
        "targetEulerCharacteristic": {
          "type": "integer"
        },
        "targetForbidden": {
          "type": "boolean"
        }
      },
      "required": [
        "targetEulerCharacteristic",
        "targetForbidden"
      ],
      "title": "TypeSynthesisGoal",
      "type": "object"
    },
    "type/TypeSynthesisResult": {
      "description": "The output of a TypeSynthesisResolver run. Contains the SynthesizedType, the realised topological signature (as a SynthesisSignature), and the SynthesisTrace recording the construction steps.",
      "title": "TypeSynthesisResult",
      "type": "object"
    },
    "type/VarianceAnnotation": {
      "description": "The variance of a structural type position under operad composition. One of Covariant, Contravariant, Invariant, or Bivariant.",
      "enum": [
        "Covariant",
        "Contravariant",
        "Invariant",
        "Bivariant"
      ],
      "title": "VarianceAnnotation"
    },
    "type/VersalDeformation": {
      "description": "The versal deformation of a CompleteType T.",
      "properties": {
        "versalBase": {
          "$ref": "#/$defs/type~1CompleteType"
        },
        "versalDimension": {
          "minimum": 0,
          "type": "integer"
        }
      },
      "required": [
        "versalBase",
        "versalDimension"
      ],
      "title": "VersalDeformation",
      "type": "object"
    },
    "type/WittLift": {
      "description": "A ConstrainedType T' over R_{n+1} obtained by extending a ConstrainedType T over R_n. Carries a link to the base type (liftBase), the quantum level it lifts to (liftTargetLevel), and the LiftObstruction (if the lift fails to transfer completeness). A WittLift is a CompleteType iff its LiftObstruction is trivial.",
      "properties": {
        "liftBase": {
          "$ref": "#/$defs/type~1ConstrainedType"
        },
        "liftObstruction": {
          "$ref": "#/$defs/type~1LiftObstruction"
        },
        "liftTargetLevel": {
          "$ref": "#/$defs/schema~1WittLevel"
        }
      },
      "required": [
        "liftBase",
        "liftTargetLevel",
        "liftObstruction"
      ],
      "title": "WittLift",
      "type": "object"
    },
    "u/Element": {
      "description": "A content-addressable ring element. Each Element uniquely identifies a piece of content via its hash-derived identifier.",
      "properties": {
        "addresses": {
          "format": "iri",
          "type": "string"
        },
        "canonicalBytes": {
          "pattern": "^[0-9a-fA-F]*$",
          "type": "string"
        },
        "digest": {
          "type": "string"
        },
        "digestAlgorithm": {
          "type": "string"
        },
        "length": {
          "minimum": 0,
          "type": "integer"
        },
        "wittLength": {
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "length",
        "addresses",
        "digest",
        "digestAlgorithm",
        "canonicalBytes",
        "wittLength"
      ],
      "title": "Element",
      "type": "object"
    }
  },
  "$id": "https://uor.foundation/schema.json",
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "description": "JSON Schema for UOR Foundation v0.2.0. 441 classes, 892 properties, 3356 individuals.",
  "title": "UOR Foundation Ontology"
}