use crate::hom::HomError;
use crate::homotopy::{BoundedComplex, BoundedComplexError, ChainMap, ChainMapError};
use super::cover::ComplexProjectiveCoverError;
use super::quasi::{
QuasiIsomorphism, QuasiIsomorphismError, agrees_with_zero_padding, same_nominal_complex,
};
use super::term::{ProjectiveComplex, ProjectiveComplexError};
#[derive(Clone, Debug)]
pub enum ReplacementError {
Cover(ComplexProjectiveCoverError),
Arithmetic,
DegreeOverflow,
Complex(BoundedComplexError),
Chain(ChainMapError),
Hom(HomError),
Projective(ProjectiveComplexError),
QuasiIsomorphism(QuasiIsomorphismError),
Replacement(PerfectReplacementError),
}
display_error! { ReplacementError {
Self::Cover(error) => "complex-resolution cover failed: {error}";
Self::Arithmetic => "replacement resource count overflowed";
Self::DegreeOverflow => "replacement total degree overflowed";
Self::Complex(error) => "replacement total complex is invalid: {error}";
Self::Chain(error) => "replacement augmentation is invalid: {error}";
Self::Hom(error) => "replacement total component is invalid: {error}";
Self::Projective(error) => "replacement total term is not projective: {error}";
Self::QuasiIsomorphism(error) => "replacement augmentation is not a quasi-isomorphism: {error}";
Self::Replacement(error) => "replacement endpoints are invalid: {error}";
} }
error_source! { ReplacementError {
Self::Cover(error) => Some(error),
Self::Complex(error) => Some(error),
Self::Chain(error) => Some(error),
Self::Hom(error) => Some(error),
Self::Projective(error) => Some(error),
Self::QuasiIsomorphism(error) => Some(error),
Self::Replacement(error) => Some(error),
Self::Arithmetic | Self::DegreeOverflow => None,
} }
from_variants! { ReplacementError {
ComplexProjectiveCoverError => Cover,
BoundedComplexError => Complex,
ChainMapError => Chain,
HomError => Hom,
ProjectiveComplexError => Projective,
QuasiIsomorphismError => QuasiIsomorphism,
PerfectReplacementError => Replacement,
} }
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PerfectReplacementError {
SourceMismatch,
TargetMismatch,
}
display_error! { error PerfectReplacementError {
Self::SourceMismatch => "replacement map does not start at the projective model";
Self::TargetMismatch => "replacement map does not end at the original complex";
} }
#[derive(Clone, Debug)]
pub struct PerfectReplacement {
original: BoundedComplex,
projective: ProjectiveComplex,
quasi_isomorphism: QuasiIsomorphism,
}
impl PerfectReplacement {
pub fn new(
original: BoundedComplex,
projective: ProjectiveComplex,
quasi_isomorphism: QuasiIsomorphism,
) -> Result<PerfectReplacement, PerfectReplacementError> {
if !same_nominal_complex(projective.complex(), quasi_isomorphism.map().source()) {
return Err(PerfectReplacementError::SourceMismatch);
}
if !agrees_with_zero_padding(&original, quasi_isomorphism.map().target()) {
return Err(PerfectReplacementError::TargetMismatch);
}
Ok(PerfectReplacement {
original,
projective,
quasi_isomorphism,
})
}
pub fn identity(projective: ProjectiveComplex) -> PerfectReplacement {
let original = projective.complex().clone();
let quasi_isomorphism = QuasiIsomorphism::new(ChainMap::identity(&original))
.expect("the cone of an identity chain map is exact");
PerfectReplacement::new(original, projective, quasi_isomorphism)
.expect("the identity map has the stored complex as both endpoints")
}
accessor_methods! {
pub original() -> &BoundedComplex = |this| &this.original;
pub projective() -> &ProjectiveComplex = |this| &this.projective;
pub quasi_isomorphism() -> &QuasiIsomorphism = |this| &this.quasi_isomorphism;
}
pub fn verify(&self) -> bool {
self.original.verify()
&& self.projective.verify()
&& self.quasi_isomorphism.verify()
&& PerfectReplacement::new(
self.original.clone(),
self.projective.clone(),
self.quasi_isomorphism.clone(),
)
.is_ok()
}
}