clm-kernel 0.0.11

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! Layer 1: Colored Petri Net (CPN) Domain Types
//! Canonical Path: kernel/clm_rust_core/src/layer1/types.rs

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

/// Unique identifier for a Petri net Place.
pub type PlaceId = String;

/// Unique identifier for a Petri net Transition.
pub type TransitionId = String;

/// Token record carrying color (value/type) within a Place.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TokenRecord {
    pub color: String,
    pub count: u32,
    #[serde(default)]
    pub metadata: HashMap<String, serde_json::Value>,
}

/// Place definition within the Petri net graph.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Place {
    pub id: PlaceId,
    pub initial_tokens: u32,
    pub initial_color: Option<String>,
}

/// Transition definition within the Petri net graph.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Transition {
    pub id: TransitionId,
    pub inputs: Vec<PlaceId>,
    pub outputs: Vec<PlaceId>,
}

/// Current marking of the Petri net: mapping from PlaceId to token count.
pub type Marking = HashMap<PlaceId, u32>;

/// Representation of a discrete Petri net graph.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PetriNet {
    pub places: Vec<Place>,
    pub transitions: Vec<Transition>,
}

impl Default for PetriNet {
    fn default() -> Self {
        Self::new()
    }
}

impl PetriNet {
    pub fn new() -> Self {
        Self {
            places: Vec::new(),
            transitions: Vec::new(),
        }
    }

    pub fn add_place(&mut self, id: impl Into<String>, initial_tokens: u32) {
        self.places.push(Place {
            id: id.into(),
            initial_tokens,
            initial_color: None,
        });
    }

    pub fn add_transition(
        &mut self,
        id: impl Into<String>,
        inputs: Vec<String>,
        outputs: Vec<String>,
    ) {
        self.transitions.push(Transition {
            id: id.into(),
            inputs,
            outputs,
        });
    }

    pub fn initial_marking(&self) -> Marking {
        let mut marking = HashMap::new();
        for p in &self.places {
            marking.insert(p.id.clone(), p.initial_tokens);
        }
        marking
    }
}