use super::*;
#[derive(Clone, Debug)]
pub enum TiltingMutationOutcome {
Tilting(Box<CertifiedTiltingComplex>),
SiltingOnly(Box<TiltingSelfOrthogonalityRejection>),
Silting(Box<CertifiedSiltingComplex>),
Undetermined(TiltingComplexBlocker),
}
pub(super) fn cone_replacement(
map: &ChainMap,
direction: ApproximationDirection,
) -> Result<BoundedComplex, BoundedComplexError> {
let cone = map.mapping_cone()?;
match direction {
ApproximationDirection::Left => Ok(cone),
ApproximationDirection::Right => cone.shift(-1),
}
}
fn mutated_candidate(
parent: &CertifiedSiltingComplex,
approximation: &ComplexApproximationWitness,
) -> TiltingComplexCandidate {
let mut summands = parent.candidate().summands().to_vec();
summands[approximation.replaced] = approximation.reduction.minimal().clone();
TiltingComplexCandidate::new(summands)
.expect("mutation keeps nonzero summands over one algebra")
}
pub(crate) fn tilting_mutation(
parent: &CertifiedSiltingComplex,
replaced: usize,
limits: TiltingComplexLimits,
step: (ApproximationDirection, OrthogonalityGoal),
) -> Result<TiltingMutationOutcome, TiltingComplexError> {
let mut meter = WorkMeter::default();
unmetered(tilting_mutation_with_cache(
parent, replaced, limits, step, true, &mut meter,
))
}
pub(crate) fn metered_tilting_mutation(
parent: &CertifiedSiltingComplex,
replaced: usize,
limits: TiltingComplexLimits,
step: (ApproximationDirection, OrthogonalityGoal),
meter: &mut WorkMeter,
) -> Result<TiltingMutationOutcome, Interrupt> {
tilting_mutation_with_cache(parent, replaced, limits, step, true, meter)
}
pub(super) fn tilting_mutation_with_cache(
parent: &CertifiedSiltingComplex,
replaced: usize,
limits: TiltingComplexLimits,
(direction, goal): (ApproximationDirection, OrthogonalityGoal),
reuse: bool,
meter: &mut WorkMeter,
) -> Result<TiltingMutationOutcome, Interrupt> {
if replaced >= parent.candidate().len() {
return Ok(TiltingMutationOutcome::Undetermined(
TiltingComplexBlocker::Generation,
));
}
let mut blocks = mutation_blocks(parent, reuse, meter);
let (map, indices) = approximation_map_with_blocks(parent, replaced, direction, &mut blocks)?;
let cone = ProjectiveComplex::new(cone_replacement(&map, direction)?)?;
let Some(reduction) = MinimalReduction::new(&cone, blocks.meter)? else {
return Ok(TiltingMutationOutcome::Undetermined(
TiltingComplexBlocker::EndomorphismLocality {
summand: replaced,
dimension: 0,
},
));
};
let approximation = ComplexApproximationWitness {
direction,
replaced,
indices,
map,
reduction: Box::new(reduction),
};
let candidate = mutated_candidate(parent, &approximation);
blocks.set_changed(replaced);
let generation = ThickGenerationWitness::Mutation {
parent: Arc::new(parent.clone()),
approximation,
};
let classified =
classify_tilting_complex_inner(candidate, Some(generation), limits, blocks, false, goal);
mutation_outcome(classified)
}
fn mutation_blocks<'a>(
parent: &'a CertifiedSiltingComplex,
reuse: bool,
meter: &'a mut WorkMeter,
) -> HomotopyBlockBuilder<'a> {
if reuse {
HomotopyBlockBuilder::with_inherited(parent.block_cache(), meter)
} else {
HomotopyBlockBuilder::cold(meter)
}
}
fn mutation_outcome(
classified: Result<Box<CertifiedSiltingComplex>, ClassificationFailure>,
) -> Result<TiltingMutationOutcome, Interrupt> {
match classified {
Ok(certified) if certified.negative_class.is_some() => {
Ok(TiltingMutationOutcome::Silting(certified))
}
Ok(certified) => Ok(TiltingMutationOutcome::Tilting(Box::new(
CertifiedTiltingComplex {
silting: *certified,
},
))),
Err(ClassificationFailure::Outcome(outcome)) => Ok(failed_outcome(outcome)),
Err(ClassificationFailure::Interrupt(interrupt)) => Err(interrupt),
}
}
fn failed_outcome(outcome: TiltingComplexResult) -> TiltingMutationOutcome {
match outcome {
TiltingComplexResult::NotTilting(rejection) => {
assert!(rejection.degree < 0, "a mutation lost silting; library bug");
TiltingMutationOutcome::SiltingOnly(rejection)
}
TiltingComplexResult::Undetermined(blocker) => {
TiltingMutationOutcome::Undetermined(blocker)
}
TiltingComplexResult::Tilting(_) => unreachable!("a failed classification is not tilting"),
}
}
pub fn left_tilting_mutation(
parent: &CertifiedTiltingComplex,
replaced: usize,
limits: TiltingComplexLimits,
) -> Result<TiltingMutationOutcome, TiltingComplexError> {
let step = (ApproximationDirection::Left, OrthogonalityGoal::Tilting);
tilting_mutation(parent, replaced, limits, step)
}
pub fn right_tilting_mutation(
parent: &CertifiedTiltingComplex,
replaced: usize,
limits: TiltingComplexLimits,
) -> Result<TiltingMutationOutcome, TiltingComplexError> {
let step = (ApproximationDirection::Right, OrthogonalityGoal::Tilting);
tilting_mutation(parent, replaced, limits, step)
}
pub fn silting_mutation(
parent: &CertifiedSiltingComplex,
replaced: usize,
direction: ApproximationDirection,
limits: TiltingComplexLimits,
) -> Result<TiltingMutationOutcome, TiltingComplexError> {
tilting_mutation(
parent,
replaced,
limits,
(direction, OrthogonalityGoal::Silting),
)
}