bench(tableau): add fused+tgate combined circuit benchmark

Adds a `fused-tgate-circuit` benchmark group that combines batch
Clifford operations (fusion) with variable T-gates and measurement.
Also adds profile_combined example showing time breakdown.

Key finding: measurement dominates at 85-90% of total circuit time
when coefficient counts are large (>4K). Fusion reduces Clifford
overhead to <1%. T-gate branching (rayon target) is ~10%.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Roger-luo

crates/ppvm-tableau/benches/tableau.rs

@@ -127,6 +127,56 @@ pub fn benchmark_suite_tableau(c: &mut Criterion, name: impl AsRef<str>) {
     }
 
     large_group.finish();
+
+    // Combined benchmark: fused Clifford batches + variable T gates + measurement.
+    // Shows how fusion and rayon compose in a realistic circuit.
+    let mut combined_group = c.benchmark_group("fused-tgate-circuit");
+    combined_group
+        .warm_up_time(Duration::from_secs(1))
+        .measurement_time(Duration::from_secs(5))
+        .sample_size(20);
+
+    for n_tgates in [8, 12, 16] {
+        // Circuit: batched Cliffords → H (ensure branching) → T gates → batched Cliffords → measure.
+        // H is applied AFTER Cliffords to ensure T gates see non-stabilizer states and branch.
+        let n_qubits: usize = 85;
+
+        // Pre-build the Clifford portion so the setup cost is excluded
+        let mut setup = GeneralizedTableau::<Byte8F64<2>, u128>::new(n_qubits, 1e-10);
+        let block1: Vec<usize> = (0..17).collect();
+        let block2: Vec<usize> = (17..34).collect();
+        setup.sqrt_y_batch(&block1);
+        setup.sqrt_x_batch(&block2);
+        setup.cz_block_pairs(0, 17, 17);
+        // H on qubits that will get T gates — applied after Cliffords to guarantee branching
+        for i in 0..n_tgates {
+            setup.h(i);
+        }
+
+        combined_group.bench_function(format!("fused-{n_tgates}t-{n_qubits}q"), |b| {
+            b.iter_batched_ref(
+                || setup.fork(Some(0)),
+                |tab| {
+                    // T gates (coefficient branching — rayon target)
+                    for i in 0..n_tgates {
+                        tab.t(i);
+                    }
+
+                    // More batched Cliffords after T gates
+                    tab.sqrt_x_adj_batch(&block1);
+                    tab.sqrt_y_adj_batch(&block2);
+
+                    // Measure all
+                    for i in 0..n_qubits {
+                        tab.measure(i);
+                    }
+                },
+                criterion::BatchSize::LargeInput,
+            );
+        });
+    }
+
+    combined_group.finish();
 }
 
 pub fn tableau_scaling_benchmarks(c: &mut Criterion) {

crates/ppvm-tableau/examples/profile_combined.rs

@@ -0,0 +1,78 @@
+//! Profile the time breakdown of a fused circuit with variable T gates.
+
+use std::time::Instant;
+
+use ppvm_runtime::config::fx64hash::Byte8F64;
+use ppvm_tableau::prelude::*;
+
+type Tab = GeneralizedTableau<Byte8F64<2>, u128>;
+
+fn main() {
+    let n_qubits = 85;
+
+    println!(
+        "{:>4}  {:>10}  {:>10}  {:>10}  {:>10}  {:>6}  {:>6}  {:>6}",
+        "T#", "clifford", "t-gates", "measure", "total", "%clif", "%t", "%meas"
+    );
+
+    for n_tgates in [4, 8, 12, 14, 16] {
+        let block1: Vec<usize> = (0..17).collect();
+        let block2: Vec<usize> = (17..34).collect();
+
+        let n_runs = if n_tgates <= 12 { 5 } else { 2 };
+        let mut clif_ns = 0u128;
+        let mut tgate_ns = 0u128;
+        let mut meas_ns = 0u128;
+
+        for _ in 0..n_runs {
+            let mut tab: Tab = GeneralizedTableau::new(n_qubits, 1e-10);
+
+            // Clifford layer 1 (fused)
+            let t0 = Instant::now();
+            tab.sqrt_y_batch(&block1);
+            tab.sqrt_x_batch(&block2);
+            tab.cz_block_pairs(0, 17, 17);
+            for i in 0..n_tgates {
+                tab.h(i);
+            }
+            clif_ns += t0.elapsed().as_nanos();
+
+            // T gates
+            let t1 = Instant::now();
+            for i in 0..n_tgates {
+                tab.t(i);
+            }
+            tgate_ns += t1.elapsed().as_nanos();
+
+            // Clifford layer 2 (fused)
+            let t2 = Instant::now();
+            tab.sqrt_x_adj_batch(&block1);
+            tab.sqrt_y_adj_batch(&block2);
+            clif_ns += t2.elapsed().as_nanos();
+
+            // Measure
+            let t3 = Instant::now();
+            for i in 0..n_qubits {
+                tab.measure(i);
+            }
+            meas_ns += t3.elapsed().as_nanos();
+        }
+
+        let d = n_runs as f64;
+        let c = clif_ns as f64 / d / 1000.0;
+        let t = tgate_ns as f64 / d / 1000.0;
+        let m = meas_ns as f64 / d / 1000.0;
+        let total = c + t + m;
+        println!(
+            "{:>4}  {:>9.0}µ  {:>9.0}µ  {:>9.0}µ  {:>9.0}µ  {:>5.1}%  {:>5.1}%  {:>5.1}%",
+            n_tgates,
+            c,
+            t,
+            m,
+            total,
+            c / total * 100.0,
+            t / total * 100.0,
+            m / total * 100.0,
+        );
+    }
+}