libpetri 2.7.1 → 2.9.0

package/dist/verification/index.js

@@ -1,10 +1,14 @@
 import {
+  DBM,
   IncidenceMatrix,
   MarkingState,
   MarkingStateBuilder,
   SmtVerifier,
+  StateClass,
+  StateClassGraph,
   alwaysAvailable,
   bounded,
+  branchPlaceBound,
   computePInvariants,
   createSpacerRunner,
   deadlockFree,
@@ -22,6 +26,7 @@ import {
   isCoveredByInvariants,
   isProven,
   isViolated,
+  joinedOrDeadLettered,
   mutualExclusion,
   pInvariant,
   pInvariantToString,
@@ -29,222 +34,8 @@ import {
   propertyDescription,
   structuralCheck,
   unreachable
-} from "../chunk-ETNHEAS6.js";
-import {
-  earliest,
-  latest
-} from "../chunk-ATT7U5H5.js";
-
-// src/verification/analysis/dbm.ts
-var EPSILON = 1e-9;
-var DBM = class _DBM {
-  bounds;
-  dim;
-  clockNames;
-  _empty;
-  constructor(bounds, dim, clockNames, empty) {
-    this.bounds = bounds;
-    this.dim = dim;
-    this.clockNames = clockNames;
-    this._empty = empty;
-  }
-  /** Creates an initial firing domain for enabled transitions. */
-  static create(clockNames, lowerBounds, upperBounds) {
-    const n = clockNames.length;
-    const dim = n + 1;
-    const bounds = makeMatrix(dim, Infinity);
-    for (let i = 0; i < n; i++) {
-      bounds[0 * dim + (i + 1)] = -lowerBounds[i];
-      bounds[(i + 1) * dim + 0] = upperBounds[i];
-    }
-    return new _DBM(bounds, dim, clockNames, false).canonicalize();
-  }
-  /** Creates an empty (unsatisfiable) zone. */
-  static empty(clockNames) {
-    const b = new Float64Array(1);
-    b[0] = 0;
-    return new _DBM(b, 1, clockNames, true);
-  }
-  isEmpty() {
-    return this._empty;
-  }
-  clockCount() {
-    return this.clockNames.length;
-  }
-  get(i, j) {
-    return this.bounds[i * this.dim + j];
-  }
-  /** Gets the lower bound (earliest firing time) for clock i. */
-  getLowerBound(clockIndex) {
-    if (this._empty || clockIndex < 0 || clockIndex >= this.clockNames.length) return 0;
-    const val = -this.get(0, clockIndex + 1);
-    return val === 0 ? 0 : val;
-  }
-  /** Gets the upper bound (latest firing time / deadline) for clock i. */
-  getUpperBound(clockIndex) {
-    if (this._empty || clockIndex < 0 || clockIndex >= this.clockNames.length) return Infinity;
-    return this.get(clockIndex + 1, 0);
-  }
-  /** Checks if transition can fire (lower bound <= 0 after time passage). */
-  canFire(clockIndex) {
-    return !this._empty && this.getLowerBound(clockIndex) <= EPSILON;
-  }
-  /**
-   * Computes the successor firing domain after firing transition t_f.
-   * Implements the 5-step Berthomieu-Diaz successor formula.
-   */
-  fireTransition(firedClock, newClockNames, newLowerBounds, newUpperBounds, persistentClocks) {
-    if (this._empty) return this;
-    const n = this.clockNames.length;
-    if (firedClock < 0 || firedClock >= n) {
-      throw new Error(`Invalid fired clock index: ${firedClock}`);
-    }
-    const constrained = new Float64Array(this.bounds);
-    const dim = this.dim;
-    const f = firedClock + 1;
-    for (let i = 0; i < n; i++) {
-      if (i !== firedClock) {
-        const idx = i + 1;
-        const pos = f * dim + idx;
-        constrained[pos] = Math.min(constrained[pos], 0);
-      }
-    }
-    if (!canonicalizeInPlace(constrained, dim)) {
-      return _DBM.empty([]);
-    }
-    const newN = persistentClocks.length + newClockNames.length;
-    const newDim = newN + 1;
-    const newBounds = makeMatrix(newDim, Infinity);
-    for (let pi = 0; pi < persistentClocks.length; pi++) {
-      const oldIdx = persistentClocks[pi] + 1;
-      const newIdx = pi + 1;
-      const upper = constrained[oldIdx * dim + f];
-      const lower = Math.max(0, -constrained[f * dim + oldIdx]);
-      newBounds[0 * newDim + newIdx] = -lower;
-      newBounds[newIdx * newDim + 0] = upper;
-      for (let pj = 0; pj < persistentClocks.length; pj++) {
-        const oldJ = persistentClocks[pj] + 1;
-        const newJ = pj + 1;
-        newBounds[newIdx * newDim + newJ] = constrained[oldIdx * dim + oldJ];
-      }
-    }
-    const offset = persistentClocks.length;
-    for (let k = 0; k < newClockNames.length; k++) {
-      const idx = offset + k + 1;
-      newBounds[0 * newDim + idx] = -newLowerBounds[k];
-      newBounds[idx * newDim + 0] = newUpperBounds[k];
-    }
-    const allNames = [];
-    for (const idx of persistentClocks) {
-      allNames.push(this.clockNames[idx]);
-    }
-    allNames.push(...newClockNames);
-    return new _DBM(newBounds, newDim, allNames, false).canonicalize();
-  }
-  /** Lets time pass: set all lower bounds to 0. */
-  letTimePass() {
-    if (this._empty) return this;
-    const newBounds = new Float64Array(this.bounds);
-    for (let i = 1; i < this.dim; i++) {
-      newBounds[0 * this.dim + i] = 0;
-    }
-    return new _DBM(newBounds, this.dim, this.clockNames, false).canonicalize();
-  }
-  canonicalize() {
-    if (this._empty) return this;
-    const canon = new Float64Array(this.bounds);
-    if (!canonicalizeInPlace(canon, this.dim)) {
-      return _DBM.empty(this.clockNames);
-    }
-    return new _DBM(canon, this.dim, this.clockNames, false);
-  }
-  equals(other) {
-    if (this === other) return true;
-    if (this._empty && other._empty) return true;
-    if (this._empty || other._empty) return false;
-    if (this.clockNames.length !== other.clockNames.length) return false;
-    for (let i = 0; i < this.clockNames.length; i++) {
-      if (this.clockNames[i] !== other.clockNames[i]) return false;
-    }
-    if (this.bounds.length !== other.bounds.length) return false;
-    for (let i = 0; i < this.bounds.length; i++) {
-      if (Math.abs(this.bounds[i] - other.bounds[i]) > EPSILON) return false;
-    }
-    return true;
-  }
-  toString() {
-    if (this._empty) return "DBM[empty]";
-    const parts = [];
-    for (let i = 0; i < this.clockNames.length; i++) {
-      const lo = formatBound(this.getLowerBound(i));
-      const hi = formatBound(this.getUpperBound(i));
-      parts.push(`${this.clockNames[i]}:[${lo},${hi}]`);
-    }
-    return `DBM{${parts.join(", ")}}`;
-  }
-};
-function makeMatrix(dim, fill) {
-  const m = new Float64Array(dim * dim).fill(fill);
-  for (let i = 0; i < dim; i++) {
-    m[i * dim + i] = 0;
-  }
-  return m;
-}
-function canonicalizeInPlace(dbm, dim) {
-  for (let k = 0; k < dim; k++) {
-    for (let i = 0; i < dim; i++) {
-      for (let j = 0; j < dim; j++) {
-        const ik = dbm[i * dim + k];
-        const kj = dbm[k * dim + j];
-        if (ik < Infinity && kj < Infinity) {
-          const via = ik + kj;
-          if (via < dbm[i * dim + j]) {
-            dbm[i * dim + j] = via;
-          }
-        }
-      }
-    }
-  }
-  for (let i = 0; i < dim; i++) {
-    if (dbm[i * dim + i] < -EPSILON) return false;
-  }
-  return true;
-}
-function formatBound(b) {
-  if (b >= Infinity / 2) return "\u221E";
-  if (b === Math.trunc(b)) return String(b);
-  return b.toFixed(3);
-}
-
-// src/verification/analysis/state-class.ts
-var StateClass = class {
-  marking;
-  firingDomain;
-  enabledTransitions;
-  constructor(marking, firingDomain, enabledTransitions) {
-    this.marking = marking;
-    this.firingDomain = firingDomain;
-    this.enabledTransitions = [...enabledTransitions];
-  }
-  isEmpty() {
-    return this.firingDomain.isEmpty();
-  }
-  canFire(transition) {
-    const idx = this.enabledTransitions.indexOf(transition);
-    if (idx < 0) return false;
-    return this.firingDomain.getUpperBound(idx) >= 0;
-  }
-  transitionIndex(transition) {
-    return this.enabledTransitions.indexOf(transition);
-  }
-  equals(other) {
-    if (this === other) return true;
-    return this.marking.toString() === other.marking.toString() && this.firingDomain.equals(other.firingDomain);
-  }
-  toString() {
-    return `StateClass{${this.marking}, ${this.firingDomain}}`;
-  }
-};
+} from "../chunk-M3KT7BFO.js";
+import "../chunk-ATT7U5H5.js";
 
 // src/verification/analysis/scc-analyzer.ts
 function computeSCCs(nodes, successors) {
@@ -308,298 +99,6 @@ function findTerminalSCCs(nodes, successors) {
   return terminal;
 }
 
-// src/verification/analysis/state-class-graph.ts
-var StateClassGraph = class _StateClassGraph {
-  net;
-  initialClass;
-  _stateClasses;
-  _transitions;
-  _successors;
-  _predecessors;
-  _complete;
-  constructor(net, initialClass, stateClasses, transitions, complete) {
-    this.net = net;
-    this.initialClass = initialClass;
-    this._stateClasses = stateClasses;
-    this._transitions = transitions;
-    this._complete = complete;
-    this._successors = /* @__PURE__ */ new Map();
-    this._predecessors = /* @__PURE__ */ new Map();
-    for (const sc of stateClasses) {
-      this._successors.set(sc, /* @__PURE__ */ new Set());
-      this._predecessors.set(sc, /* @__PURE__ */ new Set());
-    }
-    for (const [from, tMap] of transitions) {
-      for (const edges of tMap.values()) {
-        for (const edge of edges) {
-          this._successors.get(from).add(edge.target);
-          this._predecessors.get(edge.target).add(from);
-        }
-      }
-    }
-  }
-  /** Builds the state class graph for a Time Petri Net. */
-  static build(net, initialMarking, maxClasses, environmentPlaces, environmentMode) {
-    const envMode = environmentMode ?? ignore();
-    const envPlaces = /* @__PURE__ */ new Set();
-    if (environmentPlaces) {
-      for (const ep of environmentPlaces) {
-        envPlaces.add(ep.place);
-      }
-    }
-    const enabledTransitions = findEnabledTransitions(net, initialMarking, envPlaces, envMode);
-    const clockNames = enabledTransitions.map((t) => t.name);
-    const lowerBounds = enabledTransitions.map((t) => earliest(t.timing) / 1e3);
-    const upperBounds = enabledTransitions.map((t) => latest(t.timing) / 1e3);
-    let initialDBM = DBM.create(clockNames, lowerBounds, upperBounds);
-    initialDBM = initialDBM.letTimePass();
-    const initialClass = new StateClass(initialMarking, initialDBM, enabledTransitions);
-    const stateClasses = [initialClass];
-    const stateClassSet = /* @__PURE__ */ new Set([classKey(initialClass)]);
-    const classMap = /* @__PURE__ */ new Map([[classKey(initialClass), initialClass]]);
-    const transitionMap = /* @__PURE__ */ new Map();
-    transitionMap.set(initialClass, /* @__PURE__ */ new Map());
-    const queue = [initialClass];
-    let complete = true;
-    while (queue.length > 0) {
-      if (stateClasses.length >= maxClasses) {
-        complete = false;
-        break;
-      }
-      const current = queue.shift();
-      for (const transition of current.enabledTransitions) {
-        const virtualTransitions = expandTransition(transition);
-        for (const vt of virtualTransitions) {
-          const successor = computeSuccessor(net, current, vt, envPlaces, envMode);
-          if (successor === null || successor.isEmpty()) continue;
-          const tEdges = transitionMap.get(current);
-          if (!tEdges.has(transition)) tEdges.set(transition, []);
-          tEdges.get(transition).push({ branchIndex: vt.branchIndex, target: successor });
-          const key = classKey(successor);
-          if (!stateClassSet.has(key)) {
-            stateClassSet.add(key);
-            classMap.set(key, successor);
-            stateClasses.push(successor);
-            transitionMap.set(successor, /* @__PURE__ */ new Map());
-            queue.push(successor);
-          } else {
-            const canonical = classMap.get(key);
-            if (canonical !== successor) {
-              const edges = tEdges.get(transition);
-              edges[edges.length - 1] = { branchIndex: vt.branchIndex, target: canonical };
-            }
-          }
-        }
-      }
-    }
-    return new _StateClassGraph(net, initialClass, stateClasses, transitionMap, complete);
-  }
-  stateClasses() {
-    return this._stateClasses;
-  }
-  size() {
-    return this._stateClasses.length;
-  }
-  isComplete() {
-    return this._complete;
-  }
-  successors(sc) {
-    return this._successors.get(sc) ?? /* @__PURE__ */ new Set();
-  }
-  predecessors(sc) {
-    return this._predecessors.get(sc) ?? /* @__PURE__ */ new Set();
-  }
-  /** Returns all outgoing transitions with their branch edges. */
-  outgoingBranchEdges(sc) {
-    return this._transitions.get(sc) ?? /* @__PURE__ */ new Map();
-  }
-  /** Returns the branch edges for a specific transition from a state class. */
-  branchEdges(sc, transition) {
-    const map = this._transitions.get(sc);
-    if (!map) return [];
-    return map.get(transition) ?? [];
-  }
-  /** Returns all transitions that are enabled from a state class. */
-  enabledTransitions(sc) {
-    const map = this._transitions.get(sc);
-    if (!map) return /* @__PURE__ */ new Set();
-    return new Set(map.keys());
-  }
-  /** Finds all state classes with a given marking. */
-  classesWithMarking(marking) {
-    const key = marking.toString();
-    return this._stateClasses.filter((sc) => sc.marking.toString() === key);
-  }
-  /** Checks if a marking is reachable. */
-  isReachable(marking) {
-    const key = marking.toString();
-    return this._stateClasses.some((sc) => sc.marking.toString() === key);
-  }
-  /** Gets all reachable markings. */
-  reachableMarkings() {
-    const markings = /* @__PURE__ */ new Set();
-    for (const sc of this._stateClasses) {
-      markings.add(sc.marking.toString());
-    }
-    return markings;
-  }
-  /** Counts edges in the graph (each branch edge counts separately). */
-  edgeCount() {
-    let count = 0;
-    for (const map of this._transitions.values()) {
-      for (const edges of map.values()) {
-        count += edges.length;
-      }
-    }
-    return count;
-  }
-  toString() {
-    return `StateClassGraph[classes=${this.size()}, edges=${this.edgeCount()}, complete=${this._complete}]`;
-  }
-};
-function classKey(sc) {
-  return `${sc.marking.toString()}|${sc.firingDomain.toString()}`;
-}
-function expandTransition(t) {
-  let branches;
-  if (t.outputSpec !== null) {
-    branches = enumerateBranches(t.outputSpec);
-  } else {
-    branches = [/* @__PURE__ */ new Set()];
-  }
-  return branches.map((outputPlaces, i) => ({
-    transition: t,
-    branchIndex: i,
-    outputPlaces
-  }));
-}
-function computeSuccessor(net, current, fired, environmentPlaces, environmentMode) {
-  const transition = fired.transition;
-  const newMarking = fireTransition(current.marking, transition, fired.outputPlaces, environmentPlaces, environmentMode);
-  const newEnabledAll = findEnabledTransitions(net, newMarking, environmentPlaces, environmentMode);
-  const persistent = [];
-  const persistentIndices = [];
-  for (let i = 0; i < current.enabledTransitions.length; i++) {
-    const t = current.enabledTransitions[i];
-    if (t !== transition && newEnabledAll.includes(t)) {
-      persistent.push(t);
-      persistentIndices.push(i);
-    }
-  }
-  const newlyEnabled = [];
-  for (const t of newEnabledAll) {
-    if (!persistent.includes(t)) {
-      newlyEnabled.push(t);
-    }
-  }
-  const firedIdx = current.transitionIndex(transition);
-  const newClockNames = newlyEnabled.map((t) => t.name);
-  const newLowerBounds = newlyEnabled.map((t) => earliest(t.timing) / 1e3);
-  const newUpperBounds = newlyEnabled.map((t) => latest(t.timing) / 1e3);
-  let newDBM = current.firingDomain.fireTransition(
-    firedIdx,
-    newClockNames,
-    newLowerBounds,
-    newUpperBounds,
-    persistentIndices
-  );
-  newDBM = newDBM.letTimePass();
-  const allEnabled = [...persistent, ...newlyEnabled];
-  return new StateClass(newMarking, newDBM, allEnabled);
-}
-function findEnabledTransitions(net, marking, environmentPlaces, environmentMode) {
-  const enabled = [];
-  for (const transition of net.transitions) {
-    if (isEnabled(transition, marking, environmentPlaces, environmentMode)) {
-      enabled.push(transition);
-    }
-  }
-  return enabled;
-}
-function isEnabled(transition, marking, environmentPlaces, environmentMode) {
-  for (const spec of transition.inputSpecs) {
-    const required = inputRequiredCount(spec);
-    if (!checkPlaceEnabled(spec.place, required, marking, environmentPlaces, environmentMode)) {
-      return false;
-    }
-  }
-  for (const arc of transition.reads) {
-    if (!checkPlaceEnabled(arc.place, 1, marking, environmentPlaces, environmentMode)) {
-      return false;
-    }
-  }
-  for (const arc of transition.inhibitors) {
-    if (marking.hasTokens(arc.place)) {
-      return false;
-    }
-  }
-  return true;
-}
-function inputRequiredCount(spec) {
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return 1;
-    case "at-least":
-      return spec.minimum;
-  }
-}
-function inputConsumeCount(spec) {
-  switch (spec.type) {
-    case "one":
-      return 1;
-    case "exactly":
-      return spec.count;
-    case "all":
-      return 1;
-    // Analysis: consume minimum (1 token)
-    case "at-least":
-      return spec.minimum;
-  }
-}
-function checkPlaceEnabled(place, required, marking, environmentPlaces, environmentMode) {
-  if (!environmentPlaces.has(place)) {
-    return marking.tokens(place) >= required;
-  }
-  switch (environmentMode.type) {
-    case "always-available":
-      return true;
-    case "bounded":
-      return required <= environmentMode.maxTokens;
-    case "ignore":
-      return marking.tokens(place) >= required;
-  }
-}
-function fireTransition(marking, transition, outputPlaces, environmentPlaces, environmentMode) {
-  const builder = MarkingState.builder().copyFrom(marking);
-  for (const spec of transition.inputSpecs) {
-    const toConsume = inputConsumeCount(spec);
-    consumeFromPlace(builder, spec.place, toConsume, environmentPlaces, environmentMode);
-  }
-  for (const arc of transition.resets) {
-    const current = marking.tokens(arc.place);
-    if (current > 0) {
-      builder.removeTokens(arc.place, current);
-    }
-  }
-  for (const place of outputPlaces) {
-    builder.addTokens(place, 1);
-  }
-  return builder.build();
-}
-function consumeFromPlace(builder, place, count, environmentPlaces, environmentMode) {
-  if (!environmentPlaces.has(place)) {
-    builder.removeTokens(place, count);
-    return;
-  }
-  if (environmentMode.type === "ignore") {
-    builder.removeTokens(place, count);
-  }
-}
-
 // src/verification/analysis/time-petri-net-analyzer.ts
 var TimePetriNetAnalyzer = class _TimePetriNetAnalyzer {
   net;
@@ -900,6 +399,7 @@ export {
   bounded as analysisBounded,
   ignore as analysisIgnore,
   bounded,
+  branchPlaceBound,
   computePInvariants,
   computeSCCs,
   createSpacerRunner,
@@ -918,6 +418,7 @@ export {
   isCoveredByInvariants,
   isProven,
   isViolated,
+  joinedOrDeadLettered,
   mutualExclusion,
   pInvariant,
   pInvariantToString,