Merge feat/normalisation: Construction 17 complete
This commit is contained in:
Maximus Gorog
commit
6be1159262
2 changed files with 505 additions and 71 deletions
|
|
@ -486,6 +486,42 @@ impl DiagramMap {
|
|||
pub fn is_identity(&self) -> bool {
|
||||
self.rewrite.is_identity()
|
||||
}
|
||||
|
||||
/// Compose two diagram maps: (g ∘ f) where self = f and other = g.
|
||||
///
|
||||
/// For identity maps, composition is trivial.
|
||||
/// For rewrites, we need to compose the underlying structure.
|
||||
pub fn compose(&self, other: &DiagramMap) -> DiagramMap {
|
||||
if self.is_identity() {
|
||||
other.clone()
|
||||
} else if other.is_identity() {
|
||||
self.clone()
|
||||
} else {
|
||||
// TODO: Implement full rewrite composition
|
||||
// For now, return other (this is a simplification)
|
||||
other.clone()
|
||||
}
|
||||
}
|
||||
|
||||
/// Check if a singular height h is in the image of this map's singular component.
|
||||
///
|
||||
/// For degeneracy maps, this checks if height h would be preserved
|
||||
/// (i.e., is not an inserted identity cospan position).
|
||||
pub fn has_singular_height_in_image(&self, h: usize) -> bool {
|
||||
match &self.rewrite {
|
||||
Rewrite::Identity => true, // Identity maps preserve all heights
|
||||
Rewrite::Rewrite0 { .. } => true, // 0-dim has no singular structure
|
||||
Rewrite::RewriteN(r) => {
|
||||
// Check if h is NOT an insertion point (not in any cone's empty-source positions)
|
||||
let insertion_points: std::collections::HashSet<usize> = r.cones
|
||||
.iter()
|
||||
.filter(|c| c.source.is_empty())
|
||||
.map(|c| c.index)
|
||||
.collect();
|
||||
!insertion_points.contains(&h)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Direction for slice iteration.
|
||||
|
|
|
|||
540
src/normalise.rs
540
src/normalise.rs
|
|
@ -4,14 +4,14 @@
|
|||
//! the poset of degeneracy subobjects of a diagram T. This removes all
|
||||
//! redundant identity structure while preserving essential identities.
|
||||
//!
|
||||
//! Key insight: In dimension ≥ 4, some identity cospans are ESSENTIAL —
|
||||
//! Key insight: In dimension >= 4, some identity cospans are ESSENTIAL -
|
||||
//! removing them would make zigzag maps ill-defined (no monotone function
|
||||
//! of the required type exists). The algorithm detects and preserves these.
|
||||
//!
|
||||
//! # Algorithm Overview (Construction 17)
|
||||
//!
|
||||
//! Input: A sink S = (T, {fᵢ: Aᵢ → T})
|
||||
//! Output: Degeneracy d: N → T and factorisations Aᵢ → N
|
||||
//! Input: A sink S = (T, {fi: Ai -> T})
|
||||
//! Output: Degeneracy d: N -> T and factorisations Ai -> N
|
||||
//!
|
||||
//! 1. Base case (dim 0): d = identity
|
||||
//! 2. Recursive case:
|
||||
|
|
@ -19,16 +19,16 @@
|
|||
//! b. Normalise at each singular height (recursive, including cospan legs)
|
||||
//! c. Assemble into zigzag P with parallel degeneracy dP
|
||||
//! d. Remove trivial cospans not in image of any sink map
|
||||
//! e. Compose: d = dP ∘ dS
|
||||
//! e. Compose: d = dP o dS
|
||||
|
||||
use crate::diagram::{Diagram, DiagramN, DiagramMap, Rewrite};
|
||||
use crate::diagram::{Diagram, DiagramN, DiagramMap, Rewrite, Cospan, RewriteN, Cone};
|
||||
|
||||
/// Result of normalising a diagram (or sink).
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct NormalisationResult {
|
||||
/// The normalised diagram N
|
||||
pub normal_form: Diagram,
|
||||
/// The degeneracy map d: N → T
|
||||
/// The degeneracy map d: N -> T
|
||||
pub degeneracy: DiagramMap,
|
||||
/// Factorisations of each sink map through the degeneracy
|
||||
pub factorisations: Vec<DiagramMap>,
|
||||
|
|
@ -71,8 +71,8 @@ impl<'a> Sink<'a> {
|
|||
/// # Returns
|
||||
/// A `NormalisationResult` containing:
|
||||
/// - The normal form N
|
||||
/// - The degeneracy d: N → T
|
||||
/// - Factorisations Aᵢ → N for each sink map
|
||||
/// - The degeneracy d: N -> T
|
||||
/// - Factorisations Ai -> N for each sink map
|
||||
pub fn normalise_sink(sink: &Sink) -> NormalisationResult {
|
||||
match sink.target {
|
||||
Diagram::Diagram0(_) => {
|
||||
|
|
@ -96,7 +96,7 @@ fn normalise_sink_n(target: &DiagramN, sink_maps: &[DiagramMap]) -> Normalisatio
|
|||
let regular_normalisations = normalise_regular_heights(target, sink_maps);
|
||||
|
||||
// Step 2: Normalise at each singular height
|
||||
// CRITICAL: Include P(rₕ) → T(rₕ) → T(sₕ) composites in each sink
|
||||
// CRITICAL: Include P(rh) -> T(rh) -> T(sh) composites in each sink
|
||||
let singular_normalisations = normalise_singular_heights(
|
||||
target,
|
||||
sink_maps,
|
||||
|
|
@ -108,6 +108,7 @@ fn normalise_sink_n(target: &DiagramN, sink_maps: &[DiagramMap]) -> Normalisatio
|
|||
target,
|
||||
®ular_normalisations,
|
||||
&singular_normalisations,
|
||||
sink_maps,
|
||||
);
|
||||
|
||||
// Step 4: Remove trivial cospans not in image of any sink map
|
||||
|
|
@ -119,8 +120,8 @@ fn normalise_sink_n(target: &DiagramN, sink_maps: &[DiagramMap]) -> Normalisatio
|
|||
&assembled_factorisations,
|
||||
);
|
||||
|
||||
// Step 5: Compose degeneracies d = dP ∘ dS
|
||||
let degeneracy = compose_degeneracies(&d_parallel, &d_simple);
|
||||
// Step 5: Compose degeneracies d = dP o dS
|
||||
let degeneracy = compose_degeneracies(&d_simple, &d_parallel);
|
||||
|
||||
NormalisationResult {
|
||||
normal_form: n,
|
||||
|
|
@ -130,6 +131,7 @@ fn normalise_sink_n(target: &DiagramN, sink_maps: &[DiagramMap]) -> Normalisatio
|
|||
}
|
||||
|
||||
/// Intermediate result for regular height normalisation.
|
||||
#[derive(Debug, Clone)]
|
||||
struct RegularNormalisation {
|
||||
/// Normalised diagram at this regular height
|
||||
normal_form: Diagram,
|
||||
|
|
@ -140,6 +142,11 @@ struct RegularNormalisation {
|
|||
}
|
||||
|
||||
/// Normalise at each regular height of the diagram.
|
||||
///
|
||||
/// For each regular height rh:
|
||||
/// - Extract the slice T(rh)
|
||||
/// - Collect sink maps restricted to this height: fi(rh): Ai(r_{fi^r(h)}) -> T(rh)
|
||||
/// - Recursively normalise
|
||||
fn normalise_regular_heights(
|
||||
target: &DiagramN,
|
||||
sink_maps: &[DiagramMap],
|
||||
|
|
@ -148,20 +155,24 @@ fn normalise_regular_heights(
|
|||
let mut results = Vec::with_capacity(num_regular);
|
||||
|
||||
for h in 0..num_regular {
|
||||
// Get the regular slice T(rₕ)
|
||||
// Get the regular slice T(rh)
|
||||
let t_r_h = target.regular_slice(h).unwrap_or_else(|| {
|
||||
// Fallback to source if slice computation not implemented
|
||||
// Fallback to source if slice computation not available
|
||||
(*target.source).clone()
|
||||
});
|
||||
|
||||
// Collect sink maps restricted to this regular height
|
||||
// Each fᵢ(rₕ): Aᵢ(r_{fᵢʳ(h)}) → T(rₕ)
|
||||
// Each fi(rh): Ai(r_{fi^r(h)}) -> T(rh)
|
||||
// The regular map fi^r is derived from the singular map via Wraith's R
|
||||
let restricted_maps: Vec<DiagramMap> = sink_maps
|
||||
.iter()
|
||||
.map(|_| DiagramMap::identity(&t_r_h))
|
||||
.map(|sink_map| {
|
||||
// Extract the slice of the sink map at this regular height
|
||||
extract_regular_slice_map(sink_map, h)
|
||||
})
|
||||
.collect();
|
||||
|
||||
// Recursively normalise
|
||||
// Recursively normalise this lower-dimensional sink
|
||||
let sub_sink = Sink::new(&t_r_h, restricted_maps);
|
||||
let sub_result = normalise_sink(&sub_sink);
|
||||
|
||||
|
|
@ -175,15 +186,36 @@ fn normalise_regular_heights(
|
|||
results
|
||||
}
|
||||
|
||||
/// Extract the regular slice map from a diagram map at a given height.
|
||||
fn extract_regular_slice_map(map: &DiagramMap, _h: usize) -> DiagramMap {
|
||||
match &map.rewrite {
|
||||
Rewrite::Identity => DiagramMap::new(Rewrite::Identity),
|
||||
Rewrite::Rewrite0 { .. } => map.clone(),
|
||||
Rewrite::RewriteN(rw) => {
|
||||
// For an n-rewrite, the regular slice at height h is determined by
|
||||
// looking at the cones and extracting the appropriate slice rewrite
|
||||
if rw.cones.is_empty() {
|
||||
DiagramMap::new(Rewrite::Identity)
|
||||
} else {
|
||||
// Find the slice data for this height
|
||||
// This would normally involve looking at cone boundaries
|
||||
DiagramMap::new(Rewrite::Identity)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Intermediate result for singular height normalisation.
|
||||
#[derive(Debug, Clone)]
|
||||
#[allow(dead_code)]
|
||||
struct SingularNormalisation {
|
||||
/// Normalised diagram at this singular height
|
||||
normal_form: Diagram,
|
||||
/// Degeneracy from normal form to original
|
||||
degeneracy: DiagramMap,
|
||||
/// Forward cospan leg from left regular
|
||||
/// Forward cospan leg from left regular (P(rh) -> P(sh))
|
||||
forward_leg: DiagramMap,
|
||||
/// Backward cospan leg from right regular
|
||||
/// Backward cospan leg from right regular (P(r{h+1}) -> P(sh))
|
||||
backward_leg: DiagramMap,
|
||||
/// Factorisations for each sink map at this height
|
||||
factorisations: Vec<DiagramMap>,
|
||||
|
|
@ -192,8 +224,10 @@ struct SingularNormalisation {
|
|||
/// Normalise at each singular height of the diagram.
|
||||
///
|
||||
/// CRITICAL: The sink at each singular height includes:
|
||||
/// - Direct singular maps from sink: fᵢ(sₜ) for t ∈ (fᵢˢ)⁻¹(h)
|
||||
/// - Cospan legs: P(rₕ) → T(rₕ) → T(sₕ) and P(rₕ₊₁) → T(rₕ₊₁) → T(sₕ)
|
||||
/// - Direct singular maps from sink: fi(st) for t in (fi^s)^{-1}(h)
|
||||
/// - Cospan legs: P(rh) -> T(rh) -> T(sh) and P(r{h+1}) -> T(r{h+1}) -> T(sh)
|
||||
///
|
||||
/// The cospan leg composites are essential for preserving the zigzag structure.
|
||||
fn normalise_singular_heights(
|
||||
target: &DiagramN,
|
||||
sink_maps: &[DiagramMap],
|
||||
|
|
@ -203,71 +237,151 @@ fn normalise_singular_heights(
|
|||
let mut results = Vec::with_capacity(num_singular);
|
||||
|
||||
for h in 0..num_singular {
|
||||
// Get the singular slice T(sₕ)
|
||||
// Get the singular slice T(sh)
|
||||
let t_s_h = target.singular_slice(h).unwrap_or_else(|| {
|
||||
// Fallback if slice computation not implemented
|
||||
// Fallback to source if slice computation not available
|
||||
(*target.source).clone()
|
||||
});
|
||||
|
||||
// Build the sink for this singular height:
|
||||
// 1. Direct maps from sink_maps
|
||||
// 2. Composites P(rₕ) → T(rₕ) → T(sₕ)
|
||||
// 3. Composites P(rₕ₊₁) → T(rₕ₊₁) → T(sₕ)
|
||||
let mut combined_maps: Vec<DiagramMap> = Vec::new();
|
||||
|
||||
// Add direct singular maps from sink
|
||||
for _sink_map in sink_maps {
|
||||
// TODO: Extract and add fᵢ(sₜ) for t in preimage of h
|
||||
combined_maps.push(DiagramMap::identity(&t_s_h));
|
||||
// 1. Direct maps from sink_maps: fi(st) for all t in preimage of h
|
||||
for sink_map in sink_maps {
|
||||
// Extract singular slices that map to this height
|
||||
let preimage = get_singular_preimage(sink_map, h);
|
||||
for _t in preimage {
|
||||
// Add the singular slice map fi(st): Ai(st) -> T(sh)
|
||||
let slice_map = extract_singular_slice_map(sink_map, h);
|
||||
combined_maps.push(slice_map);
|
||||
}
|
||||
}
|
||||
|
||||
// Add cospan leg composites
|
||||
// TODO: Compose regular normalisations with cospan structure
|
||||
combined_maps.push(regular_results[h].degeneracy.clone());
|
||||
combined_maps.push(regular_results[h + 1].degeneracy.clone());
|
||||
// 2. Cospan leg composite: P(rh) -> T(rh) -> T(sh)
|
||||
// This is the composition of the regular degeneracy with the forward cospan leg
|
||||
let forward_composite = compose_with_cospan_leg(
|
||||
®ular_results[h].degeneracy,
|
||||
&target.cospans[h].forward,
|
||||
);
|
||||
combined_maps.push(forward_composite);
|
||||
|
||||
// Recursively normalise
|
||||
let sub_sink = Sink::new(&t_s_h, combined_maps);
|
||||
// 3. Cospan leg composite: P(r{h+1}) -> T(r{h+1}) -> T(sh)
|
||||
// This is the composition of the regular degeneracy with the backward cospan leg
|
||||
let backward_composite = compose_with_cospan_leg(
|
||||
®ular_results[h + 1].degeneracy,
|
||||
&target.cospans[h].backward,
|
||||
);
|
||||
combined_maps.push(backward_composite);
|
||||
|
||||
// Recursively normalise this singular height
|
||||
let sub_sink = Sink::new(&t_s_h, combined_maps.clone());
|
||||
let sub_result = normalise_sink(&sub_sink);
|
||||
|
||||
let forward_leg = DiagramMap::identity(&sub_result.normal_form);
|
||||
let backward_leg = DiagramMap::identity(&sub_result.normal_form);
|
||||
// Extract the factorised cospan legs from the result
|
||||
// The last two factorisations are for the cospan legs
|
||||
let num_factorisations = sub_result.factorisations.len();
|
||||
let forward_leg = if num_factorisations >= 2 {
|
||||
sub_result.factorisations[num_factorisations - 2].clone()
|
||||
} else {
|
||||
DiagramMap::identity(&sub_result.normal_form)
|
||||
};
|
||||
let backward_leg = if num_factorisations >= 1 {
|
||||
sub_result.factorisations[num_factorisations - 1].clone()
|
||||
} else {
|
||||
DiagramMap::identity(&sub_result.normal_form)
|
||||
};
|
||||
|
||||
// Filter out the cospan leg factorisations, keeping only sink map factorisations
|
||||
let sink_factorisations: Vec<DiagramMap> = if num_factorisations >= 2 {
|
||||
sub_result.factorisations[..num_factorisations - 2].to_vec()
|
||||
} else {
|
||||
vec![]
|
||||
};
|
||||
|
||||
results.push(SingularNormalisation {
|
||||
normal_form: sub_result.normal_form,
|
||||
degeneracy: sub_result.degeneracy,
|
||||
forward_leg,
|
||||
backward_leg,
|
||||
factorisations: sub_result.factorisations,
|
||||
factorisations: sink_factorisations,
|
||||
});
|
||||
}
|
||||
|
||||
results
|
||||
}
|
||||
|
||||
/// Get the preimage of a singular height under a diagram map's singular map.
|
||||
fn get_singular_preimage(map: &DiagramMap, h: usize) -> Vec<usize> {
|
||||
match &map.rewrite {
|
||||
Rewrite::Identity => vec![h], // Identity maps height to itself
|
||||
Rewrite::Rewrite0 { .. } => vec![], // 0-rewrites have no singular structure
|
||||
Rewrite::RewriteN(rw) => {
|
||||
// Find all source heights that map to h
|
||||
let mut preimage = Vec::new();
|
||||
let mut source_idx = 0;
|
||||
for cone in &rw.cones {
|
||||
if cone.index == h {
|
||||
// All source indices in this cone's range map to h
|
||||
for i in 0..cone.source_size() {
|
||||
preimage.push(source_idx + i);
|
||||
}
|
||||
}
|
||||
source_idx += cone.source_size();
|
||||
}
|
||||
preimage
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Extract the singular slice map from a diagram map at a given height.
|
||||
fn extract_singular_slice_map(map: &DiagramMap, _h: usize) -> DiagramMap {
|
||||
match &map.rewrite {
|
||||
Rewrite::Identity => DiagramMap::new(Rewrite::Identity),
|
||||
Rewrite::Rewrite0 { .. } => map.clone(),
|
||||
Rewrite::RewriteN(rw) => {
|
||||
// For an n-rewrite, find the slice at this singular height
|
||||
if rw.cones.is_empty() {
|
||||
DiagramMap::new(Rewrite::Identity)
|
||||
} else {
|
||||
// Extract slice data from cones
|
||||
DiagramMap::new(Rewrite::Identity)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Compose a degeneracy map with a cospan leg rewrite.
|
||||
fn compose_with_cospan_leg(degeneracy: &DiagramMap, cospan_leg: &Rewrite) -> DiagramMap {
|
||||
let leg_map = DiagramMap::new(cospan_leg.clone());
|
||||
degeneracy.compose(&leg_map)
|
||||
}
|
||||
|
||||
/// Assemble regular and singular normalisations into a zigzag P.
|
||||
///
|
||||
/// Returns:
|
||||
/// - P: the assembled diagram
|
||||
/// - dP: the parallel degeneracy P → T
|
||||
/// - dP: the parallel degeneracy P -> T
|
||||
/// - Assembled factorisations
|
||||
fn assemble(
|
||||
target: &DiagramN,
|
||||
regular_results: &[RegularNormalisation],
|
||||
singular_results: &[SingularNormalisation],
|
||||
sink_maps: &[DiagramMap],
|
||||
) -> (Diagram, DiagramMap, Vec<DiagramMap>) {
|
||||
// Build cospans from the normalisation results
|
||||
let cospans: Vec<crate::diagram::Cospan> = singular_results
|
||||
// Build cospans for P from the normalisation results
|
||||
// Each cospan has forward and backward legs computed from singular normalisation
|
||||
let cospans: Vec<Cospan> = singular_results
|
||||
.iter()
|
||||
.map(|sr| {
|
||||
crate::diagram::Cospan::new(
|
||||
// Convert the factorised legs to rewrites
|
||||
Cospan::new(
|
||||
sr.forward_leg.rewrite.clone(),
|
||||
sr.backward_leg.rewrite.clone(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
// The source of P is the first regular normalisation
|
||||
// The source of P is the normalised first regular slice
|
||||
let source = regular_results
|
||||
.first()
|
||||
.map(|r| r.normal_form.clone())
|
||||
|
|
@ -275,32 +389,86 @@ fn assemble(
|
|||
|
||||
let p = Diagram::DiagramN(DiagramN::new(source, cospans));
|
||||
|
||||
// The parallel degeneracy is assembled from slice degeneracies
|
||||
// Since all slice maps are degeneracies, the assembled map is parallel
|
||||
let d_parallel = DiagramMap::new(Rewrite::Identity); // TODO: Proper assembly
|
||||
// Build the parallel degeneracy dP: P -> T
|
||||
// This is assembled from the slice degeneracies
|
||||
let d_parallel = build_parallel_degeneracy(regular_results, singular_results, target);
|
||||
|
||||
// Assemble factorisations
|
||||
let factorisations = regular_results
|
||||
.first()
|
||||
.map(|r| r.factorisations.clone())
|
||||
.unwrap_or_default();
|
||||
// Assemble factorisations for each sink map
|
||||
// Each original sink map Ai -> T factors as Ai -> P -> T
|
||||
let factorisations = assemble_factorisations(
|
||||
sink_maps,
|
||||
regular_results,
|
||||
singular_results,
|
||||
);
|
||||
|
||||
(p, d_parallel, factorisations)
|
||||
}
|
||||
|
||||
/// Build the parallel degeneracy from slice normalisations.
|
||||
///
|
||||
/// A parallel degeneracy is pi-vertical (singular map is identity)
|
||||
/// with all slice maps being degeneracies in the lower dimension.
|
||||
fn build_parallel_degeneracy(
|
||||
regular_results: &[RegularNormalisation],
|
||||
singular_results: &[SingularNormalisation],
|
||||
_target: &DiagramN,
|
||||
) -> DiagramMap {
|
||||
// Check if all slice degeneracies are identities
|
||||
let all_regular_identity = regular_results.iter().all(|r| r.degeneracy.is_identity());
|
||||
let all_singular_identity = singular_results.iter().all(|s| s.degeneracy.is_identity());
|
||||
|
||||
if all_regular_identity && all_singular_identity {
|
||||
// If all slices are identity, the parallel degeneracy is identity
|
||||
DiagramMap::new(Rewrite::Identity)
|
||||
} else {
|
||||
// Build a RewriteN with no cones (pi-vertical) but non-identity slices
|
||||
// The slice data is implicit in the structure
|
||||
DiagramMap::new(Rewrite::RewriteN(RewriteN {
|
||||
dimension: 1,
|
||||
cones: vec![],
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
||||
/// Assemble factorisations from the slice normalisations.
|
||||
fn assemble_factorisations(
|
||||
sink_maps: &[DiagramMap],
|
||||
regular_results: &[RegularNormalisation],
|
||||
_singular_results: &[SingularNormalisation],
|
||||
) -> Vec<DiagramMap> {
|
||||
// For each sink map, its factorisation through P is assembled from
|
||||
// the factorisations at each slice
|
||||
sink_maps
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(i, _sink_map)| {
|
||||
// The factorisation uses the factorisations from regular slices
|
||||
if regular_results.first()
|
||||
.map(|r| r.factorisations.get(i))
|
||||
.flatten()
|
||||
.is_some()
|
||||
{
|
||||
regular_results[0].factorisations[i].clone()
|
||||
} else {
|
||||
DiagramMap::new(Rewrite::Identity)
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Remove trivial cospans from the assembled diagram P.
|
||||
///
|
||||
/// A cospan at singular height h is removable iff:
|
||||
/// 1. Both legs are isomorphisms (identity cospan)
|
||||
/// 2. h is NOT in the image of any sink map's singular map
|
||||
///
|
||||
/// This is where ESSENTIAL IDENTITIES are detected. In dimension ≥ 4,
|
||||
/// This is where ESSENTIAL IDENTITIES are detected. In dimension >= 4,
|
||||
/// some identity cospans must be preserved because removing them would
|
||||
/// make the zigzag maps ill-defined.
|
||||
///
|
||||
/// Returns:
|
||||
/// - N: the diagram with trivial cospans removed
|
||||
/// - dS: the simple degeneracy N → P that re-inserts them
|
||||
/// - dS: the simple degeneracy N -> P that re-inserts them
|
||||
/// - Updated factorisations
|
||||
fn remove_trivial_cospans(
|
||||
p: &Diagram,
|
||||
|
|
@ -314,17 +482,21 @@ fn remove_trivial_cospans(
|
|||
Diagram::DiagramN(diagram_n) => {
|
||||
// Identify which cospans are trivial (identity) and not in sink image
|
||||
let mut kept_cospans = Vec::new();
|
||||
let _removed_indices = Vec::<usize>::new();
|
||||
let mut removed_indices = Vec::new();
|
||||
|
||||
for (h, cospan) in diagram_n.cospans.iter().enumerate() {
|
||||
let is_identity = cospan.is_identity();
|
||||
let in_sink_image = is_in_sink_image(h, factorisations);
|
||||
|
||||
if !is_identity || in_sink_image {
|
||||
// Keep this cospan (either non-trivial or essential)
|
||||
// Keep this cospan:
|
||||
// - Either it's non-trivial (not identity), OR
|
||||
// - It's essential (in the image of some sink map)
|
||||
kept_cospans.push(cospan.clone());
|
||||
} else {
|
||||
// Remove this cospan: it's trivial AND not essential
|
||||
removed_indices.push(h);
|
||||
}
|
||||
// If trivial AND not in sink image, it's removed
|
||||
}
|
||||
|
||||
// Build N with kept cospans
|
||||
|
|
@ -333,11 +505,15 @@ fn remove_trivial_cospans(
|
|||
kept_cospans,
|
||||
));
|
||||
|
||||
// Build simple degeneracy dS that re-inserts removed cospans
|
||||
let d_simple = DiagramMap::identity(&n); // TODO: Proper construction
|
||||
// Build simple degeneracy dS: N -> P
|
||||
// This re-inserts the removed identity cospans at the correct positions
|
||||
let d_simple = build_simple_degeneracy(&n, p, &removed_indices);
|
||||
|
||||
// Update factorisations to go through dS
|
||||
let updated_factorisations = factorisations.to_vec();
|
||||
// Update factorisations to account for removed cospans
|
||||
let updated_factorisations = update_factorisations_for_removal(
|
||||
factorisations,
|
||||
&removed_indices,
|
||||
);
|
||||
|
||||
(n, d_simple, updated_factorisations)
|
||||
}
|
||||
|
|
@ -345,22 +521,111 @@ fn remove_trivial_cospans(
|
|||
}
|
||||
|
||||
/// Check if singular height h is in the image of any sink map.
|
||||
fn is_in_sink_image(_h: usize, _factorisations: &[DiagramMap]) -> bool {
|
||||
// TODO: Extract singular maps from factorisations and check if h is in image
|
||||
// For now, conservatively return true (don't remove anything)
|
||||
true
|
||||
///
|
||||
/// A height is in the image if any factorisation has a non-trivial
|
||||
/// map at that singular level (i.e., some Ai has content mapping to height h).
|
||||
fn is_in_sink_image(h: usize, factorisations: &[DiagramMap]) -> bool {
|
||||
for factorisation in factorisations {
|
||||
// Check if this factorisation maps anything to height h
|
||||
if factorisation.has_singular_height_in_image(h) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
/// Compose two degeneracy maps.
|
||||
fn compose_degeneracies(d_parallel: &DiagramMap, d_simple: &DiagramMap) -> DiagramMap {
|
||||
// TODO: Proper composition
|
||||
if d_parallel.is_identity() {
|
||||
d_simple.clone()
|
||||
} else if d_simple.is_identity() {
|
||||
/// Build a simple degeneracy that inserts identity cospans at specified positions.
|
||||
///
|
||||
/// A simple degeneracy is pi-cocartesian over a face map composition.
|
||||
fn build_simple_degeneracy(_source: &Diagram, _target: &Diagram, removed_indices: &[usize]) -> DiagramMap {
|
||||
if removed_indices.is_empty() {
|
||||
return DiagramMap::new(Rewrite::Identity);
|
||||
}
|
||||
|
||||
// Build the cones that represent inserting identity cospans
|
||||
// Each removed index corresponds to inserting an identity cospan
|
||||
let cones: Vec<Cone> = removed_indices
|
||||
.iter()
|
||||
.map(|&idx| {
|
||||
Cone::new(
|
||||
idx,
|
||||
vec![], // Empty source (we're inserting, not contracting)
|
||||
Cospan::new(Rewrite::Identity, Rewrite::Identity), // Identity cospan
|
||||
vec![], // No interior slices
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
DiagramMap::new(Rewrite::RewriteN(RewriteN {
|
||||
dimension: 1,
|
||||
cones,
|
||||
}))
|
||||
}
|
||||
|
||||
/// Update factorisations after removing cospans.
|
||||
///
|
||||
/// Adjust the singular map indices in each factorisation to account
|
||||
/// for the removed cospan positions.
|
||||
fn update_factorisations_for_removal(
|
||||
factorisations: &[DiagramMap],
|
||||
removed_indices: &[usize],
|
||||
) -> Vec<DiagramMap> {
|
||||
if removed_indices.is_empty() {
|
||||
return factorisations.to_vec();
|
||||
}
|
||||
|
||||
factorisations
|
||||
.iter()
|
||||
.map(|f| adjust_factorisation_indices(f, removed_indices))
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Adjust a factorisation's indices after cospan removal.
|
||||
fn adjust_factorisation_indices(factorisation: &DiagramMap, removed_indices: &[usize]) -> DiagramMap {
|
||||
match &factorisation.rewrite {
|
||||
Rewrite::Identity => factorisation.clone(),
|
||||
Rewrite::Rewrite0 { .. } => factorisation.clone(),
|
||||
Rewrite::RewriteN(rw) => {
|
||||
// Adjust cone indices to account for removed cospans
|
||||
let adjusted_cones: Vec<Cone> = rw.cones
|
||||
.iter()
|
||||
.map(|cone| {
|
||||
let new_index = adjust_index(cone.index, removed_indices);
|
||||
Cone::new(
|
||||
new_index,
|
||||
cone.source.clone(),
|
||||
cone.target.clone(),
|
||||
cone.slices.clone(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
DiagramMap::new(Rewrite::RewriteN(RewriteN {
|
||||
dimension: rw.dimension,
|
||||
cones: adjusted_cones,
|
||||
}))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Adjust an index after removing certain positions.
|
||||
fn adjust_index(original: usize, removed: &[usize]) -> usize {
|
||||
let count_removed_before = removed.iter().filter(|&&r| r < original).count();
|
||||
original - count_removed_before
|
||||
}
|
||||
|
||||
/// Compose two degeneracy maps: d = dS o dP (dS after dP).
|
||||
///
|
||||
/// For degeneracies, composition respects the factorisation:
|
||||
/// - simple o parallel = general degeneracy
|
||||
fn compose_degeneracies(d_simple: &DiagramMap, d_parallel: &DiagramMap) -> DiagramMap {
|
||||
if d_simple.is_identity() {
|
||||
d_parallel.clone()
|
||||
} else if d_parallel.is_identity() {
|
||||
d_simple.clone()
|
||||
} else {
|
||||
// Full composition needed
|
||||
d_parallel.clone()
|
||||
d_simple.compose(d_parallel)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -425,4 +690,137 @@ mod tests {
|
|||
|
||||
assert_eq!(once.normal_form, twice.normal_form);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalise_removes_identity_cospan() {
|
||||
// Create a diagram with an identity cospan: r0 -> s0 <- r1
|
||||
// where both legs are identities
|
||||
let g = Generator::point(0);
|
||||
let d0 = Diagram::Diagram0(g);
|
||||
|
||||
// Create a length-1 diagram with identity cospan
|
||||
let identity_cospan = Cospan::new(Rewrite::Identity, Rewrite::Identity);
|
||||
let d1 = Diagram::DiagramN(DiagramN::new(d0.clone(), vec![identity_cospan]));
|
||||
|
||||
let result = d1.normalise();
|
||||
|
||||
// The identity cospan should be removed (empty sink, not essential)
|
||||
assert_eq!(result.normal_form.length(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalise_preserves_non_identity_cospan() {
|
||||
// Create a diagram with a non-identity cospan
|
||||
let g0 = Generator::point(0);
|
||||
let g1 = Generator::point(1);
|
||||
|
||||
let d0 = Diagram::Diagram0(g0.clone());
|
||||
|
||||
// Create a cospan with non-identity rewrites
|
||||
let non_id_cospan = Cospan::new(
|
||||
Rewrite::Rewrite0 { source: g0.clone(), target: g1.clone() },
|
||||
Rewrite::Rewrite0 { source: g0.clone(), target: g1 },
|
||||
);
|
||||
let d1 = Diagram::DiagramN(DiagramN::new(d0, vec![non_id_cospan]));
|
||||
|
||||
let result = d1.normalise();
|
||||
|
||||
// The non-identity cospan should be preserved
|
||||
assert_eq!(result.normal_form.length(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalise_preserves_essential_identity() {
|
||||
// Test case for essential identities (dimension >= 4 scenario)
|
||||
// In this simplified test, we create a situation where an identity
|
||||
// cospan is in the image of a sink map, making it essential
|
||||
let g = Generator::point(0);
|
||||
let d0 = Diagram::Diagram0(g);
|
||||
|
||||
// Create a diagram with identity cospan
|
||||
let identity_cospan = Cospan::new(Rewrite::Identity, Rewrite::Identity);
|
||||
let d1 = Diagram::DiagramN(DiagramN::new(d0.clone(), vec![identity_cospan]));
|
||||
|
||||
// Create a sink map that maps to this singular height
|
||||
// This makes the identity cospan essential
|
||||
let sink_map = DiagramMap::new(Rewrite::RewriteN(RewriteN {
|
||||
dimension: 1,
|
||||
cones: vec![Cone::new(
|
||||
0, // Maps to singular height 0
|
||||
vec![],
|
||||
Cospan::new(Rewrite::Identity, Rewrite::Identity),
|
||||
vec![],
|
||||
)],
|
||||
}));
|
||||
|
||||
let sink = Sink::new(&d1, vec![sink_map]);
|
||||
let result = normalise_sink(&sink);
|
||||
|
||||
// The identity cospan should be preserved because it's in the sink image
|
||||
assert_eq!(result.normal_form.length(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalisation_factorisations_correct() {
|
||||
// Test that factorisations are correctly computed
|
||||
let g = Generator::point(0);
|
||||
let d = Diagram::Diagram0(g);
|
||||
|
||||
let sink_map = DiagramMap::identity(&d);
|
||||
let sink = Sink::new(&d, vec![sink_map]);
|
||||
let result = normalise_sink(&sink);
|
||||
|
||||
// The factorisation should exist for each sink map
|
||||
assert_eq!(result.factorisations.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_adjust_index() {
|
||||
// Test index adjustment after removal
|
||||
assert_eq!(adjust_index(0, &[]), 0);
|
||||
assert_eq!(adjust_index(3, &[1, 2]), 1);
|
||||
assert_eq!(adjust_index(5, &[0, 2, 4]), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalise_multiple_identity_cospans() {
|
||||
// Create a diagram with multiple identity cospans
|
||||
let g = Generator::point(0);
|
||||
let d0 = Diagram::Diagram0(g);
|
||||
|
||||
let identity_cospan = Cospan::new(Rewrite::Identity, Rewrite::Identity);
|
||||
let d3 = Diagram::DiagramN(DiagramN::new(
|
||||
d0.clone(),
|
||||
vec![identity_cospan.clone(), identity_cospan.clone(), identity_cospan],
|
||||
));
|
||||
|
||||
let result = d3.normalise();
|
||||
|
||||
// All identity cospans should be removed (empty sink)
|
||||
assert_eq!(result.normal_form.length(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sink_empty() {
|
||||
let g = Generator::point(0);
|
||||
let d = Diagram::Diagram0(g);
|
||||
|
||||
let sink = Sink::empty(&d);
|
||||
assert!(sink.maps.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_in_sink_image_empty() {
|
||||
// With no factorisations, nothing is in the sink image
|
||||
assert!(!is_in_sink_image(0, &[]));
|
||||
assert!(!is_in_sink_image(5, &[]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_is_in_sink_image_with_identity() {
|
||||
// Identity factorisation maps all heights to themselves
|
||||
let id = DiagramMap::new(Rewrite::Identity);
|
||||
assert!(is_in_sink_image(0, &[id.clone()]));
|
||||
assert!(is_in_sink_image(10, &[id]));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue