gammalooprs/graph/

threshold_counterterms.rs

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

use bincode_trait_derive::{Decode, Encode};
use color_eyre::Result;
use eyre::{Context, eyre};
use linnet::{
    half_edge::involution::{EdgeIndex, HedgePair},
    half_edge::subgraph::SubSetLike,
    permutation::Permutation,
};
use serde::{Deserialize, Serialize};

use super::{Graph, lmb::LMBwithEdges};
use crate::utils::serde_utils::{IsDefault, is_false, is_true};

pub const THRESHOLD_COUNTERTERM_SCHEMA_VERSION: u32 = 1;

/// Compact graph-local directives controlling threshold-counterterm generation.
///
/// This public representation deliberately stops at individual variants. Inferred sides,
/// left/right Cartesian products, and local/integrated components belong to process-derived data
/// and are never serialized into the graph attribute.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)]
#[serde(deny_unknown_fields)]
pub struct ThresholdCountertermSpec {
    pub schema_version: u32,
    /// Definitions shared by all multiplier expressions in this graph.
    #[serde(default, skip_serializing_if = "IsDefault::is_default")]
    pub function_map: BTreeMap<String, String>,
    #[serde(default)]
    pub cuts: Vec<ThresholdCountertermCut>,
}

impl Default for ThresholdCountertermSpec {
    fn default() -> Self {
        Self {
            schema_version: THRESHOLD_COUNTERTERM_SCHEMA_VERSION,
            function_map: BTreeMap::new(),
            cuts: Vec::new(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)]
#[serde(deny_unknown_fields)]
pub struct ThresholdCountertermCut {
    pub edges: Vec<EdgeIndex>,
    #[serde(default, skip_serializing_if = "IsDefault::is_default")]
    pub thresholds: Vec<ThresholdCountertermThreshold>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)]
#[serde(deny_unknown_fields)]
pub struct ThresholdCountertermThreshold {
    pub edges: Vec<EdgeIndex>,
    #[serde(default, skip_serializing_if = "IsDefault::is_default")]
    pub counterterms: Vec<ThresholdCountertermVariant>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)]
#[serde(deny_unknown_fields)]
pub struct ThresholdCountertermVariant {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub group_id: Option<usize>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub subspace: Option<Vec<EdgeIndex>>,
    /// Required in explicit graph metadata; absent only for internally synthesized defaults.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub parent_lmb: Option<Vec<EdgeIndex>>,
    #[serde(default, skip_serializing_if = "is_false")]
    pub disable: bool,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub multiplier: Option<ThresholdCountertermMultiplier>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Encode, Decode)]
#[serde(deny_unknown_fields)]
pub struct ThresholdCountertermMultiplier {
    pub expression: String,
    /// Definitions local to this multiplier, overriding shared definitions.
    #[serde(default, skip_serializing_if = "IsDefault::is_default")]
    pub function_map: BTreeMap<String, String>,
    #[serde(default, skip_serializing_if = "is_false")]
    pub symmetrize: bool,
    #[serde(
        default = "default_opaque_derivatives",
        skip_serializing_if = "is_true"
    )]
    pub opaque_derivatives: bool,
}

fn default_opaque_derivatives() -> bool {
    true
}

impl ThresholdCountertermSpec {
    pub(crate) fn validate_group_ids<'a>(specs: impl IntoIterator<Item = &'a Self>) -> Result<()> {
        let ids = specs
            .into_iter()
            .flat_map(|spec| &spec.cuts)
            .flat_map(|cut| &cut.thresholds)
            .flat_map(|threshold| &threshold.counterterms)
            .filter_map(|variant| variant.group_id)
            .collect::<BTreeSet<_>>();
        if let Some(max_id) = ids.iter().next_back().copied() {
            for expected in 0..=max_id {
                if !ids.contains(&expected) {
                    return Err(eyre!(
                        "threshold_counterterms group_id values must start at 0 and be contiguous; missing group_id {} (present: {:?})",
                        expected,
                        ids,
                    ));
                }
            }
        }
        Ok(())
    }
    /// Whether all explicit entries are semantically identical to legacy subtraction.
    ///
    /// Names and explicit provenance do not affect this predicate. Process resolution can use it
    /// to keep normalized `--include-autogenerated-fields` documents on the homogeneous fast path.
    pub fn is_legacy_equivalent(&self) -> bool {
        self.cuts.iter().all(|cut| {
            cut.thresholds.iter().all(|threshold| {
                threshold.counterterms.is_empty()
                    || (threshold.counterterms.len() == 1
                        && threshold.counterterms[0].is_legacy_equivalent())
            })
        })
    }

    pub(crate) fn parse_toml(source: &str) -> Result<Self> {
        let mut spec: Self = toml::from_str(source)
            .context("failed to parse graph threshold_counterterms TOML document")?;
        spec.normalize_graph_independent()?;
        Ok(spec)
    }

    pub(crate) fn to_toml(&self) -> Result<String> {
        toml::to_string_pretty(self)
            .context("failed to serialize graph threshold_counterterms TOML document")
    }

    /// Applies the edge permutation used while importing split cross-section graphs.
    ///
    /// Set-like cut and threshold identities are sorted after remapping. Ordered subspace and
    /// parent-LMB declarations retain their declared order.
    pub(crate) fn remap_edges(&mut self, permutation: &Permutation) -> Result<()> {
        let remap = |edge: &mut EdgeIndex| -> Result<()> {
            let mapped = permutation.map().get(edge.0).copied().ok_or_else(|| {
                eyre!(
                    "threshold_counterterms references edge {}, but the imported graph has only {} edges",
                    edge.0,
                    permutation.map().len(),
                )
            })?;
            *edge = EdgeIndex(mapped);
            Ok(())
        };

        for cut in &mut self.cuts {
            for edge in &mut cut.edges {
                remap(edge)?;
            }
            cut.edges.sort_unstable();

            for threshold in &mut cut.thresholds {
                for edge in &mut threshold.edges {
                    remap(edge)?;
                }
                threshold.edges.sort_unstable();

                for variant in &mut threshold.counterterms {
                    if let Some(subspace) = &mut variant.subspace {
                        for edge in subspace {
                            remap(edge)?;
                        }
                    }
                    if let Some(parent_lmb) = &mut variant.parent_lmb {
                        for edge in parent_lmb {
                            remap(edge)?;
                        }
                    }
                }
            }
        }

        Ok(())
    }

    pub(crate) fn validate_for_graph(&self, graph: &Graph) -> Result<()> {
        let graph_is_amplitude = graph.initial_state_cut.is_empty();
        // A declared amplitude member uses its master's edge IDs and topology. Group parsing
        // can choose the master implicitly, so certify topology after the group is complete.
        let defer_topology =
            graph_is_amplitude && graph.group_id.is_some() && !graph.is_group_master;
        let n_edges = graph.n_edges();
        let validate_edge = |edge: EdgeIndex, role: &str| -> Result<()> {
            if defer_topology && role != "cut" {
                return Ok(());
            }
            if edge.0 >= n_edges {
                return Err(eyre!(
                    "graph '{}' threshold_counterterms {role} references edge {}, but the graph has only {n_edges} edges",
                    graph.name,
                    edge.0,
                ));
            }

            let (pair, data) = graph
                .iter_edges()
                .find_map(|(pair, edge_id, data)| (edge_id == edge).then_some((pair, data)))
                .ok_or_else(|| {
                    eyre!(
                        "graph '{}' threshold_counterterms {role} references missing edge {}",
                        graph.name,
                        edge.0,
                    )
                })?;
            if !matches!(pair, HedgePair::Paired { .. }) || data.data.is_dummy {
                return Err(eyre!(
                    "graph '{}' threshold_counterterms {role} edge {} must be an internal, non-dummy edge",
                    graph.name,
                    edge.0,
                ));
            }
            Ok(())
        };

        for cut in &self.cuts {
            if graph_is_amplitude && !cut.edges.is_empty() {
                return Err(eyre!(
                    "amplitude graph '{}' threshold_counterterms cut edges must be empty",
                    graph.name,
                ));
            }
            if !graph_is_amplitude && cut.edges.is_empty() {
                return Err(eyre!(
                    "cross-section graph '{}' threshold_counterterms cut edges must not be empty",
                    graph.name,
                ));
            }
            for edge in &cut.edges {
                validate_edge(*edge, "cut")?;
            }

            for threshold in &cut.thresholds {
                for edge in &threshold.edges {
                    validate_edge(*edge, "threshold")?;
                }
                for variant in &threshold.counterterms {
                    if let Some(subspace) = &variant.subspace {
                        for edge in subspace {
                            validate_edge(*edge, "subspace")?;
                        }
                    }
                    let parent_lmb = variant.parent_lmb.as_ref().ok_or_else(|| {
                        eyre!(
                            "graph '{}' threshold_counterterms cut {:?}, threshold {:?}, variant {:?} requires a full parent_lmb",
                            graph.name,
                            edge_numbers(&cut.edges),
                            edge_numbers(&threshold.edges),
                            variant.name,
                        )
                    })?;
                    if let Some(subspace) = &variant.subspace {
                        let missing = subspace
                            .iter()
                            .filter(|edge| !parent_lmb.contains(edge))
                            .copied()
                            .collect::<Vec<_>>();
                        if !missing.is_empty() {
                            return Err(eyre!(
                                "graph '{}' threshold_counterterms variant {:?} selected edges {:?} are absent from parent_lmb {:?}",
                                graph.name,
                                variant.name,
                                edge_numbers(&missing),
                                edge_numbers(parent_lmb),
                            ));
                        }
                    }
                    for edge in parent_lmb {
                        validate_edge(*edge, "parent_lmb")?;
                    }
                    if defer_topology {
                        continue;
                    }
                    if parent_lmb.len() != graph.loop_momentum_basis.loop_edges.len() {
                        return Err(eyre!(
                            "graph '{}' threshold_counterterms variant {:?} requires a full parent_lmb with {} defining edges, received {:?}",
                            graph.name,
                            variant.name,
                            graph.loop_momentum_basis.loop_edges.len(),
                            edge_numbers(parent_lmb),
                        ));
                    }
                    // A cross-section graph closes the incoming external lines into
                    // topological cycles; generation turns those cycles back into fixed
                    // external momenta before exposing the physical loop-momentum basis.
                    let mut topological_parent = parent_lmb.clone();
                    if !graph_is_amplitude {
                        topological_parent.extend(graph.external_momentum_edge_order());
                    }
                    let resolved_parent = graph
                        .lmb_with_loop_edges(topological_parent.as_slice())
                        .with_context(|| format!(
                            "graph '{}' threshold_counterterms variant {:?} has invalid full parent_lmb {:?}",
                            graph.name,
                            variant.name,
                            edge_numbers(parent_lmb),
                        ))?;
                    if resolved_parent
                        .loop_edges
                        .iter()
                        .copied()
                        .collect::<BTreeSet<_>>()
                        != topological_parent.iter().copied().collect::<BTreeSet<_>>()
                    {
                        return Err(eyre!(
                            "graph '{}' threshold_counterterms variant {:?} parent_lmb {:?} does not define a full loop-momentum basis",
                            graph.name,
                            variant.name,
                            edge_numbers(parent_lmb),
                        ));
                    }
                }
            }
        }

        // Amplitude graph groups share one namespace, certified once the complete group is known.
        if !graph_is_amplitude || graph.group_id.is_none() {
            Self::validate_group_ids([self])
                .map_err(|error| eyre!("graph '{}': {error:#}", graph.name))?;
        }

        Ok(())
    }

    fn normalize_graph_independent(&mut self) -> Result<()> {
        if self.schema_version != THRESHOLD_COUNTERTERM_SCHEMA_VERSION {
            return Err(eyre!(
                "unsupported threshold_counterterms schema_version {}; supported version is {}",
                self.schema_version,
                THRESHOLD_COUNTERTERM_SCHEMA_VERSION,
            ));
        }

        let mut seen_cuts = BTreeSet::new();
        for (cut_index, cut) in self.cuts.iter_mut().enumerate() {
            canonicalize_set_edges(&mut cut.edges, &format!("cut #{cut_index}"))?;
            if !seen_cuts.insert(cut.edges.clone()) {
                return Err(eyre!(
                    "duplicate threshold_counterterms cut with edges {:?}",
                    edge_numbers(&cut.edges),
                ));
            }

            let mut seen_thresholds = BTreeSet::new();
            for (threshold_index, threshold) in cut.thresholds.iter_mut().enumerate() {
                canonicalize_set_edges(
                    &mut threshold.edges,
                    &format!("cut #{cut_index} threshold #{threshold_index}"),
                )?;
                if threshold.edges.is_empty() {
                    return Err(eyre!(
                        "threshold_counterterms cut #{cut_index} threshold #{threshold_index} has an empty edge set",
                    ));
                }
                if !seen_thresholds.insert(threshold.edges.clone()) {
                    return Err(eyre!(
                        "duplicate threshold_counterterms threshold with edges {:?} under cut {:?}",
                        edge_numbers(&threshold.edges),
                        edge_numbers(&cut.edges),
                    ));
                }

                normalize_variants(
                    &mut threshold.counterterms,
                    &format!(
                        "cut {:?}, threshold {:?}",
                        edge_numbers(&cut.edges),
                        edge_numbers(&threshold.edges),
                    ),
                )?;
            }
        }

        Ok(())
    }
}

impl ThresholdCountertermVariant {
    pub fn is_legacy_equivalent(&self) -> bool {
        !self.disable
            && self.group_id.is_none()
            && self.subspace.is_none()
            && self.parent_lmb.is_none()
            && self.multiplier.is_none()
    }
}

fn canonicalize_set_edges(edges: &mut [EdgeIndex], context: &str) -> Result<()> {
    edges.sort_unstable();
    if edges.windows(2).any(|pair| pair[0] == pair[1]) {
        return Err(eyre!(
            "threshold_counterterms {context} contains duplicate edge IDs {:?}",
            edge_numbers(edges),
        ));
    }
    Ok(())
}

fn validate_ordered_edges(
    edges: &Option<Vec<EdgeIndex>>,
    field: &str,
    context: &str,
) -> Result<()> {
    let Some(edges) = edges else {
        return Ok(());
    };
    if edges.is_empty() {
        return Err(eyre!(
            "threshold_counterterms {context} has an empty {field}; explicit parent_lmb must be full and a selected subspace must be nonempty",
        ));
    }
    let mut seen = BTreeSet::new();
    if let Some(duplicate) = edges.iter().find(|edge| !seen.insert(**edge)) {
        return Err(eyre!(
            "threshold_counterterms {context} {field} contains duplicate edge {}",
            duplicate.0,
        ));
    }
    Ok(())
}

fn normalize_variants(variants: &mut [ThresholdCountertermVariant], context: &str) -> Result<()> {
    if variants.len() == 1 && variants[0].name.is_none() {
        variants[0].name = Some("default".to_string());
    }

    let mut names = BTreeSet::new();
    for (variant_index, variant) in variants.iter().enumerate() {
        let variant_context = format!("{context}, counterterm #{variant_index}");
        let Some(name) = variant.name.as_deref() else {
            return Err(eyre!(
                "threshold_counterterms {variant_context} requires a name when multiple variants are present",
            ));
        };
        if name.trim().is_empty() {
            return Err(eyre!(
                "threshold_counterterms {variant_context} has a blank name",
            ));
        }
        if !names.insert(name) {
            return Err(eyre!(
                "threshold_counterterms {context} contains duplicate counterterm name '{name}'",
            ));
        }

        validate_ordered_edges(&variant.subspace, "subspace", &variant_context)?;
        validate_ordered_edges(&variant.parent_lmb, "parent_lmb", &variant_context)?;
        if variant.parent_lmb.is_none() {
            return Err(eyre!(
                "threshold_counterterms {variant_context}, variant '{name}' requires a full parent_lmb to identify its signed loop cycles; omit the counterterm entry to use automatic defaults",
            ));
        }

        if let Some(multiplier) = &variant.multiplier {
            if multiplier.expression.trim().is_empty() {
                return Err(eyre!(
                    "threshold_counterterms {variant_context} multiplier expression must not be blank",
                ));
            }
            if !multiplier.opaque_derivatives {
                return Err(eyre!(
                    "threshold_counterterms {variant_context} sets opaque_derivatives=false, which is not supported",
                ));
            }
        }
    }

    Ok(())
}

fn edge_numbers(edges: &[EdgeIndex]) -> Vec<usize> {
    edges.iter().map(|edge| edge.0).collect()
}

#[cfg(test)]
mod tests {
    use linnet::{half_edge::involution::EdgeIndex, permutation::Permutation};

    use super::{
        THRESHOLD_COUNTERTERM_SCHEMA_VERSION, ThresholdCountertermCut, ThresholdCountertermSpec,
        ThresholdCountertermThreshold, ThresholdCountertermVariant,
    };

    #[test]
    fn verbose_threshold_settings_preserve_optional_semantics() {
        use crate::utils::serde_utils::ShowDefaultsGuard;

        let spec = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = []
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
parent_lmb = [1]
[cuts.thresholds.counterterms.multiplier]
expression = "f(1)"
"#,
        )
        .unwrap();
        let compact = {
            let _defaults = ShowDefaultsGuard::new(false);
            spec.to_toml().unwrap()
        };
        assert!(!compact.contains("disable ="));
        assert!(!compact.contains("symmetrize ="));
        assert!(!compact.contains("opaque_derivatives ="));
        let verbose = {
            let _defaults = ShowDefaultsGuard::new(true);
            spec.to_toml().unwrap()
        };
        assert!(verbose.contains("disable = false"));
        assert!(verbose.contains("symmetrize = false"));
        assert!(verbose.contains("opaque_derivatives = true"));
        assert!(verbose.contains("[function_map]"));
        assert!(!verbose.contains("group_id"));
        assert_eq!(
            ThresholdCountertermSpec::parse_toml(&verbose).unwrap(),
            spec
        );
    }

    #[test]
    fn parses_and_canonicalizes_compact_document() {
        let spec = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1

[[cuts]]
edges = [4, 2]

  [[cuts.thresholds]]
  edges = [8, 7]

    [[cuts.thresholds.counterterms]]
    subspace = [7]
    parent_lmb = [7, 8]

      [cuts.thresholds.counterterms.multiplier]
      expression = "eta(effective, eset(7, 8))"
      symmetrize = true
"#,
        )
        .unwrap();

        assert_eq!(spec.schema_version, THRESHOLD_COUNTERTERM_SCHEMA_VERSION);
        assert_eq!(spec.cuts[0].edges, vec![EdgeIndex(2), EdgeIndex(4)]);
        assert_eq!(
            spec.cuts[0].thresholds[0].edges,
            vec![EdgeIndex(7), EdgeIndex(8)]
        );
        assert_eq!(
            spec.cuts[0].thresholds[0].counterterms[0].name.as_deref(),
            Some("default")
        );
        assert!(
            spec.cuts[0].thresholds[0].counterterms[0]
                .multiplier
                .as_ref()
                .unwrap()
                .symmetrize
        );
    }

    #[test]
    fn rejects_unknown_fields_and_unsupported_options() {
        let unknown = ThresholdCountertermSpec::parse_toml("schema_version = 1\nunknown = true\n")
            .unwrap_err();
        assert!(format!("{unknown:#}").contains("unknown field"));

        let derivatives = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = []
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
name = "v"
parent_lmb = [1]
[cuts.thresholds.counterterms.multiplier]
expression = "1"
opaque_derivatives = false
"#,
        )
        .unwrap_err();
        assert!(derivatives.to_string().contains("opaque_derivatives=false"));
    }

    #[test]
    fn validates_variant_names_and_ordered_edge_lists() {
        let unnamed = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = []
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
subspace = [1]
parent_lmb = [1, 2]
[[cuts.thresholds.counterterms]]
name = "second"
subspace = [2]
parent_lmb = [1, 2]
"#,
        )
        .unwrap_err();
        assert!(unnamed.to_string().contains("requires a name"));

        let duplicate_subspace = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = []
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
subspace = [1, 1]
parent_lmb = [1, 2]
"#,
        )
        .unwrap_err();
        assert!(duplicate_subspace.to_string().contains("duplicate edge 1"));
    }

    #[test]
    fn remaps_all_edge_fields_and_preserves_ordered_lists() {
        let mut spec = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = [0, 2]
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
subspace = [2, 0]
parent_lmb = [1, 2, 0]
"#,
        )
        .unwrap();
        let permutation = Permutation::from_map(vec![2, 0, 1]);

        spec.remap_edges(&permutation).unwrap();

        assert_eq!(spec.cuts[0].edges, vec![EdgeIndex(1), EdgeIndex(2)]);
        assert_eq!(
            spec.cuts[0].thresholds[0].edges,
            vec![EdgeIndex(0), EdgeIndex(1)]
        );
        let ThresholdCountertermVariant {
            subspace,
            parent_lmb,
            ..
        } = &spec.cuts[0].thresholds[0].counterterms[0];
        assert_eq!(subspace.as_ref().unwrap(), &[EdgeIndex(1), EdgeIndex(2)]);
        assert_eq!(
            parent_lmb.as_ref().unwrap(),
            &[EdgeIndex(0), EdgeIndex(1), EdgeIndex(2)]
        );
    }

    #[test]
    fn recognizes_semantically_legacy_documents() {
        let empty = ThresholdCountertermSpec::parse_toml("schema_version = 1\n").unwrap();
        assert!(empty.function_map.is_empty());
        assert!(empty.is_legacy_equivalent());
        assert!(empty.to_toml().unwrap().contains("cuts = []"));

        let named_default = ThresholdCountertermSpec {
            cuts: vec![ThresholdCountertermCut {
                edges: vec![],
                thresholds: vec![ThresholdCountertermThreshold {
                    edges: vec![EdgeIndex(1), EdgeIndex(2)],
                    counterterms: vec![ThresholdCountertermVariant {
                        name: Some("normalized_default".to_string()),
                        group_id: None,
                        subspace: None,
                        parent_lmb: None,
                        disable: false,
                        multiplier: None,
                    }],
                }],
            }],
            ..ThresholdCountertermSpec::default()
        };
        assert!(named_default.is_legacy_equivalent());

        let custom_subspace = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = []
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
subspace = [1]
parent_lmb = [1, 2]
"#,
        )
        .unwrap();
        assert!(!custom_subspace.is_legacy_equivalent());

        let disabled = ThresholdCountertermSpec::parse_toml(
            r#"
schema_version = 1
[[cuts]]
edges = []
[[cuts.thresholds]]
edges = [1, 2]
[[cuts.thresholds.counterterms]]
disable = true
parent_lmb = [1, 2]
"#,
        )
        .unwrap();
        assert!(!disabled.is_legacy_equivalent());
    }

    #[test]
    fn explicit_variants_require_parent_but_implicit_defaults_do_not() {
        let defaults =
            "schema_version = 1\n[[cuts]]\nedges = []\n[[cuts.thresholds]]\nedges = [1, 2]\n";
        assert!(
            ThresholdCountertermSpec::parse_toml(defaults)
                .unwrap()
                .is_legacy_equivalent()
        );
        for declaration in [
            "name = \"named\"",
            "subspace = [1]",
            "disable = true",
            "group_id = 0",
        ] {
            let error = ThresholdCountertermSpec::parse_toml(&format!(
                "{defaults}[[cuts.thresholds.counterterms]]\n{declaration}\n"
            ))
            .unwrap_err();
            assert!(error.to_string().contains("requires a full parent_lmb"));
            assert!(error.to_string().contains("threshold [1, 2]"));
        }
    }

    #[test]
    fn group_ids_must_start_at_zero_and_be_contiguous() {
        let mut spec = ThresholdCountertermSpec::default();
        spec.cuts.push(ThresholdCountertermCut {
            edges: vec![],
            thresholds: vec![ThresholdCountertermThreshold {
                edges: vec![EdgeIndex(1)],
                counterterms: vec![ThresholdCountertermVariant {
                    name: Some("gapped".to_string()),
                    group_id: Some(1),
                    subspace: None,
                    parent_lmb: None,
                    disable: false,
                    multiplier: None,
                }],
            }],
        });
        let error = super::ThresholdCountertermSpec::validate_group_ids([&spec]).unwrap_err();
        assert!(error.to_string().contains("missing group_id 0"));
    }
}