use std::sync::Arc;
use crate::algebra::{Algebra, AlgebraBuildError};
use crate::basic::BasicError;
use crate::certificate::Certificate;
use crate::completion::{CompletionLimits, TruncationDiagnostics};
use crate::decompose::Split;
use crate::endo::EndoAlgebra;
use crate::field::Fp;
use crate::homspace::row_times;
use crate::linalg::DenseMat;
use crate::module::Module;
use crate::relation::RelationError;
use crate::tilting::{ClassicalTiltingModule, ClassicalTiltingResult, TiltingLimits};
use super::{present_target, verify_target};
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TargetLimits {
pub max_endo_dimension: u64,
pub max_radical_products: u64,
pub max_paths: u64,
pub max_relation_terms: u64,
pub completion: CompletionLimits,
}
impl Default for TargetLimits {
fn default() -> TargetLimits {
TargetLimits {
max_endo_dimension: 4096,
max_radical_products: 1_000_000,
max_paths: 1_000_000,
max_relation_terms: 1_000_000,
completion: CompletionLimits::default(),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TargetCutStage {
EndoDimension,
RadicalPower { power: usize },
RadicalCorner {
source: u32,
target: u32,
power: usize,
},
Paths { length: usize },
Relations { source: u32, target: u32 },
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TargetBudgetCut {
pub stage: TargetCutStage,
pub used: u64,
pub requested: u64,
pub limit: u64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TargetCutReason {
Budget(TargetBudgetCut),
Completion(TruncationDiagnostics),
}
#[derive(Clone, Debug)]
pub struct TargetPresentationCut {
pub(crate) source: Module,
pub(crate) tilting_limits: TiltingLimits,
pub(crate) limits: TargetLimits,
pub(crate) reason: TargetCutReason,
}
impl TargetPresentationCut {
accessor_methods! {
pub source() -> &Module = |this| &this.source;
pub tilting_limits() -> TiltingLimits = |this| this.tilting_limits;
pub limits() -> &TargetLimits = |this| &this.limits;
pub reason() -> &TargetCutReason = |this| &this.reason;
}
pub fn verify(&self) -> bool {
let Ok(ClassicalTiltingResult::Tilting(tilting)) =
ClassicalTiltingModule::classify(&self.source, self.tilting_limits)
else {
return false;
};
if !tilting.verify() {
return false;
}
matches!(
present_target(&tilting, &self.limits),
Ok(TargetPresentationOutcome::Cut(cut)) if cut.reason == self.reason
)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct TargetWork {
pub endo_dimension: u64,
pub radical_products: u64,
pub paths: u64,
pub relation_terms: u64,
}
#[derive(Clone, Debug)]
pub struct NonSplitTarget {
pub(crate) module: Module,
pub(crate) tilting_limits: TiltingLimits,
pub(crate) limits: TargetLimits,
pub(crate) summand: usize,
pub(crate) residue_degree: usize,
}
impl NonSplitTarget {
accessor_methods! {
pub module() -> &Module = |this| &this.module;
pub limits() -> &TargetLimits = |this| &this.limits;
pub summand() -> usize = |this| this.summand;
pub residue_degree() -> usize = |this| this.residue_degree;
}
pub fn verify(&self) -> bool {
let Ok(ClassicalTiltingResult::Tilting(tilting)) =
ClassicalTiltingModule::classify(&self.module, self.tilting_limits)
else {
return false;
};
tilting.verify()
&& matches!(
present_target(&tilting, &self.limits),
Ok(TargetPresentationOutcome::Unsupported(value))
if value.summand == self.summand
&& value.residue_degree == self.residue_degree
)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TargetError {
Basic(BasicError),
Relation(RelationError),
Algebra(AlgebraBuildError),
SizeOverflow { stage: TargetCutStage },
Defect { reason: String },
}
display_error! { TargetError {
Self::Basic(error) => "basic layer: {error}";
Self::Relation(error) => "relation rejected: {error}";
Self::Algebra(error) => "target algebra rejected: {error}";
Self::SizeOverflow { stage } => "target size overflowed at {stage:?}";
Self::Defect { reason } => "internal cross-check failed: {reason}";
} }
error_source! { TargetError {
Self::Basic(error) => Some(error),
Self::Relation(error) => Some(error),
Self::Algebra(error) => Some(error),
_ => None,
} }
from_variants! { TargetError {
BasicError => Basic,
RelationError => Relation,
} }
#[derive(Clone)]
pub struct VerifiedTargetPresentation {
pub(crate) source: Module,
pub(crate) tilting_limits: TiltingLimits,
pub(crate) limits: TargetLimits,
pub(crate) target: Arc<Algebra>,
pub(crate) endo: EndoAlgebra,
pub(crate) split: Split,
pub(crate) completion: Certificate,
pub(crate) idempotent_images: DenseMat,
pub(crate) arrow_images: DenseMat,
pub(crate) normal_word_images: DenseMat,
pub(crate) normal_word_preimages: DenseMat,
pub(crate) radical_nilpotency_index: usize,
pub(crate) work: TargetWork,
}
debug_fields!(VerifiedTargetPresentation |this| {
"source_dim_vector" => this.source.dim_vector();
"target_dim" => this.target.dim();
"arrows" => this.target.quiver().num_arrows();
"radical_nilpotency_index" => this.radical_nilpotency_index;
});
impl VerifiedTargetPresentation {
accessor_methods! {
pub source() -> &Module = |this| &this.source;
pub target() -> &Arc<Algebra> = |this| &this.target;
pub endo() -> &EndoAlgebra = |this| &this.endo;
pub split() -> &Split = |this| &this.split;
pub idempotent_images() -> &DenseMat = |this| &this.idempotent_images;
pub arrow_images() -> &DenseMat = |this| &this.arrow_images;
pub normal_word_images() -> &DenseMat = |this| &this.normal_word_images;
pub normal_word_preimages() -> &DenseMat = |this| &this.normal_word_preimages;
pub completion_certificate() -> &Certificate = |this| &this.completion;
pub radical_nilpotency_index() -> usize = |this| this.radical_nilpotency_index;
pub limits() -> &TargetLimits = |this| &this.limits;
pub work() -> TargetWork = |this| this.work;
}
pub fn map_coordinates(&self, coordinates: &[Fp]) -> Vec<Fp> {
assert_eq!(
coordinates.len(),
self.target.dim(),
"map_coordinates: target coordinate count"
);
row_times(coordinates, &self.normal_word_images, &self.target.field())
}
pub fn preimage_coordinates(&self, coordinates: &[Fp]) -> Vec<Fp> {
assert_eq!(
coordinates.len(),
self.endo.dim(),
"preimage_coordinates: endomorphism coordinate count"
);
row_times(
coordinates,
&self.normal_word_preimages,
&self.target.field(),
)
}
pub fn verify(&self) -> bool {
verify_target(self)
}
}
#[derive(Clone, Debug)]
#[allow(clippy::large_enum_variant)]
pub enum TargetPresentationOutcome {
Presented(VerifiedTargetPresentation),
Unsupported(NonSplitTarget),
Cut(TargetPresentationCut),
}
impl TargetPresentationOutcome {
optional_accessors! {
pub presented() -> &VerifiedTargetPresentation = Self::Presented(value) => value;
pub unsupported() -> &NonSplitTarget = Self::Unsupported(value) => value;
pub cut() -> &TargetPresentationCut = Self::Cut(value) => value;
}
pub fn verify(&self) -> bool {
match self {
Self::Presented(value) => value.verify(),
Self::Unsupported(value) => value.verify(),
Self::Cut(value) => value.verify(),
}
}
}