gammalooprs/processes/

threshold_counterterms.rs

use std::collections::{BTreeMap, BTreeSet};

use bincode_trait_derive::{Decode, Encode};
use color_eyre::eyre::{Result, eyre};
use linnet::half_edge::involution::EdgeIndex;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use typed_index_collections::TiVec;

use crate::{
    GammaLoopContext,
    cff::esurface::{EsurfaceID, RaisedEsurfaceGroup},
    define_index,
    graph::{
        LmbIndex, LoopMomentumBasis,
        threshold_counterterms::{
            ThresholdCountertermCut, ThresholdCountertermMultiplier, ThresholdCountertermSpec,
            ThresholdCountertermThreshold, ThresholdCountertermVariant,
        },
    },
    momentum::sample::SubspaceData,
};

use super::{CutGroupId, CutId};

define_index! {pub struct ThresholdCountertermVariantId;}

#[derive(
    Clone,
    Copy,
    Debug,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Encode,
    Decode,
    Serialize,
    Deserialize,
    JsonSchema,
)]
#[serde(rename_all = "snake_case")]
pub enum ThresholdCountertermSide {
    Amplitude,
    Left,
    Right,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ThresholdCountertermOrigin {
    Explicit,
    Autogenerated,
}

/// Physical association provenance retained without exposing internal Cartesian products.
#[derive(Clone, Debug, Encode, Decode)]
pub struct ResolvedThresholdCountertermAssociation {
    pub cut_id: Option<CutId>,
    pub cut_edges: Vec<EdgeIndex>,
    pub threshold_edges: Vec<EdgeIndex>,
    pub esurface_id: EsurfaceID,
    /// The association-local representation is retained because one raised semantic variant may
    /// aggregate equivalent subspaces expressed in different parent bases.
    pub subspace: SubspaceData,
    /// Whether omitting `parent_lmb` from a materialized default would select a different parent
    /// from the one used after graph-global cut-group rebasing.
    pub requires_explicit_parent_lmb: bool,
    pub eligible: bool,
    pub origin: ThresholdCountertermOrigin,
}

/// One independently generated threshold-counterterm variant after graph-local resolution.
#[derive(Clone, Debug, Encode, Decode)]
#[trait_decode(trait = GammaLoopContext)]
pub struct ResolvedThresholdCountertermVariant {
    pub name: String,
    pub group_id: Option<usize>,
    pub cut_group_id: Option<CutGroupId>,
    pub associations: Vec<ResolvedThresholdCountertermAssociation>,
    pub side: ThresholdCountertermSide,
    pub threshold_esurface_ids: Vec<EsurfaceID>,
    pub raised_esurface_group: RaisedEsurfaceGroup,
    pub requested_subspace: Option<Vec<EdgeIndex>>,
    pub requested_parent_lmb: Option<Vec<EdgeIndex>>,
    pub resolved_parent_lmb: Vec<EdgeIndex>,
    pub subspace: SubspaceData,
    pub subspace_loop_count: usize,
    pub multiplier: Option<ThresholdCountertermMultiplier>,
}

#[derive(Clone, Debug, Default, Encode, Decode)]
#[trait_decode(trait = GammaLoopContext)]
pub struct ResolvedCutGroupThresholdCounterterms {
    pub left: Vec<ThresholdCountertermVariantId>,
    pub right: Vec<ThresholdCountertermVariantId>,
}

impl ResolvedCutGroupThresholdCounterterms {
    pub(crate) fn iter_pairs(
        &self,
    ) -> impl Iterator<Item = (ThresholdCountertermVariantId, ThresholdCountertermVariantId)> + '_
    {
        self.left
            .iter()
            .copied()
            .flat_map(|left| self.right.iter().copied().map(move |right| (left, right)))
    }
}

/// Complete process-derived view. Pair products remain implicit in the left/right lists.
#[derive(Clone, Debug, Encode, Decode)]
#[trait_decode(trait = GammaLoopContext)]
pub struct ResolvedThresholdCounterterms {
    pub legacy_equivalent: bool,
    pub variants: TiVec<ThresholdCountertermVariantId, ResolvedThresholdCountertermVariant>,
    pub cross_section_cut_groups: TiVec<CutGroupId, ResolvedCutGroupThresholdCounterterms>,
}

/// Whether one resolved variant has symbolic content and can be reached by the generated
/// orientation subset. The two flags deliberately remain independent: an existing semantic slot
/// may be generated but inactive for a selected-orientation integrand.
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ThresholdCountertermVariantStatus {
    pub generated: bool,
    pub active: bool,
}

/// A cut-local evaluator and the variants that reference it before graph-local IDs are assigned.
///
/// Multiplier collections deduplicate canonical scalar expressions within one input layout. This
/// neutral registration type lets the process metadata layer retain that exact deduplication
/// without depending on evaluator implementation details.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ThresholdCountertermEvaluatorRegistration {
    pub cut_group_id: Option<usize>,
    pub collection_evaluator_id: usize,
    pub expression: String,
    pub variant_ids: Vec<usize>,
}

#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
pub struct ThresholdCountertermAssociationMetadata {
    pub cut_id: Option<usize>,
    pub cut_edges: Vec<usize>,
    pub threshold_edges: Vec<usize>,
    pub esurface_id: usize,
    pub eligible: bool,
    pub origin: ThresholdCountertermOrigin,
}

#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
pub struct ThresholdCountertermMultiplierMetadata {
    pub expression: String,
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub function_map: BTreeMap<String, String>,
    pub symmetrize: bool,
    pub opaque_derivatives: bool,
}

/// Stable graph-local metadata for one independently resolved counterterm variant.
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
pub struct ThresholdCountertermVariantMetadata {
    pub variant_id: usize,
    pub name: String,
    pub group_id: Option<usize>,
    pub cut_group_id: Option<usize>,
    pub associations: Vec<ThresholdCountertermAssociationMetadata>,
    pub side: ThresholdCountertermSide,
    pub threshold_esurface_ids: Vec<usize>,
    pub requested_subspace: Option<Vec<usize>>,
    pub resolved_subspace: Vec<usize>,
    pub requested_parent_lmb: Option<Vec<usize>>,
    pub resolved_parent_lmb: Vec<usize>,
    pub subspace_loop_count: usize,
    pub multiplier: Option<ThresholdCountertermMultiplierMetadata>,
    pub generated: bool,
    pub active: bool,
}

/// One canonical multiplier evaluator. IDs are contiguous within the graph, while the original
/// cut-local ID is retained to make standalone-archive validation direct.
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
pub struct ThresholdCountertermEvaluatorMetadata {
    pub evaluator_id: usize,
    pub cut_group_id: Option<usize>,
    pub collection_evaluator_id: usize,
    pub expression: String,
    pub variant_ids: Vec<usize>,
}

/// Algebraic L/I component generated internally from the compact per-variant graph directives.
#[derive(
    Clone,
    Copy,
    Debug,
    PartialEq,
    Eq,
    PartialOrd,
    Ord,
    Encode,
    Decode,
    Serialize,
    Deserialize,
    JsonSchema,
)]
#[serde(rename_all = "snake_case")]
pub enum ThresholdCountertermComponentKind {
    Local,
    Integrated,
    LocalLocal,
    LocalIntegrated,
    IntegratedLocal,
    IntegratedIntegrated,
}

impl ThresholdCountertermComponentKind {
    pub fn variant_count(self) -> usize {
        match self {
            Self::Local | Self::Integrated => 1,
            Self::LocalLocal
            | Self::LocalIntegrated
            | Self::IntegratedLocal
            | Self::IntegratedIntegrated => 2,
        }
    }
}

/// Stable graph-local metadata for one expanded component.
///
/// `sign` is `-1` for a single-sided/amplitude counterterm and `+1` for an iterated LU term. The
/// event's bare and weighted values already include this sign.
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
pub struct ThresholdCountertermComponentMetadata {
    pub component_id: usize,
    pub cut_group_id: Option<usize>,
    pub kind: ThresholdCountertermComponentKind,
    pub variant_ids: Vec<usize>,
    pub evaluator_ids: Vec<Option<usize>>,
    pub sign: i8,
}

/// Static counterterm metadata owned by one graph term in an integrand.
///
/// Events identify this registry through their existing graph ID and a component ID, so selecting
/// a subset of graphs never renumbers metadata inside a graph.
#[derive(Clone, Debug, PartialEq, Eq, Encode, Decode, Serialize, Deserialize, JsonSchema)]
pub struct ThresholdCountertermMetadataRegistry {
    pub graph_name: String,
    pub variants: Vec<ThresholdCountertermVariantMetadata>,
    pub evaluators: Vec<ThresholdCountertermEvaluatorMetadata>,
    pub components: Vec<ThresholdCountertermComponentMetadata>,
}

impl ThresholdCountertermMetadataRegistry {
    pub(crate) fn build(
        graph_name: impl Into<String>,
        resolved: &ResolvedThresholdCounterterms,
        all_lmbs: &TiVec<LmbIndex, LoopMomentumBasis>,
        variant_statuses: &[ThresholdCountertermVariantStatus],
        mut evaluator_registrations: Vec<ThresholdCountertermEvaluatorRegistration>,
    ) -> Result<Self> {
        if variant_statuses.len() != resolved.variants.len() {
            return Err(eyre!(
                "threshold-counterterm metadata has {} variant statuses for {} resolved variants",
                variant_statuses.len(),
                resolved.variants.len(),
            ));
        }

        let variants: Vec<_> = resolved
            .variants
            .iter_enumerated()
            .zip(variant_statuses)
            .map(
                |((variant_id, variant), status)| ThresholdCountertermVariantMetadata {
                    variant_id: variant_id.0,
                    name: variant.name.clone(),
                    group_id: variant.group_id,
                    cut_group_id: variant.cut_group_id.map(|id| id.0),
                    associations: variant
                        .associations
                        .iter()
                        .map(|association| ThresholdCountertermAssociationMetadata {
                            cut_id: association.cut_id.map(|id| id.0),
                            cut_edges: association.cut_edges.iter().map(|edge| edge.0).collect(),
                            threshold_edges: association
                                .threshold_edges
                                .iter()
                                .map(|edge| edge.0)
                                .collect(),
                            esurface_id: association.esurface_id.0,
                            eligible: association.eligible,
                            origin: association.origin,
                        })
                        .collect(),
                    side: variant.side,
                    threshold_esurface_ids: variant
                        .threshold_esurface_ids
                        .iter()
                        .map(|id| id.0)
                        .collect(),
                    requested_subspace: variant
                        .requested_subspace
                        .as_ref()
                        .map(|edges| edges.iter().map(|edge| edge.0).collect()),
                    resolved_subspace: variant
                        .subspace
                        .iter_basis_edges(all_lmbs)
                        .map(|edge| edge.0)
                        .collect(),
                    requested_parent_lmb: variant
                        .requested_parent_lmb
                        .as_ref()
                        .map(|edges| edges.iter().map(|edge| edge.0).collect()),
                    resolved_parent_lmb: variant
                        .resolved_parent_lmb
                        .iter()
                        .map(|edge| edge.0)
                        .collect(),
                    subspace_loop_count: variant.subspace_loop_count,
                    multiplier: variant.multiplier.as_ref().map(|multiplier| {
                        ThresholdCountertermMultiplierMetadata {
                            expression: multiplier.expression.clone(),
                            function_map: multiplier.function_map.clone(),
                            symmetrize: multiplier.symmetrize,
                            opaque_derivatives: multiplier.opaque_derivatives,
                        }
                    }),
                    generated: status.generated,
                    active: status.active,
                },
            )
            .collect();

        evaluator_registrations.sort_by_key(|registration| {
            (
                registration.cut_group_id,
                registration.collection_evaluator_id,
            )
        });
        let mut seen_local_evaluators = BTreeSet::new();
        let mut next_local_evaluator = BTreeMap::<Option<usize>, usize>::new();
        let mut variant_evaluators = BTreeMap::<(Option<usize>, usize), usize>::new();
        let mut evaluators = Vec::with_capacity(evaluator_registrations.len());
        for mut registration in evaluator_registrations {
            let local_key = (
                registration.cut_group_id,
                registration.collection_evaluator_id,
            );
            if !seen_local_evaluators.insert(local_key) {
                return Err(eyre!(
                    "duplicate threshold-multiplier evaluator {} in cut group {:?}",
                    registration.collection_evaluator_id,
                    registration.cut_group_id,
                ));
            }
            let next = next_local_evaluator
                .entry(registration.cut_group_id)
                .or_default();
            if registration.collection_evaluator_id != *next {
                return Err(eyre!(
                    "threshold-multiplier evaluator IDs in cut group {:?} are not contiguous: expected {}, got {}",
                    registration.cut_group_id,
                    *next,
                    registration.collection_evaluator_id,
                ));
            }
            *next += 1;

            registration.variant_ids.sort_unstable();
            if registration
                .variant_ids
                .windows(2)
                .any(|ids| ids[0] == ids[1])
            {
                return Err(eyre!(
                    "threshold-multiplier evaluator {} in cut group {:?} lists a variant more than once",
                    registration.collection_evaluator_id,
                    registration.cut_group_id,
                ));
            }
            let evaluator_id = evaluators.len();
            for &variant_id in &registration.variant_ids {
                let variant = variants.get(variant_id).ok_or_else(|| {
                    eyre!(
                        "threshold-multiplier evaluator {} refers to missing variant {}",
                        registration.collection_evaluator_id,
                        variant_id,
                    )
                })?;
                if variant.cut_group_id != registration.cut_group_id {
                    return Err(eyre!(
                        "threshold-multiplier evaluator {} cut group {:?} disagrees with variant {} cut group {:?}",
                        registration.collection_evaluator_id,
                        registration.cut_group_id,
                        variant_id,
                        variant.cut_group_id,
                    ));
                }
                if variant.multiplier.is_none() {
                    return Err(eyre!(
                        "identity threshold-counterterm variant {} unexpectedly references multiplier evaluator {}",
                        variant_id,
                        registration.collection_evaluator_id,
                    ));
                }
                if variant_evaluators
                    .insert((registration.cut_group_id, variant_id), evaluator_id)
                    .is_some()
                {
                    return Err(eyre!(
                        "threshold-counterterm variant {} has more than one evaluator in cut group {:?}",
                        variant_id,
                        registration.cut_group_id,
                    ));
                }
            }
            evaluators.push(ThresholdCountertermEvaluatorMetadata {
                evaluator_id,
                cut_group_id: registration.cut_group_id,
                collection_evaluator_id: registration.collection_evaluator_id,
                expression: registration.expression,
                variant_ids: registration.variant_ids,
            });
        }

        for variant in &variants {
            let has_evaluator =
                variant_evaluators.contains_key(&(variant.cut_group_id, variant.variant_id));
            if variant.multiplier.is_some() != has_evaluator {
                return Err(eyre!(
                    "threshold-counterterm variant {} multiplier/evaluator metadata disagree",
                    variant.variant_id,
                ));
            }
        }

        let evaluator_ids = |cut_group_id: Option<usize>, variant_ids: &[usize]| {
            variant_ids
                .iter()
                .map(|variant_id| {
                    variant_evaluators
                        .get(&(cut_group_id, *variant_id))
                        .copied()
                })
                .collect()
        };
        let mut components = Vec::new();
        let mut push_component = |cut_group_id, kind, variant_ids: Vec<usize>, sign| {
            let component_id = components.len();
            let component_evaluator_ids = evaluator_ids(cut_group_id, &variant_ids);
            components.push(ThresholdCountertermComponentMetadata {
                component_id,
                cut_group_id,
                kind,
                variant_ids,
                evaluator_ids: component_evaluator_ids,
                sign,
            });
        };

        let is_amplitude = variants
            .iter()
            .all(|variant| variant.side == ThresholdCountertermSide::Amplitude);
        if is_amplitude {
            for variant in &variants {
                push_component(
                    None,
                    ThresholdCountertermComponentKind::Local,
                    vec![variant.variant_id],
                    -1,
                );
                push_component(
                    None,
                    ThresholdCountertermComponentKind::Integrated,
                    vec![variant.variant_id],
                    -1,
                );
            }
        } else {
            if variants
                .iter()
                .any(|variant| variant.side == ThresholdCountertermSide::Amplitude)
            {
                return Err(eyre!(
                    "threshold-counterterm metadata cannot mix amplitude and LU variants"
                ));
            }
            for (cut_group_id, group) in resolved.cross_section_cut_groups.iter_enumerated() {
                let cut_group = Some(cut_group_id.0);
                for variant_id in group.left.iter().chain(&group.right) {
                    push_component(
                        cut_group,
                        ThresholdCountertermComponentKind::Local,
                        vec![variant_id.0],
                        -1,
                    );
                    push_component(
                        cut_group,
                        ThresholdCountertermComponentKind::Integrated,
                        vec![variant_id.0],
                        -1,
                    );
                }
                for (left, right) in group.iter_pairs() {
                    let pair = vec![left.0, right.0];
                    for kind in [
                        ThresholdCountertermComponentKind::LocalLocal,
                        ThresholdCountertermComponentKind::LocalIntegrated,
                        ThresholdCountertermComponentKind::IntegratedLocal,
                        ThresholdCountertermComponentKind::IntegratedIntegrated,
                    ] {
                        push_component(cut_group, kind, pair.clone(), 1);
                    }
                }
            }
        }

        let registry = Self {
            graph_name: graph_name.into(),
            variants,
            evaluators,
            components,
        };
        registry.validate()?;
        Ok(registry)
    }

    /// Resolve the stable component slot generated for one expanded threshold-counterterm term.
    pub(crate) fn component_id(
        &self,
        cut_group_id: Option<CutGroupId>,
        kind: ThresholdCountertermComponentKind,
        variant_ids: &[ThresholdCountertermVariantId],
    ) -> Result<usize> {
        self.components
            .iter()
            .find(|component| {
                component.cut_group_id == cut_group_id.map(|id| id.0)
                    && component.kind == kind
                    && component.variant_ids.len() == variant_ids.len()
                    && component
                        .variant_ids
                        .iter()
                        .zip(variant_ids)
                        .all(|(stored, requested)| *stored == requested.0)
            })
            .map(|component| component.component_id)
            .ok_or_else(|| {
                eyre!(
                    "threshold-counterterm metadata has no {:?} component for cut group {:?} and variants {:?}",
                    kind,
                    cut_group_id.map(|id| id.0),
                    variant_ids.iter().map(|id| id.0).collect::<Vec<_>>(),
                )
            })
    }

    /// Return runtime threshold IDs in the same order as the generated LU side collection.
    ///
    /// This lookup is needed when an explicit normalized legacy document owns metadata but keeps
    /// the homogeneous overlap path (`variant_subspaces = None`). Local components appear once per
    /// variant and are emitted left-before-right in exactly the runtime collection order.
    pub(crate) fn lu_variant_ids(
        &self,
        cut_group_id: CutGroupId,
        side: ThresholdCountertermSide,
    ) -> Result<Vec<ThresholdCountertermVariantId>> {
        if side == ThresholdCountertermSide::Amplitude {
            return Err(eyre!(
                "amplitude threshold variants do not belong to LU cut group {}",
                cut_group_id.0,
            ));
        }

        Ok(self
            .components
            .iter()
            .filter(|component| {
                component.cut_group_id == Some(cut_group_id.0)
                    && component.kind == ThresholdCountertermComponentKind::Local
            })
            .filter_map(|component| {
                let variant_id = *component.variant_ids.first()?;
                (self.variants.get(variant_id)?.side == side)
                    .then_some(ThresholdCountertermVariantId(variant_id))
            })
            .collect())
    }

    pub fn validate(&self) -> Result<()> {
        for (variant_id, variant) in self.variants.iter().enumerate() {
            if variant.variant_id != variant_id {
                return Err(eyre!(
                    "threshold-counterterm variant metadata ID {} is stored at index {}",
                    variant.variant_id,
                    variant_id,
                ));
            }
        }
        for (evaluator_id, evaluator) in self.evaluators.iter().enumerate() {
            if evaluator.evaluator_id != evaluator_id {
                return Err(eyre!(
                    "threshold-counterterm evaluator metadata ID {} is stored at index {}",
                    evaluator.evaluator_id,
                    evaluator_id,
                ));
            }
            if evaluator
                .variant_ids
                .iter()
                .any(|variant_id| *variant_id >= self.variants.len())
            {
                return Err(eyre!(
                    "threshold-counterterm evaluator {} refers to a missing variant",
                    evaluator_id,
                ));
            }
        }
        for (component_id, component) in self.components.iter().enumerate() {
            if component.component_id != component_id {
                return Err(eyre!(
                    "threshold-counterterm component metadata ID {} is stored at index {}",
                    component.component_id,
                    component_id,
                ));
            }
            let expected_variants = component.kind.variant_count();
            if component.variant_ids.len() != expected_variants
                || component.evaluator_ids.len() != expected_variants
            {
                return Err(eyre!(
                    "threshold-counterterm component {} kind {:?} requires {} aligned variant/evaluator references",
                    component_id,
                    component.kind,
                    expected_variants,
                ));
            }
            for (&variant_id, &evaluator_id) in
                component.variant_ids.iter().zip(&component.evaluator_ids)
            {
                let variant = self.variants.get(variant_id).ok_or_else(|| {
                    eyre!(
                        "threshold-counterterm component {} refers to missing variant {}",
                        component_id,
                        variant_id,
                    )
                })?;
                if variant.cut_group_id != component.cut_group_id {
                    return Err(eyre!(
                        "threshold-counterterm component {} and variant {} have different cut groups",
                        component_id,
                        variant_id,
                    ));
                }
                match evaluator_id {
                    Some(evaluator_id) => {
                        let evaluator = self.evaluators.get(evaluator_id).ok_or_else(|| {
                            eyre!(
                                "threshold-counterterm component {} refers to missing evaluator {}",
                                component_id,
                                evaluator_id,
                            )
                        })?;
                        if evaluator.cut_group_id != component.cut_group_id
                            || !evaluator.variant_ids.contains(&variant_id)
                        {
                            return Err(eyre!(
                                "threshold-counterterm component {} evaluator {} is not registered for variant {}",
                                component_id,
                                evaluator_id,
                                variant_id,
                            ));
                        }
                    }
                    None if variant.multiplier.is_none() => {}
                    None => {
                        return Err(eyre!(
                            "threshold-counterterm component {} omits the evaluator for multiplier variant {}",
                            component_id,
                            variant_id,
                        ));
                    }
                }
            }
            let expected_sign = if expected_variants == 1 { -1 } else { 1 };
            if component.sign != expected_sign {
                return Err(eyre!(
                    "threshold-counterterm component {} has sign {}, expected {}",
                    component_id,
                    component.sign,
                    expected_sign,
                ));
            }
        }
        Ok(())
    }
}

impl ResolvedThresholdCounterterms {
    /// Complete eligible generated declarations in the compact graph document.
    ///
    /// Omitted subspaces are filled from their physical association, while dormant and disabled
    /// declarations retain their supplied semantics. Function definitions retain their graph/local
    /// scopes. The completion contains no inferred side, pair, or L/I component records.
    pub fn materialized_spec(
        &self,
        raw: &ThresholdCountertermSpec,
        all_lmbs: &TiVec<LmbIndex, LoopMomentumBasis>,
    ) -> ThresholdCountertermSpec {
        let mut materialized = raw.clone();

        for variant in &self.variants {
            for association in variant
                .associations
                .iter()
                .filter(|association| association.eligible)
            {
                let resolved_subspace = association
                    .subspace
                    .iter_basis_edges(all_lmbs)
                    .collect::<Vec<_>>();
                let resolved_parent_lmb = association
                    .subspace
                    .get_lmb(all_lmbs)
                    .loop_edges
                    .iter()
                    .copied()
                    .collect();
                let cut = if let Some(index) = materialized
                    .cuts
                    .iter()
                    .position(|cut| cut.edges == association.cut_edges)
                {
                    &mut materialized.cuts[index]
                } else {
                    materialized.cuts.push(ThresholdCountertermCut {
                        edges: association.cut_edges.clone(),
                        thresholds: Vec::new(),
                    });
                    materialized.cuts.last_mut().unwrap()
                };

                let threshold = if let Some(index) = cut
                    .thresholds
                    .iter()
                    .position(|threshold| threshold.edges == association.threshold_edges)
                {
                    &mut cut.thresholds[index]
                } else {
                    cut.thresholds.push(ThresholdCountertermThreshold {
                        edges: association.threshold_edges.clone(),
                        counterterms: Vec::new(),
                    });
                    cut.thresholds.last_mut().unwrap()
                };

                if let Some(declaration) = threshold.counterterms.iter_mut().find(|declaration| {
                    declaration.name.as_deref().unwrap_or("default") == variant.name
                }) {
                    if !declaration.disable {
                        declaration.subspace.get_or_insert(resolved_subspace);
                        declaration.parent_lmb.get_or_insert(resolved_parent_lmb);
                    }
                } else if threshold.counterterms.is_empty()
                    && association.origin == ThresholdCountertermOrigin::Autogenerated
                {
                    threshold.counterterms.push(ThresholdCountertermVariant {
                        name: Some("default".to_string()),
                        group_id: None,
                        subspace: Some(resolved_subspace),
                        parent_lmb: Some(resolved_parent_lmb),
                        disable: false,
                        multiplier: None,
                    });
                }
            }
        }

        for cut in &mut materialized.cuts {
            cut.thresholds
                .sort_by(|left, right| left.edges.cmp(&right.edges));
        }
        materialized
            .cuts
            .sort_by(|left, right| left.edges.cmp(&right.edges));
        materialized
    }
}

#[cfg(test)]
mod tests {
    use linnet::half_edge::involution::EdgeIndex;
    use typed_index_collections::{TiVec, ti_vec};

    use crate::{
        dot,
        graph::{
            Graph, LMBext, LmbIndex,
            parse::from_dot::IntoGraph,
            threshold_counterterms::{ThresholdCountertermMultiplier, ThresholdCountertermSpec},
        },
        initialisation::test_initialise,
        momentum::sample::{LoopIndex, SubspaceData},
        processes::CutGroupId,
    };

    use super::{
        ResolvedCutGroupThresholdCounterterms, ResolvedThresholdCountertermAssociation,
        ResolvedThresholdCountertermVariant, ResolvedThresholdCounterterms,
        ThresholdCountertermComponentKind, ThresholdCountertermEvaluatorRegistration,
        ThresholdCountertermMetadataRegistry, ThresholdCountertermOrigin, ThresholdCountertermSide,
        ThresholdCountertermVariantId, ThresholdCountertermVariantStatus,
    };

    #[test]
    fn cut_group_pairs_keep_duplicate_geometry_variants_distinct() {
        let group = ResolvedCutGroupThresholdCounterterms {
            left: vec![
                ThresholdCountertermVariantId::from(0),
                ThresholdCountertermVariantId::from(1),
            ],
            right: vec![
                ThresholdCountertermVariantId::from(2),
                ThresholdCountertermVariantId::from(3),
            ],
        };

        assert_eq!(
            group.iter_pairs().collect::<Vec<_>>(),
            vec![
                (
                    ThresholdCountertermVariantId::from(0),
                    ThresholdCountertermVariantId::from(2),
                ),
                (
                    ThresholdCountertermVariantId::from(0),
                    ThresholdCountertermVariantId::from(3),
                ),
                (
                    ThresholdCountertermVariantId::from(1),
                    ThresholdCountertermVariantId::from(2),
                ),
                (
                    ThresholdCountertermVariantId::from(1),
                    ThresholdCountertermVariantId::from(3),
                ),
            ]
        );
    }

    #[test]
    fn materialized_export_adds_only_eligible_implicit_defaults() {
        test_initialise().unwrap();
        let graph: Graph = dot!(digraph materialized_threshold_defaults {
            ext [style=invis]
            edge [num=1 mass=0]
            node [num=1]
            ext->v1:0 [id=0]
            v1->v2 [id=1]
            v2->v1 [id=2]
            ext->v2:1 [id=3]
        })
        .unwrap();
        let all_lmbs = ti_vec![graph.loop_momentum_basis.clone()];
        let basis_edge = graph.loop_momentum_basis.loop_edges[LoopIndex(0)];
        let subspace = SubspaceData::new_from_parent_basis_edges(
            &[basis_edge],
            &graph.full_filter(),
            LmbIndex::from(0),
            &graph,
            &all_lmbs,
        )
        .unwrap();
        let association = ResolvedThresholdCountertermAssociation {
            cut_id: None,
            cut_edges: Vec::new(),
            threshold_edges: vec![EdgeIndex::from(1), EdgeIndex::from(2)],
            esurface_id: crate::cff::esurface::EsurfaceID::from(0),
            subspace: subspace.clone(),
            requires_explicit_parent_lmb: false,
            eligible: true,
            origin: ThresholdCountertermOrigin::Autogenerated,
        };
        let variant = ResolvedThresholdCountertermVariant {
            name: "default".to_string(),
            group_id: None,
            cut_group_id: None,
            associations: vec![association],
            side: ThresholdCountertermSide::Amplitude,
            threshold_esurface_ids: vec![crate::cff::esurface::EsurfaceID::from(0)],
            raised_esurface_group: crate::cff::esurface::RaisedEsurfaceGroup {
                esurface_ids: vec![crate::cff::esurface::EsurfaceID::from(0)],
                max_occurence: 1,
            },
            requested_subspace: None,
            requested_parent_lmb: None,
            resolved_parent_lmb: graph.loop_momentum_basis.loop_edges.clone().into(),
            subspace,
            subspace_loop_count: 1,
            multiplier: None,
        };
        let resolved = ResolvedThresholdCounterterms {
            legacy_equivalent: true,
            variants: TiVec::from(vec![variant]),
            cross_section_cut_groups: TiVec::new(),
        };

        let materialized =
            resolved.materialized_spec(&ThresholdCountertermSpec::default(), &all_lmbs);
        assert_eq!(materialized.cuts.len(), 1);
        let threshold = &materialized.cuts[0].thresholds[0];
        assert_eq!(threshold.counterterms.len(), 1);
        let default = &threshold.counterterms[0];
        assert_eq!(default.name.as_deref(), Some("default"));
        assert_eq!(default.subspace.as_deref(), Some([basis_edge].as_slice()));
        assert_eq!(
            default.parent_lmb.as_deref(),
            Some(graph.loop_momentum_basis.loop_edges.raw.as_slice())
        );
        assert!(default.multiplier.is_none());

        let mut raw = materialized.clone();
        raw.function_map.insert("shared(x)".into(), "x + 1".into());
        let declaration = &mut raw.cuts[0].thresholds[0].counterterms[0];
        declaration.subspace = None;
        declaration.multiplier = Some(ThresholdCountertermMultiplier {
            expression: "shared(1)".into(),
            function_map: [("shared(x)".into(), "x + 2".into())].into(),
            symmetrize: false,
            opaque_derivatives: true,
        });
        let mut disabled = declaration.clone();
        disabled.name = Some("disabled".into());
        disabled.disable = true;
        raw.cuts[0].thresholds[0].counterterms.push(disabled);
        let mut dormant = raw.cuts[0].thresholds[0].counterterms[0].clone();
        dormant.name = Some("dormant".into());
        raw.cuts[0].thresholds[0].counterterms.insert(0, dormant);
        let mut explicit = resolved.clone();
        explicit.variants[ThresholdCountertermVariantId(0)].associations[0].origin =
            ThresholdCountertermOrigin::Explicit;
        // Runtime multipliers have merged scopes; materialization must preserve the raw split.
        explicit.variants[ThresholdCountertermVariantId(0)].multiplier =
            Some(ThresholdCountertermMultiplier {
                expression: "shared(1)".into(),
                function_map: [
                    ("shared(x)".into(), "x + 2".into()),
                    ("extra()".into(), "3".into()),
                ]
                .into(),
                symmetrize: false,
                opaque_derivatives: true,
            });
        let mut expected = raw.clone();
        expected.cuts[0].thresholds[0].counterterms[1].subspace = Some(vec![basis_edge]);
        assert_eq!(explicit.materialized_spec(&raw, &all_lmbs), expected);
        assert!(raw.cuts[0].thresholds[0].counterterms[1].subspace.is_none());

        explicit.variants[ThresholdCountertermVariantId(0)].associations[0].eligible = false;
        assert_eq!(explicit.materialized_spec(&raw, &all_lmbs), raw);
    }

    #[test]
    fn materialized_raised_defaults_round_trip_association_local_embeddings() {
        test_initialise().unwrap();
        let graph: Graph = dot!(digraph raised_materialized_threshold_defaults {
            ext [style=invis]
            edge [num=1 mass=0]
            node [num=1]
            ext->v1:0 [id=0]
            v1->v2 [id=1]
            v2->v1 [id=2]
            v2->v3 [id=3]
            v3->v2 [id=4]
            ext->v3:1 [id=5]
        })
        .unwrap();
        let all_lmbs = graph.generate_loop_momentum_bases();
        let containing_subgraph = graph.full_filter();
        let subspaces = all_lmbs
            .iter_enumerated()
            .filter_map(|(lmb_index, _)| {
                SubspaceData::new_from_parent_basis_edges(
                    &[EdgeIndex(1)],
                    &containing_subgraph,
                    lmb_index,
                    &graph,
                    &all_lmbs,
                )
                .ok()
            })
            .collect::<Vec<_>>();
        let (implicit_subspace, rebased_subspace) = subspaces
            .iter()
            .enumerate()
            .flat_map(|(left_index, left)| {
                subspaces
                    .iter()
                    .skip(left_index + 1)
                    .map(move |right| (left, right))
            })
            .find(|(left, right)| {
                left.parent_lmb_index() != right.parent_lmb_index()
                    && left.has_equivalent_embedding(right, &all_lmbs)
            })
            .expect("the two-loop fixture must admit equivalent distinct parent LMBs");
        assert!(!implicit_subspace.has_same_embedding(rebased_subspace));

        let association = |threshold_edges: Vec<EdgeIndex>,
                           esurface_id: usize,
                           subspace: &SubspaceData,
                           requires_explicit_parent_lmb| {
            ResolvedThresholdCountertermAssociation {
                cut_id: None,
                cut_edges: Vec::new(),
                threshold_edges,
                esurface_id: crate::cff::esurface::EsurfaceID::from(esurface_id),
                subspace: subspace.clone(),
                requires_explicit_parent_lmb,
                eligible: true,
                origin: ThresholdCountertermOrigin::Autogenerated,
            }
        };
        let associations = vec![
            association(
                vec![EdgeIndex::from(1), EdgeIndex::from(2)],
                0,
                implicit_subspace,
                false,
            ),
            association(
                vec![EdgeIndex::from(2), EdgeIndex::from(3)],
                1,
                rebased_subspace,
                true,
            ),
        ];
        let resolved = ResolvedThresholdCounterterms {
            legacy_equivalent: true,
            variants: TiVec::from(vec![ResolvedThresholdCountertermVariant {
                name: "default".to_string(),
                group_id: None,
                cut_group_id: None,
                associations: associations.clone(),
                side: ThresholdCountertermSide::Amplitude,
                threshold_esurface_ids: vec![
                    crate::cff::esurface::EsurfaceID::from(0),
                    crate::cff::esurface::EsurfaceID::from(1),
                ],
                raised_esurface_group: crate::cff::esurface::RaisedEsurfaceGroup {
                    esurface_ids: vec![
                        crate::cff::esurface::EsurfaceID::from(0),
                        crate::cff::esurface::EsurfaceID::from(1),
                    ],
                    max_occurence: 2,
                },
                requested_subspace: None,
                requested_parent_lmb: None,
                resolved_parent_lmb: implicit_subspace
                    .get_lmb(&all_lmbs)
                    .loop_edges
                    .iter()
                    .copied()
                    .collect(),
                subspace: implicit_subspace.clone(),
                subspace_loop_count: implicit_subspace.loopcount(),
                multiplier: None,
            }]),
            cross_section_cut_groups: TiVec::new(),
        };

        let materialized =
            resolved.materialized_spec(&ThresholdCountertermSpec::default(), &all_lmbs);
        let reparsed = ThresholdCountertermSpec::parse_toml(
            &materialized
                .to_toml()
                .expect("materialized defaults must serialize"),
        )
        .expect("materialized defaults must parse");
        assert_eq!(reparsed.cuts.len(), 1);
        assert_eq!(reparsed.cuts[0].thresholds.len(), 2);

        for (threshold, association) in reparsed.cuts[0].thresholds.iter().zip(&associations) {
            let counterterm = &threshold.counterterms[0];
            let parent = counterterm
                .parent_lmb
                .as_ref()
                .expect("materialized variants must declare their full parent");
            let parent_lmb_index = all_lmbs
                .iter_enumerated()
                .find_map(|(lmb_index, lmb)| {
                    lmb.loop_edges.iter().eq(parent.iter()).then_some(lmb_index)
                })
                .expect("serialized parent LMB must be generated");
            let round_tripped = SubspaceData::new_from_parent_basis_edges(
                counterterm.subspace.as_deref().unwrap(),
                &containing_subgraph,
                parent_lmb_index,
                &graph,
                &all_lmbs,
            )
            .expect("materialized association must reconstruct");
            assert!(round_tripped.has_same_embedding(&association.subspace));
            assert!(round_tripped.has_equivalent_embedding(implicit_subspace, &all_lmbs));
        }

        assert_eq!(
            reparsed.cuts[0].thresholds[0].counterterms[0].parent_lmb,
            Some(implicit_subspace.get_lmb(&all_lmbs).loop_edges.raw.clone()),
        );
        assert_eq!(
            reparsed.cuts[0].thresholds[1].counterterms[0].parent_lmb,
            Some(
                rebased_subspace
                    .get_lmb(&all_lmbs)
                    .loop_edges
                    .iter()
                    .copied()
                    .collect()
            ),
        );

        let mut explicit = resolved.clone();
        for variant in &mut explicit.variants {
            for association in &mut variant.associations {
                association.origin = ThresholdCountertermOrigin::Explicit;
            }
        }
        let mut incomplete = reparsed.clone();
        for threshold in &mut incomplete.cuts[0].thresholds {
            threshold.counterterms[0].subspace = None;
        }
        assert_eq!(explicit.materialized_spec(&incomplete, &all_lmbs), reparsed);
    }

    #[test]
    fn graph_registry_expands_components_in_stable_cartesian_order() {
        test_initialise().unwrap();
        let graph: Graph = dot!(digraph threshold_metadata_registry {
            ext [style=invis]
            edge [num=1 mass=0]
            node [num=1]
            ext->v1:0 [id=0]
            v1->v2 [id=1]
            v2->v1 [id=2]
            ext->v2:1 [id=3]
        })
        .unwrap();
        let all_lmbs = ti_vec![graph.loop_momentum_basis.clone()];
        let basis_edge = graph.loop_momentum_basis.loop_edges[LoopIndex(0)];
        let subspace = SubspaceData::new_from_parent_basis_edges(
            &[basis_edge],
            &graph.full_filter(),
            LmbIndex::from(0),
            &graph,
            &all_lmbs,
        )
        .unwrap();
        let association = ResolvedThresholdCountertermAssociation {
            cut_id: Some(crate::processes::CutId(0)),
            cut_edges: vec![EdgeIndex::from(0), EdgeIndex::from(3)],
            threshold_edges: vec![EdgeIndex::from(1), EdgeIndex::from(2)],
            esurface_id: crate::cff::esurface::EsurfaceID::from(0),
            subspace: subspace.clone(),
            requires_explicit_parent_lmb: false,
            eligible: true,
            origin: ThresholdCountertermOrigin::Explicit,
        };
        let multiplier = |expression: &str| ThresholdCountertermMultiplier {
            expression: expression.to_string(),
            function_map: Default::default(),
            symmetrize: false,
            opaque_derivatives: true,
        };
        let variant = |name: &str,
                       side: ThresholdCountertermSide,
                       multiplier: Option<ThresholdCountertermMultiplier>| {
            ResolvedThresholdCountertermVariant {
                name: name.to_string(),
                group_id: None,
                cut_group_id: Some(CutGroupId(0)),
                associations: vec![association.clone()],
                side,
                threshold_esurface_ids: vec![crate::cff::esurface::EsurfaceID::from(0)],
                raised_esurface_group: crate::cff::esurface::RaisedEsurfaceGroup {
                    esurface_ids: vec![crate::cff::esurface::EsurfaceID::from(0)],
                    max_occurence: 1,
                },
                requested_subspace: Some(vec![basis_edge]),
                requested_parent_lmb: None,
                resolved_parent_lmb: graph.loop_momentum_basis.loop_edges.clone().into(),
                subspace: subspace.clone(),
                subspace_loop_count: 1,
                multiplier,
            }
        };
        let resolved = ResolvedThresholdCounterterms {
            legacy_equivalent: false,
            variants: TiVec::from(vec![
                variant(
                    "left_a",
                    ThresholdCountertermSide::Left,
                    Some(multiplier("f")),
                ),
                variant(
                    "left_b",
                    ThresholdCountertermSide::Left,
                    Some(multiplier("f")),
                ),
                variant("right_identity", ThresholdCountertermSide::Right, None),
                variant(
                    "right_g",
                    ThresholdCountertermSide::Right,
                    Some(multiplier("g")),
                ),
            ]),
            cross_section_cut_groups: ti_vec![ResolvedCutGroupThresholdCounterterms {
                left: vec![
                    ThresholdCountertermVariantId(0),
                    ThresholdCountertermVariantId(1),
                ],
                right: vec![
                    ThresholdCountertermVariantId(2),
                    ThresholdCountertermVariantId(3),
                ],
            }],
        };
        let statuses = vec![
            ThresholdCountertermVariantStatus {
                generated: true,
                active: true,
            };
            4
        ];
        let registry = ThresholdCountertermMetadataRegistry::build(
            "threshold_metadata_registry",
            &resolved,
            &all_lmbs,
            &statuses,
            vec![
                ThresholdCountertermEvaluatorRegistration {
                    cut_group_id: Some(0),
                    collection_evaluator_id: 0,
                    expression: "canonical_f".to_string(),
                    variant_ids: vec![1, 0],
                },
                ThresholdCountertermEvaluatorRegistration {
                    cut_group_id: Some(0),
                    collection_evaluator_id: 1,
                    expression: "canonical_g".to_string(),
                    variant_ids: vec![3],
                },
            ],
        )
        .unwrap();

        assert_eq!(registry.evaluators[0].variant_ids, vec![0, 1]);
        assert_eq!(registry.components.len(), 24);
        assert_eq!(registry.components[0].variant_ids, vec![0]);
        assert_eq!(registry.components[7].variant_ids, vec![3]);
        assert_eq!(
            registry.components[8].kind,
            ThresholdCountertermComponentKind::LocalLocal
        );
        assert_eq!(registry.components[8].variant_ids, vec![0, 2]);
        assert_eq!(registry.components[8].evaluator_ids, vec![Some(0), None]);
        assert_eq!(registry.components[8].sign, 1);
        assert_eq!(
            registry.components[12].kind,
            ThresholdCountertermComponentKind::LocalLocal
        );
        assert_eq!(registry.components[12].variant_ids, vec![0, 3]);
        assert_eq!(
            registry.components[12].evaluator_ids,
            vec![Some(0), Some(1)]
        );
        assert_eq!(
            registry.components[23].kind,
            ThresholdCountertermComponentKind::IntegratedIntegrated
        );
        assert_eq!(registry.components[23].variant_ids, vec![1, 3]);
        assert_eq!(
            registry
                .lu_variant_ids(CutGroupId(0), ThresholdCountertermSide::Left)
                .unwrap(),
            vec![
                ThresholdCountertermVariantId(0),
                ThresholdCountertermVariantId(1),
            ],
        );
        assert_eq!(
            registry
                .lu_variant_ids(CutGroupId(0), ThresholdCountertermSide::Right)
                .unwrap(),
            vec![
                ThresholdCountertermVariantId(2),
                ThresholdCountertermVariantId(3),
            ],
        );
        for kind in [
            ThresholdCountertermComponentKind::Local,
            ThresholdCountertermComponentKind::Integrated,
            ThresholdCountertermComponentKind::LocalLocal,
            ThresholdCountertermComponentKind::LocalIntegrated,
            ThresholdCountertermComponentKind::IntegratedLocal,
            ThresholdCountertermComponentKind::IntegratedIntegrated,
        ] {
            assert!(
                registry
                    .components
                    .iter()
                    .any(|component| component.kind == kind)
            );
        }
        assert_eq!(
            registry
                .component_id(
                    Some(CutGroupId(0)),
                    ThresholdCountertermComponentKind::LocalIntegrated,
                    &[
                        ThresholdCountertermVariantId(0),
                        ThresholdCountertermVariantId(3),
                    ],
                )
                .unwrap(),
            13,
        );
        assert_eq!(
            serde_json::from_str::<ThresholdCountertermMetadataRegistry>(
                &serde_json::to_string(&registry).unwrap(),
            )
            .unwrap(),
            registry,
        );
    }
}