Bump version to 0.4.15

Wire ψ_1 Recurse expansion per wiki ADR-057 step 3.

Foundation's `primitive_simplicial_nerve_betti<T>` previously treated
`ConstraintRef::Recurse` entries as opaque anonymous Sites with all-sites
support — the structural-typing-at-the-constraint-geometry property
declared by ADR-057 was unrealized in evaluation. v0.4.15 adds:

- `primitive_simplicial_nerve_betti_in<T, R>` — registry-parameterized
  variant that walks `T::CONSTRAINTS`, expands `Recurse { shape_iri,
  descent_bound }` entries through `lookup_shape_in::<R>(iri)` with
  bounded descent, and computes N(C) on the flattened constraint set.
- `primitive_simplicial_nerve_betti<T>` — now delegates to the `_in`
  variant with `EmptyShapeRegistry` (foundation built-in registry only)
  and returns `RECURSE_SHAPE_UNREGISTERED` on unknown shapes.
- `primitive_cartesian_nerve_betti_in<S, R>` — registry-aware Künneth
  companion for `CartesianProductShape` inputs.
- `expand_constraints_in<R>` — the underlying flattening walker.
- `constraint_site_support_mask_of` — slice-based site-support computation
  on a `&ConstraintRef` (used after expansion).
- `ResolverTuple::ShapeRegistry` associated type — `NullResolverTuple`
  defaults to `EmptyShapeRegistry`; the SDK `resolver!` macro admits a
  `shape_registry: MyRegistry` clause that binds the application's
  `register_shape!`-emitted marker.

Behavioral tests prove N(C) reflects the expanded grammar (different
Betti profile for the same `Recurse` entry with/without a populated
registry), and validate the zero-bound bottom-out plus the
unknown-shape error propagation.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: afflom

Cargo.lock

@@ -18,7 +18,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.4.14"
+version = "0.4.15"
 edition = "2021"
 rust-version = "1.83"
 license = "Apache-2.0"

Cargo.toml

@@ -9,7 +9,7 @@ structure based on Z/(2^n)Z.
 
 ## Ontology
 
-Version 0.4.14: 34 namespaces · 474 classes · 948 properties · 3601 named individuals
+Version 0.4.15: 34 namespaces · 474 classes · 948 properties · 3601 named individuals
 
 All terms are encoded as typed Rust data in `spec/` (`uor-ontology`) and exported as:
 - `foundation/` (`uor-foundation`) — typed Rust traits (published to crates.io)

README.md

@@ -7559,19 +7559,70 @@ fn emit_phase_j_primitives(f: &mut RustFile) {
     f.doc_comment("differently-shaped complex than the caller asked about. Callers propagate");
     f.doc_comment("the witness via `?` (pattern mirrored on `primitive_terminal_reduction`).");
     f.doc_comment("");
+    f.doc_comment("ADR-057: `T::CONSTRAINTS` may contain `ConstraintRef::Recurse` entries");
+    f.doc_comment("referencing shapes by IRI. This primitive expands Recurse references");
+    f.doc_comment("through the **foundation built-in shape-IRI registry** (`lookup_shape`),");
+    f.doc_comment("decrementing the descent budget on each Recurse encountered and");
+    f.doc_comment("terminating when the budget reaches zero. Applications that register");
+    f.doc_comment("their own shapes (via the SDK `register_shape!` macro) use");
+    f.doc_comment("[`primitive_simplicial_nerve_betti_in`] which is generic over the");
+    f.doc_comment("application's `ShapeRegistryProvider`. The structural reading at ψ_1");
+    f.doc_comment("reflects the expanded constraint geometry — Recurse entries are not");
+    f.doc_comment("opaque anonymous Sites but their structurally-substituted body per the");
+    f.doc_comment("registered shape's `CONSTRAINTS` array.");
+    f.doc_comment("");
     f.doc_comment("# Errors");
     f.doc_comment("");
-    f.doc_comment("Returns `NERVE_CAPACITY_EXCEEDED` when either cap is exceeded.");
+    f.doc_comment("Returns `NERVE_CAPACITY_EXCEEDED` when either cap is exceeded after");
+    f.doc_comment("expansion. Returns `RECURSE_SHAPE_UNREGISTERED` when a `Recurse`");
+    f.doc_comment("entry references an IRI not present in the consulted registry");
+    f.doc_comment("(non-zero descent budget).");
     f.line("pub fn primitive_simplicial_nerve_betti<T: crate::pipeline::ConstrainedTypeShape + ?Sized>() -> Result<[u32; MAX_BETTI_DIMENSION], GenericImpossibilityWitness> {");
-    f.line("    let k_all = T::CONSTRAINTS.len();");
-    f.line("    if k_all > NERVE_CONSTRAINTS_CAP {");
+    f.line("    // ADR-057: foundation-default registry path. EmptyShapeRegistry's");
+    f.line("    // REGISTRY is the empty slice, so lookup_shape_in falls through to");
+    f.line("    // foundation's built-in FOUNDATION_REGISTRY (the canonical stdlib path).");
+    f.line("    primitive_simplicial_nerve_betti_in::<T, crate::pipeline::shape_iri_registry::EmptyShapeRegistry>()");
+    f.line("}");
+    f.blank();
+    f.doc_comment("ADR-057: registry-parameterized variant of");
+    f.doc_comment("[`primitive_simplicial_nerve_betti`]. Walks `T::CONSTRAINTS` and expands");
+    f.doc_comment("every `ConstraintRef::Recurse { shape_iri, descent_bound }` entry by");
+    f.doc_comment("looking up `shape_iri` through `R`'s registry plus foundation's");
+    f.doc_comment("built-in registry, decrementing the descent budget on each recursive");
+    f.doc_comment("walk, and terminating when the budget reaches zero. The expanded");
+    f.doc_comment("constraint sequence is the input to the nerve computation — the");
+    f.doc_comment("structural reading at ψ_1 reflects the recursive grammar.");
+    f.doc_comment("");
+    f.doc_comment("This is the entry point ψ_1 `NerveResolver` impls call from the");
+    f.doc_comment("application's resolver-tuple — `R` is the ResolverTuple's");
+    f.doc_comment("`ShapeRegistry` associated type per ADR-036+ADR-057.");
+    f.doc_comment("");
+    f.doc_comment("# Errors");
+    f.doc_comment("");
+    f.doc_comment("Returns `NERVE_CAPACITY_EXCEEDED` when the expanded constraint set");
+    f.doc_comment("exceeds `NERVE_CONSTRAINTS_CAP` or `NERVE_SITES_CAP`. Returns");
+    f.doc_comment("`RECURSE_SHAPE_UNREGISTERED` when a `Recurse` entry references an");
+    f.doc_comment("IRI not present in either `R::REGISTRY` or foundation's built-in.");
+    f.line("pub fn primitive_simplicial_nerve_betti_in<");
+    f.line("    T: crate::pipeline::ConstrainedTypeShape + ?Sized,");
+    f.line("    R: crate::pipeline::shape_iri_registry::ShapeRegistryProvider,");
+    f.line(">() -> Result<[u32; MAX_BETTI_DIMENSION], GenericImpossibilityWitness> {");
+    f.line("    // ADR-057 step 3: expand T::CONSTRAINTS, walking ConstraintRef::Recurse");
+    f.line("    // through R's registry with bounded descent.");
+    f.line("    let mut expanded: [crate::pipeline::ConstraintRef; NERVE_CONSTRAINTS_CAP] =");
+    f.line(
+        "        [crate::pipeline::ConstraintRef::Site { position: 0 }; NERVE_CONSTRAINTS_CAP];",
+    );
+    f.line("    let mut n_expanded: usize = 0;");
+    f.line("    expand_constraints_in::<R>(T::CONSTRAINTS, u32::MAX, &mut expanded, &mut n_expanded)?;");
+    f.line("    let n_constraints = n_expanded;");
+    f.line("    if n_constraints > NERVE_CONSTRAINTS_CAP {");
     f.line("        return Err(GenericImpossibilityWitness::for_identity(\"NERVE_CAPACITY_EXCEEDED\"));");
     f.line("    }");
     f.line("    let s_all = T::SITE_COUNT;");
     f.line("    if s_all > NERVE_SITES_CAP {");
     f.line("        return Err(GenericImpossibilityWitness::for_identity(\"NERVE_CAPACITY_EXCEEDED\"));");
     f.line("    }");
-    f.line("    let n_constraints = k_all;");
     f.line("    let n_sites = s_all;");
     f.line("    let mut out = [0u32; MAX_BETTI_DIMENSION];");
     f.line("    if n_constraints == 0 {");
@@ -7582,7 +7633,7 @@ fn emit_phase_j_primitives(f: &mut RustFile) {
     f.line("    let mut support = [0u16; NERVE_CONSTRAINTS_CAP];");
     f.line("    let mut c = 0;");
     f.line("    while c < n_constraints {");
-    f.line("        support[c] = constraint_site_support_mask::<T>(c, n_sites);");
+    f.line("        support[c] = constraint_site_support_mask_of(&expanded[c], n_sites);");
     f.line("        c += 1;");
     f.line("    }");
     f.line("    // Enumerate 1-simplices: pairs (i,j) with i<j and support[i] & support[j] != 0.");
@@ -7668,6 +7719,78 @@ fn emit_phase_j_primitives(f: &mut RustFile) {
     f.line("    Ok(out)");
     f.line("}");
     f.blank();
+
+    // ── ADR-057: Recurse expansion helper ─────────────────────────────────
+    f.doc_comment("ADR-057 step 3: walk `in_constraints`, copying non-Recurse entries into");
+    f.doc_comment("`out_arr` and expanding every `ConstraintRef::Recurse { shape_iri,");
+    f.doc_comment("descent_bound }` by looking up `shape_iri` through `R`'s registry plus");
+    f.doc_comment("foundation's built-in registry and recursing into the referenced shape's");
+    f.doc_comment("`CONSTRAINTS`. The effective descent budget at each Recurse is the min");
+    f.doc_comment("of the caller's `descent_remaining` and the constraint's own");
+    f.doc_comment("`descent_bound`; on Recurse the budget decrements by 1 before recursion.");
+    f.doc_comment("A budget of 0 terminates the descent (the Recurse contributes no");
+    f.doc_comment("further constraints — the recursion bottoms out).");
+    f.doc_comment("");
+    f.doc_comment("# Errors");
+    f.doc_comment("");
+    f.doc_comment("Returns `NERVE_CAPACITY_EXCEEDED` when the expansion would exceed");
+    f.doc_comment("`NERVE_CONSTRAINTS_CAP`. Returns `RECURSE_SHAPE_UNREGISTERED` when a");
+    f.doc_comment("`Recurse` entry with non-zero effective budget references an IRI not");
+    f.doc_comment("present in either `R::REGISTRY` or foundation's built-in registry.");
+    f.line(
+        "pub fn expand_constraints_in<R: crate::pipeline::shape_iri_registry::ShapeRegistryProvider>(",
+    );
+    f.line("    in_constraints: &[crate::pipeline::ConstraintRef],");
+    f.line("    descent_remaining: u32,");
+    f.line("    out_arr: &mut [crate::pipeline::ConstraintRef; NERVE_CONSTRAINTS_CAP],");
+    f.line("    out_n: &mut usize,");
+    f.line(") -> Result<(), GenericImpossibilityWitness> {");
+    f.line("    let mut i = 0;");
+    f.line("    while i < in_constraints.len() {");
+    f.line("        match in_constraints[i] {");
+    f.line("            crate::pipeline::ConstraintRef::Recurse { shape_iri, descent_bound } => {");
+    f.line("                // Effective budget = min(caller's remaining, this Recurse's bound).");
+    f.line("                let budget = if descent_remaining < descent_bound {");
+    f.line("                    descent_remaining");
+    f.line("                } else {");
+    f.line("                    descent_bound");
+    f.line("                };");
+    f.line("                if budget == 0 {");
+    f.line("                    // Bottom out — contribute no further constraints.");
+    f.line("                } else {");
+    f.line("                    match crate::pipeline::shape_iri_registry::lookup_shape_in::<R>(shape_iri) {");
+    f.line("                        Some(registered) => {");
+    f.line("                            expand_constraints_in::<R>(");
+    f.line("                                registered.constraints,");
+    f.line("                                budget - 1,");
+    f.line("                                out_arr,");
+    f.line("                                out_n,");
+    f.line("                            )?;");
+    f.line("                        }");
+    f.line("                        None => {");
+    f.line("                            return Err(GenericImpossibilityWitness::for_identity(");
+    f.line("                                \"RECURSE_SHAPE_UNREGISTERED\",");
+    f.line("                            ));");
+    f.line("                        }");
+    f.line("                    }");
+    f.line("                }");
+    f.line("            }");
+    f.line("            other => {");
+    f.line("                if *out_n >= NERVE_CONSTRAINTS_CAP {");
+    f.line("                    return Err(GenericImpossibilityWitness::for_identity(");
+    f.line("                        \"NERVE_CAPACITY_EXCEEDED\",");
+    f.line("                    ));");
+    f.line("                }");
+    f.line("                out_arr[*out_n] = other;");
+    f.line("                *out_n += 1;");
+    f.line("            }");
+    f.line("        }");
+    f.line("        i += 1;");
+    f.line("    }");
+    f.line("    Ok(())");
+    f.line("}");
+    f.blank();
+
     f.doc_comment("Phase X.4: cap on the number of constraints considered by the nerve");
     f.doc_comment("primitive. Phase 1a (orphan-closure): inputs exceeding this cap are");
     f.doc_comment("rejected via `NERVE_CAPACITY_EXCEEDED` (was previously silent truncation).");
@@ -7702,14 +7825,21 @@ fn emit_phase_j_primitives(f: &mut RustFile) {
     f.line("pub(crate) const NERVE_RANK_MOD_P: i64 = 1_000_000_007;");
     f.blank();
     f.doc_comment("Phase X.4: per-constraint site-support bitmask. Returns bit `s` set iff");
-    f.doc_comment("constraint `c` in `T::CONSTRAINTS` touches site index `s` (`s < n_sites`).");
+    f.doc_comment("constraint `c` touches site index `s` (`s < n_sites`).");
     f.doc_comment("`Affine { coefficients, .. }` returns the bitmask of sites whose");
     f.doc_comment("coefficient is non-zero — the natural \"site support\" of the affine");
     f.doc_comment("relation. Remaining non-site-local variants (Residue, Hamming, Depth,");
     f.doc_comment("Bound, Conjunction, SatClauses) return an all-ones mask over `n_sites`.");
-    f.line("pub(crate) const fn constraint_site_support_mask<T: crate::pipeline::ConstrainedTypeShape + ?Sized>(c: usize, n_sites: usize) -> u16 {");
+    f.doc_comment("");
+    f.doc_comment("ADR-057: slice-based — operates directly on a `&ConstraintRef` rather");
+    f.doc_comment("than indexing a `ConstrainedTypeShape::CONSTRAINTS` slot. ψ_1 calls this");
+    f.doc_comment("from [`primitive_simplicial_nerve_betti_in`] after `T::CONSTRAINTS` has");
+    f.doc_comment("been expanded into a fixed-size array via [`expand_constraints_in`].");
+    f.line(
+        "pub(crate) const fn constraint_site_support_mask_of(c: &crate::pipeline::ConstraintRef, n_sites: usize) -> u16 {",
+    );
     f.line("    let all_mask: u16 = if n_sites == 0 { 0 } else { (1u16 << n_sites) - 1 };");
-    f.line("    match &T::CONSTRAINTS[c] {");
+    f.line("    match c {");
     f.line("        crate::pipeline::ConstraintRef::Site { position } => {");
     f.line("            if n_sites == 0 { 0 } else { 1u16 << (*position as usize % n_sites) }");
     f.line("        }");
@@ -7730,6 +7860,9 @@ fn emit_phase_j_primitives(f: &mut RustFile) {
     f.line("                if mask == 0 { all_mask } else { mask }");
     f.line("            }");
     f.line("        }");
+    f.line("        // ADR-057: any Recurse entry left in the array means");
+    f.line("        // expand_constraints_in already bottomed out (descent_bound = 0).");
+    f.line("        // Treat it as a structural placeholder with no specific site support.");
     f.line("        _ => all_mask,");
     f.line("    }");
     f.line("}");