use std::collections::HashMap;
use super::types::{PetriNetYaml, AssertionsYaml};
pub struct IncidenceMatrix {
pub d: Vec<Vec<i64>>,
pub place_to_idx: HashMap<String, usize>,
pub trans_to_idx: HashMap<String, usize>,
pub place_count: usize,
pub trans_count: usize,
}
pub fn build_incidence_matrix(net: &PetriNetYaml) -> IncidenceMatrix {
let place_count = net.places.len();
let trans_count = net.transitions.len();
let mut place_to_idx = HashMap::new();
for (i, p) in net.places.iter().enumerate() {
place_to_idx.insert(p.id.clone(), i);
}
let mut trans_to_idx = HashMap::new();
for (j, t) in net.transitions.iter().enumerate() {
trans_to_idx.insert(t.id.clone(), j);
}
let mut d_minus = vec![vec![0i64; trans_count]; place_count];
let mut d_plus = vec![vec![0i64; trans_count]; place_count];
for (j, t) in net.transitions.iter().enumerate() {
for inp in &t.inputs {
if let Some(&pidx) = place_to_idx.get(inp) {
d_minus[pidx][j] += 1;
}
}
for outp in &t.outputs {
if let Some(&pidx) = place_to_idx.get(outp) {
d_plus[pidx][j] += 1;
}
}
}
let mut d = vec![vec![0i64; trans_count]; place_count];
for r in 0..place_count {
for c in 0..trans_count {
d[r][c] = d_plus[r][c] - d_minus[r][c];
}
}
IncidenceMatrix {
d,
place_to_idx,
trans_to_idx,
place_count,
trans_count,
}
}
pub struct ComputedInvariants {
pub p_invariants: Vec<Vec<i64>>,
pub p_constants: Vec<i64>,
pub t_invariants: Vec<Vec<i64>>,
}
pub fn compute_invariants(
net: &PetriNetYaml,
matrix: &IncidenceMatrix,
place_ids: &[String],
place_markings: &HashMap<String, i64>,
) -> ComputedInvariants {
let mut p_invariants = Vec::new();
let mut p_constants = Vec::new();
let has_declared_p = net.assertions.as_ref()
.and_then(|a| a.noetherian_invariants.as_ref())
.is_some_and(|n| !n.p_invariants.is_empty());
if has_declared_p {
if let Some(noether) = net.assertions.as_ref()
.and_then(|a| a.noetherian_invariants.as_ref())
{
for pinv in &noether.p_invariants {
let mut weights_vec = vec![0i64; matrix.place_count];
for (pid, &w) in &pinv.weights {
if let Some(&pidx) = matrix.place_to_idx.get(pid) {
weights_vec[pidx] = w;
}
}
p_invariants.push(weights_vec);
p_constants.push(pinv.expected_constant);
}
}
} else {
let basis = crate::cpn::solver::solve_nullspace(
&matrix.d, matrix.place_count, matrix.trans_count, true,
);
for basis_vector in basis {
let mut init_sum = 0;
for (p_idx, &weight) in basis_vector.iter().enumerate() {
let pid = &place_ids[p_idx];
let tokens = place_markings.get(pid).cloned().unwrap_or(0);
init_sum += weight * tokens;
}
p_invariants.push(basis_vector);
p_constants.push(init_sum);
}
}
let mut t_invariants = Vec::new();
let has_declared_t = net.assertions.as_ref()
.and_then(|a| a.noetherian_invariants.as_ref())
.is_some_and(|n| !n.t_invariants.is_empty());
if has_declared_t {
if let Some(noether) = net.assertions.as_ref()
.and_then(|a| a.noetherian_invariants.as_ref())
{
for tinv in &noether.t_invariants {
let mut firings_vec = vec![0i64; matrix.trans_count];
for (tid, &f) in &tinv.firing_counts {
if let Some(&tidx) = matrix.trans_to_idx.get(tid) {
firings_vec[tidx] = f;
}
}
t_invariants.push(firings_vec);
}
}
} else {
let basis = crate::cpn::solver::solve_nullspace(
&matrix.d, matrix.place_count, matrix.trans_count, false,
);
for basis_vector in basis {
t_invariants.push(basis_vector);
}
}
ComputedInvariants {
p_invariants,
p_constants,
t_invariants,
}
}
pub fn verify_t_invariant_idempotency(
d: &[Vec<i64>],
cumulative_fires: &[i64],
_fire_count: i64,
place_count: usize,
trans_count: usize,
net: &PetriNetYaml,
place_markings: &HashMap<String, i64>,
) -> Result<String, String> {
let mut buf = String::new();
let mut is_t_invariant = true;
for r in 0..place_count {
let mut sum = 0;
for c in 0..trans_count {
sum += d[r][c] * cumulative_fires[c];
}
if sum != 0 {
is_t_invariant = false;
break;
}
}
let total_fires: i64 = cumulative_fires.iter().sum();
if is_t_invariant && total_fires > 0 {
buf.push_str(&format!(
" 🔍 Firing sequence is a proven T-invariant cycle ({} total fires)\n",
total_fires
));
let mut mismatch = false;
for p in &net.places {
let final_tok = place_markings.get(&p.id).cloned().unwrap_or(0);
if final_tok != p.initial_tokens {
buf.push_str(" ❌ [NOETHER_ERR] T-Invariant Idempotency Violation (State Drift)!\n");
buf.push_str(&format!(" Place: {}\n", p.id));
buf.push_str(&format!(" Initial Tokens: {}\n", p.initial_tokens));
buf.push_str(&format!(" Final Tokens: {}\n", final_tok));
mismatch = true;
}
}
if mismatch {
return Err(buf);
} else {
buf.push_str(" ✅ Temporal idempotency proven (zero state drift)\n");
}
}
Ok(buf)
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum AssertionCheckKind {
EventCount(String),
Deadlock,
FinalMarking(String),
FireCount,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AssertionCheckResult {
pub kind: AssertionCheckKind,
pub passed: bool,
pub actual_display: String,
pub expected_display: String,
pub deadlocked: bool,
}
pub fn check_assertions(
assertions: &AssertionsYaml,
observed_events: &HashMap<String, i64>,
fire_count: i64,
deadlocked: bool,
place_markings: &HashMap<String, i64>,
) -> Vec<AssertionCheckResult> {
let mut results = Vec::new();
for (key, &expected) in &assertions.event_counts {
let actual = observed_events.get(key).copied().unwrap_or(0);
results.push(AssertionCheckResult {
kind: AssertionCheckKind::EventCount(key.clone()),
passed: actual == expected,
actual_display: actual.to_string(),
expected_display: expected.to_string(),
deadlocked,
});
}
if let Some(expected_deadlock) = assertions.deadlock {
results.push(AssertionCheckResult {
kind: AssertionCheckKind::Deadlock,
passed: expected_deadlock == deadlocked,
actual_display: deadlocked.to_string(),
expected_display: expected_deadlock.to_string(),
deadlocked,
});
}
for (key, &expected) in &assertions.final_marking {
let actual = place_markings.get(key).copied().unwrap_or(0);
results.push(AssertionCheckResult {
kind: AssertionCheckKind::FinalMarking(key.clone()),
passed: actual == expected,
actual_display: actual.to_string(),
expected_display: expected.to_string(),
deadlocked,
});
}
if assertions.fire_count >= 0 {
results.push(AssertionCheckResult {
kind: AssertionCheckKind::FireCount,
passed: fire_count == assertions.fire_count,
actual_display: fire_count.to_string(),
expected_display: assertions.fire_count.to_string(),
deadlocked,
});
}
results
}
pub fn render_assertion_results(results: &[AssertionCheckResult]) -> (String, i64, i64) {
let mut buf = String::new();
let mut pass = 0i64;
let mut fail = 0i64;
for r in results {
if r.passed {
pass += 1;
} else {
fail += 1;
}
match &r.kind {
AssertionCheckKind::EventCount(key) => {
if r.passed {
buf.push_str(&format!(" ✅ {}: {} (expected {})\n", key, r.actual_display, r.expected_display));
} else {
buf.push_str(&format!(" ❌ {}: {} (expected {})\n", key, r.actual_display, r.expected_display));
}
}
AssertionCheckKind::Deadlock => {
if r.passed {
buf.push_str(&format!(
" ✅ deadlock: {} (expected)\n",
if r.deadlocked { "detected" } else { "none" }
));
} else {
buf.push_str(&format!(
" ❌ deadlock: {} (expected {})\n",
r.actual_display, r.expected_display
));
}
}
AssertionCheckKind::FinalMarking(key) => {
if r.passed {
buf.push_str(&format!(" ✅ marking[{}]: {} (expected {})\n", key, r.actual_display, r.expected_display));
} else {
buf.push_str(&format!(" ❌ marking[{}]: {} (expected {})\n", key, r.actual_display, r.expected_display));
}
}
AssertionCheckKind::FireCount => {
if r.passed {
buf.push_str(&format!(" ✅ fire_count: {} (expected {})\n", r.actual_display, r.expected_display));
} else {
buf.push_str(&format!(" ❌ fire_count: {} (expected {})\n", r.actual_display, r.expected_display));
}
}
}
}
(buf, pass, fail)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn pure_assertions_and_byte_identical_rendering() {
let mut event_counts = HashMap::new();
event_counts.insert("evt_a".to_string(), 2);
event_counts.insert("evt_miss".to_string(), 1);
let mut final_marking = HashMap::new();
final_marking.insert("p_done".to_string(), 1);
let assertions = AssertionsYaml {
fire_count: 3,
event_counts,
deadlock: Some(false),
final_marking,
noetherian_invariants: None,
};
let mut observed = HashMap::new();
observed.insert("evt_a".to_string(), 2);
observed.insert("evt_miss".to_string(), 0);
let mut markings = HashMap::new();
markings.insert("p_done".to_string(), 1);
let results = check_assertions(&assertions, &observed, 3, false, &markings);
let (buf, pass, fail) = render_assertion_results(&results);
assert_eq!(pass, 4);
assert_eq!(fail, 1);
assert!(buf.contains(" ✅ evt_a: 2 (expected 2)\n"));
assert!(buf.contains(" ❌ evt_miss: 0 (expected 1)\n"));
assert!(buf.contains(" ✅ deadlock: none (expected)\n"));
assert!(buf.contains(" ✅ marking[p_done]: 1 (expected 1)\n"));
assert!(buf.contains(" ✅ fire_count: 3 (expected 3)\n"));
}
}