uor-foundation 0.1.5

// @generated by uor-crate from uor-ontology — do not edit manually

//! `morphism/` namespace — Runtime abstractions for maps between UOR objects: transforms, isometries, embeddings, and group actions. The foundation provides the vocabulary; Prism writes the sentences..
//!
//! Space: User

use crate::Primitives;

/// A map between UOR objects. The root abstraction: source, target, and optionally what structure (if any) is preserved. This is what cert:TransformCertificate certifies.
/// Disjoint with: CompositionLaw.
pub trait Transform<P: Primitives> {
    /// The domain of the transform.
    fn source(&self) -> &P::String;
    /// The codomain of the transform.
    fn target(&self) -> &P::String;
    /// The structure preserved by this transform (if any). E.g., a ring homomorphism preserves addition and multiplication.
    fn preserves_count(&self) -> usize;
    /// Returns the item at `index`. Must satisfy `index < self.preserves_count()`.
    fn preserves_at(&self, index: usize) -> &P::String;
    /// Associated type for `ComputationTrace`.
    type ComputationTrace: crate::bridge::trace::ComputationTrace<P>;
    /// The computation trace that realized this transform at runtime. A Transform is an abstraction; a trace is the kernel's record of how it was executed via concrete operations.
    fn trace(&self) -> &Self::ComputationTrace;
    /// Associated type for `Transform`.
    type TransformTarget: Transform<P>;
    /// A transform that this transform can be composed with. The target of this transform must match the source of the composed transform.
    fn composes_with(&self) -> &[Self::TransformTarget];
    /// Associated type for `Identity`.
    type Identity: crate::kernel::op::Identity<P>;
    /// The identity preserved by this transform (reference to the op:Identity that the transform commutes with).
    fn preserved_invariant(&self) -> &Self::Identity;
    /// The OWL class of inputs this transform accepts. Uses OWL2 punning so the value is a class IRI treated as an individual at this position.
    fn input_class(&self) -> &P::String;
    /// The OWL class of outputs this transform produces. Uses OWL2 punning.
    fn output_class(&self) -> &P::String;
    /// Associated type for `Witness`.
    type Witness: Witness<P>;
    /// Zero or more witness pairs documenting specific input/output bindings of this transform.
    fn has_witness(&self) -> &[Self::Witness];
}

/// 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.
/// Disjoint with: Composition.
pub trait Isometry<P: Primitives>: Transform<P> {
    /// Associated type for `MetricObservable`.
    type MetricObservable: crate::bridge::observable::MetricObservable<P>;
    /// The specific metric this isometry preserves. Points to observable:RingMetric or observable:HammingMetric. A transform that preserves both is an isometry of the full UOR geometry. A transform that preserves one but not the other has nontrivial curvature — observable:CurvatureObservable measures this gap.
    fn preserves_metric(&self) -> &[Self::MetricObservable];
}

/// 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.
/// Disjoint with: Composition.
pub trait Embedding<P: Primitives>: Transform<P> {
    /// The quantum level n of the source ring for an embedding.
    fn source_quantum(&self) -> P::PositiveInteger;
    /// The quantum level n' of the target ring for an embedding. Must satisfy n' > n (embeddings go to larger rings).
    fn target_quantum(&self) -> P::PositiveInteger;
    /// Certificate that this embedding's addressing diagram commutes: glyph ∘ ι ∘ addresses is well-defined and injective.
    fn address_coherence(&self) -> &Self::Identity;
}

/// 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.
pub trait Action<P: Primitives> {
    /// Associated type for `Group`.
    type Group: crate::kernel::op::Group<P>;
    /// The group acting in this group action.
    fn group(&self) -> &Self::Group;
    /// The set being acted upon by this group action.
    fn acting_on(&self) -> &P::String;
    /// Whether every transform induced by this action is an isometry. True for the dihedral action on 𝒯_n (Frame Theorem).
    fn action_isometry(&self) -> P::Boolean;
}

/// A transform formed by composing two or more transforms sequentially. The categorical composition operation that turns transforms into a category.
/// Disjoint with: Isometry, Embedding, Identity.
pub trait Composition<P: Primitives>: Transform<P> {
    /// Associated type for `Transform`.
    type Transform: Transform<P>;
    /// The transform that results from this composition.
    fn composition_result(&self) -> &Self::Transform;
    /// A component transform of this composition.
    fn composition_components(&self) -> &[Self::Transform];
}

/// The identity transform on a type: maps every element to itself. The categorical identity morphism.
/// Disjoint with: Composition.
pub trait Identity<P: Primitives>: Transform<P> {
    /// Associated type for `TypeDefinition`.
    type TypeDefinition: crate::user::type_::TypeDefinition<P>;
    /// The type on which this identity transform acts.
    fn identity_on(&self) -> &Self::TypeDefinition;
}

/// 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.
/// Disjoint with: Transform.
pub trait CompositionLaw<P: Primitives> {
    /// Whether this composition law is associative.
    fn is_associative(&self) -> P::Boolean;
    /// Whether this composition law is commutative.
    fn is_commutative(&self) -> P::Boolean;
    /// Associated type for `Operation`.
    type Operation: crate::kernel::op::Operation<P>;
    /// An operation that is a component of this composition law.
    fn law_components(&self) -> &[Self::Operation];
    /// The operation that results from this composition law.
    fn law_result(&self) -> &Self::Operation;
}

/// 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.
/// Disjoint with: ProjectionMap.
pub trait GroundingMap<P: Primitives>: Transform<P> {
    /// Associated type for `Derivation`.
    type Derivation: crate::bridge::derivation::Derivation<P>;
    /// The derivation witnessing the content-addressing computation that produced the grounded address from the surface symbol.
    fn grounding_derivation(&self) -> &Self::Derivation;
    /// Associated type for `Constraint`.
    type Constraint: crate::user::type_::Constraint<P>;
    /// A typed attribute preserved by this grounding. Non-functional: one assertion per active constraint axis (vertical, horizontal, diagonal).
    fn symbol_constraints(&self) -> &[Self::Constraint];
}

/// 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.
/// Disjoint with: GroundingMap.
pub trait ProjectionMap<P: Primitives>: Transform<P> {
    /// Associated type for `Frame`.
    type Frame: crate::user::state::Frame<P>;
    /// The active frame — shared with the grounding that produced the query. The shared-frame condition (Surface Symmetry Theorem) requires G and P to reference the same frame.
    fn projection_frame(&self) -> &Self::Frame;
    /// Associated type for `CompositeConstraint`.
    type CompositeConstraint: crate::user::type_::CompositeConstraint<P>;
    /// Ordering constraint determining the output symbol sequence. Domain-specific: syntactic position (NLP), row-major scan (ARC), temporal sequence (music).
    fn projection_order(&self) -> &Self::CompositeConstraint;
    /// Completeness criterion: does projecting the grounded source address recover a symbol in the same type class as the input? True iff the shared-frame condition holds.
    fn round_trip_coherence(&self) -> P::Boolean;
    /// When outputClass is a sequence type, the OWL class of individual sequence elements. Uses OWL2 punning.
    fn output_element_class(&self) -> &P::String;
}

/// 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.
pub trait GroundingCertificate<P: Primitives>: crate::bridge::cert::Certificate<P> {
    /// Associated type for `GroundingMap`.
    type GroundingMap: GroundingMap<P>;
    /// The GroundingMap used in this certified round-trip.
    fn grounding_cert_map(&self) -> &Self::GroundingMap;
    /// Associated type for `ProjectionMap`.
    type ProjectionMap: ProjectionMap<P>;
    /// The ProjectionMap used in this certified round-trip.
    fn grounding_cert_projection(&self) -> &Self::ProjectionMap;
    /// Associated type for `Literal`.
    type Literal: crate::kernel::schema::Literal<P>;
    /// The surface symbol that entered the grounding boundary.
    fn grounding_cert_source_symbol(&self) -> &Self::Literal;
    /// Associated type for `Address`.
    type Address: crate::kernel::address::Address<P>;
    /// The ring address the symbol was grounded to.
    fn grounding_cert_address(&self) -> &Self::Address;
}

/// A topological delta: records changes in topological invariants (Betti numbers, Euler characteristic, nerve structure) before and after a morphism.
pub trait TopologicalDelta<P: Primitives> {
    /// Associated type for `BettiNumber`.
    type BettiNumber: crate::bridge::observable::BettiNumber<P>;
    /// Betti numbers before the morphism.
    fn bettis_before(&self) -> &Self::BettiNumber;
    /// Betti numbers after the morphism.
    fn bettis_after(&self) -> &Self::BettiNumber;
    /// Euler characteristic before the morphism.
    fn euler_before(&self) -> P::Integer;
    /// Euler characteristic after the morphism.
    fn euler_after(&self) -> P::Integer;
    /// Associated type for `SimplicialComplex`.
    type SimplicialComplex: crate::bridge::homology::SimplicialComplex<P>;
    /// Constraint nerve (simplicial complex) before the morphism.
    fn nerve_before(&self) -> &Self::SimplicialComplex;
    /// Constraint nerve (simplicial complex) after the morphism.
    fn nerve_after(&self) -> &Self::SimplicialComplex;
}

/// 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.
pub trait ComputationDatum<P: Primitives>: crate::kernel::schema::Datum<P> {
    /// Associated type for `TransformCertificate`.
    type TransformCertificate: crate::bridge::cert::TransformCertificate<P>;
    /// The certificate this computation datum encodes.
    fn referenced_certificate(&self) -> &Self::TransformCertificate;
    /// The content address of the referenced certificate.
    fn computation_address(&self) -> &Self::Address;
}

/// A transform that applies a ComputationDatum to an input datum, producing an output datum. The output inherits the certificate of the ComputationDatum.
pub trait ApplicationMorphism<P: Primitives>: Transform<P> {
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: ComputationDatum<P>;
    /// The computation being applied.
    fn application_target(&self) -> &Self::ComputationDatum;
    /// Associated type for `Datum`.
    type Datum: crate::kernel::schema::Datum<P>;
    /// The input datum to the application.
    fn application_input(&self) -> &Self::Datum;
}

/// A ComputationDatum formed by fixing some but not all inputs of a multi-argument transform.
pub trait PartialApplication<P: Primitives>: ComputationDatum<P> {
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: ComputationDatum<P>;
    /// The base computation being partially applied.
    fn partial_base(&self) -> &Self::ComputationDatum;
    /// Associated type for `Datum`.
    type Datum: crate::kernel::schema::Datum<P>;
    /// The arguments already bound.
    fn bound_arguments(&self) -> &[Self::Datum];
    /// Number of unbound arguments remaining.
    fn remaining_arity(&self) -> P::PositiveInteger;
}

/// A ComputationDatum representing the composition f ∘ g of two ComputationDatums. Certified iff both components are certified and range(g) = domain(f).
pub trait TransformComposition<P: Primitives>: ComputationDatum<P> {
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: ComputationDatum<P>;
    /// The outer function f in f ∘ g.
    fn composition_left(&self) -> &Self::ComputationDatum;
    /// The inner function g in f ∘ g.
    fn composition_right(&self) -> &Self::ComputationDatum;
}

/// Abstract supertype for one specific input/output pair witnessing a Transform.
pub trait Witness<P: Primitives> {}

/// One specific surface symbol mapped to one specific grounded address by some GroundingMap.
/// Disjoint with: ProjectionWitness.
pub trait GroundingWitness<P: Primitives>: Witness<P> {
    /// Associated type for `SurfaceSymbol`.
    type SurfaceSymbol: crate::kernel::schema::SurfaceSymbol<P>;
    /// The surface symbol that is the source of this grounding witness.
    fn surface_symbol(&self) -> &Self::SurfaceSymbol;
    /// Associated type for `Address`.
    type Address: crate::kernel::address::Address<P>;
    /// The resolved ring address that is the target of this grounding witness.
    fn grounded_address(&self) -> &Self::Address;
}

/// One specific input partition mapped to one specific surface symbol sequence by some ProjectionMap.
/// Disjoint with: GroundingWitness.
pub trait ProjectionWitness<P: Primitives>: Witness<P> {
    /// Associated type for `Partition`.
    type Partition: crate::bridge::partition::Partition<P>;
    /// The resolved partition (address neighbourhood) that this projection witness projects back to surface symbols.
    fn projection_source(&self) -> &Self::Partition;
    /// Associated type for `SymbolSequence`.
    type SymbolSequence: SymbolSequence<P>;
    /// The single SymbolSequence produced by this projection witness.
    fn projection_output(&self) -> &Self::SymbolSequence;
}

/// An ordered sequence of surface symbols. Elements are reified as SequenceElement individuals with explicit position indices.
pub trait SymbolSequence<P: Primitives> {
    /// Associated type for `SequenceElement`.
    type SequenceElement: SequenceElement<P>;
    /// Membership of a SymbolSequence. The sequence is reconstructed by sorting elements by elementIndex.
    fn has_element(&self) -> &[Self::SequenceElement];
}

/// One position in a SymbolSequence: a reified (value, index) pair.
pub trait SequenceElement<P: Primitives> {
    /// Associated type for `SurfaceSymbol`.
    type SurfaceSymbol: crate::kernel::schema::SurfaceSymbol<P>;
    /// The surface symbol value of this sequence element.
    fn element_value(&self) -> &Self::SurfaceSymbol;
    /// The zero-based position of this element in the sequence.
    fn element_index(&self) -> P::NonNegativeInteger;
}

/// The critical composition law: neg ∘ bnot = succ. This is the operational form of the critical identity theorem. The composition of the two involutions (neg, bnot) yields the successor operation. Non-associative and non-commutative.
pub mod critical_composition {
    /// `isAssociative`
    pub const IS_ASSOCIATIVE: bool = false;
    /// `isCommutative`
    pub const IS_COMMUTATIVE: bool = false;
    /// `lawComponents`
    pub const LAW_COMPONENTS: &[&str] = &[
        "https://uor.foundation/op/neg",
        "https://uor.foundation/op/bnot",
    ];
    /// `lawResult` -> `succ`
    pub const LAW_RESULT: &str = "https://uor.foundation/op/succ";
}

/// Grounds integer surface symbols to ring addresses.
pub mod integer_grounding_map {
    /// `inputClass` -> `Literal`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/Literal";
    /// `outputClass` -> `Address`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Address";
}

/// Grounds UTF-8 host strings to ring addresses.
pub mod utf8_grounding_map {
    /// `inputClass` -> `HostStringLiteral`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
    /// `outputClass` -> `Address`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Address";
}

/// Grounds JSON host strings to ring addresses.
pub mod json_grounding_map {
    /// `inputClass` -> `HostStringLiteral`
    pub const INPUT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
    /// `outputClass` -> `Address`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/u/Address";
}

/// Projects partitions to integer symbol sequences.
pub mod integer_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `Literal`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/Literal";
}

/// Projects partitions to UTF-8 symbol sequences.
pub mod utf8_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `HostStringLiteral`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
}

/// Projects partitions to JSON symbol sequences.
pub mod json_projection_map {
    /// `inputClass` -> `Partition`
    pub const INPUT_CLASS: &str = "https://uor.foundation/partition/Partition";
    /// `outputClass` -> `SymbolSequence`
    pub const OUTPUT_CLASS: &str = "https://uor.foundation/morphism/SymbolSequence";
    /// `outputElementClass` -> `HostStringLiteral`
    pub const OUTPUT_ELEMENT_CLASS: &str = "https://uor.foundation/schema/HostStringLiteral";
}