use std::sync::Arc;
use crate::algebra::Algebra;
use crate::complex_target::{
ComplexTargetError, ComplexTargetOutcome, VerifiedComplexTargetPresentation,
present_complex_target,
};
use crate::target::TargetLimits;
use crate::tilting_complex::CertifiedTiltingComplex;
fn same_algebra(left: &Algebra, right: &Algebra) -> bool {
left.certificate() == right.certificate()
}
#[derive(Clone, Debug)]
pub struct DerivedEquivalenceEdge {
tilting: CertifiedTiltingComplex,
target: VerifiedComplexTargetPresentation,
}
impl DerivedEquivalenceEdge {
pub fn recover(
tilting: CertifiedTiltingComplex,
limits: &TargetLimits,
) -> Result<DerivedEquivalenceEdgeOutcome, ComplexTargetError> {
match present_complex_target(&tilting, limits)? {
ComplexTargetOutcome::Presented(target) => Ok(
DerivedEquivalenceEdgeOutcome::Certified(Box::new(DerivedEquivalenceEdge {
tilting,
target: *target,
})),
),
ComplexTargetOutcome::Cut(cut) => Ok(DerivedEquivalenceEdgeOutcome::Cut(cut)),
}
}
accessor_methods! {
pub source() -> &Arc<Algebra> = |this| this.tilting.candidate().algebra();
pub tilting() -> &CertifiedTiltingComplex = |this| &this.tilting;
pub target_presentation() -> &VerifiedComplexTargetPresentation = |this| &this.target;
pub target() -> &Arc<Algebra> = |this| this.target.target();
}
pub fn verify(&self) -> bool {
self.tilting.verify()
&& self.target.verify()
&& self
.target
.tilting()
.candidate()
.summands()
.iter()
.zip(self.tilting.candidate().summands())
.all(|(left, right)| left.complex().agrees_with(right.complex()))
}
pub fn path(&self) -> DerivedEquivalencePath {
DerivedEquivalencePath {
source: self.source().clone(),
steps: vec![DirectedDerivedEquivalence {
edge: self.clone(),
direction: EquivalenceDirection::Forward,
}],
}
}
pub fn inverse(&self) -> DirectedDerivedEquivalence {
DirectedDerivedEquivalence {
edge: self.clone(),
direction: EquivalenceDirection::Inverse,
}
}
}
#[derive(Clone, Debug)]
pub enum DerivedEquivalenceEdgeOutcome {
Certified(Box<DerivedEquivalenceEdge>),
Cut(Box<crate::complex_target::ComplexTargetCut>),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum EquivalenceDirection {
Forward,
Inverse,
}
#[derive(Clone, Debug)]
pub struct DirectedDerivedEquivalence {
edge: DerivedEquivalenceEdge,
direction: EquivalenceDirection,
}
impl DirectedDerivedEquivalence {
accessor_methods! {
pub edge() -> &DerivedEquivalenceEdge = |this| &this.edge;
pub direction() -> EquivalenceDirection = |this| this.direction;
}
pub fn source(&self) -> &Arc<Algebra> {
match self.direction {
EquivalenceDirection::Forward => self.edge.source(),
EquivalenceDirection::Inverse => self.edge.target(),
}
}
pub fn target(&self) -> &Arc<Algebra> {
match self.direction {
EquivalenceDirection::Forward => self.edge.target(),
EquivalenceDirection::Inverse => self.edge.source(),
}
}
pub fn inverse(&self) -> DirectedDerivedEquivalence {
DirectedDerivedEquivalence {
edge: self.edge.clone(),
direction: match self.direction {
EquivalenceDirection::Forward => EquivalenceDirection::Inverse,
EquivalenceDirection::Inverse => EquivalenceDirection::Forward,
},
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum EquivalenceCompositionError {
AlgebraMismatch,
}
display_error! { error EquivalenceCompositionError {
Self::AlgebraMismatch => "equivalence paths meet at different algebras";
} }
#[derive(Clone, Debug)]
pub struct DerivedEquivalencePath {
source: Arc<Algebra>,
steps: Vec<DirectedDerivedEquivalence>,
}
impl DerivedEquivalencePath {
pub fn identity(algebra: &Arc<Algebra>) -> DerivedEquivalencePath {
DerivedEquivalencePath {
source: algebra.clone(),
steps: Vec::new(),
}
}
accessor_methods! {
pub source() -> &Arc<Algebra> = |this| &this.source;
pub steps() -> &[DirectedDerivedEquivalence] = |this| &this.steps;
}
pub fn target(&self) -> &Arc<Algebra> {
self.steps
.last()
.map_or(&self.source, DirectedDerivedEquivalence::target)
}
pub fn then_edge(
&self,
next: DirectedDerivedEquivalence,
) -> Result<DerivedEquivalencePath, EquivalenceCompositionError> {
if !same_algebra(self.target(), next.source()) {
return Err(EquivalenceCompositionError::AlgebraMismatch);
}
let mut steps = self.steps.clone();
steps.push(next);
Ok(DerivedEquivalencePath {
source: self.source.clone(),
steps,
})
}
pub fn then(
&self,
next: &DerivedEquivalencePath,
) -> Result<DerivedEquivalencePath, EquivalenceCompositionError> {
if !same_algebra(self.target(), next.source()) {
return Err(EquivalenceCompositionError::AlgebraMismatch);
}
let mut steps = self.steps.clone();
steps.extend(next.steps.clone());
Ok(DerivedEquivalencePath {
source: self.source.clone(),
steps,
})
}
pub fn inverse(&self) -> DerivedEquivalencePath {
DerivedEquivalencePath {
source: self.target().clone(),
steps: self
.steps
.iter()
.rev()
.map(DirectedDerivedEquivalence::inverse)
.collect(),
}
}
pub fn verify(&self) -> bool {
let mut current = &self.source;
for step in &self.steps {
if !step.edge.verify() || !same_algebra(current, step.source()) {
return false;
}
current = step.target();
}
true
}
}