uor-foundation 0.1.2

UOR Foundation — typed Rust traits for the complete ontology. Import and implement.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

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

//! `recursion/` namespace — Self-referential computations with well-founded descent measures guaranteeing termination..
//!
//! Space: Kernel

use crate::Primitives;

/// 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.
pub trait BoundedRecursion<P: Primitives> {
    /// Associated type for `DescentMeasure`.
    type DescentMeasure: DescentMeasure<P>;
    /// The descent measure guaranteeing termination.
    fn measure(&self) -> &Self::DescentMeasure;
    /// Associated type for `BaseCase`.
    type BaseCase: BaseCase<P>;
    /// The base case match arm.
    fn base_case(&self) -> &Self::BaseCase;
    /// Associated type for `RecursiveCase`.
    type RecursiveCase: RecursiveCase<P>;
    /// The recursive case match arm.
    fn recursive_case(&self) -> &Self::RecursiveCase;
    /// Associated type for `Predicate`.
    type Predicate: crate::kernel::predicate::Predicate<P>;
    /// The predicate that identifies the base case.
    fn base_predicate(&self) -> &Self::Predicate;
    /// Associated type for `ComputationDatum`.
    type ComputationDatum: crate::user::morphism::ComputationDatum<P>;
    /// The computation applied at each recursive step (may reference itself via its content address).
    fn recursion_body(&self) -> &Self::ComputationDatum;
    /// The measure value at the start of recursion. Bounds the maximum recursion depth.
    fn initial_measure(&self) -> P::NonNegativeInteger;
}

/// A well-founded function from computation state to xsd:nonNegativeInteger. Strictly decreases on every recursive step.
pub trait DescentMeasure<P: Primitives> {
    /// The current value of the descent measure.
    fn measure_value(&self) -> P::NonNegativeInteger;
}

/// The match arm selected when the descent measure reaches zero or the base predicate is satisfied. Produces a direct result without further recursion.
pub trait BaseCase<P: Primitives>: crate::kernel::predicate::MatchArm<P> {}

/// The match arm selected when the descent measure is positive. Applies a decomposition step, decreases the measure, and invokes the recursion.
pub trait RecursiveCase<P: Primitives>: crate::kernel::predicate::MatchArm<P> {}

/// A single step in a bounded recursion: the decomposition applied before the recursive invocation. Must strictly decrease the DescentMeasure.
pub trait RecursiveStep<P: Primitives> {
    /// Associated type for `Transform`.
    type Transform: crate::user::morphism::Transform<P>;
    /// The transform applied to decompose the input before recursion.
    fn step_decomposition(&self) -> &Self::Transform;
    /// Associated type for `DescentMeasure`.
    type DescentMeasure: DescentMeasure<P>;
    /// The measure value before this step.
    fn step_measure_pre(&self) -> &Self::DescentMeasure;
    /// The measure value after this step.
    fn step_measure_post(&self) -> &Self::DescentMeasure;
}

/// 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.
pub trait RecursionTrace<P: Primitives>: crate::bridge::trace::ComputationTrace<P> {}

/// A bounded recursion where the descent measure is the structural size of the input type (fiber count, constraint count, or operad nesting depth).
pub trait StructuralRecursion<P: Primitives>: BoundedRecursion<P> {}