use std::sync::Arc;
use crate::basic::{BasicDecomposition, ProjectiveSupport};
use crate::context::VerificationContext;
use crate::module::Module;
use crate::taurigid::{
TauCache, TauRigidError, TauRigidModule, TauRigidityOutcome, is_tau_rigid_summandwise,
is_tau_rigid_summandwise_with_context,
};
use super::errors::{Checked, PairRejection, SupportTauError};
pub(super) fn check_conditions(
module: &BasicDecomposition,
projective: &ProjectiveSupport,
expected: usize,
summand_indices: &[usize],
cache: Option<&mut TauCache>,
) -> Result<Checked, SupportTauError> {
let mut owned = TauCache::new();
let cache = cache.unwrap_or(&mut owned);
check_conditions_with(module, projective, expected, summand_indices, |summands| {
is_tau_rigid_summandwise(summands, cache)
})
}
pub(super) fn check_conditions_with_context(
module: &BasicDecomposition,
projective: &ProjectiveSupport,
expected: usize,
summand_indices: &[usize],
context: &VerificationContext,
) -> Result<Checked, SupportTauError> {
check_conditions_with(module, projective, expected, summand_indices, |summands| {
is_tau_rigid_summandwise_with_context(summands, context)
})
}
fn check_conditions_with(
module: &BasicDecomposition,
projective: &ProjectiveSupport,
expected: usize,
summand_indices: &[usize],
mut rigidity: impl FnMut(&[(usize, Module)]) -> Result<TauRigidityOutcome, TauRigidError>,
) -> Result<Checked, SupportTauError> {
if summand_indices.len() != module.len() {
return Err(SupportTauError::SummandIndexCount {
indices: summand_indices.len(),
summands: module.len(),
});
}
if !Arc::ptr_eq(module.module().algebra(), projective.algebra()) {
return Ok(Checked::Rejected(PairRejection::DifferentAlgebras));
}
let dims = module.module().dim_vector();
if let Some(&vertex) = projective
.vertices()
.iter()
.find(|&&v| dims[v as usize] != 0)
{
return Ok(Checked::Rejected(PairRejection::HomFromProjectiveNonzero {
vertex,
dim: dims[vertex as usize],
}));
}
let summands: Vec<(usize, Module)> = summand_indices
.iter()
.zip(module.summands())
.map(|(&index, x)| (index, x.module().clone()))
.collect();
let rigid = match rigidity(&summands)? {
TauRigidityOutcome::TauRigid(rigid) => rigid,
TauRigidityOutcome::NotTauRigid(witness) => {
return Ok(Checked::Rejected(PairRejection::NotTauRigid(witness)));
}
};
if module.len() + projective.len() != expected {
return Ok(Checked::Rejected(PairRejection::SummandCount {
module: module.len(),
projective: projective.len(),
expected,
}));
}
Ok(Checked::Accepted(rigid))
}
pub(super) fn vertex_count(module: &BasicDecomposition) -> usize {
module.module().algebra().quiver().num_vertices() as usize
}
pub(super) fn positional(module: &BasicDecomposition) -> Vec<usize> {
(0..module.len()).collect()
}
pub(super) fn support_complement(module: &BasicDecomposition) -> Vec<u32> {
module
.module()
.dim_vector()
.iter()
.enumerate()
.filter(|&(_, &dim)| dim == 0)
.map(|(vertex, _)| vertex as u32)
.collect()
}
pub(super) fn as_support(module: &BasicDecomposition, vertices: &[u32]) -> ProjectiveSupport {
ProjectiveSupport::new(module.module().algebra(), vertices)
.expect("the support complement lists vertices of the module's own algebra")
}
fn omitted_vertices(module: &BasicDecomposition, projective: &ProjectiveSupport) -> Vec<u32> {
support_complement(module)
.into_iter()
.filter(|&v| !projective.contains(v))
.collect()
}
pub(super) fn checked_omissions(
module: &BasicDecomposition,
projective: &ProjectiveSupport,
limit: usize,
subject: &str,
) -> Result<Vec<u32>, SupportTauError> {
let omitted = omitted_vertices(module, projective);
if omitted.len() > limit {
return Err(SupportTauError::Defect {
reason: format!(
"{subject} with module dimension vectors {:?} and support {:?} left the vertices \
{omitted:?} out of the support complement",
module.dim_vectors(),
projective.vertices()
),
});
}
Ok(omitted)
}
pub(super) fn recheck_shared(
module: &BasicDecomposition,
projective_len: usize,
rigid: &TauRigidModule,
expected: usize,
) -> bool {
verify_guard!(module.len() + projective_len == expected);
verify_guard!(rigid.summands().len() == module.len());
rigid
.summands()
.iter()
.zip(module.summands())
.all(|((_, stored), x)| stored.ptr_eq(x.module()))
}