use crate::basic::{BasicDecomposition, ProjectiveSupport};
use crate::context::VerificationContext;
use crate::profile::{Site, hit};
use crate::taurigid::{TauCache, TauRigidModule};
use super::conditions::{
as_support, check_conditions, check_conditions_with_context, checked_omissions, positional,
recheck_shared, support_complement, vertex_count,
};
use super::errors::{Checked, PairRejection, SupportTauError};
pub struct SupportTauTiltingPair {
pub(super) module: BasicDecomposition,
pub(super) rigid: TauRigidModule,
}
debug_fields!(SupportTauTiltingPair |this| {
"module_dim_vectors" => this.module.dim_vectors();
"projective_support" => support_complement(&this.module);
});
#[derive(Debug)]
pub enum SupportTauTiltingClassification {
Pair(SupportTauTiltingPair),
Rejected(PairRejection),
}
impl SupportTauTiltingClassification {
binary_outcome_accessors!(
Pair,
Rejected,
pair -> SupportTauTiltingPair = |value| value,
rejection -> PairRejection = |value| value,
is_pair,
into_pair -> SupportTauTiltingPair = |value| value;
flag = "Whether the candidate is a pair.";
positive = "The pair, or `None` for a rejection.";
negative = "The rejection, or `None` for a pair.";
into = "Takes the pair out, or `None` for a rejection.";
);
}
impl SupportTauTiltingPair {
pub fn classify_with_cache(
module: BasicDecomposition,
projective: ProjectiveSupport,
summand_indices: &[usize],
cache: Option<&mut TauCache>,
) -> Result<SupportTauTiltingClassification, SupportTauError> {
hit(Site::SupportPairClassify);
let expected = vertex_count(&module);
let checked = check_conditions(&module, &projective, expected, summand_indices, cache)?;
Self::from_checked(module, projective, checked)
}
pub(crate) fn classify_with_context(
module: BasicDecomposition,
projective: ProjectiveSupport,
context: &VerificationContext,
) -> Result<SupportTauTiltingClassification, SupportTauError> {
hit(Site::SupportPairClassify);
let expected = vertex_count(&module);
let checked = check_conditions_with_context(
&module,
&projective,
expected,
&positional(&module),
context,
)?;
Self::from_checked(module, projective, checked)
}
fn from_checked(
module: BasicDecomposition,
projective: ProjectiveSupport,
checked: Checked,
) -> Result<SupportTauTiltingClassification, SupportTauError> {
match checked {
Checked::Accepted(rigid) => {
checked_omissions(&module, &projective, 0, "a pair")?;
Ok(SupportTauTiltingClassification::Pair(
SupportTauTiltingPair { module, rigid },
))
}
Checked::Rejected(rejection) => {
Ok(SupportTauTiltingClassification::Rejected(rejection))
}
}
}
pub fn classify(
module: BasicDecomposition,
projective: ProjectiveSupport,
) -> Result<SupportTauTiltingClassification, SupportTauError> {
let indices = positional(&module);
Self::classify_with_cache(module, projective, &indices, None)
}
pub fn new(
module: BasicDecomposition,
projective: ProjectiveSupport,
) -> Result<Option<SupportTauTiltingPair>, SupportTauError> {
Ok(Self::classify(module, projective)?.into_pair())
}
accessor_methods! {
pub module() -> &BasicDecomposition = |this| &this.module;
pub rigid() -> &TauRigidModule = |this| &this.rigid;
pub projective() -> ProjectiveSupport = |this|
as_support(&this.module, &support_complement(&this.module));
pub is_tau_tilting() -> bool = |this|
this.module.module().dim_vector().iter().all(|&d| d > 0);
pub summand_count() -> usize = |this|
this.module.len() + support_complement(&this.module).len();
}
verify_methods!(pub(crate), { hit(Site::SupportPairVerify); },
|self, context| {
recheck_shared(
&self.module,
support_complement(&self.module).len(),
&self.rigid,
vertex_count(&self.module),
) && self.rigid.verify_with_context(context)
});
}