libpetri 4.0.0 → 4.1.0

package/dist/{chunk-WYCGGQAW.js → chunk-FD3S4TZM.js}

@@ -3528,6 +3528,7 @@ function counterexamplePath(scg, target) {
 }
 
 // src/verification/smt-verifier.ts
+var IGNORE_MODE_VACUITY_REASON = "environment places present but not modeled (mode=ignore); a proof would be vacuous \u2014 use alwaysAvailable() or bounded(k) to model external injection";
 var SmtVerifier = class _SmtVerifier {
   constructor(net) {
     this.net = net;
@@ -3636,13 +3637,26 @@ var SmtVerifier = class _SmtVerifier {
    * into a chain whose other combinations avoid it (dropped by the H1 guard). On a
    * net with a few reset arcs that can lose every law of the chains those arcs
    * touch, and without them IC3 has to rediscover the conservation of each chain —
-   * on a ~100-place net it does not within any practical budget. With the semiflows
-   * in, the same reachability-safety queries close in about a second.
+   * on a ~100-place net it does not within any practical budget.
+   *
+   * **Turn this on if the net has any `all()` / `atLeast(n)` or reset arc on a busy
+   * place** — draining an input queue is the everyday case. Every basis row whose
+   * support touches such a place fails the H1 guard and is dropped, so the encoders
+   * run on a deficient invariant set and nothing in the report says a law is missing
+   * beyond the `Dropped` lines.
+   *
+   * This reaches the **name-coloured** encoder (NU-050) as well as the flat one, and
+   * it matters most there. On a 113-place ν-net, whole-net deadlock-freedom went from
+   * `unknown` after 50 minutes to `proven` in about 15 seconds with this option as the
+   * only change; on the flat path, reachability-safety queries that timed out at 120 s
+   * close in about a second.
    *
    * Soundness is unchanged: the semiflows pass the same exact re-validation as the
    * basis rows, the union is pure strengthening (`Semiflow.lean`,
    * `semiflow_union_sound`), and the certificate check re-proves the strengthened
-   * invariant. Off by default so reports stay byte-equal.
+   * invariant — that check is flat-path only, so a coloured `proven` reports
+   * `Certificate check: not applicable (name-coloured encoding)`. Off by default so
+   * reports stay byte-equal.
    */
   semiflowInvariants(enabled) {
     this._semiflowInvariants = enabled;
@@ -3702,6 +3716,48 @@ var SmtVerifier = class _SmtVerifier {
     this._prioritySemantics = semantics;
     return this;
   }
+  /**
+   * The name-coloured plan and its encoding, or a null plan when the net is outside
+   * the fragment (NU-050) and a null encoding when the property names a place the net
+   * does not resolve.
+   *
+   * {@link verify} and {@link encodeScripts} share this deliberately. They used to
+   * invoke `buildColouredPlan` and `encodeColoured` separately, so handing the encoder
+   * the wrong one of the two lists changed only one of them — and the script-parity
+   * goldens are generated from `encodeScripts`. Unifying the invocation closes that. It
+   * does not make the two paths identical: each still computes its own invariant and
+   * semiflow lists, so they can still drift through the arguments rather than the call.
+   *
+   * `invariants` is what the encoder conjoins into every rule body (the null-space
+   * basis, unioned with the semiflows when VER-007 is enabled); `semiflows` sets the
+   * colour-slot bound k (NU-053). They are not the same list.
+   */
+  colouredAttempt(flatNet, invariants, semiflows) {
+    const hasMatch = [...this.net.transitions].some((t) => t.matchSpec !== null);
+    const nuBounded = this._budgetPlaces.size > 0;
+    if (!hasMatch || !nuBounded) return { plan: null, encoding: null };
+    const plan = buildColouredPlan(
+      this.net,
+      flatNet,
+      this._initialMarking,
+      this._budgetPlaces,
+      this._fragmentMode,
+      this._carrierPlaces,
+      semiflows
+    );
+    if (plan == null) return { plan: null, encoding: null };
+    return {
+      plan,
+      encoding: encodeColoured(
+        plan,
+        flatNet,
+        this._initialMarking,
+        this._property,
+        invariants,
+        this._sinkPlaces
+      )
+    };
+  }
   /**
    * The SMT-LIB2 scripts {@link verify} would send to z3 for this configuration,
    * without running a solver (VER-013 AC1): the HORN query (flat, or name-coloured
@@ -3713,8 +3769,6 @@ var SmtVerifier = class _SmtVerifier {
    */
   encodeScripts() {
     requireOutputProducingActions(this.net);
-    const hasMatch = [...this.net.transitions].some((t) => t.matchSpec !== null);
-    const nuBounded = this._budgetPlaces.size > 0;
     const flatNet = flatten(this.net, this._environmentPlaces, this._environmentMode);
     const matrix = IncidenceMatrix.from(flatNet);
     const { valid: basis } = validateInvariantsExact(
@@ -3732,20 +3786,9 @@ var SmtVerifier = class _SmtVerifier {
     let invariants = basis;
     if (this._semiflowInvariants) invariants = strengthenWithSemiflows(basis, semiflows).invariants;
     invariants = canonicalInvariantOrder(invariants);
-    if (hasMatch && nuBounded) {
-      const plan = buildColouredPlan(
-        this.net,
-        flatNet,
-        this._initialMarking,
-        this._budgetPlaces,
-        this._fragmentMode,
-        this._carrierPlaces,
-        semiflows
-      );
-      if (plan != null) {
-        const coloured = encodeColoured(plan, flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces);
-        if (coloured != null) return { horn: coloured.smt2, certificate: null, coloured: true };
-      }
+    const attempt = this.colouredAttempt(flatNet, invariants, semiflows);
+    if (attempt.encoding != null) {
+      return { horn: attempt.encoding.smt2, certificate: null, coloured: true };
     }
     const horn = encode(flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces, this._counterexampleReplay).smt2;
     const certificate = vcScript(
@@ -3796,8 +3839,13 @@ var SmtVerifier = class _SmtVerifier {
         if (outcome.transitions.length > 0) {
           report.push(`  Counterexample trace: ${outcome.trace.length} states, ${outcome.transitions.length} transitions`);
         }
+        let routeBVerdict = outcome.verdict;
+        if (routeBVerdict.type === "proven" && this._environmentPlaces.size > 0 && this._environmentMode.type === "ignore") {
+          report.push(`  Downgraded to UNKNOWN: ${IGNORE_MODE_VACUITY_REASON}`);
+          routeBVerdict = { type: "unknown", reason: IGNORE_MODE_VACUITY_REASON };
+        }
         return buildResult(
-          outcome.verdict,
+          routeBVerdict,
           report.join("\n"),
           [],
           [],
@@ -3903,15 +3951,6 @@ var SmtVerifier = class _SmtVerifier {
     }
     report.push("");
     report.push("Phase 4: IC3/PDR verification via Z3 Spacer...");
-    const colouredPlan = hasMatch && nuBounded ? buildColouredPlan(
-      this.net,
-      flatNet,
-      this._initialMarking,
-      this._budgetPlaces,
-      this._fragmentMode,
-      this._carrierPlaces,
-      semiflows
-    ) : null;
     const stats = {
       places: flatNet.places.length,
       transitions: flatNet.transitions.length,
@@ -3932,12 +3971,14 @@ var SmtVerifier = class _SmtVerifier {
       return buildResult({ type: "unknown", reason }, report.join("\n"), invariants, [], [], [], performance.now() - start, stats);
     }
     report.push(`  Solver: z3 ${formatZ3Version(solver.version)}`);
+    const colouredAttempt = this.colouredAttempt(flatNet, invariants, semiflows);
+    const colouredPlan = colouredAttempt.plan;
     let encoding;
     if (colouredPlan != null) {
       report.push(
         `  \u03BD-encoding: name-coloured (exact within budget k=${colouredPlan.k}; ${colouredPlan.coloured.length} coloured place(s))`
       );
-      const coloured = encodeColoured(colouredPlan, flatNet, this._initialMarking, this._property, invariants, this._sinkPlaces);
+      const coloured = colouredAttempt.encoding;
       if (coloured == null) {
         const reason = "property names a place that does not resolve in the net; refusing to certify (the encoding would be vacuously proven)";
         report.push("  Status: UNKNOWN (unresolved property place)\n");
@@ -3966,7 +4007,7 @@ var SmtVerifier = class _SmtVerifier {
     switch (queryResult.type) {
       case "proven": {
         if (this._environmentPlaces.size > 0 && this._environmentMode.type === "ignore") {
-          const reason = "environment places present but not modeled (mode=ignore); a proof would be vacuous \u2014 use alwaysAvailable() or bounded(k) to model external injection";
+          const reason = IGNORE_MODE_VACUITY_REASON;
           report.push(`  Status: UNSAT, but vacuous under ignore mode
 `);
           report.push("=== RESULT ===\n");
@@ -4362,4 +4403,4 @@ export {
   isProven,
   isViolated
 };
-//# sourceMappingURL=chunk-WYCGGQAW.js.map
+//# sourceMappingURL=chunk-FD3S4TZM.js.map