uor-foundation 0.4.5

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

//! `division/` namespace — The four normed division algebras R, C, H, O and the Cayley-Dickson construction..
//!
//! Space: Kernel

use crate::HostTypes;

/// An algebra over R that is a division ring with multiplicative norm. Exactly four exist (Hurwitz theorem): R, C, H, O.
pub trait NormedDivisionAlgebra<H: HostTypes> {
    /// The dimension of this division algebra (1, 2, 4, or 8).
    fn algebra_dimension(&self) -> u64;
    /// Whether multiplication in this algebra is commutative.
    fn is_commutative(&self) -> bool;
    /// Whether multiplication in this algebra is associative.
    fn is_associative(&self) -> bool;
    /// The basis elements of this division algebra.
    fn basis_elements(&self) -> &H::HostString;
    /// Associated type for `MultiplicationTable`.
    type MultiplicationTable: MultiplicationTable<H>;
    /// The multiplication table for this algebra.
    fn algebra_multiplication_table(&self) -> &Self::MultiplicationTable;
}

/// The doubling construction that builds each division algebra from the previous: R → C → H → O.
pub trait CayleyDicksonConstruction<H: HostTypes> {
    /// Associated type for `NormedDivisionAlgebra`.
    type NormedDivisionAlgebra: NormedDivisionAlgebra<H>;
    /// The source algebra of the Cayley-Dickson doubling.
    fn cayley_dickson_source(&self) -> &Self::NormedDivisionAlgebra;
    /// The target algebra of the Cayley-Dickson doubling.
    fn cayley_dickson_target(&self) -> &Self::NormedDivisionAlgebra;
    /// The new basis element adjoined by this doubling step.
    fn adjoined_element(&self) -> &H::HostString;
    /// The conjugation and multiplication rule for the adjoined element.
    fn conjugation_rule(&self) -> &H::HostString;
}

/// The explicit product rules for a division algebra’s basis elements.
pub trait MultiplicationTable<H: HostTypes> {}

/// The commutator \[a,b\] = ab − ba. Zero for R and C; non-zero for H and O.
pub trait AlgebraCommutator<H: HostTypes> {}

/// The associator \[a,b,c\] = (ab)c − a(bc). Zero for R, C, H; non-zero for O.
pub trait AlgebraAssociator<H: HostTypes> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `NormedDivisionAlgebra<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullNormedDivisionAlgebra<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullNormedDivisionAlgebra<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullNormedDivisionAlgebra<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullNormedDivisionAlgebra<H> = NullNormedDivisionAlgebra {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> NormedDivisionAlgebra<H> for NullNormedDivisionAlgebra<H> {
    fn algebra_dimension(&self) -> u64 {
        0
    }
    fn is_commutative(&self) -> bool {
        false
    }
    fn is_associative(&self) -> bool {
        false
    }
    fn basis_elements(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    type MultiplicationTable = NullMultiplicationTable<H>;
    fn algebra_multiplication_table(&self) -> &Self::MultiplicationTable {
        &<NullMultiplicationTable<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `CayleyDicksonConstruction<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullCayleyDicksonConstruction<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCayleyDicksonConstruction<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCayleyDicksonConstruction<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCayleyDicksonConstruction<H> = NullCayleyDicksonConstruction {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CayleyDicksonConstruction<H> for NullCayleyDicksonConstruction<H> {
    type NormedDivisionAlgebra = NullNormedDivisionAlgebra<H>;
    fn cayley_dickson_source(&self) -> &Self::NormedDivisionAlgebra {
        &<NullNormedDivisionAlgebra<H>>::ABSENT
    }
    fn cayley_dickson_target(&self) -> &Self::NormedDivisionAlgebra {
        &<NullNormedDivisionAlgebra<H>>::ABSENT
    }
    fn adjoined_element(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
    fn conjugation_rule(&self) -> &H::HostString {
        H::EMPTY_HOST_STRING
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `MultiplicationTable<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullMultiplicationTable<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullMultiplicationTable<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullMultiplicationTable<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullMultiplicationTable<H> = NullMultiplicationTable {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> MultiplicationTable<H> for NullMultiplicationTable<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `AlgebraCommutator<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullAlgebraCommutator<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullAlgebraCommutator<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullAlgebraCommutator<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullAlgebraCommutator<H> = NullAlgebraCommutator {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> AlgebraCommutator<H> for NullAlgebraCommutator<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `AlgebraAssociator<H>`.
/// Every accessor returns `H::EMPTY_*` sentinels (for scalar / host-typed
/// returns) or a `'static`-lifetime reference to a sibling `Null*`'s `ABSENT`
/// const (for trait-typed returns).  Downstream provides concrete impls;
/// this stub closes the ontology-derived trait orphan.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullAlgebraAssociator<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullAlgebraAssociator<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullAlgebraAssociator<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullAlgebraAssociator<H> = NullAlgebraAssociator {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> AlgebraAssociator<H> for NullAlgebraAssociator<H> {}

/// Phase 8 (orphan-closure) — content-addressed handle for `NormedDivisionAlgebra<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct NormedDivisionAlgebraHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for NormedDivisionAlgebraHandle<H> {}
impl<H: HostTypes> Clone for NormedDivisionAlgebraHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for NormedDivisionAlgebraHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for NormedDivisionAlgebraHandle<H> {}
impl<H: HostTypes> core::hash::Hash for NormedDivisionAlgebraHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> NormedDivisionAlgebraHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `NormedDivisionAlgebra<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait NormedDivisionAlgebraResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(
        &self,
        handle: NormedDivisionAlgebraHandle<H>,
    ) -> Option<NormedDivisionAlgebraRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `NormedDivisionAlgebra<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct NormedDivisionAlgebraRecord<H: HostTypes> {
    pub algebra_dimension: u64,
    pub is_commutative: bool,
    pub is_associative: bool,
    pub basis_elements: &'static H::HostString,
    pub algebra_multiplication_table_handle: MultiplicationTableHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `NormedDivisionAlgebra<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedNormedDivisionAlgebra<'r, R: NormedDivisionAlgebraResolver<H>, H: HostTypes> {
    handle: NormedDivisionAlgebraHandle<H>,
    resolver: &'r R,
    record: Option<NormedDivisionAlgebraRecord<H>>,
}
impl<'r, R: NormedDivisionAlgebraResolver<H>, H: HostTypes>
    ResolvedNormedDivisionAlgebra<'r, R, H>
{
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: NormedDivisionAlgebraHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> NormedDivisionAlgebraHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&NormedDivisionAlgebraRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: NormedDivisionAlgebraResolver<H>, H: HostTypes> NormedDivisionAlgebra<H>
    for ResolvedNormedDivisionAlgebra<'r, R, H>
{
    fn algebra_dimension(&self) -> u64 {
        match &self.record {
            Some(r) => r.algebra_dimension,
            None => 0,
        }
    }
    fn is_commutative(&self) -> bool {
        match &self.record {
            Some(r) => r.is_commutative,
            None => false,
        }
    }
    fn is_associative(&self) -> bool {
        match &self.record {
            Some(r) => r.is_associative,
            None => false,
        }
    }
    fn basis_elements(&self) -> &H::HostString {
        match &self.record {
            Some(r) => r.basis_elements,
            None => H::EMPTY_HOST_STRING,
        }
    }
    type MultiplicationTable = NullMultiplicationTable<H>;
    fn algebra_multiplication_table(&self) -> &Self::MultiplicationTable {
        &<NullMultiplicationTable<H>>::ABSENT
    }
}
impl<'r, R: NormedDivisionAlgebraResolver<H>, H: HostTypes>
    ResolvedNormedDivisionAlgebra<'r, R, H>
{
    /// Promote the `algebra_multiplication_table` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_algebra_multiplication_table<'r2, R2: MultiplicationTableResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedMultiplicationTable<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedMultiplicationTable::new(
            record.algebra_multiplication_table_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `CayleyDicksonConstruction<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct CayleyDicksonConstructionHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for CayleyDicksonConstructionHandle<H> {}
impl<H: HostTypes> Clone for CayleyDicksonConstructionHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for CayleyDicksonConstructionHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for CayleyDicksonConstructionHandle<H> {}
impl<H: HostTypes> core::hash::Hash for CayleyDicksonConstructionHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> CayleyDicksonConstructionHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `CayleyDicksonConstruction<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait CayleyDicksonConstructionResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(
        &self,
        handle: CayleyDicksonConstructionHandle<H>,
    ) -> Option<CayleyDicksonConstructionRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `CayleyDicksonConstruction<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct CayleyDicksonConstructionRecord<H: HostTypes> {
    pub cayley_dickson_source_handle: NormedDivisionAlgebraHandle<H>,
    pub cayley_dickson_target_handle: NormedDivisionAlgebraHandle<H>,
    pub adjoined_element: &'static H::HostString,
    pub conjugation_rule: &'static H::HostString,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CayleyDicksonConstruction<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedCayleyDicksonConstruction<
    'r,
    R: CayleyDicksonConstructionResolver<H>,
    H: HostTypes,
> {
    handle: CayleyDicksonConstructionHandle<H>,
    resolver: &'r R,
    record: Option<CayleyDicksonConstructionRecord<H>>,
}
impl<'r, R: CayleyDicksonConstructionResolver<H>, H: HostTypes>
    ResolvedCayleyDicksonConstruction<'r, R, H>
{
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CayleyDicksonConstructionHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> CayleyDicksonConstructionHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&CayleyDicksonConstructionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CayleyDicksonConstructionResolver<H>, H: HostTypes> CayleyDicksonConstruction<H>
    for ResolvedCayleyDicksonConstruction<'r, R, H>
{
    type NormedDivisionAlgebra = NullNormedDivisionAlgebra<H>;
    fn cayley_dickson_source(&self) -> &Self::NormedDivisionAlgebra {
        &<NullNormedDivisionAlgebra<H>>::ABSENT
    }
    fn cayley_dickson_target(&self) -> &Self::NormedDivisionAlgebra {
        &<NullNormedDivisionAlgebra<H>>::ABSENT
    }
    fn adjoined_element(&self) -> &H::HostString {
        match &self.record {
            Some(r) => r.adjoined_element,
            None => H::EMPTY_HOST_STRING,
        }
    }
    fn conjugation_rule(&self) -> &H::HostString {
        match &self.record {
            Some(r) => r.conjugation_rule,
            None => H::EMPTY_HOST_STRING,
        }
    }
}
impl<'r, R: CayleyDicksonConstructionResolver<H>, H: HostTypes>
    ResolvedCayleyDicksonConstruction<'r, R, H>
{
    /// Promote the `cayley_dickson_source` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_cayley_dickson_source<'r2, R2: NormedDivisionAlgebraResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedNormedDivisionAlgebra<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedNormedDivisionAlgebra::new(
            record.cayley_dickson_source_handle,
            r,
        ))
    }
    /// Promote the `cayley_dickson_target` handle on the cached record into a
    /// resolved wrapper, given a resolver for the range class.
    /// Returns `None` if no record was resolved at construction.
    #[inline]
    pub fn resolve_cayley_dickson_target<'r2, R2: NormedDivisionAlgebraResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedNormedDivisionAlgebra<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedNormedDivisionAlgebra::new(
            record.cayley_dickson_target_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `MultiplicationTable<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct MultiplicationTableHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for MultiplicationTableHandle<H> {}
impl<H: HostTypes> Clone for MultiplicationTableHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for MultiplicationTableHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for MultiplicationTableHandle<H> {}
impl<H: HostTypes> core::hash::Hash for MultiplicationTableHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> MultiplicationTableHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `MultiplicationTable<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait MultiplicationTableResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: MultiplicationTableHandle<H>)
        -> Option<MultiplicationTableRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `MultiplicationTable<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct MultiplicationTableRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `MultiplicationTable<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedMultiplicationTable<'r, R: MultiplicationTableResolver<H>, H: HostTypes> {
    handle: MultiplicationTableHandle<H>,
    resolver: &'r R,
    record: Option<MultiplicationTableRecord<H>>,
}
impl<'r, R: MultiplicationTableResolver<H>, H: HostTypes> ResolvedMultiplicationTable<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: MultiplicationTableHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> MultiplicationTableHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&MultiplicationTableRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: MultiplicationTableResolver<H>, H: HostTypes> MultiplicationTable<H>
    for ResolvedMultiplicationTable<'r, R, H>
{
}

/// Phase 8 (orphan-closure) — content-addressed handle for `AlgebraCommutator<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct AlgebraCommutatorHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for AlgebraCommutatorHandle<H> {}
impl<H: HostTypes> Clone for AlgebraCommutatorHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for AlgebraCommutatorHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for AlgebraCommutatorHandle<H> {}
impl<H: HostTypes> core::hash::Hash for AlgebraCommutatorHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> AlgebraCommutatorHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `AlgebraCommutator<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait AlgebraCommutatorResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: AlgebraCommutatorHandle<H>) -> Option<AlgebraCommutatorRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `AlgebraCommutator<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct AlgebraCommutatorRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `AlgebraCommutator<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedAlgebraCommutator<'r, R: AlgebraCommutatorResolver<H>, H: HostTypes> {
    handle: AlgebraCommutatorHandle<H>,
    resolver: &'r R,
    record: Option<AlgebraCommutatorRecord<H>>,
}
impl<'r, R: AlgebraCommutatorResolver<H>, H: HostTypes> ResolvedAlgebraCommutator<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: AlgebraCommutatorHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> AlgebraCommutatorHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&AlgebraCommutatorRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: AlgebraCommutatorResolver<H>, H: HostTypes> AlgebraCommutator<H>
    for ResolvedAlgebraCommutator<'r, R, H>
{
}

/// Phase 8 (orphan-closure) — content-addressed handle for `AlgebraAssociator<H>`.
///
/// Pairs a [`crate::enforcement::ContentFingerprint`] with a phantom
/// `H` so type-state checks can't mix handles across `HostTypes` impls.
#[derive(Debug)]
pub struct AlgebraAssociatorHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for AlgebraAssociatorHandle<H> {}
impl<H: HostTypes> Clone for AlgebraAssociatorHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for AlgebraAssociatorHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for AlgebraAssociatorHandle<H> {}
impl<H: HostTypes> core::hash::Hash for AlgebraAssociatorHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> AlgebraAssociatorHandle<H> {
    /// Construct a handle from its content fingerprint.
    #[inline]
    #[must_use]
    pub const fn new(fingerprint: crate::enforcement::ContentFingerprint) -> Self {
        Self {
            fingerprint,
            _phantom: core::marker::PhantomData,
        }
    }
}

/// Phase 8 (orphan-closure) — resolver trait for `AlgebraAssociator<H>`.
///
/// Hosts implement this trait to map a handle into a typed record.
/// The default Null stub does not implement this trait — it carries
/// no record. Resolution is the responsibility of the host pipeline.
pub trait AlgebraAssociatorResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: AlgebraAssociatorHandle<H>) -> Option<AlgebraAssociatorRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `AlgebraAssociator<H>`.
///
/// Carries a field per functional accessor of the trait. Object
/// fields hold `{Range}Handle<H>`; iterate via the Resolved wrapper
/// chain-resolver methods.
#[derive(Clone, Debug, PartialEq, Eq, Hash)]
pub struct AlgebraAssociatorRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `AlgebraAssociator<H>`.
///
/// Caches the resolver's lookup at construction. Accessors return
/// the cached record's fields when present, falling back to the
/// `Null{Class}<H>` absent sentinels when the resolver returned
/// `None`. Object accessors always return absent sentinels — use
/// the `resolve_{m}` chain methods to descend into sub-records.
pub struct ResolvedAlgebraAssociator<'r, R: AlgebraAssociatorResolver<H>, H: HostTypes> {
    handle: AlgebraAssociatorHandle<H>,
    resolver: &'r R,
    record: Option<AlgebraAssociatorRecord<H>>,
}
impl<'r, R: AlgebraAssociatorResolver<H>, H: HostTypes> ResolvedAlgebraAssociator<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: AlgebraAssociatorHandle<H>, resolver: &'r R) -> Self {
        let record = resolver.resolve(handle);
        Self {
            handle,
            resolver,
            record,
        }
    }
    /// The handle this wrapper resolves.
    #[inline]
    #[must_use]
    pub const fn handle(&self) -> AlgebraAssociatorHandle<H> {
        self.handle
    }
    /// The resolver supplied at construction.
    #[inline]
    #[must_use]
    pub const fn resolver(&self) -> &'r R {
        self.resolver
    }
    /// The cached record, or `None` when the resolver returned `None`.
    #[inline]
    #[must_use]
    pub const fn record(&self) -> Option<&AlgebraAssociatorRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: AlgebraAssociatorResolver<H>, H: HostTypes> AlgebraAssociator<H>
    for ResolvedAlgebraAssociator<'r, R, H>
{
}

/// The real numbers R: dimension 1, commutative, associative.
pub mod real_algebra {
    /// `algebraDimension`
    pub const ALGEBRA_DIMENSION: i64 = 1;
    /// `basisElements`
    pub const BASIS_ELEMENTS: &str = "{1}";
    /// `isAssociative`
    pub const IS_ASSOCIATIVE: bool = true;
    /// `isCommutative`
    pub const IS_COMMUTATIVE: bool = true;
}

/// The complex numbers C: dimension 2, commutative, associative.
pub mod complex_algebra {
    /// `algebraDimension`
    pub const ALGEBRA_DIMENSION: i64 = 2;
    /// `basisElements`
    pub const BASIS_ELEMENTS: &str = "{1, i}";
    /// `isAssociative`
    pub const IS_ASSOCIATIVE: bool = true;
    /// `isCommutative`
    pub const IS_COMMUTATIVE: bool = true;
}

/// The quaternions H: dimension 4, non-commutative, associative.
pub mod quaternion_algebra {
    /// `algebraDimension`
    pub const ALGEBRA_DIMENSION: i64 = 4;
    /// `basisElements`
    pub const BASIS_ELEMENTS: &str = "{1, i, j, k}";
    /// `isAssociative`
    pub const IS_ASSOCIATIVE: bool = true;
    /// `isCommutative`
    pub const IS_COMMUTATIVE: bool = false;
}

/// The octonions O: dimension 8, non-commutative, non-associative.
pub mod octonion_algebra {
    /// `algebraDimension`
    pub const ALGEBRA_DIMENSION: i64 = 8;
    /// `basisElements`
    pub const BASIS_ELEMENTS: &str = "{1, i, j, k, l, il, jl, kl}";
    /// `isAssociative`
    pub const IS_ASSOCIATIVE: bool = false;
    /// `isCommutative`
    pub const IS_COMMUTATIVE: bool = false;
}

/// Cayley-Dickson doubling R → C: adjoin i with i² = −1.
pub mod cayley_dickson_r_to_c {
    /// `adjoinedElement`
    pub const ADJOINED_ELEMENT: &str = "i";
    /// `cayleyDicksonSource` -> `RealAlgebra`
    pub const CAYLEY_DICKSON_SOURCE: &str = "https://uor.foundation/division/RealAlgebra";
    /// `cayleyDicksonTarget` -> `ComplexAlgebra`
    pub const CAYLEY_DICKSON_TARGET: &str = "https://uor.foundation/division/ComplexAlgebra";
    /// `conjugationRule`
    pub const CONJUGATION_RULE: &str = "i² = −1";
}

/// Cayley-Dickson doubling C → H: adjoin j with j² = −1, ij = k, ji = −k.
pub mod cayley_dickson_c_to_h {
    /// `adjoinedElement`
    pub const ADJOINED_ELEMENT: &str = "j";
    /// `cayleyDicksonSource` -> `ComplexAlgebra`
    pub const CAYLEY_DICKSON_SOURCE: &str = "https://uor.foundation/division/ComplexAlgebra";
    /// `cayleyDicksonTarget` -> `QuaternionAlgebra`
    pub const CAYLEY_DICKSON_TARGET: &str = "https://uor.foundation/division/QuaternionAlgebra";
    /// `conjugationRule`
    pub const CONJUGATION_RULE: &str = "ij = k, ji = −k";
}

/// Cayley-Dickson doubling H → O: adjoin l, non-associative Fano plane products.
pub mod cayley_dickson_h_to_o {
    /// `adjoinedElement`
    pub const ADJOINED_ELEMENT: &str = "l";
    /// `cayleyDicksonSource` -> `QuaternionAlgebra`
    pub const CAYLEY_DICKSON_SOURCE: &str = "https://uor.foundation/division/QuaternionAlgebra";
    /// `cayleyDicksonTarget` -> `OctonionAlgebra`
    pub const CAYLEY_DICKSON_TARGET: &str = "https://uor.foundation/division/OctonionAlgebra";
    /// `conjugationRule`
    pub const CONJUGATION_RULE: &str = "non-associative Fano plane products";
}