uor-foundation 0.3.3

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

//! `cohomology/` namespace — Cochain complexes, sheaf cohomology, and local-to-global obstruction detection..
//!
//! Space: Bridge

use crate::HostTypes;

/// A cochain group: the dual of a chain group, maps chains to coefficients.
pub trait CochainGroup<H: HostTypes> {
    /// The degree k of this cochain group C^k.
    fn cochain_degree(&self) -> i64;
    /// The rank (dimension) of this cochain group.
    fn cochain_rank(&self) -> u64;
    /// Associated type for `ChainGroup`.
    type ChainGroup: crate::bridge::homology::ChainGroup<H>;
    /// The chain group that this cochain group is dual to.
    fn dual_of(&self) -> &Self::ChainGroup;
}

/// The coboundary operator δ^k: C^k → C^{k+1}. Satisfies δ² = 0.
pub trait CoboundaryOperator<H: HostTypes> {
    /// Associated type for `CochainGroup`.
    type CochainGroup: CochainGroup<H>;
    /// The source cochain group of this coboundary operator.
    fn coboundary_source(&self) -> &Self::CochainGroup;
    /// The target cochain group of this coboundary operator.
    fn coboundary_target(&self) -> &Self::CochainGroup;
    /// Whether this coboundary operator satisfies δ² = 0.
    fn satisfies_coboundary_squared_zero(&self) -> bool;
}

/// A cochain complex: a sequence of cochain groups connected by coboundary operators.
pub trait CochainComplex<H: HostTypes> {
    /// Associated type for `CochainGroup`.
    type CochainGroup: CochainGroup<H>;
    /// A cochain group belonging to this cochain complex.
    fn has_cochain_group(&self) -> &[Self::CochainGroup];
    /// Associated type for `CoboundaryOperator`.
    type CoboundaryOperator: CoboundaryOperator<H>;
    /// A coboundary operator belonging to this cochain complex.
    fn has_coboundary(&self) -> &[Self::CoboundaryOperator];
}

/// The k-th cohomology group H^k = ker(δ^k) / im(δ^{k-1}). Measures k-dimensional obstructions.
pub trait CohomologyGroup<H: HostTypes> {
    /// The degree k of this cohomology group H^k.
    fn cohomology_degree(&self) -> i64;
    /// The rank (dimension) of this cohomology group.
    fn cohomology_rank(&self) -> u64;
}

/// A sheaf F over a simplicial complex: assigns data to each simplex with restriction maps.
pub trait Sheaf<H: HostTypes> {
    /// Associated type for `SimplicialComplex`.
    type SimplicialComplex: crate::bridge::homology::SimplicialComplex<H>;
    /// The simplicial complex that this sheaf is defined over.
    fn sheaf_over(&self) -> &Self::SimplicialComplex;
    /// Associated type for `Ring`.
    type Ring: crate::kernel::schema::Ring<H>;
    /// The coefficient ring of this sheaf.
    fn coefficient_in(&self) -> &Self::Ring;
    /// Associated type for `Stalk`.
    type Stalk: Stalk<H>;
    /// A stalk belonging to this sheaf.
    fn has_stalks(&self) -> &[Self::Stalk];
    /// Associated type for `Section`.
    type Section: Section<H>;
    /// A global section of this sheaf.
    fn has_global_section(&self) -> &[Self::Section];
}

/// A stalk F_σ: the local data of a sheaf at a simplex σ.
pub trait Stalk<H: HostTypes> {
    /// Associated type for `Simplex`.
    type Simplex: crate::bridge::homology::Simplex<H>;
    /// The simplex at which this stalk is located.
    fn stalk_at(&self) -> &Self::Simplex;
}

/// A global section of a sheaf: a consistent choice of local data across all simplices.
pub trait Section<H: HostTypes> {}

/// A local section: a consistent choice of data over a subcomplex.
pub trait LocalSection<H: HostTypes>: Section<H> {}

/// A restriction map ρ_{σ,τ}: maps data from a simplex to a face.
pub trait RestrictionMap<H: HostTypes> {
    /// Associated type for `Simplex`.
    type Simplex: crate::bridge::homology::Simplex<H>;
    /// The source simplex of this restriction map.
    fn restricts_from(&self) -> &Self::Simplex;
    /// The target simplex (face) of this restriction map.
    fn restricts_to(&self) -> &Self::Simplex;
}

/// A gluing obstruction: a cohomology class that detects when local sections fail to glue.
pub trait GluingObstruction<H: HostTypes> {
    /// Associated type for `CohomologyGroup`.
    type CohomologyGroup: CohomologyGroup<H>;
    /// The cohomology class that this gluing obstruction represents.
    fn obstruction_class(&self) -> &Self::CohomologyGroup;
    /// Associated type for `RefinementSuggestion`.
    type RefinementSuggestion: crate::bridge::resolver::RefinementSuggestion<H>;
    /// The refinement suggestion that, if applied, would resolve this gluing obstruction. Computed by the kernel when ψ₆ detects H^1 ≠ 0: the obstruction class indexes the site pair that is incompatible, and the suggestion targets that pair with a new bridging constraint.
    fn addresses_suggestion(&self) -> &[Self::RefinementSuggestion];
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `CochainGroup<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 NullCochainGroup<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCochainGroup<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCochainGroup<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCochainGroup<H> = NullCochainGroup {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CochainGroup<H> for NullCochainGroup<H> {
    fn cochain_degree(&self) -> i64 {
        0
    }
    fn cochain_rank(&self) -> u64 {
        0
    }
    type ChainGroup = crate::bridge::homology::NullChainGroup<H>;
    fn dual_of(&self) -> &Self::ChainGroup {
        &<crate::bridge::homology::NullChainGroup<H>>::ABSENT
    }
}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `CoboundaryOperator<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 NullCoboundaryOperator<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCoboundaryOperator<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCoboundaryOperator<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCoboundaryOperator<H> = NullCoboundaryOperator {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CoboundaryOperator<H> for NullCoboundaryOperator<H> {
    type CochainGroup = NullCochainGroup<H>;
    fn coboundary_source(&self) -> &Self::CochainGroup {
        &<NullCochainGroup<H>>::ABSENT
    }
    fn coboundary_target(&self) -> &Self::CochainGroup {
        &<NullCochainGroup<H>>::ABSENT
    }
    fn satisfies_coboundary_squared_zero(&self) -> bool {
        false
    }
}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullCochainComplex<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCochainComplex<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCochainComplex<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCochainComplex<H> = NullCochainComplex {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CochainComplex<H> for NullCochainComplex<H> {
    type CochainGroup = NullCochainGroup<H>;
    fn has_cochain_group(&self) -> &[Self::CochainGroup] {
        &[]
    }
    type CoboundaryOperator = NullCoboundaryOperator<H>;
    fn has_coboundary(&self) -> &[Self::CoboundaryOperator] {
        &[]
    }
}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullCohomologyGroup<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullCohomologyGroup<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullCohomologyGroup<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullCohomologyGroup<H> = NullCohomologyGroup {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> CohomologyGroup<H> for NullCohomologyGroup<H> {
    fn cohomology_degree(&self) -> i64 {
        0
    }
    fn cohomology_rank(&self) -> u64 {
        0
    }
}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullSheaf<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullSheaf<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullSheaf<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullSheaf<H> = NullSheaf {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Sheaf<H> for NullSheaf<H> {
    type SimplicialComplex = crate::bridge::homology::NullSimplicialComplex<H>;
    fn sheaf_over(&self) -> &Self::SimplicialComplex {
        &<crate::bridge::homology::NullSimplicialComplex<H>>::ABSENT
    }
    type Ring = crate::kernel::schema::NullRing<H>;
    fn coefficient_in(&self) -> &Self::Ring {
        &<crate::kernel::schema::NullRing<H>>::ABSENT
    }
    type Stalk = NullStalk<H>;
    fn has_stalks(&self) -> &[Self::Stalk] {
        &[]
    }
    type Section = NullSection<H>;
    fn has_global_section(&self) -> &[Self::Section] {
        &[]
    }
}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullStalk<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullStalk<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullStalk<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullStalk<H> = NullStalk {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Stalk<H> for NullStalk<H> {
    type Simplex = crate::bridge::homology::NullSimplex<H>;
    fn stalk_at(&self) -> &Self::Simplex {
        &<crate::bridge::homology::NullSimplex<H>>::ABSENT
    }
}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullSection<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullSection<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullSection<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullSection<H> = NullSection {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Section<H> for NullSection<H> {}

/// Phase 2 (orphan-closure) — resolver-absent default impl of `LocalSection<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 NullLocalSection<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullLocalSection<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullLocalSection<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullLocalSection<H> = NullLocalSection {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> Section<H> for NullLocalSection<H> {}
impl<H: HostTypes> LocalSection<H> for NullLocalSection<H> {}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullRestrictionMap<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullRestrictionMap<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullRestrictionMap<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullRestrictionMap<H> = NullRestrictionMap {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> RestrictionMap<H> for NullRestrictionMap<H> {
    type Simplex = crate::bridge::homology::NullSimplex<H>;
    fn restricts_from(&self) -> &Self::Simplex {
        &<crate::bridge::homology::NullSimplex<H>>::ABSENT
    }
    fn restricts_to(&self) -> &Self::Simplex {
        &<crate::bridge::homology::NullSimplex<H>>::ABSENT
    }
}

#[doc(hidden)]
#[doc = "THEORY-DEFERRED \u{2014} not a valid implementation; see [docs/theory_deferred.md]. Exists only to satisfy downstream trait-bound references."]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct NullGluingObstruction<H: HostTypes> {
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Default for NullGluingObstruction<H> {
    fn default() -> Self {
        Self {
            _phantom: core::marker::PhantomData,
        }
    }
}
impl<H: HostTypes> NullGluingObstruction<H> {
    /// Absent-value sentinel. `&Self::ABSENT` gives every trait-typed accessor a `'static`-lifetime reference target.
    pub const ABSENT: NullGluingObstruction<H> = NullGluingObstruction {
        _phantom: core::marker::PhantomData,
    };
}
impl<H: HostTypes> GluingObstruction<H> for NullGluingObstruction<H> {
    type CohomologyGroup = NullCohomologyGroup<H>;
    fn obstruction_class(&self) -> &Self::CohomologyGroup {
        &<NullCohomologyGroup<H>>::ABSENT
    }
    type RefinementSuggestion = crate::bridge::resolver::NullRefinementSuggestion<H>;
    fn addresses_suggestion(&self) -> &[Self::RefinementSuggestion] {
        &[]
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `CochainGroup<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 CochainGroupHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for CochainGroupHandle<H> {}
impl<H: HostTypes> Clone for CochainGroupHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for CochainGroupHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for CochainGroupHandle<H> {}
impl<H: HostTypes> core::hash::Hash for CochainGroupHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> CochainGroupHandle<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 `CochainGroup<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 CochainGroupResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: CochainGroupHandle<H>) -> Option<CochainGroupRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `CochainGroup<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 CochainGroupRecord<H: HostTypes> {
    pub cochain_degree: i64,
    pub cochain_rank: u64,
    pub dual_of_handle: crate::bridge::homology::ChainGroupHandle<H>,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CochainGroup<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 ResolvedCochainGroup<'r, R: CochainGroupResolver<H>, H: HostTypes> {
    handle: CochainGroupHandle<H>,
    resolver: &'r R,
    record: Option<CochainGroupRecord<H>>,
}
impl<'r, R: CochainGroupResolver<H>, H: HostTypes> ResolvedCochainGroup<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CochainGroupHandle<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) -> CochainGroupHandle<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<&CochainGroupRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CochainGroupResolver<H>, H: HostTypes> CochainGroup<H>
    for ResolvedCochainGroup<'r, R, H>
{
    fn cochain_degree(&self) -> i64 {
        match &self.record {
            Some(r) => r.cochain_degree,
            None => 0,
        }
    }
    fn cochain_rank(&self) -> u64 {
        match &self.record {
            Some(r) => r.cochain_rank,
            None => 0,
        }
    }
    type ChainGroup = crate::bridge::homology::NullChainGroup<H>;
    fn dual_of(&self) -> &Self::ChainGroup {
        &<crate::bridge::homology::NullChainGroup<H>>::ABSENT
    }
}
impl<'r, R: CochainGroupResolver<H>, H: HostTypes> ResolvedCochainGroup<'r, R, H> {
    /// Promote the `dual_of` 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_dual_of<'r2, R2: crate::bridge::homology::ChainGroupResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<crate::bridge::homology::ResolvedChainGroup<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(crate::bridge::homology::ResolvedChainGroup::new(
            record.dual_of_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `CoboundaryOperator<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 CoboundaryOperatorHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for CoboundaryOperatorHandle<H> {}
impl<H: HostTypes> Clone for CoboundaryOperatorHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for CoboundaryOperatorHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for CoboundaryOperatorHandle<H> {}
impl<H: HostTypes> core::hash::Hash for CoboundaryOperatorHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> CoboundaryOperatorHandle<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 `CoboundaryOperator<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 CoboundaryOperatorResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: CoboundaryOperatorHandle<H>) -> Option<CoboundaryOperatorRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `CoboundaryOperator<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 CoboundaryOperatorRecord<H: HostTypes> {
    pub coboundary_source_handle: CochainGroupHandle<H>,
    pub coboundary_target_handle: CochainGroupHandle<H>,
    pub satisfies_coboundary_squared_zero: bool,
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `CoboundaryOperator<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 ResolvedCoboundaryOperator<'r, R: CoboundaryOperatorResolver<H>, H: HostTypes> {
    handle: CoboundaryOperatorHandle<H>,
    resolver: &'r R,
    record: Option<CoboundaryOperatorRecord<H>>,
}
impl<'r, R: CoboundaryOperatorResolver<H>, H: HostTypes> ResolvedCoboundaryOperator<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: CoboundaryOperatorHandle<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) -> CoboundaryOperatorHandle<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<&CoboundaryOperatorRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: CoboundaryOperatorResolver<H>, H: HostTypes> CoboundaryOperator<H>
    for ResolvedCoboundaryOperator<'r, R, H>
{
    type CochainGroup = NullCochainGroup<H>;
    fn coboundary_source(&self) -> &Self::CochainGroup {
        &<NullCochainGroup<H>>::ABSENT
    }
    fn coboundary_target(&self) -> &Self::CochainGroup {
        &<NullCochainGroup<H>>::ABSENT
    }
    fn satisfies_coboundary_squared_zero(&self) -> bool {
        match &self.record {
            Some(r) => r.satisfies_coboundary_squared_zero,
            None => false,
        }
    }
}
impl<'r, R: CoboundaryOperatorResolver<H>, H: HostTypes> ResolvedCoboundaryOperator<'r, R, H> {
    /// Promote the `coboundary_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_coboundary_source<'r2, R2: CochainGroupResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedCochainGroup<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedCochainGroup::new(
            record.coboundary_source_handle,
            r,
        ))
    }
    /// Promote the `coboundary_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_coboundary_target<'r2, R2: CochainGroupResolver<H>>(
        &self,
        r: &'r2 R2,
    ) -> Option<ResolvedCochainGroup<'r2, R2, H>> {
        let record = self.record.as_ref()?;
        Some(ResolvedCochainGroup::new(
            record.coboundary_target_handle,
            r,
        ))
    }
}

/// Phase 8 (orphan-closure) — content-addressed handle for `LocalSection<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 LocalSectionHandle<H: HostTypes> {
    /// Content fingerprint identifying the resolved record.
    pub fingerprint: crate::enforcement::ContentFingerprint,
    _phantom: core::marker::PhantomData<H>,
}
impl<H: HostTypes> Copy for LocalSectionHandle<H> {}
impl<H: HostTypes> Clone for LocalSectionHandle<H> {
    #[inline]
    fn clone(&self) -> Self {
        *self
    }
}
impl<H: HostTypes> PartialEq for LocalSectionHandle<H> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.fingerprint == other.fingerprint
    }
}
impl<H: HostTypes> Eq for LocalSectionHandle<H> {}
impl<H: HostTypes> core::hash::Hash for LocalSectionHandle<H> {
    #[inline]
    fn hash<S: core::hash::Hasher>(&self, state: &mut S) {
        self.fingerprint.hash(state);
    }
}
impl<H: HostTypes> LocalSectionHandle<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 `LocalSection<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 LocalSectionResolver<H: HostTypes> {
    /// Resolve a handle into its record. Returns `None` when the
    /// handle does not correspond to known content.
    fn resolve(&self, handle: LocalSectionHandle<H>) -> Option<LocalSectionRecord<H>>;
}

/// Phase 8 (orphan-closure) — typed record for `LocalSection<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 LocalSectionRecord<H: HostTypes> {
    #[doc(hidden)]
    pub _phantom: core::marker::PhantomData<H>,
}

/// Phase 8 (orphan-closure) — content-addressed wrapper for `LocalSection<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 ResolvedLocalSection<'r, R: LocalSectionResolver<H>, H: HostTypes> {
    handle: LocalSectionHandle<H>,
    resolver: &'r R,
    record: Option<LocalSectionRecord<H>>,
}
impl<'r, R: LocalSectionResolver<H>, H: HostTypes> ResolvedLocalSection<'r, R, H> {
    /// Construct the wrapper, eagerly resolving the handle.
    #[inline]
    pub fn new(handle: LocalSectionHandle<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) -> LocalSectionHandle<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<&LocalSectionRecord<H>> {
        self.record.as_ref()
    }
}
impl<'r, R: LocalSectionResolver<H>, H: HostTypes> Section<H> for ResolvedLocalSection<'r, R, H> {}
impl<'r, R: LocalSectionResolver<H>, H: HostTypes> LocalSection<H>
    for ResolvedLocalSection<'r, R, H>
{
}

/// δ² = 0: the coboundary of a coboundary is zero.
pub mod coboundary_squared_zero {
    /// `forAll` -> `term_coboundarySquaredZero_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_coboundarySquaredZero_forAll";
    /// `lhs` -> `term_coboundarySquaredZero_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_coboundarySquaredZero_lhs";
    /// `rhs` -> `term_coboundarySquaredZero_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_coboundarySquaredZero_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}

/// Discrete de Rham duality: H^k ≅ Hom(H_k, R).
pub mod de_rham_duality {
    /// `forAll` -> `term_deRhamDuality_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_deRhamDuality_forAll";
    /// `lhs` -> `term_deRhamDuality_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_deRhamDuality_lhs";
    /// `rhs` -> `term_deRhamDuality_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_deRhamDuality_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}

/// Sheaf cohomology equals simplicial cohomology for constant sheaves.
pub mod sheaf_cohomology_bridge {
    /// `forAll` -> `term_sheafCohomologyBridge_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_sheafCohomologyBridge_forAll";
    /// `lhs` -> `term_sheafCohomologyBridge_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_sheafCohomologyBridge_lhs";
    /// `rhs` -> `term_sheafCohomologyBridge_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_sheafCohomologyBridge_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}

/// Local-global principle: H^1(K; F) = 0 implies all local sections glue to global sections.
pub mod local_global_principle {
    /// `forAll` -> `term_localGlobalPrinciple_forAll`
    pub const FOR_ALL: &str = "https://uor.foundation/schema/term_localGlobalPrinciple_forAll";
    /// `lhs` -> `term_localGlobalPrinciple_lhs`
    pub const LHS: &str = "https://uor.foundation/schema/term_localGlobalPrinciple_lhs";
    /// `rhs` -> `term_localGlobalPrinciple_rhs`
    pub const RHS: &str = "https://uor.foundation/schema/term_localGlobalPrinciple_rhs";
    /// `verificationDomain` -> `Topological`
    pub const VERIFICATION_DOMAIN: &str = "https://uor.foundation/op/Topological";
}