libpetri 0.3.2

package/dist/verification/index.js

@@ -0,0 +1,1201 @@
+import {
+  allPlaces,
+  enumerateBranches
+} from "../chunk-VQ4XMJTD.js";
+
+// src/verification/marking-state.ts
+var MARKING_STATE_KEY = /* @__PURE__ */ Symbol("MarkingState.internal");
+var MarkingState = class _MarkingState {
+  tokenCounts;
+  placesByName;
+  /** @internal Use {@link MarkingState.builder} or {@link MarkingState.empty} to create instances. */
+  constructor(key, tokenCounts, placesByName) {
+    if (key !== MARKING_STATE_KEY) throw new Error("Use MarkingState.builder() to create instances");
+    this.tokenCounts = tokenCounts;
+    this.placesByName = placesByName;
+  }
+  /** Returns the token count for a place (0 if absent). */
+  tokens(place) {
+    return this.tokenCounts.get(place.name) ?? 0;
+  }
+  /** Checks if a place has at least one token. */
+  hasTokens(place) {
+    return this.tokens(place) > 0;
+  }
+  /** Checks if any of the given places has tokens. */
+  hasTokensInAny(places) {
+    for (const p of places) {
+      if (this.hasTokens(p)) return true;
+    }
+    return false;
+  }
+  /** Returns all places with tokens > 0. */
+  placesWithTokens() {
+    return [...this.placesByName.values()];
+  }
+  /** Returns the total number of tokens. */
+  totalTokens() {
+    let sum = 0;
+    for (const count of this.tokenCounts.values()) sum += count;
+    return sum;
+  }
+  /** Checks if no tokens exist anywhere. */
+  isEmpty() {
+    return this.tokenCounts.size === 0;
+  }
+  toString() {
+    if (this.tokenCounts.size === 0) return "{}";
+    const entries = [...this.tokenCounts.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, count]) => `${name}:${count}`);
+    return `{${entries.join(", ")}}`;
+  }
+  static empty() {
+    return new _MarkingState(MARKING_STATE_KEY, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Map());
+  }
+  static builder() {
+    return new MarkingStateBuilder();
+  }
+};
+var MarkingStateBuilder = class {
+  tokenCounts = /* @__PURE__ */ new Map();
+  placesByName = /* @__PURE__ */ new Map();
+  /** Sets the token count for a place. */
+  tokens(place, count) {
+    if (count < 0) throw new Error(`Token count cannot be negative: ${count}`);
+    if (count > 0) {
+      this.tokenCounts.set(place.name, count);
+      this.placesByName.set(place.name, place);
+    } else {
+      this.tokenCounts.delete(place.name);
+      this.placesByName.delete(place.name);
+    }
+    return this;
+  }
+  /** Adds tokens to a place. */
+  addTokens(place, count) {
+    if (count < 0) throw new Error(`Token count cannot be negative: ${count}`);
+    if (count > 0) {
+      const current = this.tokenCounts.get(place.name) ?? 0;
+      this.tokenCounts.set(place.name, current + count);
+      this.placesByName.set(place.name, place);
+    }
+    return this;
+  }
+  build() {
+    return new MarkingState(MARKING_STATE_KEY, new Map(this.tokenCounts), new Map(this.placesByName));
+  }
+};
+
+// src/verification/encoding/flat-transition.ts
+function flatTransition(name, source, branchIndex, preVector, postVector, inhibitorPlaces, readPlaces, resetPlaces, consumeAll) {
+  return {
+    name,
+    source,
+    branchIndex,
+    preVector,
+    postVector,
+    inhibitorPlaces,
+    readPlaces,
+    resetPlaces,
+    consumeAll
+  };
+}
+
+// src/verification/encoding/flat-net.ts
+function flatNetPlaceCount(net) {
+  return net.places.length;
+}
+function flatNetTransitionCount(net) {
+  return net.transitions.length;
+}
+function flatNetIndexOf(net, place) {
+  return net.placeIndex.get(place.name) ?? -1;
+}
+
+// src/verification/encoding/incidence-matrix.ts
+var IncidenceMatrix = class _IncidenceMatrix {
+  _pre;
+  _post;
+  _incidence;
+  _numTransitions;
+  _numPlaces;
+  constructor(pre, post, incidence, numTransitions, numPlaces) {
+    this._pre = pre;
+    this._post = post;
+    this._incidence = incidence;
+    this._numTransitions = numTransitions;
+    this._numPlaces = numPlaces;
+  }
+  /**
+   * Computes the incidence matrix from a FlatNet.
+   */
+  static from(flatNet) {
+    const T = flatNet.transitions.length;
+    const P = flatNet.places.length;
+    const pre = [];
+    const post = [];
+    const incidence = [];
+    for (let t = 0; t < T; t++) {
+      const ft = flatNet.transitions[t];
+      const preRow = new Array(P);
+      const postRow = new Array(P);
+      const incRow = new Array(P);
+      for (let p = 0; p < P; p++) {
+        preRow[p] = ft.preVector[p];
+        postRow[p] = ft.postVector[p];
+        incRow[p] = postRow[p] - preRow[p];
+      }
+      pre.push(preRow);
+      post.push(postRow);
+      incidence.push(incRow);
+    }
+    return new _IncidenceMatrix(pre, post, incidence, T, P);
+  }
+  /**
+   * Returns C^T (transpose of incidence matrix), dimensions [P][T].
+   * Used for P-invariant computation: null space of C^T gives P-invariants.
+   */
+  transposedIncidence() {
+    const ct = [];
+    for (let p = 0; p < this._numPlaces; p++) {
+      const row = new Array(this._numTransitions);
+      for (let t = 0; t < this._numTransitions; t++) {
+        row[t] = this._incidence[t][p];
+      }
+      ct.push(row);
+    }
+    return ct;
+  }
+  /** Returns the pre-matrix (tokens consumed). T×P. */
+  pre() {
+    return this._pre;
+  }
+  /** Returns the post-matrix (tokens produced). T×P. */
+  post() {
+    return this._post;
+  }
+  /** Returns the incidence matrix C[t][p] = post - pre. T×P. */
+  incidence() {
+    return this._incidence;
+  }
+  numTransitions() {
+    return this._numTransitions;
+  }
+  numPlaces() {
+    return this._numPlaces;
+  }
+};
+
+// src/verification/encoding/net-flattener.ts
+function unbounded() {
+  return { type: "unbounded" };
+}
+function bounded(maxTokens) {
+  return { type: "bounded", maxTokens };
+}
+function flatten(net, environmentPlaces = /* @__PURE__ */ new Set(), environmentMode = unbounded()) {
+  const allPlacesSet = /* @__PURE__ */ new Map();
+  for (const p of net.places) {
+    allPlacesSet.set(p.name, p);
+  }
+  for (const t of net.transitions) {
+    for (const inSpec of t.inputSpecs) {
+      allPlacesSet.set(inSpec.place.name, inSpec.place);
+    }
+    if (t.outputSpec !== null) {
+      for (const p of allPlaces(t.outputSpec)) {
+        allPlacesSet.set(p.name, p);
+      }
+    }
+    for (const arc of t.inhibitors) allPlacesSet.set(arc.place.name, arc.place);
+    for (const arc of t.reads) allPlacesSet.set(arc.place.name, arc.place);
+    for (const arc of t.resets) allPlacesSet.set(arc.place.name, arc.place);
+  }
+  const places = [...allPlacesSet.values()].sort((a, b) => a.name.localeCompare(b.name));
+  const placeIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < places.length; i++) {
+    placeIndex.set(places[i].name, i);
+  }
+  const environmentBounds = /* @__PURE__ */ new Map();
+  if (environmentMode.type === "bounded") {
+    for (const ep of environmentPlaces) {
+      environmentBounds.set(ep.place.name, environmentMode.maxTokens);
+    }
+  }
+  const n = places.length;
+  const flatTransitions = [];
+  for (const transition of net.transitions) {
+    const branches = enumerateOutputBranches(transition);
+    for (let branchIdx = 0; branchIdx < branches.length; branchIdx++) {
+      const branchPlaces = branches[branchIdx];
+      const name = branches.length > 1 ? `${transition.name}_b${branchIdx}` : transition.name;
+      const preVector = new Array(n).fill(0);
+      const consumeAll = new Array(n).fill(false);
+      for (const inSpec of transition.inputSpecs) {
+        const idx = placeIndex.get(inSpec.place.name);
+        if (idx === void 0) continue;
+        switch (inSpec.type) {
+          case "one":
+            preVector[idx] = 1;
+            break;
+          case "exactly":
+            preVector[idx] = inSpec.count;
+            break;
+          case "all":
+            preVector[idx] = 1;
+            consumeAll[idx] = true;
+            break;
+          case "at-least":
+            preVector[idx] = inSpec.minimum;
+            consumeAll[idx] = true;
+            break;
+        }
+      }
+      const postVector = new Array(n).fill(0);
+      for (const p of branchPlaces) {
+        const idx = placeIndex.get(p.name);
+        if (idx !== void 0) {
+          postVector[idx] = 1;
+        }
+      }
+      const inhibitorPlaces = transition.inhibitors.map((arc) => placeIndex.get(arc.place.name)).filter((idx) => idx !== void 0);
+      const readPlaces = transition.reads.map((arc) => placeIndex.get(arc.place.name)).filter((idx) => idx !== void 0);
+      const resetPlaces = transition.resets.map((arc) => placeIndex.get(arc.place.name)).filter((idx) => idx !== void 0);
+      flatTransitions.push(flatTransition(
+        name,
+        transition,
+        branches.length > 1 ? branchIdx : -1,
+        preVector,
+        postVector,
+        inhibitorPlaces,
+        readPlaces,
+        resetPlaces,
+        consumeAll
+      ));
+    }
+  }
+  return {
+    places,
+    placeIndex,
+    transitions: flatTransitions,
+    environmentBounds
+  };
+}
+function enumerateOutputBranches(t) {
+  if (t.outputSpec !== null) {
+    return enumerateBranches(t.outputSpec);
+  }
+  return [/* @__PURE__ */ new Set()];
+}
+
+// src/verification/invariant/p-invariant.ts
+function pInvariant(weights, constant, support) {
+  return { weights, constant, support };
+}
+function pInvariantToString(inv) {
+  const parts = [];
+  for (const i of inv.support) {
+    if (inv.weights[i] !== 1) {
+      parts.push(`${inv.weights[i]}*p${i}`);
+    } else {
+      parts.push(`p${i}`);
+    }
+  }
+  return `PInvariant[${parts.join(" + ")} = ${inv.constant}]`;
+}
+
+// src/verification/invariant/p-invariant-computer.ts
+function computePInvariants(matrix, flatNet, initialMarking) {
+  const P = matrix.numPlaces();
+  const T = matrix.numTransitions();
+  if (P === 0 || T === 0) return [];
+  const ct = matrix.transposedIncidence();
+  const cols = T + P;
+  const augmented = [];
+  for (let i = 0; i < P; i++) {
+    const row = new Array(cols).fill(0);
+    for (let j = 0; j < T; j++) {
+      row[j] = ct[i][j];
+    }
+    row[T + i] = 1;
+    augmented.push(row);
+  }
+  let pivotRow = 0;
+  for (let col = 0; col < T && pivotRow < P; col++) {
+    let pivot = -1;
+    for (let row = pivotRow; row < P; row++) {
+      if (augmented[row][col] !== 0) {
+        pivot = row;
+        break;
+      }
+    }
+    if (pivot === -1) continue;
+    if (pivot !== pivotRow) {
+      const tmp = augmented[pivotRow];
+      augmented[pivotRow] = augmented[pivot];
+      augmented[pivot] = tmp;
+    }
+    for (let row = 0; row < P; row++) {
+      if (row === pivotRow || augmented[row][col] === 0) continue;
+      const a = augmented[pivotRow][col];
+      const b = augmented[row][col];
+      for (let c = 0; c < cols; c++) {
+        augmented[row][c] = a * augmented[row][c] - b * augmented[pivotRow][c];
+      }
+      normalizeRow(augmented[row], cols);
+    }
+    pivotRow++;
+  }
+  const invariants = [];
+  for (let row = 0; row < P; row++) {
+    let isZero = true;
+    for (let col = 0; col < T; col++) {
+      if (augmented[row][col] !== 0) {
+        isZero = false;
+        break;
+      }
+    }
+    if (!isZero) continue;
+    const weights = new Array(P);
+    let allNonNegative = true;
+    let hasPositive = false;
+    for (let i = 0; i < P; i++) {
+      weights[i] = augmented[row][T + i];
+      if (weights[i] < 0) {
+        allNonNegative = false;
+        break;
+      }
+      if (weights[i] > 0) hasPositive = true;
+    }
+    if (!allNonNegative) {
+      let allNonPositive = true;
+      for (let i = 0; i < P; i++) {
+        if (augmented[row][T + i] > 0) {
+          allNonPositive = false;
+          break;
+        }
+      }
+      if (allNonPositive) {
+        for (let i = 0; i < P; i++) {
+          weights[i] = -augmented[row][T + i];
+        }
+        hasPositive = true;
+        allNonNegative = true;
+      }
+    }
+    if (!allNonNegative || !hasPositive) continue;
+    let g = 0;
+    for (const w of weights) {
+      if (w > 0) g = gcd(g, w);
+    }
+    if (g > 1) {
+      for (let i = 0; i < P; i++) {
+        weights[i] = weights[i] / g;
+      }
+    }
+    const support = /* @__PURE__ */ new Set();
+    let constant = 0;
+    for (let i = 0; i < P; i++) {
+      if (weights[i] !== 0) {
+        support.add(i);
+        const place = flatNet.places[i];
+        constant += weights[i] * initialMarking.tokens(place);
+      }
+    }
+    invariants.push(pInvariant(weights, constant, support));
+  }
+  return invariants;
+}
+function isCoveredByInvariants(invariants, numPlaces) {
+  const covered = new Array(numPlaces).fill(false);
+  for (const inv of invariants) {
+    for (const idx of inv.support) {
+      if (idx < numPlaces) covered[idx] = true;
+    }
+  }
+  return covered.every((c) => c);
+}
+function normalizeRow(row, cols) {
+  let g = 0;
+  for (let c = 0; c < cols; c++) {
+    if (row[c] !== 0) {
+      g = gcd(g, Math.abs(row[c]));
+    }
+  }
+  if (g > 1) {
+    for (let c = 0; c < cols; c++) {
+      row[c] = row[c] / g;
+    }
+  }
+}
+function gcd(a, b) {
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+
+// src/verification/invariant/structural-check.ts
+var MAX_PLACES_FOR_SIPHON_ANALYSIS = 50;
+function structuralCheck(flatNet, initialMarking) {
+  const P = flatNet.places.length;
+  if (P === 0) {
+    return { type: "no-potential-deadlock" };
+  }
+  if (P > MAX_PLACES_FOR_SIPHON_ANALYSIS) {
+    return { type: "inconclusive", reason: `Net has ${P} places, siphon enumeration skipped` };
+  }
+  const siphons = findMinimalSiphons(flatNet);
+  if (siphons.length === 0) {
+    return { type: "no-potential-deadlock" };
+  }
+  for (const siphon of siphons) {
+    const trap = findMaximalTrapIn(flatNet, siphon);
+    if (trap.size === 0 || !isMarked(trap, flatNet, initialMarking)) {
+      return { type: "potential-deadlock", siphon };
+    }
+  }
+  return { type: "no-potential-deadlock" };
+}
+function findMinimalSiphons(flatNet) {
+  const P = flatNet.places.length;
+  const siphons = [];
+  const placeAsOutput = [];
+  for (let p = 0; p < P; p++) {
+    placeAsOutput.push([]);
+  }
+  for (let t = 0; t < flatNet.transitions.length; t++) {
+    const ft = flatNet.transitions[t];
+    for (let p = 0; p < P; p++) {
+      if (ft.postVector[p] > 0) {
+        placeAsOutput[p].push(t);
+      }
+    }
+  }
+  for (let startPlace = 0; startPlace < P; startPlace++) {
+    const siphon = computeSiphonContaining(startPlace, flatNet, placeAsOutput);
+    if (siphon !== null && siphon.size > 0) {
+      let isMinimal = true;
+      const toRemove = [];
+      for (let i = 0; i < siphons.length; i++) {
+        const existing = siphons[i];
+        if (setsEqual(existing, siphon)) {
+          isMinimal = false;
+          break;
+        }
+        if (isSubsetOf(existing, siphon)) {
+          isMinimal = false;
+          break;
+        }
+        if (isSubsetOf(siphon, existing)) {
+          toRemove.push(i);
+        }
+      }
+      for (let i = toRemove.length - 1; i >= 0; i--) {
+        siphons.splice(toRemove[i], 1);
+      }
+      if (isMinimal) {
+        siphons.push(siphon);
+      }
+    }
+  }
+  return siphons;
+}
+function computeSiphonContaining(startPlace, flatNet, placeAsOutput) {
+  const siphon = /* @__PURE__ */ new Set();
+  siphon.add(startPlace);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const snapshot = [...siphon];
+    for (const p of snapshot) {
+      for (const t of placeAsOutput[p]) {
+        const ft = flatNet.transitions[t];
+        let hasInputInSiphon = false;
+        for (let q = 0; q < flatNet.places.length; q++) {
+          if (ft.preVector[q] > 0 && siphon.has(q)) {
+            hasInputInSiphon = true;
+            break;
+          }
+        }
+        if (!hasInputInSiphon) {
+          let added = false;
+          for (let q = 0; q < flatNet.places.length; q++) {
+            if (ft.preVector[q] > 0) {
+              if (!siphon.has(q)) {
+                siphon.add(q);
+                changed = true;
+              }
+              added = true;
+              break;
+            }
+          }
+          if (!added) {
+            return null;
+          }
+        }
+      }
+    }
+  }
+  return siphon;
+}
+function findMaximalTrapIn(flatNet, places) {
+  const trap = new Set(places);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    const toRemove = [];
+    for (const p of trap) {
+      let satisfies = true;
+      for (let t = 0; t < flatNet.transitions.length; t++) {
+        const ft = flatNet.transitions[t];
+        if (ft.preVector[p] > 0) {
+          let outputsToTrap = false;
+          for (const q of trap) {
+            if (ft.postVector[q] > 0) {
+              outputsToTrap = true;
+              break;
+            }
+          }
+          if (!outputsToTrap) {
+            satisfies = false;
+            break;
+          }
+        }
+      }
+      if (!satisfies) {
+        toRemove.push(p);
+      }
+    }
+    if (toRemove.length > 0) {
+      for (const p of toRemove) trap.delete(p);
+      changed = true;
+    }
+  }
+  return trap;
+}
+function isMarked(placeIndices, flatNet, marking) {
+  for (const idx of placeIndices) {
+    const place = flatNet.places[idx];
+    if (marking.tokens(place) > 0) return true;
+  }
+  return false;
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) return false;
+  for (const v of a) {
+    if (!b.has(v)) return false;
+  }
+  return true;
+}
+function isSubsetOf(sub, sup) {
+  if (sub.size > sup.size) return false;
+  for (const v of sub) {
+    if (!sup.has(v)) return false;
+  }
+  return true;
+}
+
+// src/verification/smt-property.ts
+function deadlockFree() {
+  return { type: "deadlock-free" };
+}
+function mutualExclusion(p1, p2) {
+  return { type: "mutual-exclusion", p1, p2 };
+}
+function placeBound(place, bound) {
+  return { type: "place-bound", place, bound };
+}
+function unreachable(places) {
+  return { type: "unreachable", places: new Set(places) };
+}
+function propertyDescription(prop) {
+  switch (prop.type) {
+    case "deadlock-free":
+      return "Deadlock-freedom";
+    case "mutual-exclusion":
+      return `Mutual exclusion of ${prop.p1.name} and ${prop.p2.name}`;
+    case "place-bound":
+      return `Place ${prop.place.name} bounded by ${prop.bound}`;
+    case "unreachable":
+      return `Unreachability of marking with tokens in {${[...prop.places].map((p) => p.name).join(", ")}}`;
+  }
+}
+
+// src/verification/smt-verification-result.ts
+function isProven(result) {
+  return result.verdict.type === "proven";
+}
+function isViolated(result) {
+  return result.verdict.type === "violated";
+}
+
+// src/verification/z3/spacer-runner.ts
+import { init } from "z3-solver";
+async function createSpacerRunner(timeoutMs) {
+  const { Context } = await init();
+  const ctx = new Context("main");
+  const fp = new ctx.Fixedpoint();
+  fp.set("engine", "spacer");
+  fp.set("spacer.global", true);
+  fp.set("spacer.use_bg_invs", true);
+  if (timeoutMs > 0) {
+    fp.set("timeout", Math.min(timeoutMs, 2147483647));
+  }
+  async function query(errorExpr, reachableDecl) {
+    try {
+      const status = await fp.query(errorExpr);
+      if (status === "unsat") {
+        let invariantFormula = null;
+        const levelInvariants = [];
+        try {
+          const answer = fp.getAnswer();
+          if (answer != null) {
+            invariantFormula = answer.toString();
+          }
+        } catch {
+        }
+        if (reachableDecl != null) {
+          try {
+            const levels = fp.getNumLevels(reachableDecl);
+            for (let i = 0; i < levels; i++) {
+              const cover = fp.getCoverDelta(i, reachableDecl);
+              if (cover != null && !ctx.isTrue(cover)) {
+                levelInvariants.push(`Level ${i}: ${cover.toString()}`);
+              }
+            }
+          } catch {
+          }
+        }
+        return { type: "proven", invariantFormula, levelInvariants };
+      }
+      if (status === "sat") {
+        let answer = null;
+        try {
+          answer = fp.getAnswer();
+        } catch {
+        }
+        return { type: "violated", answer };
+      }
+      return { type: "unknown", reason: fp.getReasonUnknown() };
+    } catch (e) {
+      return { type: "unknown", reason: `Z3 exception: ${e.message ?? e}` };
+    }
+  }
+  function dispose() {
+    try {
+      fp.release();
+    } catch {
+    }
+  }
+  return {
+    ctx,
+    fp,
+    query,
+    dispose
+  };
+}
+
+// src/verification/z3/smt-encoder.ts
+function encode(ctx, fp, flatNet, initialMarking, property, invariants) {
+  const P = flatNet.places.length;
+  const Int = ctx.Int;
+  const Bool_ = ctx.Bool;
+  const intSort = Int.sort();
+  const boolSort = Bool_.sort();
+  const markingSorts = new Array(P).fill(intSort);
+  const reachable = ctx.Function.declare("Reachable", ...markingSorts, boolSort);
+  fp.registerRelation(reachable);
+  const error = ctx.Function.declare("Error", boolSort);
+  fp.registerRelation(error);
+  const m0Args = [];
+  for (let i = 0; i < P; i++) {
+    const tokens = initialMarking.tokens(flatNet.places[i]);
+    m0Args.push(Int.val(tokens));
+  }
+  const initFact = reachable.call(...m0Args);
+  fp.addRule(initFact, "init");
+  for (let t = 0; t < flatNet.transitions.length; t++) {
+    const ft = flatNet.transitions[t];
+    encodeTransitionRule(ctx, fp, reachable, ft, flatNet, invariants, P);
+  }
+  encodeErrorRule(ctx, fp, reachable, error, flatNet, property, P);
+  return {
+    errorExpr: error.call(),
+    reachableDecl: reachable
+  };
+}
+function encodeTransitionRule(ctx, fp, reachable, ft, flatNet, invariants, P) {
+  const Int = ctx.Int;
+  const mVars = [];
+  const mPrimeVars = [];
+  for (let i = 0; i < P; i++) {
+    mVars.push(Int.const(`m${i}`));
+    mPrimeVars.push(Int.const(`mp${i}`));
+  }
+  const reachBody = reachable.call(...mVars);
+  const enabled = encodeEnabled(ctx, ft, flatNet, mVars, P);
+  const fireRelation = encodeFire(ctx, ft, flatNet, mVars, mPrimeVars, P);
+  let nonNeg = ctx.Bool.val(true);
+  for (let i = 0; i < P; i++) {
+    nonNeg = ctx.And(nonNeg, mPrimeVars[i].ge(0));
+  }
+  const invConstraints = encodeInvariantConstraints(ctx, invariants, mPrimeVars, P);
+  let envBounds = ctx.Bool.val(true);
+  for (const [name, bound] of flatNet.environmentBounds) {
+    const idx = flatNet.placeIndex.get(name);
+    if (idx != null) {
+      envBounds = ctx.And(envBounds, mPrimeVars[idx].le(bound));
+    }
+  }
+  const body = ctx.And(reachBody, enabled, fireRelation, nonNeg, invConstraints, envBounds);
+  const head = reachable.call(...mPrimeVars);
+  const allVars = [...mVars, ...mPrimeVars];
+  const rule = ctx.Implies(body, head);
+  const qRule = ctx.ForAll(allVars, rule);
+  fp.addRule(qRule, `t_${ft.name}`);
+}
+function encodeEnabled(ctx, ft, _flatNet, mVars, P) {
+  let result = ctx.Bool.val(true);
+  for (let p = 0; p < P; p++) {
+    if (ft.preVector[p] > 0) {
+      result = ctx.And(result, mVars[p].ge(ft.preVector[p]));
+    }
+  }
+  for (const p of ft.readPlaces) {
+    result = ctx.And(result, mVars[p].ge(1));
+  }
+  for (const p of ft.inhibitorPlaces) {
+    result = ctx.And(result, mVars[p].eq(0));
+  }
+  for (let p = 0; p < P; p++) {
+    result = ctx.And(result, mVars[p].ge(0));
+  }
+  return result;
+}
+function encodeFire(ctx, ft, _flatNet, mVars, mPrimeVars, P) {
+  let result = ctx.Bool.val(true);
+  for (let p = 0; p < P; p++) {
+    const isReset = ft.resetPlaces.includes(p);
+    if (isReset || ft.consumeAll[p]) {
+      result = ctx.And(result, mPrimeVars[p].eq(ft.postVector[p]));
+    } else {
+      const delta = ft.postVector[p] - ft.preVector[p];
+      if (delta === 0) {
+        result = ctx.And(result, mPrimeVars[p].eq(mVars[p]));
+      } else {
+        result = ctx.And(result, mPrimeVars[p].eq(mVars[p].add(delta)));
+      }
+    }
+  }
+  return result;
+}
+function encodeErrorRule(ctx, fp, reachable, error, flatNet, property, P) {
+  const Int = ctx.Int;
+  const mVars = [];
+  for (let i = 0; i < P; i++) {
+    mVars.push(Int.const(`em${i}`));
+  }
+  const reachBody = reachable.call(...mVars);
+  const violation = encodePropertyViolation(ctx, flatNet, property, mVars, P);
+  const head = error.call();
+  const body = ctx.And(reachBody, violation);
+  const rule = ctx.Implies(body, head);
+  const qRule = ctx.ForAll(mVars, rule);
+  fp.addRule(qRule, `error_${property.type}`);
+}
+function encodePropertyViolation(ctx, flatNet, property, mVars, P) {
+  switch (property.type) {
+    case "deadlock-free":
+      return encodeDeadlock(ctx, flatNet, mVars, P);
+    case "mutual-exclusion": {
+      const idx1 = flatNetIndexOf(flatNet, property.p1);
+      const idx2 = flatNetIndexOf(flatNet, property.p2);
+      if (idx1 < 0) throw new Error(`MutualExclusion references unknown place: ${property.p1.name}`);
+      if (idx2 < 0) throw new Error(`MutualExclusion references unknown place: ${property.p2.name}`);
+      return ctx.And(mVars[idx1].ge(1), mVars[idx2].ge(1));
+    }
+    case "place-bound": {
+      const idx = flatNetIndexOf(flatNet, property.place);
+      if (idx < 0) throw new Error(`PlaceBound references unknown place: ${property.place.name}`);
+      return mVars[idx].gt(property.bound);
+    }
+    case "unreachable": {
+      let allMarked = ctx.Bool.val(true);
+      for (const place of property.places) {
+        const idx = flatNetIndexOf(flatNet, place);
+        if (idx >= 0) {
+          allMarked = ctx.And(allMarked, mVars[idx].ge(1));
+        }
+      }
+      return allMarked;
+    }
+  }
+}
+function encodeDeadlock(ctx, flatNet, mVars, P) {
+  let deadlock = ctx.Bool.val(true);
+  for (const ft of flatNet.transitions) {
+    const enabled = encodeEnabled(ctx, ft, flatNet, mVars, P);
+    deadlock = ctx.And(deadlock, ctx.Not(enabled));
+  }
+  return deadlock;
+}
+function encodeInvariantConstraints(ctx, invariants, mVars, P) {
+  let result = ctx.Bool.val(true);
+  for (const inv of invariants) {
+    let sum = ctx.Int.val(0);
+    for (const idx of inv.support) {
+      if (idx < P) {
+        sum = sum.add(mVars[idx].mul(inv.weights[idx]));
+      }
+    }
+    result = ctx.And(result, sum.eq(inv.constant));
+  }
+  return result;
+}
+
+// src/verification/z3/counterexample-decoder.ts
+function decode(ctx, answer, flatNet) {
+  const trace = [];
+  const transitions = [];
+  if (answer == null) {
+    return { trace, transitions };
+  }
+  try {
+    extractTrace(ctx, answer, flatNet, trace, transitions);
+  } catch {
+  }
+  return { trace, transitions };
+}
+function extractTrace(ctx, expr, flatNet, trace, transitions) {
+  if (expr == null) return;
+  if (!ctx.isApp(expr)) return;
+  let name;
+  try {
+    const decl = expr.decl();
+    name = String(decl.name());
+  } catch {
+    return;
+  }
+  const P = flatNet.places.length;
+  if (name === "Reachable") {
+    const numArgs = expr.numArgs();
+    if (numArgs === P) {
+      const marking = extractMarking(ctx, expr, flatNet);
+      if (marking != null) {
+        trace.push(marking);
+      }
+    }
+  }
+  try {
+    const numArgs = expr.numArgs();
+    for (let i = 0; i < numArgs; i++) {
+      const child = expr.arg(i);
+      extractTrace(ctx, child, flatNet, trace, transitions);
+    }
+  } catch {
+  }
+  if (name.startsWith("t_")) {
+    transitions.push(name.substring(2));
+  }
+}
+function extractMarking(ctx, reachableApp, flatNet) {
+  const P = flatNet.places.length;
+  if (reachableApp.numArgs() !== P) return null;
+  const builder = MarkingState.builder();
+  for (let i = 0; i < P; i++) {
+    const arg = reachableApp.arg(i);
+    if (ctx.isIntVal(arg)) {
+      const tokens = Number(arg.value());
+      if (tokens > 0) {
+        builder.tokens(flatNet.places[i], tokens);
+      }
+    } else {
+      return null;
+    }
+  }
+  return builder.build();
+}
+
+// src/verification/smt-verifier.ts
+var SmtVerifier = class _SmtVerifier {
+  constructor(net) {
+    this.net = net;
+  }
+  _initialMarking = MarkingState.empty();
+  _property = deadlockFree();
+  _environmentPlaces = /* @__PURE__ */ new Set();
+  _environmentMode = unbounded();
+  _timeoutMs = 6e4;
+  static forNet(net) {
+    return new _SmtVerifier(net);
+  }
+  initialMarking(arg) {
+    if (arg instanceof MarkingState) {
+      this._initialMarking = arg;
+    } else {
+      const builder = MarkingState.builder();
+      arg(builder);
+      this._initialMarking = builder.build();
+    }
+    return this;
+  }
+  property(property) {
+    this._property = property;
+    return this;
+  }
+  environmentPlaces(...places) {
+    for (const p of places) this._environmentPlaces.add(p);
+    return this;
+  }
+  environmentMode(mode) {
+    this._environmentMode = mode;
+    return this;
+  }
+  timeout(ms) {
+    this._timeoutMs = ms;
+    return this;
+  }
+  /**
+   * Runs the verification pipeline.
+   */
+  async verify() {
+    const start = performance.now();
+    const report = [];
+    report.push("=== IC3/PDR SAFETY VERIFICATION ===\n");
+    report.push(`Net: ${this.net.name}`);
+    report.push(`Property: ${propertyDescription(this._property)}`);
+    report.push(`Timeout: ${(this._timeoutMs / 1e3).toFixed(0)}s
+`);
+    report.push("Phase 1: Flattening net...");
+    const flatNet = flatten(this.net, this._environmentPlaces, this._environmentMode);
+    report.push(`  Places: ${flatNet.places.length}`);
+    report.push(`  Transitions (expanded): ${flatNet.transitions.length}`);
+    if (flatNet.environmentBounds.size > 0) {
+      report.push(`  Environment bounds: ${flatNet.environmentBounds.size} places`);
+    }
+    report.push("");
+    report.push("Phase 2: Structural pre-check (siphon/trap)...");
+    const structResult = structuralCheck(flatNet, this._initialMarking);
+    let structResultStr;
+    switch (structResult.type) {
+      case "no-potential-deadlock":
+        structResultStr = "no potential deadlock";
+        break;
+      case "potential-deadlock":
+        structResultStr = `potential deadlock (siphon: {${[...structResult.siphon].join(",")}})`;
+        break;
+      case "inconclusive":
+        structResultStr = `inconclusive (${structResult.reason})`;
+        break;
+    }
+    report.push(`  Result: ${structResultStr}
+`);
+    if (this._property.type === "deadlock-free" && structResult.type === "no-potential-deadlock") {
+      report.push("=== RESULT ===\n");
+      report.push("PROVEN (structural): Deadlock-freedom verified by Commoner's theorem.");
+      report.push("  All siphons contain initially marked traps.");
+      return buildResult(
+        { type: "proven", method: "structural", inductiveInvariant: null },
+        report.join("\n"),
+        [],
+        [],
+        [],
+        [],
+        performance.now() - start,
+        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: 0, structuralResult: structResultStr }
+      );
+    }
+    report.push("Phase 3: Computing P-invariants...");
+    const matrix = IncidenceMatrix.from(flatNet);
+    const invariants = computePInvariants(matrix, flatNet, this._initialMarking);
+    report.push(`  Found: ${invariants.length} P-invariant(s)`);
+    const structurallyBounded = isCoveredByInvariants(invariants, flatNet.places.length);
+    report.push(`  Structurally bounded: ${structurallyBounded ? "YES" : "NO"}`);
+    for (const inv of invariants) {
+      report.push(`  ${formatInvariant(inv, flatNet)}`);
+    }
+    report.push("");
+    report.push("Phase 4: IC3/PDR verification via Z3 Spacer...");
+    let runner;
+    try {
+      runner = await createSpacerRunner(this._timeoutMs);
+    } catch (e) {
+      report.push(`  ERROR: ${e.message ?? e}
+`);
+      report.push("=== RESULT ===\n");
+      report.push(`UNKNOWN: Z3 initialization error: ${e.message ?? e}`);
+      return buildResult(
+        { type: "unknown", reason: `Z3 init error: ${e.message ?? e}` },
+        report.join("\n"),
+        invariants,
+        [],
+        [],
+        [],
+        performance.now() - start,
+        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+      );
+    }
+    try {
+      const encoding = encode(runner.ctx, runner.fp, flatNet, this._initialMarking, this._property, invariants);
+      const queryResult = await runner.query(encoding.errorExpr, encoding.reachableDecl);
+      switch (queryResult.type) {
+        case "proven": {
+          report.push("  Status: UNSAT (property holds)\n");
+          const discoveredInvariants = [];
+          if (queryResult.invariantFormula != null) {
+            discoveredInvariants.push(substituteNames(queryResult.invariantFormula, flatNet));
+          }
+          for (const level of queryResult.levelInvariants) {
+            discoveredInvariants.push(substituteNames(level, flatNet));
+          }
+          if (discoveredInvariants.length > 0) {
+            report.push("Phase 5: Inductive invariant (discovered by IC3)");
+            report.push(`  Spacer synthesized: ${discoveredInvariants[0]}`);
+            report.push("  This formula is INDUCTIVE: preserved by all transitions.");
+            if (discoveredInvariants.length > 1) {
+              report.push("  Per-level clauses:");
+              for (let i = 1; i < discoveredInvariants.length; i++) {
+                report.push(`    ${discoveredInvariants[i]}`);
+              }
+            }
+            report.push("");
+          }
+          report.push("=== RESULT ===\n");
+          report.push(`PROVEN (IC3/PDR): ${propertyDescription(this._property)}`);
+          report.push("  Z3 Spacer proved no reachable state violates the property.");
+          report.push("  NOTE: Verification ignores timing constraints and JS guards.");
+          report.push("  An untimed proof is STRONGER than a timed one (timing only restricts behavior).");
+          return buildResult(
+            {
+              type: "proven",
+              method: "IC3/PDR",
+              inductiveInvariant: queryResult.invariantFormula != null ? substituteNames(queryResult.invariantFormula, flatNet) : null
+            },
+            report.join("\n"),
+            invariants,
+            discoveredInvariants,
+            [],
+            [],
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          );
+        }
+        case "violated": {
+          report.push("  Status: SAT (counterexample found)\n");
+          const decoded = decode(runner.ctx, queryResult.answer, flatNet);
+          report.push("=== RESULT ===\n");
+          report.push(`VIOLATED: ${propertyDescription(this._property)}`);
+          if (decoded.trace.length > 0) {
+            report.push(`  Counterexample trace (${decoded.trace.length} states):`);
+            for (let i = 0; i < decoded.trace.length; i++) {
+              report.push(`    ${i}: ${decoded.trace[i]}`);
+            }
+          }
+          if (decoded.transitions.length > 0) {
+            report.push(`  Firing sequence: ${decoded.transitions.join(" -> ")}`);
+          }
+          report.push("\n  WARNING: This counterexample is in UNTIMED semantics.");
+          report.push("  It may be spurious if timing constraints prevent this sequence.");
+          report.push("  JS guards are also ignored in this analysis.");
+          return buildResult(
+            { type: "violated" },
+            report.join("\n"),
+            invariants,
+            [],
+            decoded.trace,
+            decoded.transitions,
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          );
+        }
+        case "unknown": {
+          report.push(`  Status: UNKNOWN (${queryResult.reason})
+`);
+          report.push("=== RESULT ===\n");
+          report.push(`UNKNOWN: Could not determine ${propertyDescription(this._property)}`);
+          report.push(`  Reason: ${queryResult.reason}`);
+          return buildResult(
+            { type: "unknown", reason: queryResult.reason },
+            report.join("\n"),
+            invariants,
+            [],
+            [],
+            [],
+            performance.now() - start,
+            { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+          );
+        }
+      }
+    } catch (e) {
+      report.push(`  ERROR: ${e.message ?? e}
+`);
+      report.push("=== RESULT ===\n");
+      report.push(`UNKNOWN: Z3 solver error: ${e.message ?? e}`);
+      return buildResult(
+        { type: "unknown", reason: `Z3 error: ${e.message ?? e}` },
+        report.join("\n"),
+        invariants,
+        [],
+        [],
+        [],
+        performance.now() - start,
+        { places: flatNet.places.length, transitions: flatNet.transitions.length, invariantsFound: invariants.length, structuralResult: structResultStr }
+      );
+    } finally {
+      runner.dispose();
+    }
+  }
+};
+function substituteNames(formula, flatNet) {
+  for (let i = flatNet.places.length - 1; i >= 0; i--) {
+    formula = formula.replace(new RegExp(`\\bm${i}\\b`, "g"), flatNet.places[i].name);
+  }
+  return formula;
+}
+function formatInvariant(inv, flatNet) {
+  const parts = [];
+  for (const idx of inv.support) {
+    if (inv.weights[idx] !== 1) {
+      parts.push(`${inv.weights[idx]}*${flatNet.places[idx].name}`);
+    } else {
+      parts.push(flatNet.places[idx].name);
+    }
+  }
+  return `${parts.join(" + ")} = ${inv.constant}`;
+}
+function buildResult(verdict, report, invariants, discoveredInvariants, trace, transitions, elapsedMs, statistics) {
+  return { verdict, report, invariants, discoveredInvariants, counterexampleTrace: trace, counterexampleTransitions: transitions, elapsedMs, statistics };
+}
+export {
+  IncidenceMatrix,
+  MarkingState,
+  MarkingStateBuilder,
+  SmtVerifier,
+  bounded,
+  computePInvariants,
+  createSpacerRunner,
+  deadlockFree,
+  decode,
+  encode,
+  findMaximalTrapIn,
+  findMinimalSiphons,
+  flatNetIndexOf,
+  flatNetPlaceCount,
+  flatNetTransitionCount,
+  flatTransition,
+  flatten,
+  isCoveredByInvariants,
+  isProven,
+  isViolated,
+  mutualExclusion,
+  pInvariant,
+  pInvariantToString,
+  placeBound,
+  propertyDescription,
+  structuralCheck,
+  unbounded,
+  unreachable
+};
+//# sourceMappingURL=index.js.map