use crate::control::ComputationControl;
use crate::derived::{
AddTComplex, DerivedEquivalenceCertificate, ProjectiveTargetComplex, StrictTransport,
};
use crate::homotopy::BoundedComplex;
use crate::perfect::{
PerfectReplacement, ReplacementCancellation, ReplacementCut, ReplacementLimits,
ReplacementOutcome, replace_perfect,
};
use super::DerivedTransportError;
use super::model::{ProjectiveAddTModel, model_projective_complex};
#[derive(Clone)]
pub struct DerivedTransport {
certificate: DerivedEquivalenceCertificate,
}
impl DerivedTransport {
pub fn new(
certificate: DerivedEquivalenceCertificate,
) -> Result<DerivedTransport, DerivedTransportError> {
if !certificate.verify() {
return Err(DerivedTransportError::InvalidCertificate);
}
Ok(DerivedTransport { certificate })
}
accessor_methods! {
pub certificate() -> &DerivedEquivalenceCertificate = |this| &this.certificate;
pub strict() -> &StrictTransport = |this| this.certificate.transport();
}
pub fn forward(
&self,
input: &BoundedComplex,
limits: ReplacementLimits,
control: Option<&ComputationControl>,
) -> Result<DerivedForwardOutcome, DerivedTransportError> {
let replacement = match replace_perfect(input, limits, control)? {
ReplacementOutcome::Replaced(value) => value,
ReplacementOutcome::Cut(value) => {
return Ok(DerivedForwardOutcome::ReplacementCut(value));
}
ReplacementOutcome::Cancelled(value) => {
return Ok(DerivedForwardOutcome::ReplacementCancelled(value));
}
};
let source_model =
model_projective_complex(replacement.projective(), self.certificate.tilting())?;
let output = self.strict().forward(source_model.model())?;
Ok(DerivedForwardOutcome::Transported(Box::new(
DerivedForwardTransport {
certificate: self.certificate.clone(),
input: input.clone(),
replacement,
source_model,
output,
},
)))
}
pub fn reverse(
&self,
input: &BoundedComplex,
limits: ReplacementLimits,
control: Option<&ComputationControl>,
) -> Result<DerivedReverseOutcome, DerivedTransportError> {
let replacement = match replace_perfect(input, limits, control)? {
ReplacementOutcome::Replaced(value) => value,
ReplacementOutcome::Cut(value) => {
return Ok(DerivedReverseOutcome::ReplacementCut(value));
}
ReplacementOutcome::Cancelled(value) => {
return Ok(DerivedReverseOutcome::ReplacementCancelled(value));
}
};
let strict_input = self
.strict()
.target_complex(replacement.projective().complex().clone())?;
let output = self.strict().reverse(&strict_input)?;
Ok(DerivedReverseOutcome::Transported(Box::new(
DerivedReverseTransport {
certificate: self.certificate.clone(),
input: input.clone(),
replacement,
strict_input,
output,
},
)))
}
pub fn derived_tensor(
&self,
input: &BoundedComplex,
limits: ReplacementLimits,
control: Option<&ComputationControl>,
) -> Result<DerivedReverseOutcome, DerivedTransportError> {
self.reverse(input, limits, control)
}
}
#[derive(Clone)]
pub struct DerivedForwardTransport {
certificate: DerivedEquivalenceCertificate,
input: BoundedComplex,
replacement: PerfectReplacement,
source_model: ProjectiveAddTModel,
output: ProjectiveTargetComplex,
}
impl DerivedForwardTransport {
accessor_methods! {
pub input() -> &BoundedComplex = |this| &this.input;
pub replacement() -> &PerfectReplacement = |this| &this.replacement;
pub source_model() -> &ProjectiveAddTModel = |this| &this.source_model;
pub output() -> &ProjectiveTargetComplex = |this| &this.output;
}
pub fn verify(&self) -> bool {
self.certificate.verify()
&& self.input.verify()
&& self.replacement.verify()
&& self.replacement.original().agrees_with(&self.input)
&& self.source_model.verify()
&& self.output.verify()
&& model_projective_complex(self.replacement.projective(), self.certificate.tilting())
.is_ok_and(|model| {
model
.model()
.complex()
.agrees_with(self.source_model.model().complex())
&& self
.certificate
.transport()
.forward(model.model())
.is_ok_and(|output| output.complex().agrees_with(self.output.complex()))
})
}
}
#[derive(Clone)]
pub enum DerivedForwardOutcome {
Transported(Box<DerivedForwardTransport>),
ReplacementCut(ReplacementCut),
ReplacementCancelled(ReplacementCancellation),
}
impl DerivedForwardOutcome {
optional_accessors! {
pub transported() -> &DerivedForwardTransport = Self::Transported(value) => value;
pub replacement_cut() -> &ReplacementCut = Self::ReplacementCut(value) => value;
pub replacement_cancellation() -> &ReplacementCancellation = Self::ReplacementCancelled(value) => value;
}
}
#[derive(Clone)]
pub struct DerivedReverseTransport {
certificate: DerivedEquivalenceCertificate,
input: BoundedComplex,
replacement: PerfectReplacement,
strict_input: ProjectiveTargetComplex,
output: AddTComplex,
}
impl DerivedReverseTransport {
accessor_methods! {
pub input() -> &BoundedComplex = |this| &this.input;
pub replacement() -> &PerfectReplacement = |this| &this.replacement;
pub strict_input() -> &ProjectiveTargetComplex = |this| &this.strict_input;
pub output() -> &AddTComplex = |this| &this.output;
}
pub fn verify(&self) -> bool {
if !self.certificate.verify()
|| !self.input.verify()
|| !self.replacement.verify()
|| !self.replacement.original().agrees_with(&self.input)
|| !self.strict_input.verify()
|| !self.output.verify()
{
return false;
}
let strict = self.certificate.transport();
strict
.target_complex(self.replacement.projective().complex().clone())
.is_ok_and(|input| {
input.complex().agrees_with(self.strict_input.complex())
&& strict
.reverse(&input)
.is_ok_and(|output| output.complex().agrees_with(self.output.complex()))
})
}
}
#[derive(Clone)]
pub enum DerivedReverseOutcome {
Transported(Box<DerivedReverseTransport>),
ReplacementCut(ReplacementCut),
ReplacementCancelled(ReplacementCancellation),
}
impl DerivedReverseOutcome {
optional_accessors! {
pub transported() -> &DerivedReverseTransport = Self::Transported(value) => value;
pub replacement_cut() -> &ReplacementCut = Self::ReplacementCut(value) => value;
pub replacement_cancellation() -> &ReplacementCancellation = Self::ReplacementCancelled(value) => value;
}
}