Adaptive Pauli-Lindbladian shim + adaptive-evolution demo

Cargo.toml

@@ -14,6 +14,7 @@ ppvm-sym = { version = "0.1.0", path = "crates/ppvm-sym" }
 members = [
     "crates/ppvm-runtime",
     "crates/ppvm-sym",
+    "crates/ppvm-lindblad",
     "crates/ppvm-python-native",
     "crates/ppvm-tableau",
     "crates/ppvm-stim", "crates/stim-parser",

crates/ppvm-lindblad/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "ppvm-lindblad"
+version = "0.1.0"
+edition = "2024"
+description = "Direct Heisenberg-picture Lindbladian evolution on an adaptive Pauli-string basis."
+
+[dependencies]
+fxhash = "0.2.1"
+num = "0.4.3"
+ppvm-runtime = { version = "0.1.0", path = "../ppvm-runtime" }
+rayon = "1.11"
+sprs = { version = "0.11", default-features = false, features = ["multi_thread"] }
+
+[dev-dependencies]
+approx = "0.5.1"
+criterion = "0.7.0"
+
+[[bench]]
+name = "spmv_scaling"
+harness = false

crates/ppvm-lindblad/benches/spmv_scaling.rs

@@ -0,0 +1,66 @@
+// SPDX-FileCopyrightText: 2026 The PPVM Authors
+// SPDX-License-Identifier: Apache-2.0
+
+//! Parallel SpMV scaling on a tridiagonal CSR matrix. Sweeps both matrix
+//! size and thread count, so we can see where parallelism actually pays
+//! off (compute-bound, L3-fitting) vs where DRAM bandwidth ceilings out
+//! the speedup (large matrices). Each invocation runs inside a freshly
+//! built rayon pool of the requested size.
+
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
+use ppvm_lindblad::{Csr, csr_from_triplets, spmv_parallel};
+
+fn build_tridiagonal(n: usize) -> Csr {
+    let mut trips = Vec::with_capacity(3 * n);
+    for i in 0..n {
+        trips.push((i, i, -2.0));
+        if i > 0 {
+            trips.push((i, i - 1, 1.0));
+        }
+        if i + 1 < n {
+            trips.push((i, i + 1, 1.0));
+        }
+    }
+    csr_from_triplets(n, &trips)
+}
+
+fn bench_spmv_scaling(c: &mut Criterion) {
+    // (n, label) pairs: nnz ≈ 3n. ~16 bytes per nonzero (usize indices + f64)
+    // + 8 bytes per row.
+    //
+    //   n =  100_000  → nnz ≈   300_000  →   ~5 MB  (fits L2/L3, compute-bound)
+    //   n =  500_000  → nnz ≈ 1_500_000  →  ~24 MB  (L3 boundary on M-series)
+    //   n = 2_000_000 → nnz ≈ 6_000_000  →  ~96 MB  (busts L3, bandwidth-bound)
+    //   n = 8_000_000 → nnz ≈ 24_000_000 → ~384 MB  (well into DRAM)
+    let sizes = [100_000usize, 500_000, 2_000_000, 8_000_000];
+
+    for &n in &sizes {
+        let m = build_tridiagonal(n);
+        let x: Vec<f64> = (0..n).map(|i| (i as f64).sin()).collect();
+
+        let mut group = c.benchmark_group(format!("spmv_parallel/n={}", n));
+        group.throughput(Throughput::Elements(m.nnz() as u64));
+        group.sample_size(30);
+        group.measurement_time(std::time::Duration::from_secs(3));
+        group.warm_up_time(std::time::Duration::from_secs(1));
+
+        for &threads in &[1usize, 2, 4, 8] {
+            let pool = rayon::ThreadPoolBuilder::new()
+                .num_threads(threads)
+                .build()
+                .unwrap();
+            group.bench_with_input(BenchmarkId::from_parameter(threads), &threads, |b, _| {
+                b.iter_batched_ref(
+                    || vec![0f64; n],
+                    |y| pool.install(|| spmv_parallel(&m, &x, y)),
+                    criterion::BatchSize::SmallInput,
+                );
+            });
+        }
+
+        group.finish();
+    }
+}
+
+criterion_group!(benches, bench_spmv_scaling);
+criterion_main!(benches);