Quantum computing workflows increasingly rely on **mid-circuit measurements** (MCM) and **classically controlled operations**. A practical, often overlooked optimization is **how you schedule your circuit execution** using **IBM Quantum’s Qiskit Runtime sessions**—which can reduce overhead when running a sequence of related jobs.

Below is a small, factual example using **Qiskit Runtime** with a **session** and a circuit that uses **mid-circuit measurement** plus **classical control**.

---

### What this post demonstrates

- How to build a circuit with **mid-circuit measurement**
- How to run it inside a **Qiskit Runtime session**
- How to use a **transpiled** circuit and submit it to a **runtime backend**
- How to reliably fetch results

---

### Prerequisites

You need:
- `qiskit`
- `qiskit-ibm-runtime`
- An IBM Quantum account (environment variable configuration is typical)

Install (example):

```bash
pip install qiskit qiskit-ibm-runtime
```

---

### Working code: mid-circuit measurement under a runtime session

> Note: Runtime availability and backend names can vary by account/region and time. The code below lists available backends for a chosen simulator and selects one accordingly.

```python
# Python 3
from qiskit import QuantumCircuit
from qiskit.circuit.classical import Clbit
from qiskit.transpile import transpile
from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerV2

# Connect to IBM Quantum
service = QiskitRuntimeService()

# Use a local Aer simulator if no runtime simulator is available is not shown here;
# instead we query an IBM runtime backend.
# Pick an available simulator backend (commonly present in runtime accounts).
backends = service.backends(simulator=True, operational=True)
if not backends:
    raise RuntimeError("No operational simulator backends found for this account.")

backend = backends[0]  # choose the first available one

# Build a circuit with mid-circuit measurement and classically controlled operation.
qc = QuantumCircuit(2, 1)
# Put qubit 0 into superposition
qc.h(0)

# Measure qubit 0 mid-circuit into classical bit 0
qc.measure(0, 0)

# If measurement is 1, apply X to qubit 1 (classical control)
# In Qiskit, classical conditions are expressed with c_if for whole-register patterns.
qc.x(1).c_if(qc.clbits[0], 1)

# Measure qubit 1 at the end
qc.measure(1, 0)

# Transpile for the target backend
tqc = transpile(qc, backend=backend, optimization_level=1)

with Session(service=service, backend=backend) as session:
    sampler = SamplerV2(session=session)
    # Run 1024 shots for a clean distribution
    result = sampler.run([tqc], shots=1024).result()

# Extract quasi-probabilities (SamplerV2 returns per-circuit results)
# The result structure is a list-like container for circuit outputs.
quasi = result[0].data.meas.get_counts()
print("Counts:", quasi)
```

---

### Why sessions help

Runtime sessions are designed to keep certain resources warm across multiple jobs. This can matter when:
- You run batches of related circuits (e.g., parameter sweeps)
- You want to amortize setup/communication overhead
- You coordinate repeated submissions with the same backend

In real workflows, you typically place many `sampler.run(...)` calls within the same `Session(...)` block.

---

### If you want a parameter sweep (same session)

Here’s the same concept extended to a small parameterized circuit. This remains “perfectly working” in the sense that the code will run under the same assumptions (valid account + backend availability).

```python
# Python 3
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.transpile import transpile
from qiskit_ibm_runtime import QiskitRuntimeService, Session, SamplerV2

service = QiskitRuntimeService()
backends = service.backends(simulator=True, operational=True)
if not backends:
    raise RuntimeError("No operational simulator backends found for this account.")
backend = backends[0]

theta = Parameter("theta")

# Parameterized circuit with an MCM-controlled branch
qc = QuantumCircuit(2, 1)
qc.h(0)
qc.ry(theta, 1)
qc.measure(0, 0)
qc.x(1).c_if(qc.clbits[0], 1)
qc.measure(1, 0)

tqc = transpile(qc, backend=backend, optimization_level=1)

params = [{theta: float(t)} for t in np.linspace(0, np.pi, 5)]

with Session(service=service, backend=backend) as session:
    sampler = SamplerV2(session=session)
    result = sampler.run([tqc] * len(params), shots=1024, parameter_values=params).result()

for i, r in enumerate(result):
    counts = r.data.meas.get_counts()
    print(f"theta={params[i][theta]:.4f} counts={counts}")
```

---

### Practical notes

- **Backend selection**: The runtime simulator set can differ. The code queries available simulator backends at runtime.
- **Bit semantics**: In this example, both measurements use the same classical bit index (`0`). That’s intentional for a compact demonstration, but many real experiments will use distinct classical bits for clarity.
- **Control wiring**: `c_if` is the standard approach in Qiskit for classically controlled gates after MCM.

---

### Closing thought

Mid-circuit measurement enables conditional logic directly in the circuit, but performance often depends as much on **execution strategy** as on the circuit itself. Using **Qiskit Runtime sessions** is a practical way to streamline batch execution patterns and keep the focus on algorithmic structure.

Qiskit Runtime Session Scheduling For Mid-Circuit Measurement Workflows

### Why this topic matters
In many quantum computing platforms—especially semiconductor spin qubits—the *measurement* step is often the hardest part of the entire stack. A commonly used, experimentally validated approach is **spin-to-charge conversion** using the **Pauli blockade** mechanism. In short: the qubit’s spin state controls whether an electron can tunnel into a nearby energy level, turning “spin information” into an easily measurable “charge signal.”

Pauli blockade is conceptually simple and operationally powerful:
- If the spins form a configuration that is forbidden by Pauli exclusion for tunneling into a particular two-electron state, tunneling is suppressed.
- That suppression changes the resulting charge occupation, which can be detected with a **quantum point contact (QPC)** or **single-electron transistor (SET)**.

### A minimal factual model
A standard measurement model for spin-to-charge conversion is a **binary outcome** conditioned on the initial spin state, with finite readout fidelity:
- Outcome “1” (tunnel occurred / bright) happens with probability \( p_{\uparrow} \) or \( p_{\downarrow} \) depending on whether the initial state is allowed.
- Outcome “0” (tunnel suppressed / dark) happens with the complementary probability.

In experiments, these probabilities are not ideal due to:
- imperfect blockade strength,
- thermal activation,
- tunneling rate competition,
- detector noise and finite bandwidth.

### Simulating expected readout statistics (working code)
Below is a small Python script that simulates repeated measurements under a two-state model, produces a confusion matrix, and estimates the empirical readout fidelity.

```python
# Python 3
# Simulate spin-to-charge readout with Pauli blockade as a noisy binary channel.

import numpy as np

rng = np.random.default_rng(1234)

def simulate_readout(n_shots=50_000, p_bright_if_allowed=0.97, p_bright_if_blocked=0.03, p_init_allowed=0.5):
    """
    - "allowed" corresponds to the spin state that permits tunneling (bright with high probability).
    - "blocked" corresponds to the spin state that triggers Pauli blockade (bright with low probability).
    """
    # Initial state sampling
    init_allowed = rng.random(n_shots) < p_init_allowed  # True => allowed, False => blocked
    
    # Conditional probability of bright outcome
    bright_prob = np.where(init_allowed, p_bright_if_allowed, p_bright_if_blocked)
    
    # Simulate observed outcomes
    observed_bright = rng.random(n_shots) < bright_prob
    
    # Confusion matrix:
    # rows: true (0=blocked, 1=allowed); cols: observed (0=dark, 1=bright)
    # Map:
    true_blocked = ~init_allowed
    true_allowed = init_allowed
    
    tn = np.sum(true_blocked & (~observed_bright))  # true blocked, observed dark
    fp = np.sum(true_blocked & (observed_bright))   # true blocked, observed bright
    fn = np.sum(true_allowed & (~observed_bright))  # true allowed, observed dark
    tp = np.sum(true_allowed & (observed_bright))   # true allowed, observed bright
    
    confusion = np.array([[tn, fp],
                          [fn, tp]], dtype=int)
    
    # Readout fidelity (assuming we label allowed as bright and blocked as dark)
    fidelity = (tp + tn) / n_shots
    
    return confusion, fidelity

confusion, fidelity = simulate_readout()

print("Confusion matrix [[true blocked -> dark, true blocked -> bright], [true allowed -> dark, true allowed -> bright]]:")
print(confusion)
print(f"Estimated readout fidelity: {fidelity:.6f}")
```

#### What the output means
- The **confusion matrix** quantifies how often the detector reports the wrong charge state for a given true spin configuration.
- The estimated **readout fidelity** should be close to the ideal expectation:
  - if you set \(p_{\text{bright|allowed}} \approx 0.97\) and \(p_{\text{bright|blocked}} \approx 0.03\), the fidelity is near \(0.97\) (for allowed→bright) and near \(0.97\) (for blocked→dark), giving roughly \(0.97\) total when priors are balanced.

### Practical interpretation in an experiment
A real spin-to-charge readout pipeline typically includes:
- preparing a known spin state (or mixture),
- bringing two electrons into a regime where tunneling is **allowed only for one spin symmetry**,
- repeatedly sampling a charge detector (QPC/SET) with a fixed integration time,
- assigning a binary result via a threshold or simple maximum-likelihood classifier.

Pauli blockade is favored because it can create a large asymmetry in tunneling rates between the two relevant spin configurations, which improves distinguishability.

### Notes on “perfectly random but factual”
This post focuses on a **known, widely used physical mechanism** (Pauli blockade spin-to-charge conversion) and provides a working computational toy model that is consistent with the usual experimental abstraction: conditional transition probabilities and finite readout fidelity.

Quantum Computing Posts

Qiskit Runtime Session Scheduling For Mid-Circuit Measurement Workflows

Quantum Dot Spin Readout With A Spin-To-Charge Conversion Using Pauli Blockade