feat(nc): PMOO/LUDB bound via good_lp for tree-shaped multiplexing (v0.9.3 NC tightness #2) (#203)

Closes the external reviewer's NC top-5 #2 (credibility gap with
RTaW-Pegase): adds an opt-in Pay-Multiplexing-Only-Once / Bisti-LUDB
("Linear Upper Delay Bound") path in `spar-network::pmoo` that the
WCTT pass invokes when the topology is tree-shaped (one tagged flow,
≥ 2 competing flows on contiguous sub-paths of the tagged tandem,
all hops FIFO/Priority).

The LP is set up via `good_lp` with the HiGHS backend already vendored
for the deployment solver. On the canonical zonal/automotive
multiplexing pattern (one switch, many sources to one sink) the bound
is 23-27% tighter than today's per-hop SFA chain on the in-tree
fixtures, with 30-60% reported in the literature for larger fan-ins.
On LP infeasibility (`Σ ρ ≥ R_h` at any hop) the WCTT pass silently
falls back to the existing SFA chain — bound never worsens.

Numerical comparison from the in-tree fixtures:
  3-hop / 3-competing:  PMOO =  98_571_429 ps   SFA = 135_843_430 ps   tightening = 27.4%
  Zonal 5-source:        PMOO = 159_000_000 ps   SFA = 208_488_000 ps   tightening = 23.7%

API surface in `spar-network::pmoo`:
  - `TaggedFlow { alpha, path }`, `CompetingFlow { alpha, path }`
  - `PmooBound { delay_ps, model_size, solve_time_us }`
  - `LpError::{Infeasible, OutOfRange, EmptyPath, NonContiguous, SolverFailed}`
  - `ludb_bound(tagged, competing, services) -> Result<PmooBound, LpError>`

Wiring:
  - `WcttAnalysis` becomes a configurable struct with `pmoo: bool`
    (default `false` → byte-identical to v0.9.2). `WcttAnalysis::with_pmoo()`
    enables the opt-in path.
  - New `pmoo_or_sfa(stream, all_streams, switch_type, service_for_bus)`
    helper in wctt.rs validates eligibility (all-FIFO chain, ≥ 2
    competitors, contiguous sub-paths) and dispatches to `ludb_bound`.
  - New `WcttPmooBound` Info diagnostic reports method=ludb, PMOO
    delay, SFA delay for comparison, tightening %, and LP solve time.
  - New `--pmoo` CLI flag on `spar analyze` opts in. `AnalysisRunner::
    register_all_except_wctt()` lets the CLI swap in the
    PMOO-configured `WcttAnalysis` without duplicating the SFA pass.

Tests:
  - 10 new unit tests in `spar-network/src/pmoo.rs`: single-hop /
    no-competing baseline (PMOO ≡ SFA), 2-hop tandem 1 competing flow
    (PMOO ≤ SFA), 3-hop / 3-competing (PMOO ≪ SFA, ≥ 5% tightening
    asserted), LP infeasibility, validation errors, model-size and
    solve-time reporting, single-flow tandem reduces to pay-burst-once,
    canonical zonal 5-source reference comparison.
  - 2 new round-trip tests in `spar-analysis/src/wctt.rs`:
    `pmoo_flag_off_emits_no_pmoo_diagnostic` (default v0.9.2 byte-
    identical), `pmoo_flag_on_emits_pmoo_diagnostic_for_eligible_streams`
    (≥ 1 `WcttPmooBound` with method=ludb).

Quality gates:
  - cargo build --workspace: clean
  - cargo test --workspace: 851 spar-analysis tests pass (was 849;
    +2 round-trip), 87 spar-network tests pass (was 77; +10 PMOO),
    no regressions
  - cargo clippy --workspace --all-targets -- -D warnings: clean
  - cargo fmt --all -- --check: clean
  - rivet validate: PASS

Artifacts:
  - REQ-NETWORK-014 in artifacts/requirements.yaml
  - TEST-NC-PMOO in artifacts/verification.yaml (links: satisfies
    REQ-NETWORK-014)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: avrabe

Cargo.lock

@@ -1700,6 +1700,29 @@ artifacts:
     status: implemented
     tags: [network, wctt, rta, coupling, v092]
 
+  - id: REQ-NETWORK-014
+    type: requirement
+    title: PMOO/LUDB bound for tree-shaped multiplexing
+    description: >
+      v0.9.3 adds an opt-in Pay-Multiplexing-Only-Once / Bisti-LUDB
+      ("Linear Upper Delay Bound") path in `spar-network::pmoo` that
+      the `WcttAnalysis` pass invokes when (a) the stream's tandem is
+      composed entirely of FIFO/Priority switches, (b) every other
+      stream that crosses any hop on the tandem does so on a contiguous
+      sub-path (PMOO precondition), and (c) ≥ 2 such competing flows
+      exist (otherwise PMOO ≡ SFA). The LP is set up via `good_lp` with
+      the HiGHS backend already vendored for the deployment solver;
+      on infeasibility (`Σ ρ ≥ R_h` at any hop) we silently fall back
+      to per-hop SFA. New `WcttPmooBound` Info diagnostic reports the
+      method (=ludb), the PMOO delay, the SFA delay for comparison,
+      the percentage tightening, and the LP solve time. Closes the
+      external reviewer's NC top-5 #2 (credibility gap with RTaW-Pegase):
+      typical 30-60% tightening on automotive zonal aggregations,
+      observed 23-27% on the in-tree fixtures. CLI `--pmoo` flag opts
+      in; default off → byte-identical to v0.9.2.
+    status: implemented
+    tags: [network, wctt, pmoo, ludb, lp, v093]
+
   # ── Track G: spar-insight discrepancy assistant (v0.9.0) ──────────
 
   - id: REQ-INSIGHT-001

artifacts/requirements.yaml

@@ -2247,6 +2247,37 @@ artifacts:
       - type: satisfies
         target: REQ-NETWORK-011
 
+  - id: TEST-NC-PMOO
+    type: feature
+    title: PMOO/LUDB bound is tighter than SFA for tree-shaped multiplexing
+    description: >
+      Ten unit tests in `spar-network/src/pmoo.rs` plus two CLI-flag
+      round-trip tests in `spar-analysis/src/wctt.rs` exercise the
+      v0.9.3 PMOO/LUDB path. The PMOO unit tests cover: (a) single-hop
+      no-competing baseline (PMOO ≡ SFA), (b) 2-hop tandem 1 competing
+      flow joining at hop 2 (PMOO ≤ SFA, strictly tighter on the
+      fixture), (c) 3-hop / 3-competing convergent fixture (PMOO ≪ SFA,
+      ≥ 5 % tightening asserted; observed 27.4 %), (d) LP infeasibility
+      surfaces as `Err(LpError::Infeasible)` for SFA fallback,
+      (e) empty-path / out-of-range / non-contiguous validation, (f) LP
+      model size and solve-time reporting, (g) single-flow tandem
+      reduces to "pay-burst-once" closed form, (h) the canonical
+      automotive-zonal 5-source pattern (observed 23.7 % tightening).
+      CLI round-trip tests confirm `WcttPmooBound` only fires with the
+      `--pmoo` flag (`pmoo_flag_off_emits_no_pmoo_diagnostic` and
+      `pmoo_flag_on_emits_pmoo_diagnostic_for_eligible_streams`),
+      preserving v0.9.2 byte-identical default output.
+    fields:
+      method: automated-test
+      steps:
+        - run: cargo test -p spar-network --lib -- pmoo
+        - run: cargo test -p spar-analysis --lib -- pmoo_flag
+    status: passing
+    tags: [v0.9.3, network, wctt, pmoo, ludb, lp]
+    links:
+      - type: satisfies
+        target: REQ-NETWORK-014
+
   - id: TEST-INSIGHT-DISCREPANCY
     type: feature
     title: spar-insight CTF parser + 5-kind discrepancy detection

artifacts/verification.yaml

@@ -195,7 +195,77 @@ impl AnalysisRunner {
         self.register(Box::new(WeightPowerAnalysis));
         self.register(Box::new(BusBandwidthAnalysis));
         self.register(Box::new(FeatureGroupCheckAnalysis));
-        self.register(Box::new(WcttAnalysis));
+        self.register(Box::new(WcttAnalysis::default()));
+    }
+
+    /// Register all instance-level analyses **except** [`wctt::WcttAnalysis`].
+    ///
+    /// Used by the CLI's `--pmoo` flag path to register a custom-
+    /// configured `WcttAnalysis` (with PMOO/LUDB enabled) without
+    /// duplicating the v0.9.2 SFA pass. See
+    /// `spar-cli/src/main.rs::run_all_analyses_with_pmoo`.
+    pub fn register_all_except_wctt(&mut self) {
+        use ai_ml::AiMlAnalysis;
+        use arinc653::Arinc653Analysis;
+        use binding_check::BindingCheckAnalysis;
+        use binding_rules::BindingRuleAnalysis;
+        use bus_bandwidth::BusBandwidthAnalysis;
+        use classifier_match::ClassifierMatchAnalysis;
+        use completeness::CompletenessAnalysis;
+        use connection_rules::ConnectionRuleAnalysis;
+        use connectivity::ConnectivityAnalysis;
+        use direction_rules::DirectionRuleAnalysis;
+        use emv2_analysis::Emv2Analysis;
+        use emv2_stpa_bridge::Emv2StpaBridgeAnalysis;
+        use feature_group_check::FeatureGroupCheckAnalysis;
+        use flow_check::FlowCheckAnalysis;
+        use flow_rules::FlowRuleAnalysis;
+        use hierarchy::HierarchyAnalysis;
+        use latency::LatencyAnalysis;
+        use memory_budget::MemoryBudgetAnalysis;
+        use modal_rules::ModalRuleAnalysis;
+        use mode_check::ModeCheckAnalysis;
+        use mode_reachability::ModeReachabilityAnalysis;
+        use mode_rules::ModeRuleAnalysis;
+        use property_rules::PropertyRuleAnalysis;
+        use resource_budget::ResourceBudgetAnalysis;
+        use rta::RtaAnalysis;
+        use scheduling::SchedulingAnalysis;
+        use subcomponent_rules::SubcomponentRuleAnalysis;
+        use weight_power::WeightPowerAnalysis;
+        use wrpc_binding::WrpcBindingAnalysis;
+
+        self.register(Box::new(AiMlAnalysis));
+        self.register(Box::new(ConnectivityAnalysis));
+        self.register(Box::new(HierarchyAnalysis));
+        self.register(Box::new(CompletenessAnalysis));
+        self.register(Box::new(DirectionRuleAnalysis));
+        self.register(Box::new(ClassifierMatchAnalysis));
+        self.register(Box::new(BindingCheckAnalysis));
+        self.register(Box::new(BindingRuleAnalysis));
+        self.register(Box::new(FlowCheckAnalysis));
+        self.register(Box::new(FlowRuleAnalysis));
+        self.register(Box::new(ModeCheckAnalysis));
+        self.register(Box::new(ModeRuleAnalysis));
+        self.register(Box::new(ModalRuleAnalysis));
+        self.register(Box::new(PropertyRuleAnalysis));
+        self.register(Box::new(ConnectionRuleAnalysis));
+        self.register(Box::new(SubcomponentRuleAnalysis));
+        self.register(Box::new(SchedulingAnalysis));
+        self.register(Box::new(RtaAnalysis));
+        self.register(Box::new(LatencyAnalysis));
+        self.register(Box::new(MemoryBudgetAnalysis));
+        self.register(Box::new(ResourceBudgetAnalysis));
+        self.register(Box::new(Emv2Analysis));
+        self.register(Box::new(Emv2StpaBridgeAnalysis));
+        self.register(Box::new(Arinc653Analysis));
+        self.register(Box::new(WrpcBindingAnalysis));
+        self.register(Box::new(ModeReachabilityAnalysis));
+        self.register(Box::new(WeightPowerAnalysis));
+        self.register(Box::new(BusBandwidthAnalysis));
+        self.register(Box::new(FeatureGroupCheckAnalysis));
+        // WcttAnalysis intentionally omitted — caller registers a
+        // PMOO-configured variant.
     }
 
     /// Return the number of registered analyses.