clm-kernel 0.0.17

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Catalyst read-arc bindings and composition algebra for Open Petri Nets.
//!
//! Invariant: INV-CLC-03 (Open Monoidal Net Compositionality).

use std::collections::{BTreeMap, HashMap, HashSet};
use serde::{Deserialize, Serialize};

use super::open_petri_net::{OpenPetriNet, OpenPlace, OpenTransition};
use super::open_petri_pullback::{
    compose_marked_open_petri_nets, BoundaryGlueSpec, BoundaryMarkingPullbackError,
};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CatalystEvaluationResult {
    pub enabled: bool,
    pub next_marking: BTreeMap<String, i64>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CatalystPlaceBinding {
    pub left_place_id: String,
    pub right_place_id: String,
    pub catalyst_place_id: String,
    pub read_arc_weight: i64,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CatalystCompositionResult {
    pub composite_net: OpenPetriNet,
    pub glued_marking: BTreeMap<String, i64>,
    pub preserved_catalysts: Vec<String>,
}

pub fn evaluate_catalyst_transition(
    transition: &OpenTransition,
    marking: &BTreeMap<String, i64>,
) -> CatalystEvaluationResult {
    let mut consume_count: HashMap<&str, i64> = HashMap::new();
    for inp in &transition.inputs {
        *consume_count.entry(inp.as_str()).or_default() += 1;
    }
    let mut read_count: HashMap<&str, i64> = HashMap::new();
    if let Some(ref reads) = transition.read_arcs {
        for r in reads {
            *read_count.entry(r.as_str()).or_default() += 1;
        }
    }

    let mut all_places: HashSet<&str> = HashSet::new();
    all_places.extend(consume_count.keys());
    all_places.extend(read_count.keys());

    for p in all_places {
        let req = std::cmp::max(
            consume_count.get(p).copied().unwrap_or(0),
            read_count.get(p).copied().unwrap_or(0),
        );
        let cur = marking.get(p).copied().unwrap_or(0);
        if cur < req {
            return CatalystEvaluationResult {
                enabled: false,
                next_marking: marking.clone(),
            };
        }
    }

    let mut nxt = marking.clone();
    for (p, cnt) in consume_count {
        let cur = nxt.get(p).copied().unwrap_or(0);
        nxt.insert(p.to_string(), cur - cnt);
    }
    for out in &transition.outputs {
        let cur = nxt.get(out).copied().unwrap_or(0);
        nxt.insert(out.clone(), cur + 1);
    }

    CatalystEvaluationResult {
        enabled: true,
        next_marking: nxt,
    }
}

pub fn compose_with_catalyst_places(
    left: &OpenPetriNet,
    right: &OpenPetriNet,
    bindings: &[CatalystPlaceBinding],
    marking_left: &BTreeMap<String, i64>,
    marking_right: &BTreeMap<String, i64>,
) -> Result<CatalystCompositionResult, BoundaryMarkingPullbackError> {
    let left_by_id: HashMap<&str, &OpenPlace> = left.places.iter().map(|p| (p.id.as_str(), p)).collect();
    let right_by_id: HashMap<&str, &OpenPlace> = right.places.iter().map(|p| (p.id.as_str(), p)).collect();

    for b in bindings {
        let lp = left_by_id.get(b.left_place_id.as_str()).ok_or_else(|| {
            BoundaryMarkingPullbackError(format!("Unknown left catalyst place '{}'", b.left_place_id))
        })?;
        let rp = right_by_id.get(b.right_place_id.as_str()).ok_or_else(|| {
            BoundaryMarkingPullbackError(format!("Unknown right catalyst place '{}'", b.right_place_id))
        })?;

        let left_tok = marking_left.get(&b.left_place_id).copied().unwrap_or(lp.initial_tokens);
        let right_tok = marking_right.get(&b.right_place_id).copied().unwrap_or(rp.initial_tokens);
        if left_tok != right_tok {
            return Err(BoundaryMarkingPullbackError(format!(
                "Catalyst marking pullback mismatch for '{}': left={}, right={}",
                b.catalyst_place_id, left_tok, right_tok
            )));
        }
        if b.read_arc_weight <= 0 {
            return Err(BoundaryMarkingPullbackError(format!(
                "Catalyst binding '{}' must have readArcWeight >= 1 (got {})",
                b.catalyst_place_id, b.read_arc_weight
            )));
        }
        if left_tok < b.read_arc_weight {
            return Err(BoundaryMarkingPullbackError(format!(
                "Catalyst place '{}' has {} tokens, below required readArcWeight {}",
                b.catalyst_place_id, left_tok, b.read_arc_weight
            )));
        }

        for tr in &left.transitions {
            let in_count = tr.inputs.iter().filter(|&p| p == &b.left_place_id).count();
            let out_count = tr.outputs.iter().filter(|&p| p == &b.left_place_id).count();
            if in_count != out_count {
                return Err(BoundaryMarkingPullbackError(format!(
                    "Catalyst place '{}' violates read-only token conservation in transition '{}' (inputs={}, outputs={})",
                    b.left_place_id, tr.id, in_count, out_count
                )));
            }
        }
        for tr in &right.transitions {
            let in_count = tr.inputs.iter().filter(|&p| p == &b.right_place_id).count();
            let out_count = tr.outputs.iter().filter(|&p| p == &b.right_place_id).count();
            if in_count != out_count {
                return Err(BoundaryMarkingPullbackError(format!(
                    "Catalyst place '{}' violates read-only token conservation in transition '{}' (inputs={}, outputs={})",
                    b.right_place_id, tr.id, in_count, out_count
                )));
            }
        }
    }

    let mut direct_glue: BTreeMap<String, String> = BTreeMap::new();
    for out_id in &left.outputs {
        if right.inputs.contains(out_id) {
            direct_glue.insert(out_id.clone(), out_id.clone());
        }
    }
    for b in bindings {
        direct_glue.insert(b.left_place_id.clone(), b.right_place_id.clone());
    }

    let glue_spec = BoundaryGlueSpec::Direct(direct_glue);
    let res = compose_marked_open_petri_nets(left, right, Some(&glue_spec), true)?;
    let composite = res.composite;
    let glued_place_map = res.glued_place_map;

    let mut rename_map: HashMap<String, String> = HashMap::new();
    for b in bindings {
        if let Some(raw_glued) = glued_place_map.get(&format!("net1:{}", b.left_place_id)) {
            if raw_glued != &b.catalyst_place_id {
                rename_map.insert(raw_glued.clone(), b.catalyst_place_id.clone());
            }
        }
    }

    let remap_id = |id: &str| -> String {
        rename_map.get(id).cloned().unwrap_or_else(|| id.to_string())
    };
    let remap_ids = |ids: &[String]| -> Vec<String> {
        ids.iter().map(|i| remap_id(i)).collect()
    };

    let final_places: Vec<OpenPlace> = composite
        .places
        .into_iter()
        .map(|p| OpenPlace {
            id: remap_id(&p.id),
            initial_tokens: p.initial_tokens,
            label: p.label,
        })
        .collect();

    let final_transitions: Vec<OpenTransition> = composite
        .transitions
        .into_iter()
        .map(|t| OpenTransition {
            id: t.id,
            inputs: remap_ids(&t.inputs),
            outputs: remap_ids(&t.outputs),
            read_arcs: t.read_arcs.map(|ras| remap_ids(&ras)),
        })
        .collect();

    let composite_net = OpenPetriNet {
        name: composite.name,
        places: final_places.clone(),
        transitions: final_transitions,
        inputs: remap_ids(&composite.inputs),
        outputs: remap_ids(&composite.outputs),
    };

    let mut glued_marking: BTreeMap<String, i64> = BTreeMap::new();
    for p in &final_places {
        if let Some(b) = bindings.iter().find(|b| b.catalyst_place_id == p.id) {
            let tok = marking_left.get(&b.left_place_id).copied().unwrap_or(p.initial_tokens);
            glued_marking.insert(p.id.clone(), tok);
        } else {
            let mut found = false;
            for (key, comp_id) in &glued_place_map {
                if remap_id(comp_id) == p.id {
                    if key.starts_with("net1:") {
                        let tok = marking_left.get(&key[5..]).copied().unwrap_or(p.initial_tokens);
                        glued_marking.insert(p.id.clone(), tok);
                        found = true;
                        break;
                    } else if key.starts_with("net2:") {
                        let tok = marking_right.get(&key[5..]).copied().unwrap_or(p.initial_tokens);
                        glued_marking.insert(p.id.clone(), tok);
                        found = true;
                        break;
                    }
                }
            }
            if !found {
                glued_marking.insert(p.id.clone(), p.initial_tokens);
            }
        }
    }

    Ok(CatalystCompositionResult {
        composite_net,
        glued_marking,
        preserved_catalysts: bindings.iter().map(|b| b.catalyst_place_id.clone()).collect(),
    })
}