orfeas_petri_flow 0.6.0

data/lib/petri_flow/verification/boundedness_checker.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Verification
+    # Boundedness checker for Petri nets
+    # Checks if token count in places is bounded
+    class BoundednessChecker
+      attr_reader :net, :reachability_analyzer
+
+      def initialize(net, reachability_analyzer = nil)
+        @net = net
+        @reachability_analyzer = reachability_analyzer ||
+                                 ReachabilityAnalyzer.new(net)
+      end
+
+      # Check if the net is bounded
+      # A net is k-bounded if no place ever contains more than k tokens
+      def bounded?(k = nil, max_states: 10000)
+        # First compute reachability
+        @reachability_analyzer.analyze(max_states: max_states)
+
+        if k.nil?
+          # Check if there's any bound
+          check_general_boundedness
+        else
+          # Check if bounded by k
+          check_k_boundedness(k)
+        end
+      end
+
+      # Find the bound for each place
+      def place_bounds
+        bounds = {}
+
+        @reachability_analyzer.reachable_markings.each do |marking|
+          marking.to_h.each do |place_id, token_count|
+            bounds[place_id] ||= 0
+            bounds[place_id] = [bounds[place_id], token_count].max
+          end
+        end
+
+        bounds
+      end
+
+      # Check if net is safe (1-bounded)
+      def safe?
+        bounded?(1)
+      end
+
+      # Check if net is structurally bounded
+      # (bounded regardless of initial marking)
+      def structurally_bounded?
+        # This requires computing the incidence matrix
+        # and checking if the system is structurally bounded
+        # For now, we'll return a simplified check
+        incidence_matrix = compute_incidence_matrix
+
+        # Check if the rank of incidence matrix indicates structural boundedness
+        # This is a simplified heuristic
+        places_count = @net.places.size
+        transitions_count = @net.transitions.size
+
+        # If places >= transitions, likely bounded
+        places_count >= transitions_count
+      end
+
+      # Generate boundedness report
+      def report
+        {
+          is_bounded: bounded?,
+          is_safe: safe?,
+          place_bounds: place_bounds,
+          max_tokens: place_bounds.values.max || 0,
+          unbounded_places: unbounded_places,
+          structurally_bounded: structurally_bounded?
+        }
+      end
+
+      private
+
+      def check_general_boundedness
+        bounds = place_bounds
+
+        # Check if any place has "infinite" tokens (we use 1000 as threshold)
+        bounds.values.all? { |bound| bound < 1000 }
+      end
+
+      def check_k_boundedness(k)
+        bounds = place_bounds
+        bounds.values.all? { |bound| bound <= k }
+      end
+
+      def unbounded_places
+        bounds = place_bounds
+        bounds.select { |_place, bound| bound >= 1000 }.keys
+      end
+
+      def compute_incidence_matrix
+        places = @net.places.keys
+        transitions = @net.transitions.keys
+
+        matrix = {}
+        places.each do |place_id|
+          matrix[place_id] = {}
+          transitions.each do |transition_id|
+            matrix[place_id][transition_id] = 0
+          end
+        end
+
+        # Calculate incidence matrix: C = C+ - C-
+        @net.arcs.each do |arc|
+          if arc.input_arc? # place -> transition
+            place_id = arc.source.id
+            transition_id = arc.target.id
+            matrix[place_id][transition_id] -= arc.weight
+          elsif arc.output_arc? # transition -> place
+            place_id = arc.target.id
+            transition_id = arc.source.id
+            matrix[place_id][transition_id] += arc.weight
+          end
+        end
+
+        matrix
+      end
+    end
+  end
+end

data/lib/petri_flow/verification/invariant_checker.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Verification
+    # Invariant checker for Petri nets
+    # Verifies properties that should hold across all reachable states
+    class InvariantChecker
+      attr_reader :net, :reachability_analyzer, :invariants
+
+      def initialize(net, reachability_analyzer = nil)
+        @net = net
+        @reachability_analyzer = reachability_analyzer ||
+                                 ReachabilityAnalyzer.new(net)
+        @invariants = []
+      end
+
+      # Add a custom invariant
+      # @param name [String] Name of the invariant
+      # @param checker [Proc] Block that takes marking and returns true/false
+      def add_invariant(name, &checker)
+        @invariants << { name: name, checker: checker }
+      end
+
+      # Check all invariants across all reachable markings
+      def check_all_invariants
+        results = {}
+
+        @invariants.each do |invariant|
+          results[invariant[:name]] = check_invariant(invariant)
+        end
+
+        results
+      end
+
+      # Check a specific invariant
+      def check_invariant(invariant)
+        violations = []
+
+        @reachability_analyzer.reachable_markings.each do |marking|
+          @net.set_marking(marking)
+
+          unless invariant[:checker].call(marking, @net)
+            violations << marking.dup
+          end
+        end
+
+        {
+          name: invariant[:name],
+          holds: violations.empty?,
+          violations: violations,
+          violation_count: violations.size
+        }
+      end
+
+      # Common invariant: Token conservation
+      # Total tokens in system remains constant
+      def check_token_conservation(expected_total)
+        add_invariant("Token Conservation (#{expected_total})") do |marking|
+          total_tokens = marking.to_h.values.sum
+          total_tokens == expected_total
+        end
+
+        check_invariant(@invariants.last)
+      end
+
+      # Common invariant: Mutual exclusion
+      # At most one of specified places has token
+      def check_mutual_exclusion(place_ids)
+        add_invariant("Mutual Exclusion (#{place_ids.join(', ')})") do |marking|
+          tokens_in_places = place_ids.sum { |pid| marking.tokens_at(pid) }
+          tokens_in_places <= 1
+        end
+
+        check_invariant(@invariants.last)
+      end
+
+      # Common invariant: Place bound
+      # A place never exceeds a token limit
+      def check_place_bound(place_id, max_tokens)
+        add_invariant("Place Bound (#{place_id} <= #{max_tokens})") do |marking|
+          marking.tokens_at(place_id) <= max_tokens
+        end
+
+        check_invariant(@invariants.last)
+      end
+
+      # Check liveness invariant: no deadlocks
+      def check_no_deadlocks
+        add_invariant("No Deadlocks") do |_marking, net|
+          !net.deadlocked?
+        end
+
+        check_invariant(@invariants.last)
+      end
+
+      # Custom invariants for Lyra CRUD-Event mapping
+
+      # Invariant: PII always detected before storage
+      def check_pii_always_detected(pii_detected_place, storage_place)
+        add_invariant("PII Always Detected Before Storage") do |marking|
+          # If there are tokens in storage, there must have been tokens in PII detected
+          # This is a simplified check - in practice we'd track causation
+          marking.tokens_at(storage_place) <= marking.tokens_at(pii_detected_place)
+        end
+
+        check_invariant(@invariants.last)
+      end
+
+      # Invariant: Event-ORM consistency
+      def check_event_orm_consistency(event_place, orm_place)
+        add_invariant("Event-ORM Consistency") do |marking|
+          # In Monitor mode, event count should match ORM count
+          marking.tokens_at(event_place) == marking.tokens_at(orm_place)
+        end
+
+        check_invariant(@invariants.last)
+      end
+
+      # Generate comprehensive invariant report
+      def report
+        results = check_all_invariants
+
+        {
+          total_invariants: @invariants.size,
+          passed: results.count { |_, r| r[:holds] },
+          failed: results.count { |_, r| !r[:holds] },
+          results: results,
+          summary: generate_summary(results)
+        }
+      end
+
+      private
+
+      def generate_summary(results)
+        if results.all? { |_, r| r[:holds] }
+          "✓ All #{results.size} invariants hold"
+        else
+          failed = results.select { |_, r| !r[:holds] }
+          "⚠ #{failed.size} invariant(s) violated: #{failed.keys.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/petri_flow/verification/liveness_checker.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Verification
+    # Liveness checker for Petri nets
+    # Checks various liveness properties
+    class LivenessChecker
+      attr_reader :net, :reachability_analyzer
+
+      # Liveness levels:
+      # L0 (Dead): Never fires
+      # L1 (Potentially firable): Can fire at least once
+      # L2 (Potentially firable k times): Can fire k times
+      # L3 (Potentially firable infinitely): Can fire infinitely
+      # L4 (Live): Can always eventually fire
+
+      def initialize(net, reachability_analyzer = nil)
+        @net = net
+        @reachability_analyzer = reachability_analyzer ||
+                                 ReachabilityAnalyzer.new(net)
+      end
+
+      # Check if transition is dead (L0)
+      def dead?(transition_id)
+        !firable?(transition_id)
+      end
+
+      # Check if transition is potentially firable (L1)
+      def firable?(transition_id)
+        @reachability_analyzer.reachable_markings.any? do |marking|
+          @net.set_marking(marking)
+          transition = @net.transition(transition_id)
+          transition&.enabled?
+        end
+      end
+
+      # Check if transition is live (L4)
+      # A transition is live if from every reachable marking,
+      # it can eventually fire
+      def live?(transition_id, max_depth: 100)
+        @reachability_analyzer.reachable_markings.all? do |marking|
+          can_eventually_fire?(transition_id, marking, max_depth: max_depth)
+        end
+      end
+
+      # Check if net is deadlock-free
+      def deadlock_free?
+        @reachability_analyzer.reachable_markings.all? do |marking|
+          @net.set_marking(marking)
+          !@net.deadlocked?
+        end
+      end
+
+      # Find dead transitions
+      def dead_transitions
+        @net.transitions.keys.select { |tid| dead?(tid) }
+      end
+
+      # Find live transitions
+      def live_transitions(max_depth: 100)
+        @net.transitions.keys.select { |tid| live?(tid, max_depth: max_depth) }
+      end
+
+      # Classify all transitions by liveness level
+      def classify_transitions
+        classification = {}
+
+        @net.transitions.each_key do |transition_id|
+          classification[transition_id] = if dead?(transition_id)
+                                            :dead # L0
+                                          elsif live?(transition_id)
+                                            :live # L4
+                                          elsif firable?(transition_id)
+                                            :potentially_firable # L1
+                                          else
+                                            :unknown
+                                          end
+        end
+
+        classification
+      end
+
+      # Generate liveness report
+      def report
+        classification = classify_transitions
+
+        {
+          deadlock_free: deadlock_free?,
+          dead_transitions: classification.select { |_, v| v == :dead }.keys,
+          live_transitions: classification.select { |_, v| v == :live }.keys,
+          potentially_firable: classification.select { |_, v| v == :potentially_firable }.keys,
+          classification: classification,
+          liveness_score: calculate_liveness_score(classification)
+        }
+      end
+
+      private
+
+      def can_eventually_fire?(transition_id, from_marking, max_depth:)
+        # BFS to find if transition can fire within max_depth steps
+        queue = [[from_marking, 0]]
+        visited = Set.new([marking_to_key(from_marking)])
+
+        while queue.any?
+          current_marking, depth = queue.shift
+
+          return false if depth > max_depth
+
+          @net.set_marking(current_marking)
+
+          # Check if target transition is enabled
+          transition = @net.transition(transition_id)
+          return true if transition&.enabled?
+
+          # Try all enabled transitions
+          @net.enabled_transitions.each do |enabled_transition|
+            saved_marking = @net.current_marking.dup
+
+            begin
+              enabled_transition.fire!
+              new_marking = @net.current_marking.dup
+              new_key = marking_to_key(new_marking)
+
+              unless visited.include?(new_key)
+                visited.add(new_key)
+                queue << [new_marking, depth + 1]
+              end
+            ensure
+              @net.set_marking(saved_marking)
+            end
+          end
+        end
+
+        false
+      end
+
+      def marking_to_key(marking)
+        marking.to_h.sort.to_s
+      end
+
+      def calculate_liveness_score(classification)
+        total = classification.size
+        return 0 if total.zero?
+
+        live_count = classification.count { |_, v| v == :live }
+        firable_count = classification.count { |_, v| v == :potentially_firable }
+
+        # Score: (live * 1.0 + firable * 0.5) / total
+        ((live_count * 1.0) + (firable_count * 0.5)) / total
+      end
+    end
+  end
+end

data/lib/petri_flow/verification/reachability_analyzer.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module PetriFlow
+  module Verification
+    # Reachability analysis for Petri nets
+    # Determines which states are reachable from initial state
+    #
+    # Supports P/T abstraction mode for colored nets: when enabled,
+    # guards are ignored and all transitions fire non-deterministically
+    # based only on token availability. This is sound for structural
+    # properties (boundedness, liveness, reachability).
+    class ReachabilityAnalyzer
+      attr_reader :net, :initial_marking, :reachable_markings, :state_graph, :pt_abstraction
+
+      # @param net [PetriFlow::Core::Net] The Petri net to analyze
+      # @param initial_marking [PetriFlow::Core::Marking] Initial marking (default: net's current marking)
+      # @param pt_abstraction [Boolean] Enable P/T abstraction (ignore guards)
+      def initialize(net, initial_marking = nil, pt_abstraction: false)
+        @net = net
+        @initial_marking = initial_marking || net.current_marking
+        @reachable_markings = Set.new
+        @state_graph = {} # marking => { transition => next_marking }
+        @pt_abstraction = pt_abstraction
+      end
+
+      # Compute all reachable markings using BFS
+      def analyze(max_states: 10000)
+        @reachable_markings.clear
+        @state_graph.clear
+
+        queue = [@initial_marking.dup]
+        visited = Set.new
+
+        iteration = 0
+        while queue.any? && iteration < max_states
+          current_marking = queue.shift
+          marking_key = marking_to_key(current_marking)
+
+          next if visited.include?(marking_key)
+          visited.add(marking_key)
+
+          @reachable_markings.add(current_marking.dup)
+          @state_graph[marking_key] = {}
+
+          # Set net to current marking
+          @net.set_marking(current_marking)
+
+          # Try firing each enabled transition
+          # In P/T abstraction mode, ignore guards (non-deterministic choice)
+          context = @pt_abstraction ? { ignore_guards: true } : {}
+          @net.enabled_transitions(context).each do |transition|
+            # Save current state
+            saved_marking = @net.current_marking.dup
+
+            # Fire transition (pass context for P/T abstraction)
+            begin
+              transition.fire!(context)
+              new_marking = @net.current_marking.dup
+              new_marking_key = marking_to_key(new_marking)
+
+              # Record state transition
+              @state_graph[marking_key][transition.id] = new_marking_key
+
+              # Add to queue if not visited
+              queue << new_marking unless visited.include?(new_marking_key)
+            ensure
+              # Restore marking for next iteration
+              @net.set_marking(saved_marking)
+            end
+          end
+
+          iteration += 1
+        end
+
+        # Restore initial marking
+        @net.set_marking(@initial_marking)
+
+        {
+          total_states: @reachable_markings.size,
+          state_graph_size: @state_graph.size,
+          max_states_reached: iteration >= max_states
+        }
+      end
+
+      # Check if a specific marking is reachable
+      def reachable?(target_marking)
+        target_key = marking_to_key(target_marking)
+        @reachable_markings.any? { |m| marking_to_key(m) == target_key }
+      end
+
+      # Find path from initial marking to target marking
+      def find_path(target_marking)
+        target_key = marking_to_key(target_marking)
+        initial_key = marking_to_key(@initial_marking)
+
+        return [] if initial_key == target_key
+
+        # BFS to find shortest path
+        queue = [[initial_key]]
+        visited = Set.new([initial_key])
+
+        while queue.any?
+          path = queue.shift
+          current_key = path.last
+
+          next unless @state_graph[current_key]
+
+          @state_graph[current_key].each do |transition_id, next_key|
+            return path + [transition_id, next_key] if next_key == target_key
+
+            unless visited.include?(next_key)
+              visited.add(next_key)
+              queue << (path + [transition_id, next_key])
+            end
+          end
+        end
+
+        nil # No path found
+      end
+
+      # Check for terminal states (no outgoing transitions)
+      def terminal_states
+        @state_graph.select { |_marking, transitions| transitions.empty? }.keys
+      end
+
+      # Generate reachability report
+      def report
+        {
+          initial_marking: @initial_marking.to_h,
+          total_reachable_states: @reachable_markings.size,
+          terminal_states: terminal_states.size,
+          state_graph_edges: @state_graph.values.map(&:size).sum,
+          is_bounded: bounded?,
+          deadlock_states: terminal_states,
+          pt_abstraction: @pt_abstraction
+        }
+      end
+
+      private
+
+      def marking_to_key(marking)
+        marking.to_h.sort.to_s
+      end
+
+      def bounded?
+        # Check if token count in any place exceeds a reasonable bound
+        max_tokens = @reachable_markings.flat_map { |m| m.to_h.values }.max || 0
+        max_tokens < 1000 # Arbitrary bound
+      end
+    end
+  end
+end