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(),
})
}