Sansqrit quantum DSL by Karthik V with sparse/sharded lookup execution, hierarchical tensor shards, QEC, hardware exports, diagnostics, and packaged AI/ML training datasets.

Navigation

Verified details

These details have been verified by PyPI
Project links
Maintainers
Avatar for sansqrit from gravatar.com sansqrit

Unverified details

These details have not been verified by PyPI
Project links
Meta
  • License Expression: MIT
    SPDX License Expression
  • Author: Karthik V
  • Maintainer: Karthik V
  • Tags quantum , dsl , simulator , sparse , sharding , lookup , stabilizer , qec , surface-code , tensor-network , hierarchical-tensor , mps , qasm , qiskit , braket , cirq , pennylane , education , research , ai-training
  • Requires: Python >=3.10
  • Provides-Extra: dev , qec , tensor , gpu , qiskit , cirq , braket , pennylane , interop , all
Classifiers
Report project as malware

Project description

Sansqrit Quantum DSL

Author / maintainer: Karthik V
Version: 0.3.3
Package: sansqrit
Purpose: a simplified quantum-computing DSL and Python runtime for scientists, AI/ML training datasets, educational quantum-programming examples, sparse/sharded simulation, lookup-accelerated execution, hierarchical tensor shards, QEC, and hardware export workflows.

Sansqrit is designed to make quantum circuits readable:

simulate(120, engine="hierarchical", block_size=10) {
    q = quantum_register(120)
    shard node_0 [0..9]
    shard node_1 [10..19]

    apply H on node_0
    X(q[119])
    apply CNOT on q[9], q[10] bridge_mode=sparse

    print(hierarchical_report())
    print(lookup_profile())
}

It is not a claim that arbitrary dense 120-qubit state-vector simulation is possible on local hardware. Sansqrit supports 120+ logical qubit programs when the circuit remains sparse, Clifford-structured, low-entanglement, or decomposable into independent tensor blocks.

Table of contents

  1. Installation
  2. Quick start
  3. Execution architecture
  4. 120-qubit dense simulation reality
  5. Sparse, sharded, hierarchical and MPS modes
  6. Precomputed lookup files
  7. Distributed computing model
  8. GPU backend
  9. Stabilizer backend
  10. Density/noise backend
  11. Quantum error correction framework
  12. Hardware export: Qiskit, Cirq, Braket, Azure, PennyLane, QASM
  13. Complete DSL syntax
  14. Gate/function reference
  15. Algorithms and high-level helpers
  16. Logging, diagnostics and troubleshooting
  17. AI/ML training usage
  18. Real-world 120+ qubit examples
  19. PyPI upload/release notes
  20. Limitations and safe claims

1. Installation

pip install sansqrit

Optional integrations:

pip install "sansqrit[qiskit]"
pip install "sansqrit[cirq]"
pip install "sansqrit[braket]"
pip install "sansqrit[pennylane]"
pip install "sansqrit[gpu]"
pip install "sansqrit[all]"

Development install:

git clone <your-repo-url>
cd sansqrit
python -m venv .venv
source .venv/bin/activate
python -m pip install -e ".[all,dev]"

2. Quick start

Create bell.sq:

simulate(2, engine="sparse") {
    q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    print(probabilities())
    print(measure_all(shots=10))
}

Run:

sansqrit run bell.sq

Export QASM:

sansqrit qasm bell.sq --version 3 -o bell.qasm

Inspect environment:

sansqrit doctor
sansqrit backends
sansqrit estimate 120
sansqrit architecture
sansqrit troubleshoot lookup
sansqrit hardware

3. Execution architecture

Sansqrit uses a layered runtime:

flowchart TD
    A[Sansqrit .sq DSL] --> B[Translator / Parser]
    B --> C[Circuit History + Runtime Engine]
    C --> D[Optimizer Passes]
    D --> E[Adaptive Planner]
    E -->|Sparse / few amplitudes| F[Sparse State Map]
    E -->|Large sparse| G[Sharded Sparse State]
    E -->|Independent <=10q blocks| H[Hierarchical Tensor Shards]
    E -->|Cross-block low entanglement| I[MPS Bridge]
    E -->|Clifford circuit| J[Stabilizer Tableau]
    E -->|Noisy small circuit| K[Density Matrix]
    E -->|GPU available and dense small| L[CuPy / GPU Statevector]
    E -->|Cluster configured| M[TCP Distributed Sparse Workers]
    F --> N[Lookup Matrices + Sparse Updates]
    G --> N
    H --> O[Packaged 1..10q Embedded Lookups]
    I --> P[Tensor SVD / Bond Update]
    J --> Q[Tableau Update]
    K --> R[Kraus / Noise Channels]
    L --> S[GPU Vector Operations]
    M --> T[Shard Exchange / Coordinator]
    N --> U[Measurement / QASM / Hardware Export]
    O --> U
    P --> U
    Q --> U
    R --> U
    S --> U
    T --> U

Layers

Layer What it does
DSL Human-friendly .sq syntax.
Translator Converts Sansqrit into Python runtime calls.
Circuit history Records operations for export, optimization, verification and profiling.
Optimizer Cancels inverse gates, merges rotations, removes zero rotations.
Planner Recommends sparse, sharded, hierarchical, MPS, stabilizer, density, GPU or distributed mode.
Lookup layer Loads packaged precomputed gates and embedded <=10-qubit transitions.
Sparse map Stores only nonzero amplitudes as {basis_index: amplitude}.
Sharded sparse map Partitions sparse amplitudes into shards for locality and workers.
Hierarchical tensor shards Keeps independent 10-qubit blocks dense and promotes bridge entanglement to MPS.
QEC layer Logical qubits, stabilizer codes, syndrome extraction, decoders and correction.
Hardware export OpenQASM 2/3, Qiskit, Cirq, Braket, Azure payloads and PennyLane callable exports.

4. 120-qubit dense simulation reality

A dense n-qubit state vector contains 2^n amplitudes. A 120-qubit dense vector has:

2^120 ≈ 1.329e36 amplitudes

At complex128 precision, even one full vector is astronomically too large for ordinary hardware. Precomputed lookup, sharding and distributed execution reduce overhead and organize data, but they do not remove exponential dense-state growth.

Sansqrit therefore uses this decision strategy:

Circuit structure Recommended backend
Few active basis states sparse, sharded, threaded
Independent <=10-qubit blocks hierarchical
Low-entanglement chain/grid mps, hierarchical bridge mode
Clifford-only circuit stabilizer
Small noisy circuit density
Small/medium dense circuit with CUDA gpu
Multi-node sparse workloads distributed
Arbitrary dense 120-qubit state Not feasible on normal hardware

5. Sparse, sharded, hierarchical and MPS modes

Sparse mode

simulate(120, engine="sparse") {
    q = quantum_register(120)
    X(q[119])
    H(q[0])
    CNOT(q[0], q[1])
    print(engine_nnz())
}

Sparse mode stores only active amplitudes. It is efficient when the number of nonzero amplitudes stays small.

Sharded sparse mode

simulate(120, engine="sharded", n_shards=16, workers=8) {
    q = quantum_register(120)
    X(q[5])
    X(q[87])
    H(q[0])
    CNOT(q[0], q[1])
    print(shards())
}

Sharding partitions active basis keys. It helps memory locality and distributed layout. It does not blindly split entangled systems into independent sub-simulators.

Hierarchical tensor shards

simulate(120, engine="hierarchical", block_size=10) {
    q = quantum_register(120)
    shard block_0 [0..9]
    shard block_1 [10..19]
    apply H on block_0
    apply X on block_1
    print(hierarchical_report())
}

A 120-qubit register becomes 12 local blocks of 10 qubits. Each local block can be represented by 1024 amplitudes, and precomputed embedded lookup tables can accelerate local static gates.

Bridge entanglement

simulate(120, engine="hierarchical", block_size=10, cutoff=0.0, max_bond_dim=null) {
    q = quantum_register(120)
    H(q[9])
    apply CNOT on q[9], q[10] bridge_mode=sparse
    print(hierarchical_report())
}

A cross-block gate such as CNOT(q[9], q[10]) is not mathematically local to a single 10-qubit block. Sansqrit promotes the model to an MPS bridge so correlations are represented accurately when cutoff=0.0 and max_bond_dim=null.

6. Precomputed lookup files

The package includes real lookup data files:

sansqrit/data/lookup_static_gates.json
sansqrit/data/lookup_two_qubit_static_gates.json
sansqrit/data/lookup_embedded_single_upto_10.json.gz
sansqrit/data/lookup_metadata.json

Runtime lookup policy:

  1. If n <= 10 and the gate is a static single-qubit gate, use embedded full-register transition tables.
  2. Else if the gate is a static single-qubit gate, use the packaged 2x2 matrix.
  3. Else if the gate is a static two-qubit gate, use the packaged 4x4 matrix.
  4. Else compute at runtime and optionally rely on higher-level block/cache optimizations.

Check usage:

simulate(10, engine="sparse", use_lookup=true) {
    q = quantum_register(10)
    H(q[0])
    SX(q[3])
    CNOT(q[0], q[1])
    print(lookup_profile())
}

7. Distributed computing model

Start workers:

sansqrit worker --host 0.0.0.0 --port 8765
sansqrit worker --host 0.0.0.0 --port 8766

Use from Python:

from sansqrit import QuantumEngine
engine = QuantumEngine.create(120, backend="distributed", addresses=[("10.0.0.1", 8765), ("10.0.0.2", 8766)])

The built-in distributed backend is correctness-first. It is useful for sparse shard orchestration and testing. For production HPC, a future backend should add MPI/Ray/Dask, compressed amplitude transfer, worker-local gate kernels and topology-aware shard exchange.

8. GPU backend

pip install "sansqrit[gpu]"

simulate(24, engine="gpu") {
    q = quantum_register(24)
    H(q[0])
    CNOT(q[0], q[1])
    print(measure_all(shots=100))
}

GPU acceleration helps small/medium dense state vectors. It does not make arbitrary dense 120-qubit simulation feasible.

9. Stabilizer backend

simulate(1000, engine="stabilizer") {
    q = quantum_register(1000)
    for i in range(0, 999) {
        H(q[i])
        CNOT(q[i], q[i + 1])
    }
    print(measure_all(shots=5))
}

The stabilizer backend is for Clifford circuits using gates such as H, S, X, Y, Z, CNOT, CZ, and SWAP. It does not support arbitrary non-Clifford rotations as exact tableau operations.

10. Density and noise backend

simulate(3, engine="density") {
    q = quantum_register(3)
    H(q[0])
    CNOT(q[0], q[1])
    noise_bit_flip(q[1], 0.01)
    noise_phase_flip(q[0], 0.01)
    print(probabilities())
}

Noise helpers:

noise_bit_flip(q, p)
noise_phase_flip(q, p)
noise_depolarize(q, p)
noise_amplitude_damping(q, gamma)

Density matrices scale as 4^n, so use this backend for small noisy circuits.

11. Quantum error correction framework

Sansqrit includes a dedicated QEC module.

Supported codes:

bit_flip
phase_flip
repetition3
repetition distance-d
shor9
steane7
five_qubit
surface3
surface distance-d helpers

Core DSL functions:

qec_codes()
qec_code(name, distance=null)
qec_logical(code="bit_flip", base=0, name="logical", distance=null)
qec_encode(logical)
qec_decode(logical)
qec_syndrome(logical, ancilla_base=null)
qec_correct(logical, syndrome)
qec_syndrome_and_correct(logical, ancilla_base=null)
qec_inject_error(logical, pauli, physical_offset)
logical_x(logical)
logical_z(logical)
logical_h(logical)
logical_s(logical)
logical_cx(control, target)
qec_surface_lattice(distance=3)
qec_syndrome_circuit(logical, ancilla_base=null)
qec_optional_features()
qec_stim_syndrome_text(logical, ancilla_base=null)

Bit-flip example:

simulate(6, engine="sparse") {
    q = quantum_register(6)
    logical = qec_logical("bit_flip", base=0)
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    result = qec_syndrome_and_correct(logical, ancilla_base=3)
    print(result)
}

Surface-code helper:

simulate(20, engine="sparse") {
    q = quantum_register(20)
    logical = qec_logical("surface", base=0, distance=3)
    print(logical.stabilizers())
    print(qec_surface_lattice(3).stabilizers())
    print(qec_optional_features())
}

The built-in surface-code decoder is educational/greedy. If pymatching is installed, Sansqrit exposes an integration point for MWPM-style decoding. If stim is installed, the package can emit syndrome-extraction text that can be adapted into Stim workflows.

12. Hardware export

OpenQASM 3

simulate(3, engine="sparse") {
    q = quantum_register(3)
    H(q[0])
    CNOT(q[0], q[1])
    print(export_qasm3())
}

Hardware target summary

simulate(4, engine="sparse") {
    q = quantum_register(4)
    H(q[0])
    CNOT(q[0], q[1])
    print(hardware_targets())
    print(hardware_payload_summary())
    print(export_hardware("azure"))
}

Supported export modes:

Target Export
Qiskit / IBM qiskit.QuantumCircuit or OpenQASM fallback
Cirq cirq.Circuit or OpenQASM fallback
Amazon Braket braket.circuits.Circuit or OpenQASM fallback
Azure Quantum OpenQASM 3 / Qiskit / Cirq payload style
PennyLane Callable quantum function for QNode construction
OpenQASM 2/3 Text export

Sansqrit does not store cloud credentials. Submission to cloud hardware remains controlled by the provider SDK and user account.

13. Complete DSL syntax

Variables

x = 10
y = 3.14
name = "sansqrit"
flag = true
nothing = null

Lists, dictionaries and math

values = [1, 2, 3, 4]
config = {"backend": "sparse", "shots": 1000}
print(sum(values))
print(mean(values))

Functions

fn square(x) {
    return x * x
}

print(square(7))

Lambdas and pipelines

values = [1, 2, 3, 4]
result = values |> map(fn(x) => x * x) |> filter(fn(x) => x > 4)
print(result)

Loops and conditionals

for i in range(0, 10) {
    if i % 2 == 0 {
        print(i)
    } else {
        print("odd")
    }
}

Simulation blocks

simulate(5, engine="sparse") {
    q = quantum_register(5)
    H(q[0])
}

Arguments:

simulate(n_qubits, engine="sparse", n_shards=1, workers=1, seed=null, use_lookup=true, max_bond_dim=null, cutoff=0.0, addresses=null, block_size=10)

Shard declarations

shard block_A [0..9]
apply H on block_A

Bridge gate syntax

apply CNOT on q[9], q[10] bridge_mode=sparse

The translator routes this to the engine while retaining the bridge-mode intention for hierarchical backends.

14. Gate/function reference

Single-qubit gates

I(q)
X(q)
Y(q)
Z(q)
H(q)
S(q)
Sdg(q)
T(q)
Tdg(q)
SX(q)
SXdg(q)
Rx(q, theta)
Ry(q, theta)
Rz(q, theta)
Phase(q, theta)
U1(q, theta)
U2(q, phi, lambda)
U3(q, theta, phi, lambda)

Two-qubit gates

CNOT(c, t)
CX(c, t)
CZ(c, t)
CY(c, t)
CH(c, t)
CSX(c, t)
SWAP(a, b)
iSWAP(a, b)
SqrtSWAP(a, b)
fSWAP(a, b)
DCX(a, b)
CRx(c, t, theta)
CRy(c, t, theta)
CRz(c, t, theta)
CP(c, t, theta)
CU(c, t, theta, phi, lambda)
RXX(a, b, theta)
RYY(a, b, theta)
RZZ(a, b, theta)
RZX(a, b, theta)
ECR(a, b)
MS(a, b)

Three/multi-qubit gates

Toffoli(a, b, c)
CCX(a, b, c)
Fredkin(c, a, b)
CSWAP(c, a, b)
CCZ(a, b, c)
MCX(q0, q1, ..., target)
MCZ(q0, q1, ...)
C3X(a, b, c, target)
C4X(a, b, c, d, target)

Whole-register helpers

H_all(qubits=null)
Rx_all(theta, qubits=null)
Ry_all(theta, qubits=null)
Rz_all(theta, qubits=null)
qft(q=null)
iqft(q=null)
measure(q)
measure_all(q=null, shots=1)
probabilities(q=null)
expectation_z(q)
expectation_zz(a, b)
engine_nnz()
shards()
lookup_profile()
hierarchical_report()

File/data helpers

read_file(path)
write_file(path, text)
read_json(path)
write_json(path, obj)
read_csv(path)
write_csv(path, rows)

Diagnostics and architecture helpers

sansqrit_doctor()
sansqrit_backends()
estimate_qubits(n_qubits)
execution_flow()
architecture_layers()
lookup_architecture()
explain_120_qubits_dense()
troubleshooting(topic=null)
research_gaps()
enable_logging(level="INFO", path=null)
log_sansqrit_event(event, fields={})

15. Algorithms and high-level helpers

grover_search
grover_search_multi
shor_factor
vqe_h2
qaoa_maxcut
quantum_phase_estimation
hhl_solve
bernstein_vazirani
simon_algorithm
deutsch_jozsa
quantum_counting
swap_test
teleport
superdense_coding
bb84_qkd
amplitude_estimation
variational_classifier

16. Logging, diagnostics and troubleshooting

enable_logging("INFO", "sansqrit.log")
log_sansqrit_event("start", {"program": "sparse_120"})
print(sansqrit_doctor())
print(sansqrit_backends())
print(troubleshooting("lookup"))

CLI:

sansqrit doctor
sansqrit backends
sansqrit estimate 120
sansqrit troubleshoot distributed
sansqrit architecture
sansqrit hardware

17. AI/ML training usage

Sansqrit ships examples and docs inside the wheel so AI tools can inspect them after installation.

from sansqrit.dataset import builtin_training_records, generate_jsonl
records = builtin_training_records()
generate_jsonl("sansqrit_training.jsonl", records)

Training task types:

Task Input Output
DSL generation Natural language algorithm request .sq program
DSL correction Buggy .sq Corrected .sq
DSL-to-QASM .sq program OpenQASM 2/3
Backend planning Circuit description Recommended backend + explanation
QEC explanation Error model + code Syndrome/correction flow
Hardware export Sansqrit circuit Provider payload/QASM

18. Real-world 120+ qubit example themes

The package includes 300+ examples. New high-qubit examples cover:

  • Climate sensor anomaly encoding
  • Supply-chain route optimization
  • Finance portfolio risk flags
  • Cybersecurity graph threat propagation
  • Telecom network routing
  • Drug-discovery feature maps
  • QEC satellite link protection
  • Smart-grid sparse fault localization
  • Port logistics
  • Aerospace sensor fusion
  • 1000-qubit Clifford/stabilizer workflows

Run:

sansqrit run examples/278_climate_128q_sparse_sensors.sq
sansqrit run examples/283_hierarchical_120q_bridge_iot.sq
sansqrit run examples/300_city_1000q_stabilizer_graph.sq

19. PyPI release notes

Build:

python -m pip install --upgrade build twine
rm -rf build dist *.egg-info src/*.egg-info
python -m build --sdist --wheel
python -m twine check dist/*
python -m twine upload dist/*

If version 0.3.3 is already uploaded to PyPI, PyPI will reject another upload with the same version. In that case, bump to 0.3.4 or later.

20. Limitations and safe claims

Safe claim:

Sansqrit supports 120+ logical qubit programs using sparse, sharded, lookup-accelerated, stabilizer, MPS, hierarchical tensor, density-matrix, GPU and distributed backends when the circuit has exploitable structure.

Unsafe claim:

Sansqrit can simulate any arbitrary dense 120-qubit quantum state on local hardware.

That is not physically realistic.

License

MIT.

Packaged AI/ML Synthetic Training Dataset

Sansqrit v0.3.4 embeds a compressed synthetic dataset directly inside the Python wheel so model-training pipelines can discover and consume examples without separately downloading a corpus.

Dataset location inside the package

After installation, the data files are packaged under:

sansqrit/data/training/
  manifest.json
  README.md
  sansqrit_sft_train_v1.jsonl.gz
  sansqrit_sft_eval_v1.jsonl.gz
  sansqrit_preference_v1.jsonl.gz

The dataset is also accessible through the Python API and CLI, so downstream tools do not need to know the installed filesystem path.

Dataset size and purpose

The embedded corpus contains 36,100 synthetic records:

Split Records Purpose
sft_train 29,600 supervised fine-tuning / instruction tuning
sft_eval 1,500 held-out evaluation prompts
preference 5,000 DPO / preference training with chosen and rejected answers

Covered topics include:

  • Sansqrit DSL syntax and idioms
  • gate-level circuit construction
  • parameterized gates
  • algorithms such as Bell, GHZ, QFT, Grover, QAOA, VQE, BB84, and teleportation
  • sparse/sharded execution
  • hierarchical 10-qubit tensor shards with MPS bridge promotion
  • precomputed lookup acceleration
  • 120+ qubit safe simulation patterns
  • backend selection and memory estimation
  • QEC: bit-flip, phase-flip, repetition, Shor9, Steane7, five-qubit, and surface-code workflows
  • hardware exports for OpenQASM, Qiskit, Cirq, Braket, Azure, IBM-style payloads, and PennyLane
  • troubleshooting, bug fixing, and architecture explanations

Dataset schema

SFT records

Each sft_train and sft_eval row is JSONL with:

{
  "id": "sqt_...",
  "dataset": "sansqrit-synthetic-training-v1",
  "schema": "instruction-input-output-v1",
  "language": "sansqrit",
  "task_type": "code_generation",
  "instruction": "Write a Sansqrit program...",
  "input": "optional input text",
  "output": "target answer or code",
  "tags": ["qec", "120q"],
  "difficulty": "hard",
  "split": "train",
  "source": "synthetic-v1",
  "author": "Karthik V",
  "license": "MIT"
}

Preference records

The preference split uses:

{
  "id": "sqp_...",
  "schema": "preference-v1",
  "prompt": "Write a safe 120-qubit Sansqrit program.",
  "chosen": "accurate answer",
  "rejected": "unsafe or incorrect answer"
}

Use this split for DPO-style training or reward-model experiments.

Python API

from sansqrit.dataset import dataset_info, available_splits, load_training_records

print(dataset_info())
print(available_splits())

for row in load_training_records("sft_train", limit=3):
    print(row["instruction"])
    print(row["output"])

Export all packaged data to plain JSONL:

from sansqrit.dataset import export_dataset

export_dataset("./sansqrit-training-export")

CLI usage

sansqrit dataset info
sansqrit dataset splits
sansqrit dataset sample --split sft_train -n 5
sansqrit dataset sample --split preference -n 3
sansqrit dataset export --output ./sansqrit-training-export

DSL helpers

Inside Sansqrit code, use:

print(training_dataset_info())
print(training_dataset_sample("sft_train", 2))
export_training_dataset("./exported_dataset", "sft_train", 100)

Model-training recommendations

For general code generation, train on sft_train and evaluate on sft_eval.

For preference alignment, use the preference split where chosen demonstrates safer and more accurate Sansqrit behavior than rejected.

Recommended task mixtures:

60% code generation
15% code explanation
10% troubleshooting / bug fixing
10% architecture / backend selection
5% hardware export / QEC special tasks

For retrieval-augmented generation, index:

README.md
docs/*.md
sansqrit/data/training/*.jsonl.gz
examples/*.sq

Important limitation: the dataset is synthetic. It is useful for model bootstrapping and instruction tuning, but production models should also be trained or evaluated on human-reviewed prompts, real user traces, verified QASM exports, and simulator cross-checks.

v0.3.4 Real-World Scenario Training Corpus

Sansqrit now embeds a 500-record real-world scenario corpus authored by Karthik V. It is designed for AI/ML model training so models can learn to answer user prompts with valid Sansqrit code, backend reasoning, safety notes, and troubleshooting guidance.

Packaged resources:

sansqrit/data/training/sansqrit_real_world_scenarios_v1.jsonl.gz
examples/301_scenario_...sq through examples/800_scenario_...sq
docs/REAL_WORLD_SCENARIO_CORPUS.md

CLI usage:

sansqrit scenarios info
sansqrit scenarios sample -n 5 --domain smart_grid
sansqrit scenarios export --output scenarios.jsonl --limit 500
sansqrit dataset sample --split real_world_scenarios -n 3

Python usage:

from sansqrit.scenarios import scenario_info, load_scenarios
print(scenario_info())
for row in load_scenarios(limit=3):
    print(row["question"])
    print(row["sansqrit_code"])

The scenario set covers climate, energy, finance, cybersecurity, logistics, healthcare, genomics, materials, drug discovery, telecom, quantum networking, post-quantum cryptography migration, quantum error correction, hardware export, and 120+ qubit sparse/tensor/stabilizer workflows.

Important modeling lesson: for 120+ qubit examples, Sansqrit teaches AI models to select sparse/sharded, hierarchical tensor shards, MPS, stabilizer, or QEC strategies instead of falsely claiming arbitrary dense state-vector simulation is feasible.

Complete Sansqrit Example Program Corpus

This section intentionally embeds every .sq example program that ships with the package. It is included directly in the README so package crawlers, documentation systems, and AI/ML training pipelines can discover high-quality Sansqrit syntax, backend selection patterns, large-qubit safe examples, QEC workflows, hardware export patterns, diagnostics, and real-world scenario templates without needing to execute the package.

Total programs embedded below: 800.

The same files are also included under examples/ in the source distribution and under sansqrit/examples/ inside the installed package.

Program index

  1. 001_bell_state.sq — 001 bell state
  2. 002_ghz_chain_8.sq — 002 ghz chain 8
  3. 003_qft_three_qubits.sq — 003 qft three qubits
  4. 004_inverse_qft_roundtrip.sq — 004 inverse qft roundtrip
  5. 005_sharded_bell.sq — 005 sharded bell
  6. 006_threaded_superposition.sq — 006 threaded superposition
  7. 007_lookup_sx_inverse.sq — 007 lookup sx inverse
  8. 008_toffoli_adder_bit.sq — 008 toffoli adder bit
  9. 009_fredkin_swap.sq — 009 fredkin swap
  10. 010_rzz_entangler.sq — 010 rzz entangler
  11. 011_ms_gate.sq — 011 ms gate
  12. 012_qasm_export.sq — 012 qasm export
  13. 013_pipeline_statistics.sq — 013 pipeline statistics
  14. 014_classical_function.sq — 014 classical function
  15. 015_json_csv_io.sq — 015 json csv io
  16. 016_grover_search.sq — 016 grover search
  17. 017_grover_multi.sq — 017 grover multi
  18. 018_bernstein_vazirani.sq — 018 bernstein vazirani
  19. 019_deutsch_jozsa_balanced.sq — 019 deutsch jozsa balanced
  20. 020_deutsch_jozsa_constant.sq — 020 deutsch jozsa constant
  21. 021_qaoa_triangle.sq — 021 qaoa triangle
  22. 022_qaoa_square.sq — 022 qaoa square
  23. 023_vqe_h2.sq — 023 vqe h2
  24. 024_phase_estimation.sq — 024 phase estimation
  25. 025_hhl_2x2.sq — 025 hhl 2x2
  26. 026_teleport_one.sq — 026 teleport one
  27. 027_superdense_coding.sq — 027 superdense coding
  28. 028_bb84_qkd.sq — 028 bb84 qkd
  29. 029_bb84_with_eavesdropper.sq — 029 bb84 with eavesdropper
  30. 030_shor_factor_15.sq — 030 shor factor 15
  31. 031_amplitude_estimation.sq — 031 amplitude estimation
  32. 032_quantum_counting.sq — 032 quantum counting
  33. 033_variational_classifier.sq — 033 variational classifier
  34. 034_variational_pattern_34.sq — 034 variational pattern 34
  35. 035_variational_pattern_35.sq — 035 variational pattern 35
  36. 036_variational_pattern_36.sq — 036 variational pattern 36
  37. 037_variational_pattern_37.sq — 037 variational pattern 37
  38. 038_variational_pattern_38.sq — 038 variational pattern 38
  39. 039_variational_pattern_39.sq — 039 variational pattern 39
  40. 040_variational_pattern_40.sq — 040 variational pattern 40
  41. 041_variational_pattern_41.sq — 041 variational pattern 41
  42. 042_variational_pattern_42.sq — 042 variational pattern 42
  43. 043_variational_pattern_43.sq — 043 variational pattern 43
  44. 044_variational_pattern_44.sq — 044 variational pattern 44
  45. 045_variational_pattern_45.sq — 045 variational pattern 45
  46. 046_variational_pattern_46.sq — 046 variational pattern 46
  47. 047_variational_pattern_47.sq — 047 variational pattern 47
  48. 048_variational_pattern_48.sq — 048 variational pattern 48
  49. 049_variational_pattern_49.sq — 049 variational pattern 49
  50. 050_variational_pattern_50.sq — 050 variational pattern 50
  51. 051_variational_pattern_51.sq — 051 variational pattern 51
  52. 052_variational_pattern_52.sq — 052 variational pattern 52
  53. 053_variational_pattern_53.sq — 053 variational pattern 53
  54. 054_variational_pattern_54.sq — 054 variational pattern 54
  55. 055_variational_pattern_55.sq — 055 variational pattern 55
  56. 056_variational_pattern_56.sq — 056 variational pattern 56
  57. 057_variational_pattern_57.sq — 057 variational pattern 57
  58. 058_variational_pattern_58.sq — 058 variational pattern 58
  59. 059_variational_pattern_59.sq — 059 variational pattern 59
  60. 060_variational_pattern_60.sq — 060 variational pattern 60
  61. 061_variational_pattern_61.sq — 061 variational pattern 61
  62. 062_variational_pattern_62.sq — 062 variational pattern 62
  63. 063_variational_pattern_63.sq — 063 variational pattern 63
  64. 064_variational_pattern_64.sq — 064 variational pattern 64
  65. 065_variational_pattern_65.sq — 065 variational pattern 65
  66. 066_variational_pattern_66.sq — 066 variational pattern 66
  67. 067_variational_pattern_67.sq — 067 variational pattern 67
  68. 068_variational_pattern_68.sq — 068 variational pattern 68
  69. 069_variational_pattern_69.sq — 069 variational pattern 69
  70. 070_variational_pattern_70.sq — 070 variational pattern 70
  71. 071_phase_kickback.sq — 071 phase kickback
  72. 072_hidden_shift.sq — 072 hidden shift
  73. 073_qft_phase_grid.sq — 073 qft phase grid
  74. 074_entangled_ladder.sq — 074 entangled ladder
  75. 075_hardware_efficient_ansatz.sq — 075 hardware efficient ansatz
  76. 076_maxcut_ansatz.sq — 076 maxcut ansatz
  77. 077_qml_feature_map.sq — 077 qml feature map
  78. 078_controlled_rotation_bank.sq — 078 controlled rotation bank
  79. 079_multi_control_demo.sq — 079 multi control demo
  80. 080_sparse_large_index.sq — 080 sparse large index
  81. 081_phase_kickback.sq — 081 phase kickback
  82. 082_hidden_shift.sq — 082 hidden shift
  83. 083_qft_phase_grid.sq — 083 qft phase grid
  84. 084_entangled_ladder.sq — 084 entangled ladder
  85. 085_hardware_efficient_ansatz.sq — 085 hardware efficient ansatz
  86. 086_maxcut_ansatz.sq — 086 maxcut ansatz
  87. 087_qml_feature_map.sq — 087 qml feature map
  88. 088_controlled_rotation_bank.sq — 088 controlled rotation bank
  89. 089_multi_control_demo.sq — 089 multi control demo
  90. 090_sparse_large_index.sq — 090 sparse large index
  91. 091_phase_kickback.sq — 091 phase kickback
  92. 092_hidden_shift.sq — 092 hidden shift
  93. 093_qft_phase_grid.sq — 093 qft phase grid
  94. 094_entangled_ladder.sq — 094 entangled ladder
  95. 095_hardware_efficient_ansatz.sq — 095 hardware efficient ansatz
  96. 096_maxcut_ansatz.sq — 096 maxcut ansatz
  97. 097_qml_feature_map.sq — 097 qml feature map
  98. 098_controlled_rotation_bank.sq — 098 controlled rotation bank
  99. 099_multi_control_demo.sq — 099 multi control demo
  100. 100_sparse_large_index.sq — 100 sparse large index
  101. 101_stabilizer_ghz_1000.sq — 101 stabilizer ghz 1000
  102. 102_mps_low_entanglement_chain.sq — 102 mps low entanglement chain
  103. 103_density_depolarizing_noise.sq — 103 density depolarizing noise
  104. 104_density_amplitude_damping.sq — 104 density amplitude damping
  105. 105_hybrid_backend_selection.sq — 105 hybrid backend selection
  106. 106_optimizer_cancel_rotations.sq — 106 optimizer cancel rotations
  107. 107_gpu_backend_small.sq — 107 gpu backend small
  108. 108_qiskit_interop_reference.sq — 108 qiskit interop reference
  109. 109_large_sparse_150_qubits.sq — 109 large sparse 150 qubits
  110. 110_mps_qft_lite.sq — 110 mps qft lite
  111. 111_150q_sensor_fusion_111.sq — 111 150q sensor fusion 111
  112. 112_150q_satellite_telemetry_112.sq — 112 150q satellite telemetry 112
  113. 113_150q_network_intrusion_113.sq — 113 150q network intrusion 113
  114. 114_150q_portfolio_risk_114.sq — 114 150q portfolio risk 114
  115. 115_150q_drug_screening_115.sq — 115 150q drug screening 115
  116. 116_150q_battery_material_116.sq — 116 150q battery material 116
  117. 117_150q_smart_grid_117.sq — 117 150q smart grid 117
  118. 118_150q_robotics_path_118.sq — 118 150q robotics path 118
  119. 119_150q_climate_event_119.sq — 119 150q climate event 119
  120. 120_150q_factory_quality_120.sq — 120 150q factory quality 120
  121. 121_150q_traffic_routing_121.sq — 121 150q traffic routing 121
  122. 122_150q_fraud_detection_122.sq — 122 150q fraud detection 122
  123. 123_150q_genomics_variant_123.sq — 123 150q genomics variant 123
  124. 124_150q_seismic_monitor_124.sq — 124 150q seismic monitor 124
  125. 125_150q_iot_edge_125.sq — 125 150q iot edge 125
  126. 126_150q_cyber_key_health_126.sq — 126 150q cyber key health 126
  127. 127_150q_medical_triage_127.sq — 127 150q medical triage 127
  128. 128_150q_supply_chain_128.sq — 128 150q supply chain 128
  129. 129_150q_water_network_129.sq — 129 150q water network 129
  130. 130_150q_energy_market_130.sq — 130 150q energy market 130
  131. 131_150q_sensor_fusion_131.sq — 131 150q sensor fusion 131
  132. 132_150q_satellite_telemetry_132.sq — 132 150q satellite telemetry 132
  133. 133_150q_network_intrusion_133.sq — 133 150q network intrusion 133
  134. 134_150q_portfolio_risk_134.sq — 134 150q portfolio risk 134
  135. 135_150q_drug_screening_135.sq — 135 150q drug screening 135
  136. 136_150q_battery_material_136.sq — 136 150q battery material 136
  137. 137_150q_smart_grid_137.sq — 137 150q smart grid 137
  138. 138_150q_robotics_path_138.sq — 138 150q robotics path 138
  139. 139_150q_climate_event_139.sq — 139 150q climate event 139
  140. 140_150q_factory_quality_140.sq — 140 150q factory quality 140
  141. 141_stabilizer_clifford_comm_141.sq — 141 stabilizer clifford comm 141
  142. 142_stabilizer_graph_state_142.sq — 142 stabilizer graph state 142
  143. 143_stabilizer_cluster_state_143.sq — 143 stabilizer cluster state 143
  144. 144_stabilizer_parity_monitor_144.sq — 144 stabilizer parity monitor 144
  145. 145_stabilizer_surface_code_syndrome_145.sq — 145 stabilizer surface code syndrome 145
  146. 146_stabilizer_clifford_comm_146.sq — 146 stabilizer clifford comm 146
  147. 147_stabilizer_graph_state_147.sq — 147 stabilizer graph state 147
  148. 148_stabilizer_cluster_state_148.sq — 148 stabilizer cluster state 148
  149. 149_stabilizer_parity_monitor_149.sq — 149 stabilizer parity monitor 149
  150. 150_stabilizer_surface_code_syndrome_150.sq — 150 stabilizer surface code syndrome 150
  151. 151_stabilizer_clifford_comm_151.sq — 151 stabilizer clifford comm 151
  152. 152_stabilizer_graph_state_152.sq — 152 stabilizer graph state 152
  153. 153_stabilizer_cluster_state_153.sq — 153 stabilizer cluster state 153
  154. 154_stabilizer_parity_monitor_154.sq — 154 stabilizer parity monitor 154
  155. 155_stabilizer_surface_code_syndrome_155.sq — 155 stabilizer surface code syndrome 155
  156. 156_stabilizer_clifford_comm_156.sq — 156 stabilizer clifford comm 156
  157. 157_stabilizer_graph_state_157.sq — 157 stabilizer graph state 157
  158. 158_stabilizer_cluster_state_158.sq — 158 stabilizer cluster state 158
  159. 159_stabilizer_parity_monitor_159.sq — 159 stabilizer parity monitor 159
  160. 160_stabilizer_surface_code_syndrome_160.sq — 160 stabilizer surface code syndrome 160
  161. 161_stabilizer_clifford_comm_161.sq — 161 stabilizer clifford comm 161
  162. 162_stabilizer_graph_state_162.sq — 162 stabilizer graph state 162
  163. 163_stabilizer_cluster_state_163.sq — 163 stabilizer cluster state 163
  164. 164_stabilizer_parity_monitor_164.sq — 164 stabilizer parity monitor 164
  165. 165_stabilizer_surface_code_syndrome_165.sq — 165 stabilizer surface code syndrome 165
  166. 166_mps_adiabatic_line_166.sq — 166 mps adiabatic line 166
  167. 167_mps_qft_lite_167.sq — 167 mps qft lite 167
  168. 168_mps_bond_dimension_probe_168.sq — 168 mps bond dimension probe 168
  169. 169_mps_matrix_product_feature_map_169.sq — 169 mps matrix product feature map 169
  170. 170_mps_spin_chain_170.sq — 170 mps spin chain 170
  171. 171_mps_adiabatic_line_171.sq — 171 mps adiabatic line 171
  172. 172_mps_qft_lite_172.sq — 172 mps qft lite 172
  173. 173_mps_bond_dimension_probe_173.sq — 173 mps bond dimension probe 173
  174. 174_mps_matrix_product_feature_map_174.sq — 174 mps matrix product feature map 174
  175. 175_mps_spin_chain_175.sq — 175 mps spin chain 175
  176. 176_mps_adiabatic_line_176.sq — 176 mps adiabatic line 176
  177. 177_mps_qft_lite_177.sq — 177 mps qft lite 177
  178. 178_mps_bond_dimension_probe_178.sq — 178 mps bond dimension probe 178
  179. 179_mps_matrix_product_feature_map_179.sq — 179 mps matrix product feature map 179
  180. 180_mps_spin_chain_180.sq — 180 mps spin chain 180
  181. 181_mps_adiabatic_line_181.sq — 181 mps adiabatic line 181
  182. 182_mps_qft_lite_182.sq — 182 mps qft lite 182
  183. 183_mps_bond_dimension_probe_183.sq — 183 mps bond dimension probe 183
  184. 184_mps_matrix_product_feature_map_184.sq — 184 mps matrix product feature map 184
  185. 185_mps_spin_chain_185.sq — 185 mps spin chain 185
  186. 186_mps_adiabatic_line_186.sq — 186 mps adiabatic line 186
  187. 187_mps_qft_lite_187.sq — 187 mps qft lite 187
  188. 188_mps_bond_dimension_probe_188.sq — 188 mps bond dimension probe 188
  189. 189_mps_matrix_product_feature_map_189.sq — 189 mps matrix product feature map 189
  190. 190_mps_spin_chain_190.sq — 190 mps spin chain 190
  191. 191_noise_readout_channel_191.sq — 191 noise readout channel 191
  192. 192_noise_amplitude_decay_192.sq — 192 noise amplitude decay 192
  193. 193_noise_phase_noise_193.sq — 193 noise phase noise 193
  194. 194_noise_depolarizing_benchmark_194.sq — 194 noise depolarizing benchmark 194
  195. 195_noise_noisy_bell_195.sq — 195 noise noisy bell 195
  196. 196_noise_readout_channel_196.sq — 196 noise readout channel 196
  197. 197_noise_amplitude_decay_197.sq — 197 noise amplitude decay 197
  198. 198_noise_phase_noise_198.sq — 198 noise phase noise 198
  199. 199_noise_depolarizing_benchmark_199.sq — 199 noise depolarizing benchmark 199
  200. 200_noise_noisy_bell_200.sq — 200 noise noisy bell 200
  201. 201_noise_readout_channel_201.sq — 201 noise readout channel 201
  202. 202_noise_amplitude_decay_202.sq — 202 noise amplitude decay 202
  203. 203_noise_phase_noise_203.sq — 203 noise phase noise 203
  204. 204_noise_depolarizing_benchmark_204.sq — 204 noise depolarizing benchmark 204
  205. 205_noise_noisy_bell_205.sq — 205 noise noisy bell 205
  206. 206_noise_readout_channel_206.sq — 206 noise readout channel 206
  207. 207_noise_amplitude_decay_207.sq — 207 noise amplitude decay 207
  208. 208_noise_phase_noise_208.sq — 208 noise phase noise 208
  209. 209_noise_depolarizing_benchmark_209.sq — 209 noise depolarizing benchmark 209
  210. 210_noise_noisy_bell_210.sq — 210 noise noisy bell 210
  211. 211_algorithm_grover_cyber_signature_211.sq — 211 algorithm grover cyber signature 211
  212. 212_algorithm_qaoa_logistics_triangle_212.sq — 212 algorithm qaoa logistics triangle 212
  213. 213_algorithm_vqe_molecule_scan_213.sq — 213 algorithm vqe molecule scan 213
  214. 214_algorithm_phase_estimation_sensor_214.sq — 214 algorithm phase estimation sensor 214
  215. 215_algorithm_hhl_toy_linear_system_215.sq — 215 algorithm hhl toy linear system 215
  216. 216_algorithm_bernstein_vazirani_secret_216.sq — 216 algorithm bernstein vazirani secret 216
  217. 217_algorithm_deutsch_jozsa_balanced_217.sq — 217 algorithm deutsch jozsa balanced 217
  218. 218_algorithm_quantum_counting_inventory_218.sq — 218 algorithm quantum counting inventory 218
  219. 219_algorithm_amplitude_estimation_risk_219.sq — 219 algorithm amplitude estimation risk 219
  220. 220_algorithm_bb84_key_distribution_220.sq — 220 algorithm bb84 key distribution 220
  221. 221_algorithm_grover_cyber_signature_221.sq — 221 algorithm grover cyber signature 221
  222. 222_algorithm_qaoa_logistics_triangle_222.sq — 222 algorithm qaoa logistics triangle 222
  223. 223_algorithm_vqe_molecule_scan_223.sq — 223 algorithm vqe molecule scan 223
  224. 224_algorithm_phase_estimation_sensor_224.sq — 224 algorithm phase estimation sensor 224
  225. 225_algorithm_hhl_toy_linear_system_225.sq — 225 algorithm hhl toy linear system 225
  226. 226_algorithm_bernstein_vazirani_secret_226.sq — 226 algorithm bernstein vazirani secret 226
  227. 227_algorithm_deutsch_jozsa_balanced_227.sq — 227 algorithm deutsch jozsa balanced 227
  228. 228_algorithm_quantum_counting_inventory_228.sq — 228 algorithm quantum counting inventory 228
  229. 229_algorithm_amplitude_estimation_risk_229.sq — 229 algorithm amplitude estimation risk 229
  230. 230_algorithm_bb84_key_distribution_230.sq — 230 algorithm bb84 key distribution 230
  231. 231_qml_feature_map_231.sq — 231 qml feature map 231
  232. 232_qml_feature_map_232.sq — 232 qml feature map 232
  233. 233_qml_feature_map_233.sq — 233 qml feature map 233
  234. 234_qml_feature_map_234.sq — 234 qml feature map 234
  235. 235_qml_feature_map_235.sq — 235 qml feature map 235
  236. 236_qml_feature_map_236.sq — 236 qml feature map 236
  237. 237_qml_feature_map_237.sq — 237 qml feature map 237
  238. 238_qml_feature_map_238.sq — 238 qml feature map 238
  239. 239_qml_feature_map_239.sq — 239 qml feature map 239
  240. 240_qml_feature_map_240.sq — 240 qml feature map 240
  241. 241_qasm3_export_climate_circuit.sq — 241 qasm3 export climate circuit
  242. 242_qasm2_export_network_circuit.sq — 242 qasm2 export network circuit
  243. 243_distributed_cluster_template.sq — 243 distributed cluster template
  244. 244_gpu_cuda_template.sq — 244 gpu cuda template
  245. 245_hybrid_backend_template.sq — 245 hybrid backend template
  246. 246_formal_verification_qasm_reference.sq — 246 formal verification qasm reference
  247. 247_optimizer_cancel_pairs.sq — 247 optimizer cancel pairs
  248. 248_ai_training_minimal_pair.sq — 248 ai training minimal pair
  249. 249_large_sparse_oracle_150q.sq — 249 large sparse oracle 150q
  250. 250_large_stabilizer_4096q.sq — 250 large stabilizer 4096q
  251. 251_precomputed_lookup_10q.sq — 251 precomputed lookup 10q
  252. 252_lookup_vs_sparse_150q.sq — 252 lookup vs sparse 150q
  253. 253_qec_bit_flip_correct.sq — 253 qec bit flip correct
  254. 254_qec_phase_flip_correct.sq — 254 qec phase flip correct
  255. 255_qec_repetition5_layout.sq — 255 qec repetition5 layout
  256. 256_qec_shor9_encode.sq — 256 qec shor9 encode
  257. 257_qec_steane7_syndrome_circuit.sq — 257 qec steane7 syndrome circuit
  258. 258_qec_five_qubit_lookup_decoder.sq — 258 qec five qubit lookup decoder
  259. 259_qec_surface3_lattice.sq — 259 qec surface3 lattice
  260. 260_qec_surface3_code.sq — 260 qec surface3 code
  261. 261_qec_logical_cnot_bitflip.sq — 261 qec logical cnot bitflip
  262. 262_qec_noise_density_bitflip.sq — 262 qec noise density bitflip
  263. 263_qec_codes_index.sq — 263 qec codes index
  264. 264_auto_backend_plan_120q.sq — 264 auto backend plan 120q
  265. 265_lookup_profile_10q.sq — 265 lookup profile 10q
  266. 266_qec_stabilizer_syndrome_terms.sq — 266 qec stabilizer syndrome terms
  267. 267_qec_repetition7_terms.sq — 267 qec repetition7 terms
  268. 268_qec_surface5_metadata.sq — 268 qec surface5 metadata
  269. 269_qec_bitflip_manual_syndrome.sq — 269 qec bitflip manual syndrome
  270. 270_qec_logical_gates.sq — 270 qec logical gates
  271. 271_qec_shor9_terms.sq — 271 qec shor9 terms
  272. 272_qec_steane7_terms.sq — 272 qec steane7 terms
  273. 273_qec_five_qubit_terms.sq — 273 qec five qubit terms
  274. 274_qec_surface_decoder_interface.sq — 274 qec surface decoder interface
  275. 275_qec_ai_training_record.sq — 275 qec ai training record
  276. 276_hierarchical_120q_local_blocks.sq — 276 hierarchical 120q local blocks
  277. 277_hierarchical_120q_bridge_mps.sq — 277 hierarchical 120q bridge mps
  278. 278_climate_128q_sparse_sensors.sq — 278 climate 128q sparse sensors
  279. 279_supply_chain_160q_route_flags.sq — 279 supply chain 160q route flags
  280. 280_finance_128q_portfolio_sparse_risk.sq — 280 finance 128q portfolio sparse risk
  281. 281_cyber_144q_stabilizer_threat_graph.sq — 281 cyber 144q stabilizer threat graph
  282. 282_telecom_130q_hierarchical_blocks.sq — 282 telecom 130q hierarchical blocks
  283. 283_hierarchical_120q_bridge_iot.sq — 283 hierarchical 120q bridge iot
  284. 284_drug_discovery_124q_mps_feature_map.sq — 284 drug discovery 124q mps feature map
  285. 285_satellite_132q_qec_link.sq — 285 satellite 132q qec link
  286. 286_hardware_export_121q_openqasm3.sq — 286 hardware export 121q openqasm3
  287. 287_distributed_120q_readiness_report.sq — 287 distributed 120q readiness report
  288. 288_troubleshooting_lookup_profile.sq — 288 troubleshooting lookup profile
  289. 289_ai_training_dataset_record.sq — 289 ai training dataset record
  290. 290_surface_code_121q_control_register.sq — 290 surface code 121q control register
  291. 291_robotics_150q_sparse_path_flags.sq — 291 robotics 150q sparse path flags
  292. 292_power_grid_150q_fault_localization.sq — 292 power grid 150q fault localization
  293. 293_port_logistics_150q_hierarchical_yards.sq — 293 port logistics 150q hierarchical yards
  294. 294_qkd_128q_stabilizer_network.sq — 294 qkd 128q stabilizer network
  295. 295_aerospace_140q_sensor_fusion.sq — 295 aerospace 140q sensor fusion
  296. 296_lookup_profile_10q_block_kernel.sq — 296 lookup profile 10q block kernel
  297. 297_openqasm2_3_export_122q.sq — 297 openqasm2 3 export 122q
  298. 298_azure_payload_123q_sparse.sq — 298 azure payload 123q sparse
  299. 299_pennylane_export_124q_fallback.sq — 299 pennylane export 124q fallback
  300. 300_city_1000q_stabilizer_graph.sq — 300 city 1000q stabilizer graph
  301. 301_scenario_climate_risk_01.sq — 301 scenario climate risk 01
  302. 302_scenario_climate_risk_02.sq — 302 scenario climate risk 02
  303. 303_scenario_climate_risk_03.sq — 303 scenario climate risk 03
  304. 304_scenario_climate_risk_04.sq — 304 scenario climate risk 04
  305. 305_scenario_climate_risk_05.sq — 305 scenario climate risk 05
  306. 306_scenario_climate_risk_06.sq — 306 scenario climate risk 06
  307. 307_scenario_climate_risk_07.sq — 307 scenario climate risk 07
  308. 308_scenario_climate_risk_08.sq — 308 scenario climate risk 08
  309. 309_scenario_climate_risk_09.sq — 309 scenario climate risk 09
  310. 310_scenario_climate_risk_10.sq — 310 scenario climate risk 10
  311. 311_scenario_climate_risk_11.sq — 311 scenario climate risk 11
  312. 312_scenario_climate_risk_12.sq — 312 scenario climate risk 12
  313. 313_scenario_climate_risk_13.sq — 313 scenario climate risk 13
  314. 314_scenario_climate_risk_14.sq — 314 scenario climate risk 14
  315. 315_scenario_climate_risk_15.sq — 315 scenario climate risk 15
  316. 316_scenario_climate_risk_16.sq — 316 scenario climate risk 16
  317. 317_scenario_climate_risk_17.sq — 317 scenario climate risk 17
  318. 318_scenario_climate_risk_18.sq — 318 scenario climate risk 18
  319. 319_scenario_climate_risk_19.sq — 319 scenario climate risk 19
  320. 320_scenario_climate_risk_20.sq — 320 scenario climate risk 20
  321. 321_scenario_smart_grid_01.sq — 321 scenario smart grid 01
  322. 322_scenario_smart_grid_02.sq — 322 scenario smart grid 02
  323. 323_scenario_smart_grid_03.sq — 323 scenario smart grid 03
  324. 324_scenario_smart_grid_04.sq — 324 scenario smart grid 04
  325. 325_scenario_smart_grid_05.sq — 325 scenario smart grid 05
  326. 326_scenario_smart_grid_06.sq — 326 scenario smart grid 06
  327. 327_scenario_smart_grid_07.sq — 327 scenario smart grid 07
  328. 328_scenario_smart_grid_08.sq — 328 scenario smart grid 08
  329. 329_scenario_smart_grid_09.sq — 329 scenario smart grid 09
  330. 330_scenario_smart_grid_10.sq — 330 scenario smart grid 10
  331. 331_scenario_smart_grid_11.sq — 331 scenario smart grid 11
  332. 332_scenario_smart_grid_12.sq — 332 scenario smart grid 12
  333. 333_scenario_smart_grid_13.sq — 333 scenario smart grid 13
  334. 334_scenario_smart_grid_14.sq — 334 scenario smart grid 14
  335. 335_scenario_smart_grid_15.sq — 335 scenario smart grid 15
  336. 336_scenario_smart_grid_16.sq — 336 scenario smart grid 16
  337. 337_scenario_smart_grid_17.sq — 337 scenario smart grid 17
  338. 338_scenario_smart_grid_18.sq — 338 scenario smart grid 18
  339. 339_scenario_smart_grid_19.sq — 339 scenario smart grid 19
  340. 340_scenario_smart_grid_20.sq — 340 scenario smart grid 20
  341. 341_scenario_portfolio_01.sq — 341 scenario portfolio 01
  342. 342_scenario_portfolio_02.sq — 342 scenario portfolio 02
  343. 343_scenario_portfolio_03.sq — 343 scenario portfolio 03
  344. 344_scenario_portfolio_04.sq — 344 scenario portfolio 04
  345. 345_scenario_portfolio_05.sq — 345 scenario portfolio 05
  346. 346_scenario_portfolio_06.sq — 346 scenario portfolio 06
  347. 347_scenario_portfolio_07.sq — 347 scenario portfolio 07
  348. 348_scenario_portfolio_08.sq — 348 scenario portfolio 08
  349. 349_scenario_portfolio_09.sq — 349 scenario portfolio 09
  350. 350_scenario_portfolio_10.sq — 350 scenario portfolio 10
  351. 351_scenario_portfolio_11.sq — 351 scenario portfolio 11
  352. 352_scenario_portfolio_12.sq — 352 scenario portfolio 12
  353. 353_scenario_portfolio_13.sq — 353 scenario portfolio 13
  354. 354_scenario_portfolio_14.sq — 354 scenario portfolio 14
  355. 355_scenario_portfolio_15.sq — 355 scenario portfolio 15
  356. 356_scenario_portfolio_16.sq — 356 scenario portfolio 16
  357. 357_scenario_portfolio_17.sq — 357 scenario portfolio 17
  358. 358_scenario_portfolio_18.sq — 358 scenario portfolio 18
  359. 359_scenario_portfolio_19.sq — 359 scenario portfolio 19
  360. 360_scenario_portfolio_20.sq — 360 scenario portfolio 20
  361. 361_scenario_cybersecurity_01.sq — 361 scenario cybersecurity 01
  362. 362_scenario_cybersecurity_02.sq — 362 scenario cybersecurity 02
  363. 363_scenario_cybersecurity_03.sq — 363 scenario cybersecurity 03
  364. 364_scenario_cybersecurity_04.sq — 364 scenario cybersecurity 04
  365. 365_scenario_cybersecurity_05.sq — 365 scenario cybersecurity 05
  366. 366_scenario_cybersecurity_06.sq — 366 scenario cybersecurity 06
  367. 367_scenario_cybersecurity_07.sq — 367 scenario cybersecurity 07
  368. 368_scenario_cybersecurity_08.sq — 368 scenario cybersecurity 08
  369. 369_scenario_cybersecurity_09.sq — 369 scenario cybersecurity 09
  370. 370_scenario_cybersecurity_10.sq — 370 scenario cybersecurity 10
  371. 371_scenario_cybersecurity_11.sq — 371 scenario cybersecurity 11
  372. 372_scenario_cybersecurity_12.sq — 372 scenario cybersecurity 12
  373. 373_scenario_cybersecurity_13.sq — 373 scenario cybersecurity 13
  374. 374_scenario_cybersecurity_14.sq — 374 scenario cybersecurity 14
  375. 375_scenario_cybersecurity_15.sq — 375 scenario cybersecurity 15
  376. 376_scenario_cybersecurity_16.sq — 376 scenario cybersecurity 16
  377. 377_scenario_cybersecurity_17.sq — 377 scenario cybersecurity 17
  378. 378_scenario_cybersecurity_18.sq — 378 scenario cybersecurity 18
  379. 379_scenario_cybersecurity_19.sq — 379 scenario cybersecurity 19
  380. 380_scenario_cybersecurity_20.sq — 380 scenario cybersecurity 20
  381. 381_scenario_supply_chain_01.sq — 381 scenario supply chain 01
  382. 382_scenario_supply_chain_02.sq — 382 scenario supply chain 02
  383. 383_scenario_supply_chain_03.sq — 383 scenario supply chain 03
  384. 384_scenario_supply_chain_04.sq — 384 scenario supply chain 04
  385. 385_scenario_supply_chain_05.sq — 385 scenario supply chain 05
  386. 386_scenario_supply_chain_06.sq — 386 scenario supply chain 06
  387. 387_scenario_supply_chain_07.sq — 387 scenario supply chain 07
  388. 388_scenario_supply_chain_08.sq — 388 scenario supply chain 08
  389. 389_scenario_supply_chain_09.sq — 389 scenario supply chain 09
  390. 390_scenario_supply_chain_10.sq — 390 scenario supply chain 10
  391. 391_scenario_supply_chain_11.sq — 391 scenario supply chain 11
  392. 392_scenario_supply_chain_12.sq — 392 scenario supply chain 12
  393. 393_scenario_supply_chain_13.sq — 393 scenario supply chain 13
  394. 394_scenario_supply_chain_14.sq — 394 scenario supply chain 14
  395. 395_scenario_supply_chain_15.sq — 395 scenario supply chain 15
  396. 396_scenario_supply_chain_16.sq — 396 scenario supply chain 16
  397. 397_scenario_supply_chain_17.sq — 397 scenario supply chain 17
  398. 398_scenario_supply_chain_18.sq — 398 scenario supply chain 18
  399. 399_scenario_supply_chain_19.sq — 399 scenario supply chain 19
  400. 400_scenario_supply_chain_20.sq — 400 scenario supply chain 20
  401. 401_scenario_traffic_01.sq — 401 scenario traffic 01
  402. 402_scenario_traffic_02.sq — 402 scenario traffic 02
  403. 403_scenario_traffic_03.sq — 403 scenario traffic 03
  404. 404_scenario_traffic_04.sq — 404 scenario traffic 04
  405. 405_scenario_traffic_05.sq — 405 scenario traffic 05
  406. 406_scenario_traffic_06.sq — 406 scenario traffic 06
  407. 407_scenario_traffic_07.sq — 407 scenario traffic 07
  408. 408_scenario_traffic_08.sq — 408 scenario traffic 08
  409. 409_scenario_traffic_09.sq — 409 scenario traffic 09
  410. 410_scenario_traffic_10.sq — 410 scenario traffic 10
  411. 411_scenario_traffic_11.sq — 411 scenario traffic 11
  412. 412_scenario_traffic_12.sq — 412 scenario traffic 12
  413. 413_scenario_traffic_13.sq — 413 scenario traffic 13
  414. 414_scenario_traffic_14.sq — 414 scenario traffic 14
  415. 415_scenario_traffic_15.sq — 415 scenario traffic 15
  416. 416_scenario_traffic_16.sq — 416 scenario traffic 16
  417. 417_scenario_traffic_17.sq — 417 scenario traffic 17
  418. 418_scenario_traffic_18.sq — 418 scenario traffic 18
  419. 419_scenario_traffic_19.sq — 419 scenario traffic 19
  420. 420_scenario_traffic_20.sq — 420 scenario traffic 20
  421. 421_scenario_satellite_01.sq — 421 scenario satellite 01
  422. 422_scenario_satellite_02.sq — 422 scenario satellite 02
  423. 423_scenario_satellite_03.sq — 423 scenario satellite 03
  424. 424_scenario_satellite_04.sq — 424 scenario satellite 04
  425. 425_scenario_satellite_05.sq — 425 scenario satellite 05
  426. 426_scenario_satellite_06.sq — 426 scenario satellite 06
  427. 427_scenario_satellite_07.sq — 427 scenario satellite 07
  428. 428_scenario_satellite_08.sq — 428 scenario satellite 08
  429. 429_scenario_satellite_09.sq — 429 scenario satellite 09
  430. 430_scenario_satellite_10.sq — 430 scenario satellite 10
  431. 431_scenario_satellite_11.sq — 431 scenario satellite 11
  432. 432_scenario_satellite_12.sq — 432 scenario satellite 12
  433. 433_scenario_satellite_13.sq — 433 scenario satellite 13
  434. 434_scenario_satellite_14.sq — 434 scenario satellite 14
  435. 435_scenario_satellite_15.sq — 435 scenario satellite 15
  436. 436_scenario_satellite_16.sq — 436 scenario satellite 16
  437. 437_scenario_satellite_17.sq — 437 scenario satellite 17
  438. 438_scenario_satellite_18.sq — 438 scenario satellite 18
  439. 439_scenario_satellite_19.sq — 439 scenario satellite 19
  440. 440_scenario_satellite_20.sq — 440 scenario satellite 20
  441. 441_scenario_telecom_01.sq — 441 scenario telecom 01
  442. 442_scenario_telecom_02.sq — 442 scenario telecom 02
  443. 443_scenario_telecom_03.sq — 443 scenario telecom 03
  444. 444_scenario_telecom_04.sq — 444 scenario telecom 04
  445. 445_scenario_telecom_05.sq — 445 scenario telecom 05
  446. 446_scenario_telecom_06.sq — 446 scenario telecom 06
  447. 447_scenario_telecom_07.sq — 447 scenario telecom 07
  448. 448_scenario_telecom_08.sq — 448 scenario telecom 08
  449. 449_scenario_telecom_09.sq — 449 scenario telecom 09
  450. 450_scenario_telecom_10.sq — 450 scenario telecom 10
  451. 451_scenario_telecom_11.sq — 451 scenario telecom 11
  452. 452_scenario_telecom_12.sq — 452 scenario telecom 12
  453. 453_scenario_telecom_13.sq — 453 scenario telecom 13
  454. 454_scenario_telecom_14.sq — 454 scenario telecom 14
  455. 455_scenario_telecom_15.sq — 455 scenario telecom 15
  456. 456_scenario_telecom_16.sq — 456 scenario telecom 16
  457. 457_scenario_telecom_17.sq — 457 scenario telecom 17
  458. 458_scenario_telecom_18.sq — 458 scenario telecom 18
  459. 459_scenario_telecom_19.sq — 459 scenario telecom 19
  460. 460_scenario_telecom_20.sq — 460 scenario telecom 20
  461. 461_scenario_drug_discovery_01.sq — 461 scenario drug discovery 01
  462. 462_scenario_drug_discovery_02.sq — 462 scenario drug discovery 02
  463. 463_scenario_drug_discovery_03.sq — 463 scenario drug discovery 03
  464. 464_scenario_drug_discovery_04.sq — 464 scenario drug discovery 04
  465. 465_scenario_drug_discovery_05.sq — 465 scenario drug discovery 05
  466. 466_scenario_drug_discovery_06.sq — 466 scenario drug discovery 06
  467. 467_scenario_drug_discovery_07.sq — 467 scenario drug discovery 07
  468. 468_scenario_drug_discovery_08.sq — 468 scenario drug discovery 08
  469. 469_scenario_drug_discovery_09.sq — 469 scenario drug discovery 09
  470. 470_scenario_drug_discovery_10.sq — 470 scenario drug discovery 10
  471. 471_scenario_drug_discovery_11.sq — 471 scenario drug discovery 11
  472. 472_scenario_drug_discovery_12.sq — 472 scenario drug discovery 12
  473. 473_scenario_drug_discovery_13.sq — 473 scenario drug discovery 13
  474. 474_scenario_drug_discovery_14.sq — 474 scenario drug discovery 14
  475. 475_scenario_drug_discovery_15.sq — 475 scenario drug discovery 15
  476. 476_scenario_drug_discovery_16.sq — 476 scenario drug discovery 16
  477. 477_scenario_drug_discovery_17.sq — 477 scenario drug discovery 17
  478. 478_scenario_drug_discovery_18.sq — 478 scenario drug discovery 18
  479. 479_scenario_drug_discovery_19.sq — 479 scenario drug discovery 19
  480. 480_scenario_drug_discovery_20.sq — 480 scenario drug discovery 20
  481. 481_scenario_materials_01.sq — 481 scenario materials 01
  482. 482_scenario_materials_02.sq — 482 scenario materials 02
  483. 483_scenario_materials_03.sq — 483 scenario materials 03
  484. 484_scenario_materials_04.sq — 484 scenario materials 04
  485. 485_scenario_materials_05.sq — 485 scenario materials 05
  486. 486_scenario_materials_06.sq — 486 scenario materials 06
  487. 487_scenario_materials_07.sq — 487 scenario materials 07
  488. 488_scenario_materials_08.sq — 488 scenario materials 08
  489. 489_scenario_materials_09.sq — 489 scenario materials 09
  490. 490_scenario_materials_10.sq — 490 scenario materials 10
  491. 491_scenario_materials_11.sq — 491 scenario materials 11
  492. 492_scenario_materials_12.sq — 492 scenario materials 12
  493. 493_scenario_materials_13.sq — 493 scenario materials 13
  494. 494_scenario_materials_14.sq — 494 scenario materials 14
  495. 495_scenario_materials_15.sq — 495 scenario materials 15
  496. 496_scenario_materials_16.sq — 496 scenario materials 16
  497. 497_scenario_materials_17.sq — 497 scenario materials 17
  498. 498_scenario_materials_18.sq — 498 scenario materials 18
  499. 499_scenario_materials_19.sq — 499 scenario materials 19
  500. 500_scenario_materials_20.sq — 500 scenario materials 20
  501. 501_scenario_genomics_01.sq — 501 scenario genomics 01
  502. 502_scenario_genomics_02.sq — 502 scenario genomics 02
  503. 503_scenario_genomics_03.sq — 503 scenario genomics 03
  504. 504_scenario_genomics_04.sq — 504 scenario genomics 04
  505. 505_scenario_genomics_05.sq — 505 scenario genomics 05
  506. 506_scenario_genomics_06.sq — 506 scenario genomics 06
  507. 507_scenario_genomics_07.sq — 507 scenario genomics 07
  508. 508_scenario_genomics_08.sq — 508 scenario genomics 08
  509. 509_scenario_genomics_09.sq — 509 scenario genomics 09
  510. 510_scenario_genomics_10.sq — 510 scenario genomics 10
  511. 511_scenario_genomics_11.sq — 511 scenario genomics 11
  512. 512_scenario_genomics_12.sq — 512 scenario genomics 12
  513. 513_scenario_genomics_13.sq — 513 scenario genomics 13
  514. 514_scenario_genomics_14.sq — 514 scenario genomics 14
  515. 515_scenario_genomics_15.sq — 515 scenario genomics 15
  516. 516_scenario_genomics_16.sq — 516 scenario genomics 16
  517. 517_scenario_genomics_17.sq — 517 scenario genomics 17
  518. 518_scenario_genomics_18.sq — 518 scenario genomics 18
  519. 519_scenario_genomics_19.sq — 519 scenario genomics 19
  520. 520_scenario_genomics_20.sq — 520 scenario genomics 20
  521. 521_scenario_healthcare_01.sq — 521 scenario healthcare 01
  522. 522_scenario_healthcare_02.sq — 522 scenario healthcare 02
  523. 523_scenario_healthcare_03.sq — 523 scenario healthcare 03
  524. 524_scenario_healthcare_04.sq — 524 scenario healthcare 04
  525. 525_scenario_healthcare_05.sq — 525 scenario healthcare 05
  526. 526_scenario_healthcare_06.sq — 526 scenario healthcare 06
  527. 527_scenario_healthcare_07.sq — 527 scenario healthcare 07
  528. 528_scenario_healthcare_08.sq — 528 scenario healthcare 08
  529. 529_scenario_healthcare_09.sq — 529 scenario healthcare 09
  530. 530_scenario_healthcare_10.sq — 530 scenario healthcare 10
  531. 531_scenario_healthcare_11.sq — 531 scenario healthcare 11
  532. 532_scenario_healthcare_12.sq — 532 scenario healthcare 12
  533. 533_scenario_healthcare_13.sq — 533 scenario healthcare 13
  534. 534_scenario_healthcare_14.sq — 534 scenario healthcare 14
  535. 535_scenario_healthcare_15.sq — 535 scenario healthcare 15
  536. 536_scenario_healthcare_16.sq — 536 scenario healthcare 16
  537. 537_scenario_healthcare_17.sq — 537 scenario healthcare 17
  538. 538_scenario_healthcare_18.sq — 538 scenario healthcare 18
  539. 539_scenario_healthcare_19.sq — 539 scenario healthcare 19
  540. 540_scenario_healthcare_20.sq — 540 scenario healthcare 20
  541. 541_scenario_aerospace_01.sq — 541 scenario aerospace 01
  542. 542_scenario_aerospace_02.sq — 542 scenario aerospace 02
  543. 543_scenario_aerospace_03.sq — 543 scenario aerospace 03
  544. 544_scenario_aerospace_04.sq — 544 scenario aerospace 04
  545. 545_scenario_aerospace_05.sq — 545 scenario aerospace 05
  546. 546_scenario_aerospace_06.sq — 546 scenario aerospace 06
  547. 547_scenario_aerospace_07.sq — 547 scenario aerospace 07
  548. 548_scenario_aerospace_08.sq — 548 scenario aerospace 08
  549. 549_scenario_aerospace_09.sq — 549 scenario aerospace 09
  550. 550_scenario_aerospace_10.sq — 550 scenario aerospace 10
  551. 551_scenario_aerospace_11.sq — 551 scenario aerospace 11
  552. 552_scenario_aerospace_12.sq — 552 scenario aerospace 12
  553. 553_scenario_aerospace_13.sq — 553 scenario aerospace 13
  554. 554_scenario_aerospace_14.sq — 554 scenario aerospace 14
  555. 555_scenario_aerospace_15.sq — 555 scenario aerospace 15
  556. 556_scenario_aerospace_16.sq — 556 scenario aerospace 16
  557. 557_scenario_aerospace_17.sq — 557 scenario aerospace 17
  558. 558_scenario_aerospace_18.sq — 558 scenario aerospace 18
  559. 559_scenario_aerospace_19.sq — 559 scenario aerospace 19
  560. 560_scenario_aerospace_20.sq — 560 scenario aerospace 20
  561. 561_scenario_robotics_01.sq — 561 scenario robotics 01
  562. 562_scenario_robotics_02.sq — 562 scenario robotics 02
  563. 563_scenario_robotics_03.sq — 563 scenario robotics 03
  564. 564_scenario_robotics_04.sq — 564 scenario robotics 04
  565. 565_scenario_robotics_05.sq — 565 scenario robotics 05
  566. 566_scenario_robotics_06.sq — 566 scenario robotics 06
  567. 567_scenario_robotics_07.sq — 567 scenario robotics 07
  568. 568_scenario_robotics_08.sq — 568 scenario robotics 08
  569. 569_scenario_robotics_09.sq — 569 scenario robotics 09
  570. 570_scenario_robotics_10.sq — 570 scenario robotics 10
  571. 571_scenario_robotics_11.sq — 571 scenario robotics 11
  572. 572_scenario_robotics_12.sq — 572 scenario robotics 12
  573. 573_scenario_robotics_13.sq — 573 scenario robotics 13
  574. 574_scenario_robotics_14.sq — 574 scenario robotics 14
  575. 575_scenario_robotics_15.sq — 575 scenario robotics 15
  576. 576_scenario_robotics_16.sq — 576 scenario robotics 16
  577. 577_scenario_robotics_17.sq — 577 scenario robotics 17
  578. 578_scenario_robotics_18.sq — 578 scenario robotics 18
  579. 579_scenario_robotics_19.sq — 579 scenario robotics 19
  580. 580_scenario_robotics_20.sq — 580 scenario robotics 20
  581. 581_scenario_water_network_01.sq — 581 scenario water network 01
  582. 582_scenario_water_network_02.sq — 582 scenario water network 02
  583. 583_scenario_water_network_03.sq — 583 scenario water network 03
  584. 584_scenario_water_network_04.sq — 584 scenario water network 04
  585. 585_scenario_water_network_05.sq — 585 scenario water network 05
  586. 586_scenario_water_network_06.sq — 586 scenario water network 06
  587. 587_scenario_water_network_07.sq — 587 scenario water network 07
  588. 588_scenario_water_network_08.sq — 588 scenario water network 08
  589. 589_scenario_water_network_09.sq — 589 scenario water network 09
  590. 590_scenario_water_network_10.sq — 590 scenario water network 10
  591. 591_scenario_water_network_11.sq — 591 scenario water network 11
  592. 592_scenario_water_network_12.sq — 592 scenario water network 12
  593. 593_scenario_water_network_13.sq — 593 scenario water network 13
  594. 594_scenario_water_network_14.sq — 594 scenario water network 14
  595. 595_scenario_water_network_15.sq — 595 scenario water network 15
  596. 596_scenario_water_network_16.sq — 596 scenario water network 16
  597. 597_scenario_water_network_17.sq — 597 scenario water network 17
  598. 598_scenario_water_network_18.sq — 598 scenario water network 18
  599. 599_scenario_water_network_19.sq — 599 scenario water network 19
  600. 600_scenario_water_network_20.sq — 600 scenario water network 20
  601. 601_scenario_agriculture_01.sq — 601 scenario agriculture 01
  602. 602_scenario_agriculture_02.sq — 602 scenario agriculture 02
  603. 603_scenario_agriculture_03.sq — 603 scenario agriculture 03
  604. 604_scenario_agriculture_04.sq — 604 scenario agriculture 04
  605. 605_scenario_agriculture_05.sq — 605 scenario agriculture 05
  606. 606_scenario_agriculture_06.sq — 606 scenario agriculture 06
  607. 607_scenario_agriculture_07.sq — 607 scenario agriculture 07
  608. 608_scenario_agriculture_08.sq — 608 scenario agriculture 08
  609. 609_scenario_agriculture_09.sq — 609 scenario agriculture 09
  610. 610_scenario_agriculture_10.sq — 610 scenario agriculture 10
  611. 611_scenario_agriculture_11.sq — 611 scenario agriculture 11
  612. 612_scenario_agriculture_12.sq — 612 scenario agriculture 12
  613. 613_scenario_agriculture_13.sq — 613 scenario agriculture 13
  614. 614_scenario_agriculture_14.sq — 614 scenario agriculture 14
  615. 615_scenario_agriculture_15.sq — 615 scenario agriculture 15
  616. 616_scenario_agriculture_16.sq — 616 scenario agriculture 16
  617. 617_scenario_agriculture_17.sq — 617 scenario agriculture 17
  618. 618_scenario_agriculture_18.sq — 618 scenario agriculture 18
  619. 619_scenario_agriculture_19.sq — 619 scenario agriculture 19
  620. 620_scenario_agriculture_20.sq — 620 scenario agriculture 20
  621. 621_scenario_manufacturing_01.sq — 621 scenario manufacturing 01
  622. 622_scenario_manufacturing_02.sq — 622 scenario manufacturing 02
  623. 623_scenario_manufacturing_03.sq — 623 scenario manufacturing 03
  624. 624_scenario_manufacturing_04.sq — 624 scenario manufacturing 04
  625. 625_scenario_manufacturing_05.sq — 625 scenario manufacturing 05
  626. 626_scenario_manufacturing_06.sq — 626 scenario manufacturing 06
  627. 627_scenario_manufacturing_07.sq — 627 scenario manufacturing 07
  628. 628_scenario_manufacturing_08.sq — 628 scenario manufacturing 08
  629. 629_scenario_manufacturing_09.sq — 629 scenario manufacturing 09
  630. 630_scenario_manufacturing_10.sq — 630 scenario manufacturing 10
  631. 631_scenario_manufacturing_11.sq — 631 scenario manufacturing 11
  632. 632_scenario_manufacturing_12.sq — 632 scenario manufacturing 12
  633. 633_scenario_manufacturing_13.sq — 633 scenario manufacturing 13
  634. 634_scenario_manufacturing_14.sq — 634 scenario manufacturing 14
  635. 635_scenario_manufacturing_15.sq — 635 scenario manufacturing 15
  636. 636_scenario_manufacturing_16.sq — 636 scenario manufacturing 16
  637. 637_scenario_manufacturing_17.sq — 637 scenario manufacturing 17
  638. 638_scenario_manufacturing_18.sq — 638 scenario manufacturing 18
  639. 639_scenario_manufacturing_19.sq — 639 scenario manufacturing 19
  640. 640_scenario_manufacturing_20.sq — 640 scenario manufacturing 20
  641. 641_scenario_fraud_01.sq — 641 scenario fraud 01
  642. 642_scenario_fraud_02.sq — 642 scenario fraud 02
  643. 643_scenario_fraud_03.sq — 643 scenario fraud 03
  644. 644_scenario_fraud_04.sq — 644 scenario fraud 04
  645. 645_scenario_fraud_05.sq — 645 scenario fraud 05
  646. 646_scenario_fraud_06.sq — 646 scenario fraud 06
  647. 647_scenario_fraud_07.sq — 647 scenario fraud 07
  648. 648_scenario_fraud_08.sq — 648 scenario fraud 08
  649. 649_scenario_fraud_09.sq — 649 scenario fraud 09
  650. 650_scenario_fraud_10.sq — 650 scenario fraud 10
  651. 651_scenario_fraud_11.sq — 651 scenario fraud 11
  652. 652_scenario_fraud_12.sq — 652 scenario fraud 12
  653. 653_scenario_fraud_13.sq — 653 scenario fraud 13
  654. 654_scenario_fraud_14.sq — 654 scenario fraud 14
  655. 655_scenario_fraud_15.sq — 655 scenario fraud 15
  656. 656_scenario_fraud_16.sq — 656 scenario fraud 16
  657. 657_scenario_fraud_17.sq — 657 scenario fraud 17
  658. 658_scenario_fraud_18.sq — 658 scenario fraud 18
  659. 659_scenario_fraud_19.sq — 659 scenario fraud 19
  660. 660_scenario_fraud_20.sq — 660 scenario fraud 20
  661. 661_scenario_iot_edge_01.sq — 661 scenario iot edge 01
  662. 662_scenario_iot_edge_02.sq — 662 scenario iot edge 02
  663. 663_scenario_iot_edge_03.sq — 663 scenario iot edge 03
  664. 664_scenario_iot_edge_04.sq — 664 scenario iot edge 04
  665. 665_scenario_iot_edge_05.sq — 665 scenario iot edge 05
  666. 666_scenario_iot_edge_06.sq — 666 scenario iot edge 06
  667. 667_scenario_iot_edge_07.sq — 667 scenario iot edge 07
  668. 668_scenario_iot_edge_08.sq — 668 scenario iot edge 08
  669. 669_scenario_iot_edge_09.sq — 669 scenario iot edge 09
  670. 670_scenario_iot_edge_10.sq — 670 scenario iot edge 10
  671. 671_scenario_iot_edge_11.sq — 671 scenario iot edge 11
  672. 672_scenario_iot_edge_12.sq — 672 scenario iot edge 12
  673. 673_scenario_iot_edge_13.sq — 673 scenario iot edge 13
  674. 674_scenario_iot_edge_14.sq — 674 scenario iot edge 14
  675. 675_scenario_iot_edge_15.sq — 675 scenario iot edge 15
  676. 676_scenario_iot_edge_16.sq — 676 scenario iot edge 16
  677. 677_scenario_iot_edge_17.sq — 677 scenario iot edge 17
  678. 678_scenario_iot_edge_18.sq — 678 scenario iot edge 18
  679. 679_scenario_iot_edge_19.sq — 679 scenario iot edge 19
  680. 680_scenario_iot_edge_20.sq — 680 scenario iot edge 20
  681. 681_scenario_quantum_network_01.sq — 681 scenario quantum network 01
  682. 682_scenario_quantum_network_02.sq — 682 scenario quantum network 02
  683. 683_scenario_quantum_network_03.sq — 683 scenario quantum network 03
  684. 684_scenario_quantum_network_04.sq — 684 scenario quantum network 04
  685. 685_scenario_quantum_network_05.sq — 685 scenario quantum network 05
  686. 686_scenario_quantum_network_06.sq — 686 scenario quantum network 06
  687. 687_scenario_quantum_network_07.sq — 687 scenario quantum network 07
  688. 688_scenario_quantum_network_08.sq — 688 scenario quantum network 08
  689. 689_scenario_quantum_network_09.sq — 689 scenario quantum network 09
  690. 690_scenario_quantum_network_10.sq — 690 scenario quantum network 10
  691. 691_scenario_quantum_network_11.sq — 691 scenario quantum network 11
  692. 692_scenario_quantum_network_12.sq — 692 scenario quantum network 12
  693. 693_scenario_quantum_network_13.sq — 693 scenario quantum network 13
  694. 694_scenario_quantum_network_14.sq — 694 scenario quantum network 14
  695. 695_scenario_quantum_network_15.sq — 695 scenario quantum network 15
  696. 696_scenario_quantum_network_16.sq — 696 scenario quantum network 16
  697. 697_scenario_quantum_network_17.sq — 697 scenario quantum network 17
  698. 698_scenario_quantum_network_18.sq — 698 scenario quantum network 18
  699. 699_scenario_quantum_network_19.sq — 699 scenario quantum network 19
  700. 700_scenario_quantum_network_20.sq — 700 scenario quantum network 20
  701. 701_scenario_pqc_migration_01.sq — 701 scenario pqc migration 01
  702. 702_scenario_pqc_migration_02.sq — 702 scenario pqc migration 02
  703. 703_scenario_pqc_migration_03.sq — 703 scenario pqc migration 03
  704. 704_scenario_pqc_migration_04.sq — 704 scenario pqc migration 04
  705. 705_scenario_pqc_migration_05.sq — 705 scenario pqc migration 05
  706. 706_scenario_pqc_migration_06.sq — 706 scenario pqc migration 06
  707. 707_scenario_pqc_migration_07.sq — 707 scenario pqc migration 07
  708. 708_scenario_pqc_migration_08.sq — 708 scenario pqc migration 08
  709. 709_scenario_pqc_migration_09.sq — 709 scenario pqc migration 09
  710. 710_scenario_pqc_migration_10.sq — 710 scenario pqc migration 10
  711. 711_scenario_pqc_migration_11.sq — 711 scenario pqc migration 11
  712. 712_scenario_pqc_migration_12.sq — 712 scenario pqc migration 12
  713. 713_scenario_pqc_migration_13.sq — 713 scenario pqc migration 13
  714. 714_scenario_pqc_migration_14.sq — 714 scenario pqc migration 14
  715. 715_scenario_pqc_migration_15.sq — 715 scenario pqc migration 15
  716. 716_scenario_pqc_migration_16.sq — 716 scenario pqc migration 16
  717. 717_scenario_pqc_migration_17.sq — 717 scenario pqc migration 17
  718. 718_scenario_pqc_migration_18.sq — 718 scenario pqc migration 18
  719. 719_scenario_pqc_migration_19.sq — 719 scenario pqc migration 19
  720. 720_scenario_pqc_migration_20.sq — 720 scenario pqc migration 20
  721. 721_scenario_qec_satellite_01.sq — 721 scenario qec satellite 01
  722. 722_scenario_qec_satellite_02.sq — 722 scenario qec satellite 02
  723. 723_scenario_qec_satellite_03.sq — 723 scenario qec satellite 03
  724. 724_scenario_qec_satellite_04.sq — 724 scenario qec satellite 04
  725. 725_scenario_qec_satellite_05.sq — 725 scenario qec satellite 05
  726. 726_scenario_qec_satellite_06.sq — 726 scenario qec satellite 06
  727. 727_scenario_qec_satellite_07.sq — 727 scenario qec satellite 07
  728. 728_scenario_qec_satellite_08.sq — 728 scenario qec satellite 08
  729. 729_scenario_qec_satellite_09.sq — 729 scenario qec satellite 09
  730. 730_scenario_qec_satellite_10.sq — 730 scenario qec satellite 10
  731. 731_scenario_qec_satellite_11.sq — 731 scenario qec satellite 11
  732. 732_scenario_qec_satellite_12.sq — 732 scenario qec satellite 12
  733. 733_scenario_qec_satellite_13.sq — 733 scenario qec satellite 13
  734. 734_scenario_qec_satellite_14.sq — 734 scenario qec satellite 14
  735. 735_scenario_qec_satellite_15.sq — 735 scenario qec satellite 15
  736. 736_scenario_qec_satellite_16.sq — 736 scenario qec satellite 16
  737. 737_scenario_qec_satellite_17.sq — 737 scenario qec satellite 17
  738. 738_scenario_qec_satellite_18.sq — 738 scenario qec satellite 18
  739. 739_scenario_qec_satellite_19.sq — 739 scenario qec satellite 19
  740. 740_scenario_qec_satellite_20.sq — 740 scenario qec satellite 20
  741. 741_scenario_hardware_calibration_01.sq — 741 scenario hardware calibration 01
  742. 742_scenario_hardware_calibration_02.sq — 742 scenario hardware calibration 02
  743. 743_scenario_hardware_calibration_03.sq — 743 scenario hardware calibration 03
  744. 744_scenario_hardware_calibration_04.sq — 744 scenario hardware calibration 04
  745. 745_scenario_hardware_calibration_05.sq — 745 scenario hardware calibration 05
  746. 746_scenario_hardware_calibration_06.sq — 746 scenario hardware calibration 06
  747. 747_scenario_hardware_calibration_07.sq — 747 scenario hardware calibration 07
  748. 748_scenario_hardware_calibration_08.sq — 748 scenario hardware calibration 08
  749. 749_scenario_hardware_calibration_09.sq — 749 scenario hardware calibration 09
  750. 750_scenario_hardware_calibration_10.sq — 750 scenario hardware calibration 10
  751. 751_scenario_hardware_calibration_11.sq — 751 scenario hardware calibration 11
  752. 752_scenario_hardware_calibration_12.sq — 752 scenario hardware calibration 12
  753. 753_scenario_hardware_calibration_13.sq — 753 scenario hardware calibration 13
  754. 754_scenario_hardware_calibration_14.sq — 754 scenario hardware calibration 14
  755. 755_scenario_hardware_calibration_15.sq — 755 scenario hardware calibration 15
  756. 756_scenario_hardware_calibration_16.sq — 756 scenario hardware calibration 16
  757. 757_scenario_hardware_calibration_17.sq — 757 scenario hardware calibration 17
  758. 758_scenario_hardware_calibration_18.sq — 758 scenario hardware calibration 18
  759. 759_scenario_hardware_calibration_19.sq — 759 scenario hardware calibration 19
  760. 760_scenario_hardware_calibration_20.sq — 760 scenario hardware calibration 20
  761. 761_scenario_semiconductor_01.sq — 761 scenario semiconductor 01
  762. 762_scenario_semiconductor_02.sq — 762 scenario semiconductor 02
  763. 763_scenario_semiconductor_03.sq — 763 scenario semiconductor 03
  764. 764_scenario_semiconductor_04.sq — 764 scenario semiconductor 04
  765. 765_scenario_semiconductor_05.sq — 765 scenario semiconductor 05
  766. 766_scenario_semiconductor_06.sq — 766 scenario semiconductor 06
  767. 767_scenario_semiconductor_07.sq — 767 scenario semiconductor 07
  768. 768_scenario_semiconductor_08.sq — 768 scenario semiconductor 08
  769. 769_scenario_semiconductor_09.sq — 769 scenario semiconductor 09
  770. 770_scenario_semiconductor_10.sq — 770 scenario semiconductor 10
  771. 771_scenario_semiconductor_11.sq — 771 scenario semiconductor 11
  772. 772_scenario_semiconductor_12.sq — 772 scenario semiconductor 12
  773. 773_scenario_semiconductor_13.sq — 773 scenario semiconductor 13
  774. 774_scenario_semiconductor_14.sq — 774 scenario semiconductor 14
  775. 775_scenario_semiconductor_15.sq — 775 scenario semiconductor 15
  776. 776_scenario_semiconductor_16.sq — 776 scenario semiconductor 16
  777. 777_scenario_semiconductor_17.sq — 777 scenario semiconductor 17
  778. 778_scenario_semiconductor_18.sq — 778 scenario semiconductor 18
  779. 779_scenario_semiconductor_19.sq — 779 scenario semiconductor 19
  780. 780_scenario_semiconductor_20.sq — 780 scenario semiconductor 20
  781. 781_scenario_seismology_01.sq — 781 scenario seismology 01
  782. 782_scenario_seismology_02.sq — 782 scenario seismology 02
  783. 783_scenario_seismology_03.sq — 783 scenario seismology 03
  784. 784_scenario_seismology_04.sq — 784 scenario seismology 04
  785. 785_scenario_seismology_05.sq — 785 scenario seismology 05
  786. 786_scenario_seismology_06.sq — 786 scenario seismology 06
  787. 787_scenario_seismology_07.sq — 787 scenario seismology 07
  788. 788_scenario_seismology_08.sq — 788 scenario seismology 08
  789. 789_scenario_seismology_09.sq — 789 scenario seismology 09
  790. 790_scenario_seismology_10.sq — 790 scenario seismology 10
  791. 791_scenario_seismology_11.sq — 791 scenario seismology 11
  792. 792_scenario_seismology_12.sq — 792 scenario seismology 12
  793. 793_scenario_seismology_13.sq — 793 scenario seismology 13
  794. 794_scenario_seismology_14.sq — 794 scenario seismology 14
  795. 795_scenario_seismology_15.sq — 795 scenario seismology 15
  796. 796_scenario_seismology_16.sq — 796 scenario seismology 16
  797. 797_scenario_seismology_17.sq — 797 scenario seismology 17
  798. 798_scenario_seismology_18.sq — 798 scenario seismology 18
  799. 799_scenario_seismology_19.sq — 799 scenario seismology 19
  800. 800_scenario_seismology_20.sq — 800 scenario seismology 20

Full program listings

1. 001_bell_state.sq — 001 bell state

# Bell state with sparse simulation
simulate(2) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    let probs = probabilities(q)
    print(probs)
    print(measure_all(q, shots=512))
}

2. 002_ghz_chain_8.sq — 002 ghz chain 8

# 8-qubit GHZ state
simulate(8, engine="sparse") {
    let q = quantum_register(8)
    H(q[0])
    for i in range(7) {
        CNOT(q[i], q[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=512))
}

3. 003_qft_three_qubits.sq — 003 qft three qubits

simulate(3) {
    let q = quantum_register(3)
    X(q[0])
    qft(q)
    print(probabilities(q))
}

4. 004_inverse_qft_roundtrip.sq — 004 inverse qft roundtrip

simulate(4) {
    let q = quantum_register(4)
    X(q[0])
    X(q[2])
    qft(q)
    iqft(q)
    print(probabilities(q))
}

5. 005_sharded_bell.sq — 005 sharded bell

simulate(2, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    print(shards())
    print(measure_all(q, shots=256))
}

6. 006_threaded_superposition.sq — 006 threaded superposition

simulate(12, engine="threaded", workers=4) {
    let q = quantum_register(12)
    H_all()
    Rz_all(PI / 8)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

7. 007_lookup_sx_inverse.sq — 007 lookup sx inverse

simulate(1) {
    let q = quantum_register(1)
    SX(q[0])
    SXdg(q[0])
    print(probabilities(q))
}

8. 008_toffoli_adder_bit.sq — 008 toffoli adder bit

simulate(3) {
    let q = quantum_register(3)
    X(q[0])
    X(q[1])
    Toffoli(q[0], q[1], q[2])
    print(probabilities(q))
}

9. 009_fredkin_swap.sq — 009 fredkin swap

simulate(3) {
    let q = quantum_register(3)
    X(q[0])
    X(q[1])
    Fredkin(q[0], q[1], q[2])
    print(probabilities(q))
}

10. 010_rzz_entangler.sq — 010 rzz entangler

simulate(2) {
    let q = quantum_register(2)
    H(q[0])
    H(q[1])
    RZZ(q[0], q[1], PI / 3)
    print(probabilities(q))
}

11. 011_ms_gate.sq — 011 ms gate

simulate(2) {
    let q = quantum_register(2)
    MS(q[0], q[1])
    print(probabilities(q))
}

12. 012_qasm_export.sq — 012 qasm export

simulate(2) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    let text = export_qasm3()
    print(text)
}

13. 013_pipeline_statistics.sq — 013 pipeline statistics

let xs = [1, 2, 3, 4, 5, 6]
let squares = xs |> map(fn(x) => x * x)
let big = squares |> filter(fn(x) => x > 10)
let total = big |> sum
print(squares)
print(big)
print(total)

14. 014_classical_function.sq — 014 classical function

fn energy(theta) {
    return -cos(theta) + 0.1 * sin(2 * theta)
}
let values = [energy(x * PI / 16) for x in range(16)]
print(values)
print(min(values))

15. 015_json_csv_io.sq — 015 json csv io

let rows = [{"gate": "H", "qubit": 0}, {"gate": "CNOT", "qubit": 1}]
write_json("sansqrit_example.json", {"rows": rows, "shots": 128})
let payload = read_json("sansqrit_example.json")
print(payload)

16. 016_grover_search.sq — 016 grover search

let result = grover_search(3, 5, shots=512)
print(result)

17. 017_grover_multi.sq — 017 grover multi

let result = grover_search_multi(4, [3, 12], shots=512)
print(result)

18. 018_bernstein_vazirani.sq — 018 bernstein vazirani

let secret = bernstein_vazirani("101101")
print(secret)

19. 019_deutsch_jozsa_balanced.sq — 019 deutsch jozsa balanced

let result = deutsch_jozsa(4, "balanced")
print(result)

20. 020_deutsch_jozsa_constant.sq — 020 deutsch jozsa constant

let result = deutsch_jozsa(4, "constant")
print(result)

21. 021_qaoa_triangle.sq — 021 qaoa triangle

let result = qaoa_maxcut(3, [(0,1), (1,2), (0,2)], p=1, shots=256)
print(result)

22. 022_qaoa_square.sq — 022 qaoa square

let result = qaoa_maxcut(4, [(0,1), (1,2), (2,3), (3,0)], p=1, shots=256)
print(result)

23. 023_vqe_h2.sq — 023 vqe h2

let result = vqe_h2(0.735, max_iter=32)
print(result)

24. 024_phase_estimation.sq — 024 phase estimation

let result = quantum_phase_estimation(0.3125, 5, shots=256)
print(result)

25. 025_hhl_2x2.sq — 025 hhl 2x2

let result = hhl_solve([[2, 0], [0, 4]], [2, 8])
print(result)

26. 026_teleport_one.sq — 026 teleport one

let result = teleport(1)
print(result)

27. 027_superdense_coding.sq — 027 superdense coding

let result = superdense_coding(1, 0)
print(result)

28. 028_bb84_qkd.sq — 028 bb84 qkd

let key = bb84_qkd(24, eavesdropper=false)
print(key)

29. 029_bb84_with_eavesdropper.sq — 029 bb84 with eavesdropper

let key = bb84_qkd(24, eavesdropper=true)
print(key)

30. 030_shor_factor_15.sq — 030 shor factor 15

let factors = shor_factor(15)
print(factors)

31. 031_amplitude_estimation.sq — 031 amplitude estimation

let estimate = amplitude_estimation(0.37, 5)
print(estimate)

32. 032_quantum_counting.sq — 032 quantum counting

let estimate = quantum_counting(6, 7, 5)
print(estimate)

33. 033_variational_classifier.sq — 033 variational classifier

let score = variational_classifier([0.1, 0.5, 1.2], layers=3)
print(score)

34. 034_variational_pattern_34.sq — 034 variational pattern 34

# Generated variational circuit pattern 34
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Ry(q[0], PI / 8)
    Rz(q[1], PI / 2)
    Rx(q[2], PI / 3)
    Ry(q[3], PI / 4)
    Rz(q[4], PI / 5)
    Rx(q[5], PI / 6)
    Ry(q[6], PI / 7)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    # layer 1
    Rz(q[0], PI / 2)
    Rx(q[1], PI / 3)
    Ry(q[2], PI / 4)
    Rz(q[3], PI / 5)
    Rx(q[4], PI / 6)
    Ry(q[5], PI / 7)
    Rz(q[6], PI / 8)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

35. 035_variational_pattern_35.sq — 035 variational pattern 35

# Generated variational circuit pattern 35
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Rz(q[0], PI / 2)
    Rx(q[1], PI / 3)
    Ry(q[2], PI / 4)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    # layer 1
    Rx(q[0], PI / 3)
    Ry(q[1], PI / 4)
    Rz(q[2], PI / 5)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    # layer 2
    Ry(q[0], PI / 4)
    Rz(q[1], PI / 5)
    Rx(q[2], PI / 6)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

36. 036_variational_pattern_36.sq — 036 variational pattern 36

# Generated variational circuit pattern 36
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Rx(q[0], PI / 3)
    Ry(q[1], PI / 4)
    Rz(q[2], PI / 5)
    Rx(q[3], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

37. 037_variational_pattern_37.sq — 037 variational pattern 37

# Generated variational circuit pattern 37
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Ry(q[0], PI / 4)
    Rz(q[1], PI / 5)
    Rx(q[2], PI / 6)
    Ry(q[3], PI / 7)
    Rz(q[4], PI / 8)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    # layer 1
    Rz(q[0], PI / 5)
    Rx(q[1], PI / 6)
    Ry(q[2], PI / 7)
    Rz(q[3], PI / 8)
    Rx(q[4], PI / 2)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

38. 038_variational_pattern_38.sq — 038 variational pattern 38

# Generated variational circuit pattern 38
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Rz(q[0], PI / 5)
    Rx(q[1], PI / 6)
    Ry(q[2], PI / 7)
    Rz(q[3], PI / 8)
    Rx(q[4], PI / 2)
    Ry(q[5], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    # layer 1
    Rx(q[0], PI / 6)
    Ry(q[1], PI / 7)
    Rz(q[2], PI / 8)
    Rx(q[3], PI / 2)
    Ry(q[4], PI / 3)
    Rz(q[5], PI / 4)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    # layer 2
    Ry(q[0], PI / 7)
    Rz(q[1], PI / 8)
    Rx(q[2], PI / 2)
    Ry(q[3], PI / 3)
    Rz(q[4], PI / 4)
    Rx(q[5], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

39. 039_variational_pattern_39.sq — 039 variational pattern 39

# Generated variational circuit pattern 39
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Rx(q[0], PI / 6)
    Ry(q[1], PI / 7)
    Rz(q[2], PI / 8)
    Rx(q[3], PI / 2)
    Ry(q[4], PI / 3)
    Rz(q[5], PI / 4)
    Rx(q[6], PI / 5)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

40. 040_variational_pattern_40.sq — 040 variational pattern 40

# Generated variational circuit pattern 40
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Ry(q[0], PI / 7)
    Rz(q[1], PI / 8)
    Rx(q[2], PI / 2)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    # layer 1
    Rz(q[0], PI / 8)
    Rx(q[1], PI / 2)
    Ry(q[2], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

41. 041_variational_pattern_41.sq — 041 variational pattern 41

# Generated variational circuit pattern 41
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Rz(q[0], PI / 8)
    Rx(q[1], PI / 2)
    Ry(q[2], PI / 3)
    Rz(q[3], PI / 4)
    RZZ(q[0], q[1], PI / 4)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 6)
    # layer 1
    Rx(q[0], PI / 2)
    Ry(q[1], PI / 3)
    Rz(q[2], PI / 4)
    Rx(q[3], PI / 5)
    RZZ(q[0], q[1], PI / 4)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 6)
    # layer 2
    Ry(q[0], PI / 3)
    Rz(q[1], PI / 4)
    Rx(q[2], PI / 5)
    Ry(q[3], PI / 6)
    RZZ(q[0], q[1], PI / 4)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 6)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

42. 042_variational_pattern_42.sq — 042 variational pattern 42

# Generated variational circuit pattern 42
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Rx(q[0], PI / 2)
    Ry(q[1], PI / 3)
    Rz(q[2], PI / 4)
    Rx(q[3], PI / 5)
    Ry(q[4], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 6)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 3)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

43. 043_variational_pattern_43.sq — 043 variational pattern 43

# Generated variational circuit pattern 43
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Ry(q[0], PI / 3)
    Rz(q[1], PI / 4)
    Rx(q[2], PI / 5)
    Ry(q[3], PI / 6)
    Rz(q[4], PI / 7)
    Rx(q[5], PI / 8)
    RZZ(q[0], q[1], PI / 6)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 3)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 5)
    # layer 1
    Rz(q[0], PI / 4)
    Rx(q[1], PI / 5)
    Ry(q[2], PI / 6)
    Rz(q[3], PI / 7)
    Rx(q[4], PI / 8)
    Ry(q[5], PI / 2)
    RZZ(q[0], q[1], PI / 6)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 3)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 5)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

44. 044_variational_pattern_44.sq — 044 variational pattern 44

# Generated variational circuit pattern 44
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Rz(q[0], PI / 4)
    Rx(q[1], PI / 5)
    Ry(q[2], PI / 6)
    Rz(q[3], PI / 7)
    Rx(q[4], PI / 8)
    Ry(q[5], PI / 2)
    Rz(q[6], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    # layer 1
    Rx(q[0], PI / 5)
    Ry(q[1], PI / 6)
    Rz(q[2], PI / 7)
    Rx(q[3], PI / 8)
    Ry(q[4], PI / 2)
    Rz(q[5], PI / 3)
    Rx(q[6], PI / 4)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    # layer 2
    Ry(q[0], PI / 6)
    Rz(q[1], PI / 7)
    Rx(q[2], PI / 8)
    Ry(q[3], PI / 2)
    Rz(q[4], PI / 3)
    Rx(q[5], PI / 4)
    Ry(q[6], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

45. 045_variational_pattern_45.sq — 045 variational pattern 45

# Generated variational circuit pattern 45
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Rx(q[0], PI / 5)
    Ry(q[1], PI / 6)
    Rz(q[2], PI / 7)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

46. 046_variational_pattern_46.sq — 046 variational pattern 46

# Generated variational circuit pattern 46
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Ry(q[0], PI / 6)
    Rz(q[1], PI / 7)
    Rx(q[2], PI / 8)
    Ry(q[3], PI / 2)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    # layer 1
    Rz(q[0], PI / 7)
    Rx(q[1], PI / 8)
    Ry(q[2], PI / 2)
    Rz(q[3], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

47. 047_variational_pattern_47.sq — 047 variational pattern 47

# Generated variational circuit pattern 47
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Rz(q[0], PI / 7)
    Rx(q[1], PI / 8)
    Ry(q[2], PI / 2)
    Rz(q[3], PI / 3)
    Rx(q[4], PI / 4)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    # layer 1
    Rx(q[0], PI / 8)
    Ry(q[1], PI / 2)
    Rz(q[2], PI / 3)
    Rx(q[3], PI / 4)
    Ry(q[4], PI / 5)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    # layer 2
    Ry(q[0], PI / 2)
    Rz(q[1], PI / 3)
    Rx(q[2], PI / 4)
    Ry(q[3], PI / 5)
    Rz(q[4], PI / 6)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

48. 048_variational_pattern_48.sq — 048 variational pattern 48

# Generated variational circuit pattern 48
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Rx(q[0], PI / 8)
    Ry(q[1], PI / 2)
    Rz(q[2], PI / 3)
    Rx(q[3], PI / 4)
    Ry(q[4], PI / 5)
    Rz(q[5], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

49. 049_variational_pattern_49.sq — 049 variational pattern 49

# Generated variational circuit pattern 49
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Ry(q[0], PI / 2)
    Rz(q[1], PI / 3)
    Rx(q[2], PI / 4)
    Ry(q[3], PI / 5)
    Rz(q[4], PI / 6)
    Rx(q[5], PI / 7)
    Ry(q[6], PI / 8)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    # layer 1
    Rz(q[0], PI / 3)
    Rx(q[1], PI / 4)
    Ry(q[2], PI / 5)
    Rz(q[3], PI / 6)
    Rx(q[4], PI / 7)
    Ry(q[5], PI / 8)
    Rz(q[6], PI / 2)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

50. 050_variational_pattern_50.sq — 050 variational pattern 50

# Generated variational circuit pattern 50
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Rz(q[0], PI / 3)
    Rx(q[1], PI / 4)
    Ry(q[2], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    # layer 1
    Rx(q[0], PI / 4)
    Ry(q[1], PI / 5)
    Rz(q[2], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    # layer 2
    Ry(q[0], PI / 5)
    Rz(q[1], PI / 6)
    Rx(q[2], PI / 7)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

51. 051_variational_pattern_51.sq — 051 variational pattern 51

# Generated variational circuit pattern 51
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Rx(q[0], PI / 4)
    Ry(q[1], PI / 5)
    Rz(q[2], PI / 6)
    Rx(q[3], PI / 7)
    RZZ(q[0], q[1], PI / 4)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 6)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

52. 052_variational_pattern_52.sq — 052 variational pattern 52

# Generated variational circuit pattern 52
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Ry(q[0], PI / 5)
    Rz(q[1], PI / 6)
    Rx(q[2], PI / 7)
    Ry(q[3], PI / 8)
    Rz(q[4], PI / 2)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 6)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 3)
    # layer 1
    Rz(q[0], PI / 6)
    Rx(q[1], PI / 7)
    Ry(q[2], PI / 8)
    Rz(q[3], PI / 2)
    Rx(q[4], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 6)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 3)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

53. 053_variational_pattern_53.sq — 053 variational pattern 53

# Generated variational circuit pattern 53
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Rz(q[0], PI / 6)
    Rx(q[1], PI / 7)
    Ry(q[2], PI / 8)
    Rz(q[3], PI / 2)
    Rx(q[4], PI / 3)
    Ry(q[5], PI / 4)
    RZZ(q[0], q[1], PI / 6)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 3)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 5)
    # layer 1
    Rx(q[0], PI / 7)
    Ry(q[1], PI / 8)
    Rz(q[2], PI / 2)
    Rx(q[3], PI / 3)
    Ry(q[4], PI / 4)
    Rz(q[5], PI / 5)
    RZZ(q[0], q[1], PI / 6)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 3)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 5)
    # layer 2
    Ry(q[0], PI / 8)
    Rz(q[1], PI / 2)
    Rx(q[2], PI / 3)
    Ry(q[3], PI / 4)
    Rz(q[4], PI / 5)
    Rx(q[5], PI / 6)
    RZZ(q[0], q[1], PI / 6)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 3)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 5)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

54. 054_variational_pattern_54.sq — 054 variational pattern 54

# Generated variational circuit pattern 54
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Rx(q[0], PI / 7)
    Ry(q[1], PI / 8)
    Rz(q[2], PI / 2)
    Rx(q[3], PI / 3)
    Ry(q[4], PI / 4)
    Rz(q[5], PI / 5)
    Rx(q[6], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

55. 055_variational_pattern_55.sq — 055 variational pattern 55

# Generated variational circuit pattern 55
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Ry(q[0], PI / 8)
    Rz(q[1], PI / 2)
    Rx(q[2], PI / 3)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    # layer 1
    Rz(q[0], PI / 2)
    Rx(q[1], PI / 3)
    Ry(q[2], PI / 4)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

56. 056_variational_pattern_56.sq — 056 variational pattern 56

# Generated variational circuit pattern 56
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Rz(q[0], PI / 2)
    Rx(q[1], PI / 3)
    Ry(q[2], PI / 4)
    Rz(q[3], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    # layer 1
    Rx(q[0], PI / 3)
    Ry(q[1], PI / 4)
    Rz(q[2], PI / 5)
    Rx(q[3], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    # layer 2
    Ry(q[0], PI / 4)
    Rz(q[1], PI / 5)
    Rx(q[2], PI / 6)
    Ry(q[3], PI / 7)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

57. 057_variational_pattern_57.sq — 057 variational pattern 57

# Generated variational circuit pattern 57
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Rx(q[0], PI / 3)
    Ry(q[1], PI / 4)
    Rz(q[2], PI / 5)
    Rx(q[3], PI / 6)
    Ry(q[4], PI / 7)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

58. 058_variational_pattern_58.sq — 058 variational pattern 58

# Generated variational circuit pattern 58
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Ry(q[0], PI / 4)
    Rz(q[1], PI / 5)
    Rx(q[2], PI / 6)
    Ry(q[3], PI / 7)
    Rz(q[4], PI / 8)
    Rx(q[5], PI / 2)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    # layer 1
    Rz(q[0], PI / 5)
    Rx(q[1], PI / 6)
    Ry(q[2], PI / 7)
    Rz(q[3], PI / 8)
    Rx(q[4], PI / 2)
    Ry(q[5], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

59. 059_variational_pattern_59.sq — 059 variational pattern 59

# Generated variational circuit pattern 59
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Rz(q[0], PI / 5)
    Rx(q[1], PI / 6)
    Ry(q[2], PI / 7)
    Rz(q[3], PI / 8)
    Rx(q[4], PI / 2)
    Ry(q[5], PI / 3)
    Rz(q[6], PI / 4)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    # layer 1
    Rx(q[0], PI / 6)
    Ry(q[1], PI / 7)
    Rz(q[2], PI / 8)
    Rx(q[3], PI / 2)
    Ry(q[4], PI / 3)
    Rz(q[5], PI / 4)
    Rx(q[6], PI / 5)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    # layer 2
    Ry(q[0], PI / 7)
    Rz(q[1], PI / 8)
    Rx(q[2], PI / 2)
    Ry(q[3], PI / 3)
    Rz(q[4], PI / 4)
    Rx(q[5], PI / 5)
    Ry(q[6], PI / 6)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

60. 060_variational_pattern_60.sq — 060 variational pattern 60

# Generated variational circuit pattern 60
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Rx(q[0], PI / 6)
    Ry(q[1], PI / 7)
    Rz(q[2], PI / 8)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

61. 061_variational_pattern_61.sq — 061 variational pattern 61

# Generated variational circuit pattern 61
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Ry(q[0], PI / 7)
    Rz(q[1], PI / 8)
    Rx(q[2], PI / 2)
    Ry(q[3], PI / 3)
    RZZ(q[0], q[1], PI / 4)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 6)
    # layer 1
    Rz(q[0], PI / 8)
    Rx(q[1], PI / 2)
    Ry(q[2], PI / 3)
    Rz(q[3], PI / 4)
    RZZ(q[0], q[1], PI / 4)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 6)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

62. 062_variational_pattern_62.sq — 062 variational pattern 62

# Generated variational circuit pattern 62
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Rz(q[0], PI / 8)
    Rx(q[1], PI / 2)
    Ry(q[2], PI / 3)
    Rz(q[3], PI / 4)
    Rx(q[4], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 6)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 3)
    # layer 1
    Rx(q[0], PI / 2)
    Ry(q[1], PI / 3)
    Rz(q[2], PI / 4)
    Rx(q[3], PI / 5)
    Ry(q[4], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 6)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 3)
    # layer 2
    Ry(q[0], PI / 3)
    Rz(q[1], PI / 4)
    Rx(q[2], PI / 5)
    Ry(q[3], PI / 6)
    Rz(q[4], PI / 7)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 6)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 3)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

63. 063_variational_pattern_63.sq — 063 variational pattern 63

# Generated variational circuit pattern 63
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Rx(q[0], PI / 2)
    Ry(q[1], PI / 3)
    Rz(q[2], PI / 4)
    Rx(q[3], PI / 5)
    Ry(q[4], PI / 6)
    Rz(q[5], PI / 7)
    RZZ(q[0], q[1], PI / 6)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 3)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 5)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

64. 064_variational_pattern_64.sq — 064 variational pattern 64

# Generated variational circuit pattern 64
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Ry(q[0], PI / 3)
    Rz(q[1], PI / 4)
    Rx(q[2], PI / 5)
    Ry(q[3], PI / 6)
    Rz(q[4], PI / 7)
    Rx(q[5], PI / 8)
    Ry(q[6], PI / 2)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    # layer 1
    Rz(q[0], PI / 4)
    Rx(q[1], PI / 5)
    Ry(q[2], PI / 6)
    Rz(q[3], PI / 7)
    Rx(q[4], PI / 8)
    Ry(q[5], PI / 2)
    Rz(q[6], PI / 3)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 3)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 5)
    CNOT(q[4], q[5])
    RZZ(q[5], q[6], PI / 7)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

65. 065_variational_pattern_65.sq — 065 variational pattern 65

# Generated variational circuit pattern 65
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Rz(q[0], PI / 4)
    Rx(q[1], PI / 5)
    Ry(q[2], PI / 6)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    # layer 1
    Rx(q[0], PI / 5)
    Ry(q[1], PI / 6)
    Rz(q[2], PI / 7)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    # layer 2
    Ry(q[0], PI / 6)
    Rz(q[1], PI / 7)
    Rx(q[2], PI / 8)
    RZZ(q[0], q[1], PI / 3)
    CNOT(q[1], q[2])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

66. 066_variational_pattern_66.sq — 066 variational pattern 66

# Generated variational circuit pattern 66
simulate(4, engine="sparse") {
    let q = quantum_register(4)
    H_all()
    # layer 0
    Rx(q[0], PI / 5)
    Ry(q[1], PI / 6)
    Rz(q[2], PI / 7)
    Rx(q[3], PI / 8)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 5)
    CNOT(q[2], q[3])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

67. 067_variational_pattern_67.sq — 067 variational pattern 67

# Generated variational circuit pattern 67
simulate(5, engine="sparse") {
    let q = quantum_register(5)
    H_all()
    # layer 0
    Ry(q[0], PI / 6)
    Rz(q[1], PI / 7)
    Rx(q[2], PI / 8)
    Ry(q[3], PI / 2)
    Rz(q[4], PI / 3)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    # layer 1
    Rz(q[0], PI / 7)
    Rx(q[1], PI / 8)
    Ry(q[2], PI / 2)
    Rz(q[3], PI / 3)
    Rx(q[4], PI / 4)
    RZZ(q[0], q[1], PI / 5)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 7)
    CNOT(q[3], q[4])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

68. 068_variational_pattern_68.sq — 068 variational pattern 68

# Generated variational circuit pattern 68
simulate(6, engine="sparse") {
    let q = quantum_register(6)
    H_all()
    # layer 0
    Rz(q[0], PI / 7)
    Rx(q[1], PI / 8)
    Ry(q[2], PI / 2)
    Rz(q[3], PI / 3)
    Rx(q[4], PI / 4)
    Ry(q[5], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    # layer 1
    Rx(q[0], PI / 8)
    Ry(q[1], PI / 2)
    Rz(q[2], PI / 3)
    Rx(q[3], PI / 4)
    Ry(q[4], PI / 5)
    Rz(q[5], PI / 6)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    # layer 2
    Ry(q[0], PI / 2)
    Rz(q[1], PI / 3)
    Rx(q[2], PI / 4)
    Ry(q[3], PI / 5)
    Rz(q[4], PI / 6)
    Rx(q[5], PI / 7)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 7)
    CNOT(q[2], q[3])
    RZZ(q[3], q[4], PI / 4)
    CNOT(q[4], q[5])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

69. 069_variational_pattern_69.sq — 069 variational pattern 69

# Generated variational circuit pattern 69
simulate(7, engine="sparse") {
    let q = quantum_register(7)
    H_all()
    # layer 0
    Rx(q[0], PI / 8)
    Ry(q[1], PI / 2)
    Rz(q[2], PI / 3)
    Rx(q[3], PI / 4)
    Ry(q[4], PI / 5)
    Rz(q[5], PI / 6)
    Rx(q[6], PI / 7)
    RZZ(q[0], q[1], PI / 7)
    CNOT(q[1], q[2])
    RZZ(q[2], q[3], PI / 4)
    CNOT(q[3], q[4])
    RZZ(q[4], q[5], PI / 6)
    CNOT(q[5], q[6])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

70. 070_variational_pattern_70.sq — 070 variational pattern 70

# Generated variational circuit pattern 70
simulate(3, engine="sparse") {
    let q = quantum_register(3)
    H_all()
    # layer 0
    Ry(q[0], PI / 2)
    Rz(q[1], PI / 3)
    Rx(q[2], PI / 4)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    # layer 1
    Rz(q[0], PI / 3)
    Rx(q[1], PI / 4)
    Ry(q[2], PI / 5)
    CNOT(q[0], q[1])
    RZZ(q[1], q[2], PI / 4)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

71. 071_phase_kickback.sq — 071 phase kickback

# phase_kickback example 71
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    X(q[0])
    H_all()
    for i in range(6) {
        CP(q[i + 1], q[0], PI / (i + 2))
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

72. 072_hidden_shift.sq — 072 hidden shift

# hidden_shift example 72
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H_all()
    for i in range(4) {
        Rz(q[i], PI / (i + 2))
    }
    for i in range(3) {
        CNOT(q[i], q[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

73. 073_qft_phase_grid.sq — 073 qft phase grid

# qft_phase_grid example 73
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    X(q[0])
    X(q[2])
    qft(q)
    Rz(q[1], PI / 7)
    iqft(q)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

74. 074_entangled_ladder.sq — 074 entangled ladder

# entangled_ladder example 74
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H(q[0])
    for i in range(5) {
        CNOT(q[i], q[i + 1])
        RZZ(q[i], q[i + 1], PI / 5)
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

75. 075_hardware_efficient_ansatz.sq — 075 hardware efficient ansatz

# hardware_efficient_ansatz example 75
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    for layer in range(3) {
        for i in range(7) {
            Ry(q[i], PI / (layer + i + 2))
            Rz(q[i], PI / (layer + i + 3))
        }
        for i in range(6) {
            CNOT(q[i], q[i + 1])
        }
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

76. 076_maxcut_ansatz.sq — 076 maxcut ansatz

# maxcut_ansatz example 76
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H_all()
    for i in range(3) {
        RZZ(q[i], q[i + 1], PI / 4)
    }
    Rx_all(PI / 6)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

77. 077_qml_feature_map.sq — 077 qml feature map

# qml_feature_map example 77
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    let x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7][: 5]
    for i in range(5) {
        H(q[i])
        Rz(q[i], x[i])
    }
    for i in range(4) {
        RZZ(q[i], q[i + 1], x[i] * x[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

78. 078_controlled_rotation_bank.sq — 078 controlled rotation bank

# controlled_rotation_bank example 78
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H(q[0])
    for i in range(1, 6) {
        CRz(q[0], q[i], PI / (i + 1))
        CRx(q[0], q[i], PI / (i + 2))
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

79. 079_multi_control_demo.sq — 079 multi control demo

# multi_control_demo example 79
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    for i in range(6) {
        X(q[i])
    }
    MCX(q[0], q[1], q[2], q[6])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

80. 080_sparse_large_index.sq — 080 sparse large index

# sparse_large_index example 80
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H(q[0])
    CNOT(q[0], q[3])
    RZZ(q[0], q[3], PI / 9)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

81. 081_phase_kickback.sq — 081 phase kickback

# phase_kickback example 81
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    X(q[0])
    H_all()
    for i in range(4) {
        CP(q[i + 1], q[0], PI / (i + 2))
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

82. 082_hidden_shift.sq — 082 hidden shift

# hidden_shift example 82
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H_all()
    for i in range(6) {
        Rz(q[i], PI / (i + 2))
    }
    for i in range(5) {
        CNOT(q[i], q[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

83. 083_qft_phase_grid.sq — 083 qft phase grid

# qft_phase_grid example 83
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    X(q[0])
    X(q[2])
    qft(q)
    Rz(q[1], PI / 7)
    iqft(q)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

84. 084_entangled_ladder.sq — 084 entangled ladder

# entangled_ladder example 84
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H(q[0])
    for i in range(3) {
        CNOT(q[i], q[i + 1])
        RZZ(q[i], q[i + 1], PI / 5)
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

85. 085_hardware_efficient_ansatz.sq — 085 hardware efficient ansatz

# hardware_efficient_ansatz example 85
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    for layer in range(3) {
        for i in range(5) {
            Ry(q[i], PI / (layer + i + 2))
            Rz(q[i], PI / (layer + i + 3))
        }
        for i in range(4) {
            CNOT(q[i], q[i + 1])
        }
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

86. 086_maxcut_ansatz.sq — 086 maxcut ansatz

# maxcut_ansatz example 86
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H_all()
    for i in range(5) {
        RZZ(q[i], q[i + 1], PI / 4)
    }
    Rx_all(PI / 6)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

87. 087_qml_feature_map.sq — 087 qml feature map

# qml_feature_map example 87
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    let x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7][: 7]
    for i in range(7) {
        H(q[i])
        Rz(q[i], x[i])
    }
    for i in range(6) {
        RZZ(q[i], q[i + 1], x[i] * x[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

88. 088_controlled_rotation_bank.sq — 088 controlled rotation bank

# controlled_rotation_bank example 88
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H(q[0])
    for i in range(1, 4) {
        CRz(q[0], q[i], PI / (i + 1))
        CRx(q[0], q[i], PI / (i + 2))
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

89. 089_multi_control_demo.sq — 089 multi control demo

# multi_control_demo example 89
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    for i in range(4) {
        X(q[i])
    }
    MCX(q[0], q[1], q[2], q[4])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

90. 090_sparse_large_index.sq — 090 sparse large index

# sparse_large_index example 90
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H(q[0])
    CNOT(q[0], q[5])
    RZZ(q[0], q[5], PI / 9)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

91. 091_phase_kickback.sq — 091 phase kickback

# phase_kickback example 91
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    X(q[0])
    H_all()
    for i in range(6) {
        CP(q[i + 1], q[0], PI / (i + 2))
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

92. 092_hidden_shift.sq — 092 hidden shift

# hidden_shift example 92
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H_all()
    for i in range(4) {
        Rz(q[i], PI / (i + 2))
    }
    for i in range(3) {
        CNOT(q[i], q[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

93. 093_qft_phase_grid.sq — 093 qft phase grid

# qft_phase_grid example 93
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    X(q[0])
    X(q[2])
    qft(q)
    Rz(q[1], PI / 7)
    iqft(q)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

94. 094_entangled_ladder.sq — 094 entangled ladder

# entangled_ladder example 94
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H(q[0])
    for i in range(5) {
        CNOT(q[i], q[i + 1])
        RZZ(q[i], q[i + 1], PI / 5)
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

95. 095_hardware_efficient_ansatz.sq — 095 hardware efficient ansatz

# hardware_efficient_ansatz example 95
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    for layer in range(3) {
        for i in range(7) {
            Ry(q[i], PI / (layer + i + 2))
            Rz(q[i], PI / (layer + i + 3))
        }
        for i in range(6) {
            CNOT(q[i], q[i + 1])
        }
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

96. 096_maxcut_ansatz.sq — 096 maxcut ansatz

# maxcut_ansatz example 96
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H_all()
    for i in range(3) {
        RZZ(q[i], q[i + 1], PI / 4)
    }
    Rx_all(PI / 6)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

97. 097_qml_feature_map.sq — 097 qml feature map

# qml_feature_map example 97
simulate(5, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(5)
    let x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7][: 5]
    for i in range(5) {
        H(q[i])
        Rz(q[i], x[i])
    }
    for i in range(4) {
        RZZ(q[i], q[i + 1], x[i] * x[i + 1])
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

98. 098_controlled_rotation_bank.sq — 098 controlled rotation bank

# controlled_rotation_bank example 98
simulate(6, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(6)
    H(q[0])
    for i in range(1, 6) {
        CRz(q[0], q[i], PI / (i + 1))
        CRx(q[0], q[i], PI / (i + 2))
    }
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

99. 099_multi_control_demo.sq — 099 multi control demo

# multi_control_demo example 99
simulate(7, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(7)
    for i in range(6) {
        X(q[i])
    }
    MCX(q[0], q[1], q[2], q[6])
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

100. 100_sparse_large_index.sq — 100 sparse large index

# sparse_large_index example 100
simulate(4, engine="sharded", n_shards=4, workers=2) {
    let q = quantum_register(4)
    H(q[0])
    CNOT(q[0], q[3])
    RZZ(q[0], q[3], PI / 9)
    print(engine_nnz())
    print(measure_all(q, shots=128))
}

101. 101_stabilizer_ghz_1000.sq — 101 stabilizer ghz 1000

# 1000-qubit Clifford GHZ smoke test; exact tableau, no dense expansion.
simulate(1000, engine="stabilizer", seed=7) {
    H(0)
    for i in range(0, 999) {
        CNOT(i, i + 1)
    }
    print(measure_all(shots=8))
}

102. 102_mps_low_entanglement_chain.sq — 102 mps low entanglement chain

# Low-entanglement MPS chain with small bond dimension.
simulate(32, engine="mps", max_bond_dim=32, seed=3) {
    for i in range(0, 32) {
        Ry(i, 0.1)
    }
    for i in range(0, 31) {
        CNOT(i, i + 1)
    }
    print(measure_all(shots=16))
}

103. 103_density_depolarizing_noise.sq — 103 density depolarizing noise

# Density-matrix noisy Bell state with depolarizing noise.
simulate(2, engine="density", seed=5) {
    H(0)
    CNOT(0, 1)
    noise_depolarize(0, 0.05)
    noise_depolarize(1, 0.05)
    print(probabilities())
}

104. 104_density_amplitude_damping.sq — 104 density amplitude damping

# Amplitude damping drives |1> toward |0>.
simulate(1, engine="density", seed=5) {
    X(0)
    noise_amplitude_damping(0, 0.30)
    print(probabilities())
}

105. 105_hybrid_backend_selection.sq — 105 hybrid backend selection

# Hybrid chooses stabilizer for Clifford circuits and sparse/MPS otherwise.
simulate(4, engine="stabilizer", seed=11) {
    H(0)
    CNOT(0, 1)
    CNOT(1, 2)
    CNOT(2, 3)
    print(measure_all(shots=8))
}

106. 106_optimizer_cancel_rotations.sq — 106 optimizer cancel rotations

# Optimizer is available from Python API; in DSL use direct simplified code.
simulate(1, seed=1) {
    H(0)
    H(0)
    Rz(0, 0.25)
    Rz(0, -0.25)
    print(probabilities())
}

107. 107_gpu_backend_small.sq — 107 gpu backend small

# GPU backend syntax reference. Uncomment the simulate block after installing sansqrit[gpu].
# simulate(3, engine="gpu", seed=1) {
#     H(0)
#     CNOT(0, 1)
#     Rz(2, 0.4)
#     print(measure_all(shots=8))
# }
print("GPU example: install sansqrit[gpu], then uncomment the simulate block.")

108. 108_qiskit_interop_reference.sq — 108 qiskit interop reference

# Interop is primarily Python API: sansqrit.interop.to_qiskit(Circuit(...)).
# DSL can still export QASM for external tools.
simulate(2, seed=2) {
    H(0)
    CNOT(0, 1)
    print(export_qasm3())
}

109. 109_large_sparse_150_qubits.sq — 109 large sparse 150 qubits

# 150 logical qubits with sparse state. Avoid H_all on all 150 unless you expect expansion.
simulate(150, engine="sparse", seed=9) {
    X(149)
    H(0)
    CNOT(0, 149)
    print(engine_nnz())
    print(measure_all(shots=8))
}

110. 110_mps_qft_lite.sq — 110 mps qft lite

# Small QFT-style tensor run. For large QFT, bond growth may require high max_bond_dim.
simulate(8, engine="mps", max_bond_dim=64, seed=4) {
    X(0)
    qft()
    print(measure_all(shots=16))
}

111. 111_150q_sensor_fusion_111.sq — 111 150q sensor fusion 111

# Example 111: 150-qubit real-time sensor fusion anomaly flag.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=111) {
    let q = quantum_register(150)
    X(q[32])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[32], q[102])
    Rz(q[99], PI / 23)
    Phase(q[149], PI / 33)
    print("real-time sensor fusion anomaly flag")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

112. 112_150q_satellite_telemetry_112.sq — 112 150q satellite telemetry 112

# Example 112: 150-qubit satellite telemetry sparse state update.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=112) {
    let q = quantum_register(150)
    X(q[39])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[39], q[115])
    Rz(q[116], PI / 16)
    Phase(q[149], PI / 34)
    print("satellite telemetry sparse state update")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

113. 113_150q_network_intrusion_113.sq — 113 150q network intrusion 113

# Example 113: 150-qubit network intrusion signature superposition.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=113) {
    let q = quantum_register(150)
    X(q[46])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[46], q[128])
    Rz(q[133], PI / 17)
    Phase(q[149], PI / 35)
    print("network intrusion signature superposition")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

114. 114_150q_portfolio_risk_114.sq — 114 150q portfolio risk 114

# Example 114: 150-qubit portfolio risk qubit flagging.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=114) {
    let q = quantum_register(150)
    X(q[53])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[53], q[141])
    Rz(q[1], PI / 18)
    Phase(q[149], PI / 36)
    print("portfolio risk qubit flagging")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

115. 115_150q_drug_screening_115.sq — 115 150q drug screening 115

# Example 115: 150-qubit drug candidate sparse oracle marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=115) {
    let q = quantum_register(150)
    X(q[60])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[60], q[5])
    Rz(q[18], PI / 19)
    Phase(q[149], PI / 32)
    print("drug candidate sparse oracle marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

116. 116_150q_battery_material_116.sq — 116 150q battery material 116

# Example 116: 150-qubit battery material candidate phase tag.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=116) {
    let q = quantum_register(150)
    X(q[67])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[67], q[18])
    Rz(q[35], PI / 20)
    Phase(q[149], PI / 33)
    print("battery material candidate phase tag")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

117. 117_150q_smart_grid_117.sq — 117 150q smart grid 117

# Example 117: 150-qubit smart grid load-balancing state flag.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=117) {
    let q = quantum_register(150)
    X(q[74])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[74], q[31])
    Rz(q[52], PI / 21)
    Phase(q[149], PI / 34)
    print("smart grid load-balancing state flag")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

118. 118_150q_robotics_path_118.sq — 118 150q robotics path 118

# Example 118: 150-qubit robotics path branch marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=118) {
    let q = quantum_register(150)
    X(q[81])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[81], q[44])
    Rz(q[69], PI / 22)
    Phase(q[149], PI / 35)
    print("robotics path branch marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

119. 119_150q_climate_event_119.sq — 119 150q climate event 119

# Example 119: 150-qubit climate event sparse alert.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=119) {
    let q = quantum_register(150)
    X(q[88])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[88], q[57])
    Rz(q[86], PI / 23)
    Phase(q[149], PI / 36)
    print("climate event sparse alert")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

120. 120_150q_factory_quality_120.sq — 120 150q factory quality 120

# Example 120: 150-qubit factory quality-control qubit register.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=120) {
    let q = quantum_register(150)
    X(q[95])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[95], q[70])
    Rz(q[103], PI / 16)
    Phase(q[149], PI / 32)
    print("factory quality-control qubit register")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

121. 121_150q_traffic_routing_121.sq — 121 150q traffic routing 121

# Example 121: 150-qubit traffic routing decision bit.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=121) {
    let q = quantum_register(150)
    X(q[102])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[102], q[83])
    Rz(q[120], PI / 17)
    Phase(q[149], PI / 33)
    print("traffic routing decision bit")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

122. 122_150q_fraud_detection_122.sq — 122 150q fraud detection 122

# Example 122: 150-qubit fraud detection sparse score marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=122) {
    let q = quantum_register(150)
    X(q[109])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[109], q[96])
    Rz(q[137], PI / 18)
    Phase(q[149], PI / 34)
    print("fraud detection sparse score marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

123. 123_150q_genomics_variant_123.sq — 123 150q genomics variant 123

# Example 123: 150-qubit genomics variant marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=123) {
    let q = quantum_register(150)
    X(q[116])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[116], q[109])
    Rz(q[5], PI / 19)
    Phase(q[149], PI / 35)
    print("genomics variant marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

124. 124_150q_seismic_monitor_124.sq — 124 150q seismic monitor 124

# Example 124: 150-qubit seismic event marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=124) {
    let q = quantum_register(150)
    X(q[123])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[123], q[122])
    Rz(q[22], PI / 20)
    Phase(q[149], PI / 36)
    print("seismic event marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

125. 125_150q_iot_edge_125.sq — 125 150q iot edge 125

# Example 125: 150-qubit IoT edge telemetry marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=125) {
    let q = quantum_register(150)
    X(q[130])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[130], q[135])
    Rz(q[39], PI / 21)
    Phase(q[149], PI / 32)
    print("IoT edge telemetry marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

126. 126_150q_cyber_key_health_126.sq — 126 150q cyber key health 126

# Example 126: 150-qubit cyber key health monitor.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=126) {
    let q = quantum_register(150)
    X(q[137])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[137], q[148])
    Rz(q[56], PI / 22)
    Phase(q[149], PI / 33)
    print("cyber key health monitor")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

127. 127_150q_medical_triage_127.sq — 127 150q medical triage 127

# Example 127: 150-qubit medical triage sparse decision.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=127) {
    let q = quantum_register(150)
    X(q[144])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[144], q[12])
    Rz(q[73], PI / 23)
    Phase(q[149], PI / 34)
    print("medical triage sparse decision")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

128. 128_150q_supply_chain_128.sq — 128 150q supply chain 128

# Example 128: 150-qubit supply chain disruption indicator.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=128) {
    let q = quantum_register(150)
    X(q[2])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[2], q[25])
    Rz(q[90], PI / 16)
    Phase(q[149], PI / 35)
    print("supply chain disruption indicator")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

129. 129_150q_water_network_129.sq — 129 150q water network 129

# Example 129: 150-qubit water network pressure anomaly.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=129) {
    let q = quantum_register(150)
    X(q[9])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[9], q[38])
    Rz(q[107], PI / 17)
    Phase(q[149], PI / 36)
    print("water network pressure anomaly")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

130. 130_150q_energy_market_130.sq — 130 150q energy market 130

# Example 130: 150-qubit energy market sparse branch.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=130) {
    let q = quantum_register(150)
    X(q[16])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[16], q[51])
    Rz(q[124], PI / 18)
    Phase(q[149], PI / 32)
    print("energy market sparse branch")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

131. 131_150q_sensor_fusion_131.sq — 131 150q sensor fusion 131

# Example 131: 150-qubit real-time sensor fusion anomaly flag.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=131) {
    let q = quantum_register(150)
    X(q[23])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[23], q[64])
    Rz(q[141], PI / 19)
    Phase(q[149], PI / 33)
    print("real-time sensor fusion anomaly flag")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

132. 132_150q_satellite_telemetry_132.sq — 132 150q satellite telemetry 132

# Example 132: 150-qubit satellite telemetry sparse state update.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=132) {
    let q = quantum_register(150)
    X(q[30])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[30], q[77])
    Rz(q[9], PI / 20)
    Phase(q[149], PI / 34)
    print("satellite telemetry sparse state update")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

133. 133_150q_network_intrusion_133.sq — 133 150q network intrusion 133

# Example 133: 150-qubit network intrusion signature superposition.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=133) {
    let q = quantum_register(150)
    X(q[37])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[37], q[90])
    Rz(q[26], PI / 21)
    Phase(q[149], PI / 35)
    print("network intrusion signature superposition")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

134. 134_150q_portfolio_risk_134.sq — 134 150q portfolio risk 134

# Example 134: 150-qubit portfolio risk qubit flagging.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=134) {
    let q = quantum_register(150)
    X(q[44])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[44], q[103])
    Rz(q[43], PI / 22)
    Phase(q[149], PI / 36)
    print("portfolio risk qubit flagging")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

135. 135_150q_drug_screening_135.sq — 135 150q drug screening 135

# Example 135: 150-qubit drug candidate sparse oracle marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=135) {
    let q = quantum_register(150)
    X(q[51])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[51], q[116])
    Rz(q[60], PI / 23)
    Phase(q[149], PI / 32)
    print("drug candidate sparse oracle marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

136. 136_150q_battery_material_136.sq — 136 150q battery material 136

# Example 136: 150-qubit battery material candidate phase tag.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=136) {
    let q = quantum_register(150)
    X(q[58])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[58], q[129])
    Rz(q[77], PI / 16)
    Phase(q[149], PI / 33)
    print("battery material candidate phase tag")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

137. 137_150q_smart_grid_137.sq — 137 150q smart grid 137

# Example 137: 150-qubit smart grid load-balancing state flag.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=137) {
    let q = quantum_register(150)
    X(q[65])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[65], q[142])
    Rz(q[94], PI / 17)
    Phase(q[149], PI / 34)
    print("smart grid load-balancing state flag")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

138. 138_150q_robotics_path_138.sq — 138 150q robotics path 138

# Example 138: 150-qubit robotics path branch marker.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=138) {
    let q = quantum_register(150)
    X(q[72])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[72], q[6])
    Rz(q[111], PI / 18)
    Phase(q[149], PI / 35)
    print("robotics path branch marker")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

139. 139_150q_climate_event_139.sq — 139 150q climate event 139

# Example 139: 150-qubit climate event sparse alert.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=139) {
    let q = quantum_register(150)
    X(q[79])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[79], q[19])
    Rz(q[128], PI / 19)
    Phase(q[149], PI / 36)
    print("climate event sparse alert")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

140. 140_150q_factory_quality_140.sq — 140 150q factory quality 140

# Example 140: 150-qubit factory quality-control qubit register.
# Design rule: touch only a few sparse basis branches so this stays feasible on local hardware.
simulate(150, engine="sharded", n_shards=16, workers=4, seed=140) {
    let q = quantum_register(150)
    X(q[86])
    H(q[0])
    CNOT(q[0], q[149])
    CNOT(q[86], q[32])
    Rz(q[145], PI / 20)
    Phase(q[149], PI / 32)
    print("factory quality-control qubit register")
    print("logical_qubits", 150)
    print("nonzero_amplitudes", engine_nnz())
    print("sample", measure_all(q, shots=6))
}

141. 141_stabilizer_clifford_comm_141.sq — 141 stabilizer clifford comm 141

# Example 141: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(512, engine="stabilizer", seed=141) {
    H(423)
    S(423)
    CNOT(423, 440)
    CZ(440, 24)
    SWAP(423, 24)
    X(440)
    Z(24)
    print("clifford_comm")
    print("logical_qubits", 512)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

142. 142_stabilizer_graph_state_142.sq — 142 stabilizer graph state 142

# Example 142: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(768, engine="stabilizer", seed=142) {
    H(426)
    S(426)
    CNOT(426, 443)
    CZ(443, 539)
    SWAP(426, 539)
    X(443)
    Z(539)
    print("graph_state")
    print("logical_qubits", 768)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

143. 143_stabilizer_cluster_state_143.sq — 143 stabilizer cluster state 143

# Example 143: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1024, engine="stabilizer", seed=143) {
    H(429)
    S(429)
    CNOT(429, 446)
    CZ(446, 542)
    SWAP(429, 542)
    X(446)
    Z(542)
    print("cluster_state")
    print("logical_qubits", 1024)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

144. 144_stabilizer_parity_monitor_144.sq — 144 stabilizer parity monitor 144

# Example 144: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1280, engine="stabilizer", seed=144) {
    H(432)
    S(432)
    CNOT(432, 449)
    CZ(449, 545)
    SWAP(432, 545)
    X(449)
    Z(545)
    print("parity_monitor")
    print("logical_qubits", 1280)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

145. 145_stabilizer_surface_code_syndrome_145.sq — 145 stabilizer surface code syndrome 145

# Example 145: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1536, engine="stabilizer", seed=145) {
    H(435)
    S(435)
    CNOT(435, 452)
    CZ(452, 548)
    SWAP(435, 548)
    X(452)
    Z(548)
    print("surface_code_syndrome")
    print("logical_qubits", 1536)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

146. 146_stabilizer_clifford_comm_146.sq — 146 stabilizer clifford comm 146

# Example 146: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1792, engine="stabilizer", seed=146) {
    H(438)
    S(438)
    CNOT(438, 455)
    CZ(455, 551)
    SWAP(438, 551)
    X(455)
    Z(551)
    print("clifford_comm")
    print("logical_qubits", 1792)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

147. 147_stabilizer_graph_state_147.sq — 147 stabilizer graph state 147

# Example 147: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(512, engine="stabilizer", seed=147) {
    H(441)
    S(441)
    CNOT(441, 458)
    CZ(458, 42)
    SWAP(441, 42)
    X(458)
    Z(42)
    print("graph_state")
    print("logical_qubits", 512)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

148. 148_stabilizer_cluster_state_148.sq — 148 stabilizer cluster state 148

# Example 148: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(768, engine="stabilizer", seed=148) {
    H(444)
    S(444)
    CNOT(444, 461)
    CZ(461, 557)
    SWAP(444, 557)
    X(461)
    Z(557)
    print("cluster_state")
    print("logical_qubits", 768)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

149. 149_stabilizer_parity_monitor_149.sq — 149 stabilizer parity monitor 149

# Example 149: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1024, engine="stabilizer", seed=149) {
    H(447)
    S(447)
    CNOT(447, 464)
    CZ(464, 560)
    SWAP(447, 560)
    X(464)
    Z(560)
    print("parity_monitor")
    print("logical_qubits", 1024)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

150. 150_stabilizer_surface_code_syndrome_150.sq — 150 stabilizer surface code syndrome 150

# Example 150: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1280, engine="stabilizer", seed=150) {
    H(450)
    S(450)
    CNOT(450, 467)
    CZ(467, 563)
    SWAP(450, 563)
    X(467)
    Z(563)
    print("surface_code_syndrome")
    print("logical_qubits", 1280)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

151. 151_stabilizer_clifford_comm_151.sq — 151 stabilizer clifford comm 151

# Example 151: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1536, engine="stabilizer", seed=151) {
    H(453)
    S(453)
    CNOT(453, 470)
    CZ(470, 566)
    SWAP(453, 566)
    X(470)
    Z(566)
    print("clifford_comm")
    print("logical_qubits", 1536)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

152. 152_stabilizer_graph_state_152.sq — 152 stabilizer graph state 152

# Example 152: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1792, engine="stabilizer", seed=152) {
    H(456)
    S(456)
    CNOT(456, 473)
    CZ(473, 569)
    SWAP(456, 569)
    X(473)
    Z(569)
    print("graph_state")
    print("logical_qubits", 1792)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

153. 153_stabilizer_cluster_state_153.sq — 153 stabilizer cluster state 153

# Example 153: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(512, engine="stabilizer", seed=153) {
    H(459)
    S(459)
    CNOT(459, 476)
    CZ(476, 60)
    SWAP(459, 60)
    X(476)
    Z(60)
    print("cluster_state")
    print("logical_qubits", 512)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

154. 154_stabilizer_parity_monitor_154.sq — 154 stabilizer parity monitor 154

# Example 154: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(768, engine="stabilizer", seed=154) {
    H(462)
    S(462)
    CNOT(462, 479)
    CZ(479, 575)
    SWAP(462, 575)
    X(479)
    Z(575)
    print("parity_monitor")
    print("logical_qubits", 768)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

155. 155_stabilizer_surface_code_syndrome_155.sq — 155 stabilizer surface code syndrome 155

# Example 155: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1024, engine="stabilizer", seed=155) {
    H(465)
    S(465)
    CNOT(465, 482)
    CZ(482, 578)
    SWAP(465, 578)
    X(482)
    Z(578)
    print("surface_code_syndrome")
    print("logical_qubits", 1024)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

156. 156_stabilizer_clifford_comm_156.sq — 156 stabilizer clifford comm 156

# Example 156: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1280, engine="stabilizer", seed=156) {
    H(468)
    S(468)
    CNOT(468, 485)
    CZ(485, 581)
    SWAP(468, 581)
    X(485)
    Z(581)
    print("clifford_comm")
    print("logical_qubits", 1280)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

157. 157_stabilizer_graph_state_157.sq — 157 stabilizer graph state 157

# Example 157: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1536, engine="stabilizer", seed=157) {
    H(471)
    S(471)
    CNOT(471, 488)
    CZ(488, 584)
    SWAP(471, 584)
    X(488)
    Z(584)
    print("graph_state")
    print("logical_qubits", 1536)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

158. 158_stabilizer_cluster_state_158.sq — 158 stabilizer cluster state 158

# Example 158: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1792, engine="stabilizer", seed=158) {
    H(474)
    S(474)
    CNOT(474, 491)
    CZ(491, 587)
    SWAP(474, 587)
    X(491)
    Z(587)
    print("cluster_state")
    print("logical_qubits", 1792)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

159. 159_stabilizer_parity_monitor_159.sq — 159 stabilizer parity monitor 159

# Example 159: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(512, engine="stabilizer", seed=159) {
    H(477)
    S(477)
    CNOT(477, 494)
    CZ(494, 78)
    SWAP(477, 78)
    X(494)
    Z(78)
    print("parity_monitor")
    print("logical_qubits", 512)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

160. 160_stabilizer_surface_code_syndrome_160.sq — 160 stabilizer surface code syndrome 160

# Example 160: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(768, engine="stabilizer", seed=160) {
    H(480)
    S(480)
    CNOT(480, 497)
    CZ(497, 593)
    SWAP(480, 593)
    X(497)
    Z(593)
    print("surface_code_syndrome")
    print("logical_qubits", 768)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

161. 161_stabilizer_clifford_comm_161.sq — 161 stabilizer clifford comm 161

# Example 161: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1024, engine="stabilizer", seed=161) {
    H(483)
    S(483)
    CNOT(483, 500)
    CZ(500, 596)
    SWAP(483, 596)
    X(500)
    Z(596)
    print("clifford_comm")
    print("logical_qubits", 1024)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

162. 162_stabilizer_graph_state_162.sq — 162 stabilizer graph state 162

# Example 162: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1280, engine="stabilizer", seed=162) {
    H(486)
    S(486)
    CNOT(486, 503)
    CZ(503, 599)
    SWAP(486, 599)
    X(503)
    Z(599)
    print("graph_state")
    print("logical_qubits", 1280)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

163. 163_stabilizer_cluster_state_163.sq — 163 stabilizer cluster state 163

# Example 163: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1536, engine="stabilizer", seed=163) {
    H(489)
    S(489)
    CNOT(489, 506)
    CZ(506, 602)
    SWAP(489, 602)
    X(506)
    Z(602)
    print("cluster_state")
    print("logical_qubits", 1536)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

164. 164_stabilizer_parity_monitor_164.sq — 164 stabilizer parity monitor 164

# Example 164: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(1792, engine="stabilizer", seed=164) {
    H(492)
    S(492)
    CNOT(492, 509)
    CZ(509, 605)
    SWAP(492, 605)
    X(509)
    Z(605)
    print("parity_monitor")
    print("logical_qubits", 1792)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

165. 165_stabilizer_surface_code_syndrome_165.sq — 165 stabilizer surface code syndrome 165

# Example 165: stabilizer backend for thousands-scale Clifford simulation.
# Clifford-only circuits use tableau memory instead of dense 2^n state vectors.
simulate(512, engine="stabilizer", seed=165) {
    H(495)
    S(495)
    CNOT(495, 0)
    CZ(0, 96)
    SWAP(495, 96)
    X(0)
    Z(96)
    print("surface_code_syndrome")
    print("logical_qubits", 512)
    print("one_shot_prefix", list(measure_all(shots=1).keys())[0][0:32])
}

166. 166_mps_adiabatic_line_166.sq — 166 mps adiabatic line 166

# Example 166: MPS/tensor-network low-entanglement adiabatic_line.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(24, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=166) {
    let q = quantum_register(24)
    for layer in range(4) {
        H(q[layer % 24])
        CNOT(q[layer % 24], q[(layer + 1) % 24])
        Rz(q[(layer + 1) % 24], PI / (layer + 3))
    }
    print("adiabatic_line")
    print("logical_qubits", 24)
    print("shots", measure_all(q, shots=4))
}

167. 167_mps_qft_lite_167.sq — 167 mps qft lite 167

# Example 167: MPS/tensor-network low-entanglement qft_lite.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(28, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=167) {
    let q = quantum_register(28)
    for layer in range(5) {
        H(q[layer % 28])
        CNOT(q[layer % 28], q[(layer + 1) % 28])
        Rz(q[(layer + 1) % 28], PI / (layer + 3))
    }
    print("qft_lite")
    print("logical_qubits", 28)
    print("shots", measure_all(q, shots=4))
}

168. 168_mps_bond_dimension_probe_168.sq — 168 mps bond dimension probe 168

# Example 168: MPS/tensor-network low-entanglement bond_dimension_probe.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(32, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=168) {
    let q = quantum_register(32)
    for layer in range(3) {
        H(q[layer % 32])
        CNOT(q[layer % 32], q[(layer + 1) % 32])
        Rz(q[(layer + 1) % 32], PI / (layer + 3))
    }
    print("bond_dimension_probe")
    print("logical_qubits", 32)
    print("shots", measure_all(q, shots=4))
}

169. 169_mps_matrix_product_feature_map_169.sq — 169 mps matrix product feature map 169

# Example 169: MPS/tensor-network low-entanglement matrix_product_feature_map.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(36, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=169) {
    let q = quantum_register(36)
    for layer in range(4) {
        H(q[layer % 36])
        CNOT(q[layer % 36], q[(layer + 1) % 36])
        Rz(q[(layer + 1) % 36], PI / (layer + 3))
    }
    print("matrix_product_feature_map")
    print("logical_qubits", 36)
    print("shots", measure_all(q, shots=4))
}

170. 170_mps_spin_chain_170.sq — 170 mps spin chain 170

# Example 170: MPS/tensor-network low-entanglement spin_chain.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(40, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=170) {
    let q = quantum_register(40)
    for layer in range(5) {
        H(q[layer % 40])
        CNOT(q[layer % 40], q[(layer + 1) % 40])
        Rz(q[(layer + 1) % 40], PI / (layer + 3))
    }
    print("spin_chain")
    print("logical_qubits", 40)
    print("shots", measure_all(q, shots=4))
}

171. 171_mps_adiabatic_line_171.sq — 171 mps adiabatic line 171

# Example 171: MPS/tensor-network low-entanglement adiabatic_line.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(44, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=171) {
    let q = quantum_register(44)
    for layer in range(3) {
        H(q[layer % 44])
        CNOT(q[layer % 44], q[(layer + 1) % 44])
        Rz(q[(layer + 1) % 44], PI / (layer + 3))
    }
    print("adiabatic_line")
    print("logical_qubits", 44)
    print("shots", measure_all(q, shots=4))
}

172. 172_mps_qft_lite_172.sq — 172 mps qft lite 172

# Example 172: MPS/tensor-network low-entanglement qft_lite.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(48, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=172) {
    let q = quantum_register(48)
    for layer in range(4) {
        H(q[layer % 48])
        CNOT(q[layer % 48], q[(layer + 1) % 48])
        Rz(q[(layer + 1) % 48], PI / (layer + 3))
    }
    print("qft_lite")
    print("logical_qubits", 48)
    print("shots", measure_all(q, shots=4))
}

173. 173_mps_bond_dimension_probe_173.sq — 173 mps bond dimension probe 173

# Example 173: MPS/tensor-network low-entanglement bond_dimension_probe.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(52, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=173) {
    let q = quantum_register(52)
    for layer in range(5) {
        H(q[layer % 52])
        CNOT(q[layer % 52], q[(layer + 1) % 52])
        Rz(q[(layer + 1) % 52], PI / (layer + 3))
    }
    print("bond_dimension_probe")
    print("logical_qubits", 52)
    print("shots", measure_all(q, shots=4))
}

174. 174_mps_matrix_product_feature_map_174.sq — 174 mps matrix product feature map 174

# Example 174: MPS/tensor-network low-entanglement matrix_product_feature_map.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(24, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=174) {
    let q = quantum_register(24)
    for layer in range(3) {
        H(q[layer % 24])
        CNOT(q[layer % 24], q[(layer + 1) % 24])
        Rz(q[(layer + 1) % 24], PI / (layer + 3))
    }
    print("matrix_product_feature_map")
    print("logical_qubits", 24)
    print("shots", measure_all(q, shots=4))
}

175. 175_mps_spin_chain_175.sq — 175 mps spin chain 175

# Example 175: MPS/tensor-network low-entanglement spin_chain.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(28, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=175) {
    let q = quantum_register(28)
    for layer in range(4) {
        H(q[layer % 28])
        CNOT(q[layer % 28], q[(layer + 1) % 28])
        Rz(q[(layer + 1) % 28], PI / (layer + 3))
    }
    print("spin_chain")
    print("logical_qubits", 28)
    print("shots", measure_all(q, shots=4))
}

176. 176_mps_adiabatic_line_176.sq — 176 mps adiabatic line 176

# Example 176: MPS/tensor-network low-entanglement adiabatic_line.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(32, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=176) {
    let q = quantum_register(32)
    for layer in range(5) {
        H(q[layer % 32])
        CNOT(q[layer % 32], q[(layer + 1) % 32])
        Rz(q[(layer + 1) % 32], PI / (layer + 3))
    }
    print("adiabatic_line")
    print("logical_qubits", 32)
    print("shots", measure_all(q, shots=4))
}

177. 177_mps_qft_lite_177.sq — 177 mps qft lite 177

# Example 177: MPS/tensor-network low-entanglement qft_lite.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(36, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=177) {
    let q = quantum_register(36)
    for layer in range(3) {
        H(q[layer % 36])
        CNOT(q[layer % 36], q[(layer + 1) % 36])
        Rz(q[(layer + 1) % 36], PI / (layer + 3))
    }
    print("qft_lite")
    print("logical_qubits", 36)
    print("shots", measure_all(q, shots=4))
}

178. 178_mps_bond_dimension_probe_178.sq — 178 mps bond dimension probe 178

# Example 178: MPS/tensor-network low-entanglement bond_dimension_probe.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(40, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=178) {
    let q = quantum_register(40)
    for layer in range(4) {
        H(q[layer % 40])
        CNOT(q[layer % 40], q[(layer + 1) % 40])
        Rz(q[(layer + 1) % 40], PI / (layer + 3))
    }
    print("bond_dimension_probe")
    print("logical_qubits", 40)
    print("shots", measure_all(q, shots=4))
}

179. 179_mps_matrix_product_feature_map_179.sq — 179 mps matrix product feature map 179

# Example 179: MPS/tensor-network low-entanglement matrix_product_feature_map.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(44, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=179) {
    let q = quantum_register(44)
    for layer in range(5) {
        H(q[layer % 44])
        CNOT(q[layer % 44], q[(layer + 1) % 44])
        Rz(q[(layer + 1) % 44], PI / (layer + 3))
    }
    print("matrix_product_feature_map")
    print("logical_qubits", 44)
    print("shots", measure_all(q, shots=4))
}

180. 180_mps_spin_chain_180.sq — 180 mps spin chain 180

# Example 180: MPS/tensor-network low-entanglement spin_chain.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(48, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=180) {
    let q = quantum_register(48)
    for layer in range(3) {
        H(q[layer % 48])
        CNOT(q[layer % 48], q[(layer + 1) % 48])
        Rz(q[(layer + 1) % 48], PI / (layer + 3))
    }
    print("spin_chain")
    print("logical_qubits", 48)
    print("shots", measure_all(q, shots=4))
}

181. 181_mps_adiabatic_line_181.sq — 181 mps adiabatic line 181

# Example 181: MPS/tensor-network low-entanglement adiabatic_line.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(52, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=181) {
    let q = quantum_register(52)
    for layer in range(4) {
        H(q[layer % 52])
        CNOT(q[layer % 52], q[(layer + 1) % 52])
        Rz(q[(layer + 1) % 52], PI / (layer + 3))
    }
    print("adiabatic_line")
    print("logical_qubits", 52)
    print("shots", measure_all(q, shots=4))
}

182. 182_mps_qft_lite_182.sq — 182 mps qft lite 182

# Example 182: MPS/tensor-network low-entanglement qft_lite.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(24, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=182) {
    let q = quantum_register(24)
    for layer in range(5) {
        H(q[layer % 24])
        CNOT(q[layer % 24], q[(layer + 1) % 24])
        Rz(q[(layer + 1) % 24], PI / (layer + 3))
    }
    print("qft_lite")
    print("logical_qubits", 24)
    print("shots", measure_all(q, shots=4))
}

183. 183_mps_bond_dimension_probe_183.sq — 183 mps bond dimension probe 183

# Example 183: MPS/tensor-network low-entanglement bond_dimension_probe.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(28, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=183) {
    let q = quantum_register(28)
    for layer in range(3) {
        H(q[layer % 28])
        CNOT(q[layer % 28], q[(layer + 1) % 28])
        Rz(q[(layer + 1) % 28], PI / (layer + 3))
    }
    print("bond_dimension_probe")
    print("logical_qubits", 28)
    print("shots", measure_all(q, shots=4))
}

184. 184_mps_matrix_product_feature_map_184.sq — 184 mps matrix product feature map 184

# Example 184: MPS/tensor-network low-entanglement matrix_product_feature_map.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(32, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=184) {
    let q = quantum_register(32)
    for layer in range(4) {
        H(q[layer % 32])
        CNOT(q[layer % 32], q[(layer + 1) % 32])
        Rz(q[(layer + 1) % 32], PI / (layer + 3))
    }
    print("matrix_product_feature_map")
    print("logical_qubits", 32)
    print("shots", measure_all(q, shots=4))
}

185. 185_mps_spin_chain_185.sq — 185 mps spin chain 185

# Example 185: MPS/tensor-network low-entanglement spin_chain.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(36, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=185) {
    let q = quantum_register(36)
    for layer in range(5) {
        H(q[layer % 36])
        CNOT(q[layer % 36], q[(layer + 1) % 36])
        Rz(q[(layer + 1) % 36], PI / (layer + 3))
    }
    print("spin_chain")
    print("logical_qubits", 36)
    print("shots", measure_all(q, shots=4))
}

186. 186_mps_adiabatic_line_186.sq — 186 mps adiabatic line 186

# Example 186: MPS/tensor-network low-entanglement adiabatic_line.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(40, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=186) {
    let q = quantum_register(40)
    for layer in range(3) {
        H(q[layer % 40])
        CNOT(q[layer % 40], q[(layer + 1) % 40])
        Rz(q[(layer + 1) % 40], PI / (layer + 3))
    }
    print("adiabatic_line")
    print("logical_qubits", 40)
    print("shots", measure_all(q, shots=4))
}

187. 187_mps_qft_lite_187.sq — 187 mps qft lite 187

# Example 187: MPS/tensor-network low-entanglement qft_lite.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(44, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=187) {
    let q = quantum_register(44)
    for layer in range(4) {
        H(q[layer % 44])
        CNOT(q[layer % 44], q[(layer + 1) % 44])
        Rz(q[(layer + 1) % 44], PI / (layer + 3))
    }
    print("qft_lite")
    print("logical_qubits", 44)
    print("shots", measure_all(q, shots=4))
}

188. 188_mps_bond_dimension_probe_188.sq — 188 mps bond dimension probe 188

# Example 188: MPS/tensor-network low-entanglement bond_dimension_probe.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(48, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=188) {
    let q = quantum_register(48)
    for layer in range(5) {
        H(q[layer % 48])
        CNOT(q[layer % 48], q[(layer + 1) % 48])
        Rz(q[(layer + 1) % 48], PI / (layer + 3))
    }
    print("bond_dimension_probe")
    print("logical_qubits", 48)
    print("shots", measure_all(q, shots=4))
}

189. 189_mps_matrix_product_feature_map_189.sq — 189 mps matrix product feature map 189

# Example 189: MPS/tensor-network low-entanglement matrix_product_feature_map.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(52, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=189) {
    let q = quantum_register(52)
    for layer in range(3) {
        H(q[layer % 52])
        CNOT(q[layer % 52], q[(layer + 1) % 52])
        Rz(q[(layer + 1) % 52], PI / (layer + 3))
    }
    print("matrix_product_feature_map")
    print("logical_qubits", 52)
    print("shots", measure_all(q, shots=4))
}

190. 190_mps_spin_chain_190.sq — 190 mps spin chain 190

# Example 190: MPS/tensor-network low-entanglement spin_chain.
# Requires optional NumPy extra: pip install sansqrit[tensor].
simulate(24, engine="mps", max_bond_dim=32, cutoff=1e-10, seed=190) {
    let q = quantum_register(24)
    for layer in range(4) {
        H(q[layer % 24])
        CNOT(q[layer % 24], q[(layer + 1) % 24])
        Rz(q[(layer + 1) % 24], PI / (layer + 3))
    }
    print("spin_chain")
    print("logical_qubits", 24)
    print("shots", measure_all(q, shots=4))
}

191. 191_noise_readout_channel_191.sq — 191 noise readout channel 191

# Example 191: density-matrix/noise model readout_channel.
simulate(2, engine="density", seed=191) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_bit_flip(q[1], 0.020)
    print("readout_channel")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

192. 192_noise_amplitude_decay_192.sq — 192 noise amplitude decay 192

# Example 192: density-matrix/noise model amplitude_decay.
simulate(2, engine="density", seed=192) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_amplitude_damping(q[1], 0.030)
    print("amplitude_decay")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

193. 193_noise_phase_noise_193.sq — 193 noise phase noise 193

# Example 193: density-matrix/noise model phase_noise.
simulate(2, engine="density", seed=193) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_phase_flip(q[0], 0.040)
    print("phase_noise")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

194. 194_noise_depolarizing_benchmark_194.sq — 194 noise depolarizing benchmark 194

# Example 194: density-matrix/noise model depolarizing_benchmark.
simulate(2, engine="density", seed=194) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[1], 0.050)
    print("depolarizing_benchmark")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

195. 195_noise_noisy_bell_195.sq — 195 noise noisy bell 195

# Example 195: density-matrix/noise model noisy_bell.
simulate(2, engine="density", seed=195) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[0], 0.010)
    print("noisy_bell")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

196. 196_noise_readout_channel_196.sq — 196 noise readout channel 196

# Example 196: density-matrix/noise model readout_channel.
simulate(2, engine="density", seed=196) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_bit_flip(q[1], 0.020)
    print("readout_channel")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

197. 197_noise_amplitude_decay_197.sq — 197 noise amplitude decay 197

# Example 197: density-matrix/noise model amplitude_decay.
simulate(2, engine="density", seed=197) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_amplitude_damping(q[1], 0.030)
    print("amplitude_decay")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

198. 198_noise_phase_noise_198.sq — 198 noise phase noise 198

# Example 198: density-matrix/noise model phase_noise.
simulate(2, engine="density", seed=198) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_phase_flip(q[0], 0.040)
    print("phase_noise")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

199. 199_noise_depolarizing_benchmark_199.sq — 199 noise depolarizing benchmark 199

# Example 199: density-matrix/noise model depolarizing_benchmark.
simulate(2, engine="density", seed=199) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[1], 0.050)
    print("depolarizing_benchmark")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

200. 200_noise_noisy_bell_200.sq — 200 noise noisy bell 200

# Example 200: density-matrix/noise model noisy_bell.
simulate(2, engine="density", seed=200) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[0], 0.010)
    print("noisy_bell")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

201. 201_noise_readout_channel_201.sq — 201 noise readout channel 201

# Example 201: density-matrix/noise model readout_channel.
simulate(2, engine="density", seed=201) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_bit_flip(q[1], 0.020)
    print("readout_channel")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

202. 202_noise_amplitude_decay_202.sq — 202 noise amplitude decay 202

# Example 202: density-matrix/noise model amplitude_decay.
simulate(2, engine="density", seed=202) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_amplitude_damping(q[1], 0.030)
    print("amplitude_decay")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

203. 203_noise_phase_noise_203.sq — 203 noise phase noise 203

# Example 203: density-matrix/noise model phase_noise.
simulate(2, engine="density", seed=203) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_phase_flip(q[0], 0.040)
    print("phase_noise")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

204. 204_noise_depolarizing_benchmark_204.sq — 204 noise depolarizing benchmark 204

# Example 204: density-matrix/noise model depolarizing_benchmark.
simulate(2, engine="density", seed=204) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[1], 0.050)
    print("depolarizing_benchmark")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

205. 205_noise_noisy_bell_205.sq — 205 noise noisy bell 205

# Example 205: density-matrix/noise model noisy_bell.
simulate(2, engine="density", seed=205) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[0], 0.010)
    print("noisy_bell")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

206. 206_noise_readout_channel_206.sq — 206 noise readout channel 206

# Example 206: density-matrix/noise model readout_channel.
simulate(2, engine="density", seed=206) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_bit_flip(q[1], 0.020)
    print("readout_channel")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

207. 207_noise_amplitude_decay_207.sq — 207 noise amplitude decay 207

# Example 207: density-matrix/noise model amplitude_decay.
simulate(2, engine="density", seed=207) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_amplitude_damping(q[1], 0.030)
    print("amplitude_decay")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

208. 208_noise_phase_noise_208.sq — 208 noise phase noise 208

# Example 208: density-matrix/noise model phase_noise.
simulate(2, engine="density", seed=208) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_phase_flip(q[0], 0.040)
    print("phase_noise")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

209. 209_noise_depolarizing_benchmark_209.sq — 209 noise depolarizing benchmark 209

# Example 209: density-matrix/noise model depolarizing_benchmark.
simulate(2, engine="density", seed=209) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[1], 0.050)
    print("depolarizing_benchmark")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

210. 210_noise_noisy_bell_210.sq — 210 noise noisy bell 210

# Example 210: density-matrix/noise model noisy_bell.
simulate(2, engine="density", seed=210) {
    let q = quantum_register(2)
    H(q[0])
    CNOT(q[0], q[1])
    noise_depolarize(q[0], 0.010)
    print("noisy_bell")
    print("probabilities", probabilities(q))
    print("shots", measure_all(q, shots=16))
}

211. 211_algorithm_grover_cyber_signature_211.sq — 211 algorithm grover cyber signature 211

# Example 211: algorithm-level application - grover_cyber_signature.
let tag = "grover_cyber_signature"
print("running", tag)
print(grover_search(5, 17, shots=64, seed=211))

212. 212_algorithm_qaoa_logistics_triangle_212.sq — 212 algorithm qaoa logistics triangle 212

# Example 212: algorithm-level application - qaoa_logistics_triangle.
let tag = "qaoa_logistics_triangle"
print("running", tag)
print(qaoa_maxcut(4, [(0,1), (1,2), (2,3), (3,0)], p=1, shots=64, seed=212))

213. 213_algorithm_vqe_molecule_scan_213.sq — 213 algorithm vqe molecule scan 213

# Example 213: algorithm-level application - vqe_molecule_scan.
let tag = "vqe_molecule_scan"
print("running", tag)
print(vqe_h2(0.735, max_iter=16, seed=213))

214. 214_algorithm_phase_estimation_sensor_214.sq — 214 algorithm phase estimation sensor 214

# Example 214: algorithm-level application - phase_estimation_sensor.
let tag = "phase_estimation_sensor"
print("running", tag)
print(quantum_phase_estimation(0.3125, 4, shots=64, seed=214))

215. 215_algorithm_hhl_toy_linear_system_215.sq — 215 algorithm hhl toy linear system 215

# Example 215: algorithm-level application - hhl_toy_linear_system.
let tag = "hhl_toy_linear_system"
print("running", tag)
print(hhl_solve([[1.0, 0.0], [0.0, 2.0]], [1.0, 0.5]))

216. 216_algorithm_bernstein_vazirani_secret_216.sq — 216 algorithm bernstein vazirani secret 216

# Example 216: algorithm-level application - bernstein_vazirani_secret.
let tag = "bernstein_vazirani_secret"
print("running", tag)
print(bernstein_vazirani("101101"))

217. 217_algorithm_deutsch_jozsa_balanced_217.sq — 217 algorithm deutsch jozsa balanced 217

# Example 217: algorithm-level application - deutsch_jozsa_balanced.
let tag = "deutsch_jozsa_balanced"
print("running", tag)
print(deutsch_jozsa(5, "balanced", seed=217))

218. 218_algorithm_quantum_counting_inventory_218.sq — 218 algorithm quantum counting inventory 218

# Example 218: algorithm-level application - quantum_counting_inventory.
let tag = "quantum_counting_inventory"
print("running", tag)
print(quantum_counting(8, 13, 5))

219. 219_algorithm_amplitude_estimation_risk_219.sq — 219 algorithm amplitude estimation risk 219

# Example 219: algorithm-level application - amplitude_estimation_risk.
let tag = "amplitude_estimation_risk"
print("running", tag)
print(amplitude_estimation(0.18, 5))

220. 220_algorithm_bb84_key_distribution_220.sq — 220 algorithm bb84 key distribution 220

# Example 220: algorithm-level application - bb84_key_distribution.
let tag = "bb84_key_distribution"
print("running", tag)
print(bb84_qkd(16, seed=220))

221. 221_algorithm_grover_cyber_signature_221.sq — 221 algorithm grover cyber signature 221

# Example 221: algorithm-level application - grover_cyber_signature.
let tag = "grover_cyber_signature"
print("running", tag)
print(grover_search(5, 17, shots=64, seed=221))

222. 222_algorithm_qaoa_logistics_triangle_222.sq — 222 algorithm qaoa logistics triangle 222

# Example 222: algorithm-level application - qaoa_logistics_triangle.
let tag = "qaoa_logistics_triangle"
print("running", tag)
print(qaoa_maxcut(4, [(0,1), (1,2), (2,3), (3,0)], p=1, shots=64, seed=222))

223. 223_algorithm_vqe_molecule_scan_223.sq — 223 algorithm vqe molecule scan 223

# Example 223: algorithm-level application - vqe_molecule_scan.
let tag = "vqe_molecule_scan"
print("running", tag)
print(vqe_h2(0.735, max_iter=16, seed=223))

224. 224_algorithm_phase_estimation_sensor_224.sq — 224 algorithm phase estimation sensor 224

# Example 224: algorithm-level application - phase_estimation_sensor.
let tag = "phase_estimation_sensor"
print("running", tag)
print(quantum_phase_estimation(0.3125, 4, shots=64, seed=224))

225. 225_algorithm_hhl_toy_linear_system_225.sq — 225 algorithm hhl toy linear system 225

# Example 225: algorithm-level application - hhl_toy_linear_system.
let tag = "hhl_toy_linear_system"
print("running", tag)
print(hhl_solve([[1.0, 0.0], [0.0, 2.0]], [1.0, 0.5]))

226. 226_algorithm_bernstein_vazirani_secret_226.sq — 226 algorithm bernstein vazirani secret 226

# Example 226: algorithm-level application - bernstein_vazirani_secret.
let tag = "bernstein_vazirani_secret"
print("running", tag)
print(bernstein_vazirani("101101"))

227. 227_algorithm_deutsch_jozsa_balanced_227.sq — 227 algorithm deutsch jozsa balanced 227

# Example 227: algorithm-level application - deutsch_jozsa_balanced.
let tag = "deutsch_jozsa_balanced"
print("running", tag)
print(deutsch_jozsa(5, "balanced", seed=227))

228. 228_algorithm_quantum_counting_inventory_228.sq — 228 algorithm quantum counting inventory 228

# Example 228: algorithm-level application - quantum_counting_inventory.
let tag = "quantum_counting_inventory"
print("running", tag)
print(quantum_counting(8, 13, 5))

229. 229_algorithm_amplitude_estimation_risk_229.sq — 229 algorithm amplitude estimation risk 229

# Example 229: algorithm-level application - amplitude_estimation_risk.
let tag = "amplitude_estimation_risk"
print("running", tag)
print(amplitude_estimation(0.18, 5))

230. 230_algorithm_bb84_key_distribution_230.sq — 230 algorithm bb84 key distribution 230

# Example 230: algorithm-level application - bb84_key_distribution.
let tag = "bb84_key_distribution"
print("running", tag)
print(bb84_qkd(16, seed=230))

231. 231_qml_feature_map_231.sq — 231 qml feature map 231

# Example 231: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(6, engine="sparse", seed=231) {
    let q = quantum_register(6)
    for i in range(6) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[6-1-i] * PI / 2)
    }
    for i in range(6-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

232. 232_qml_feature_map_232.sq — 232 qml feature map 232

# Example 232: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(7, engine="sparse", seed=232) {
    let q = quantum_register(7)
    for i in range(7) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[7-1-i] * PI / 2)
    }
    for i in range(7-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

233. 233_qml_feature_map_233.sq — 233 qml feature map 233

# Example 233: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(8, engine="sparse", seed=233) {
    let q = quantum_register(8)
    for i in range(8) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[8-1-i] * PI / 2)
    }
    for i in range(8-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

234. 234_qml_feature_map_234.sq — 234 qml feature map 234

# Example 234: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(6, engine="sparse", seed=234) {
    let q = quantum_register(6)
    for i in range(6) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[6-1-i] * PI / 2)
    }
    for i in range(6-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

235. 235_qml_feature_map_235.sq — 235 qml feature map 235

# Example 235: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(7, engine="sparse", seed=235) {
    let q = quantum_register(7)
    for i in range(7) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[7-1-i] * PI / 2)
    }
    for i in range(7-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

236. 236_qml_feature_map_236.sq — 236 qml feature map 236

# Example 236: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(8, engine="sparse", seed=236) {
    let q = quantum_register(8)
    for i in range(8) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[8-1-i] * PI / 2)
    }
    for i in range(8-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

237. 237_qml_feature_map_237.sq — 237 qml feature map 237

# Example 237: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(6, engine="sparse", seed=237) {
    let q = quantum_register(6)
    for i in range(6) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[6-1-i] * PI / 2)
    }
    for i in range(6-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

238. 238_qml_feature_map_238.sq — 238 qml feature map 238

# Example 238: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(7, engine="sparse", seed=238) {
    let q = quantum_register(7)
    for i in range(7) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[7-1-i] * PI / 2)
    }
    for i in range(7-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

239. 239_qml_feature_map_239.sq — 239 qml feature map 239

# Example 239: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(8, engine="sparse", seed=239) {
    let q = quantum_register(8)
    for i in range(8) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[8-1-i] * PI / 2)
    }
    for i in range(8-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

240. 240_qml_feature_map_240.sq — 240 qml feature map 240

# Example 240: quantum ML feature map for tabular/scientific data.
let features = [0.12, 0.31, 0.07, 0.44, 0.23, 0.19, 0.27, 0.39]
simulate(6, engine="sparse", seed=240) {
    let q = quantum_register(6)
    for i in range(6) {
        Ry(q[i], features[i] * PI)
        Rz(q[i], features[6-1-i] * PI / 2)
    }
    for i in range(6-1) {
        CNOT(q[i], q[i + 1])
    }
    print("qml_feature_map")
    print("nnz", engine_nnz())
    print(measure_all(q, shots=16))
}

241. 241_qasm3_export_climate_circuit.sq — 241 qasm3 export climate circuit

# Example 241: export a climate-risk sparse circuit to OpenQASM 3.
simulate(5, seed=241) {
    H(0)
    CNOT(0, 4)
    Rz(3, PI/7)
    print(export_qasm3())
}

242. 242_qasm2_export_network_circuit.sq — 242 qasm2 export network circuit

# Example 242: export a network-routing circuit to OpenQASM 2.
simulate(4, seed=242) {
    X(1)
    H(0)
    CNOT(0, 2)
    print(export_qasm2())
}

243. 243_distributed_cluster_template.sq — 243 distributed cluster template

# Example 243: real distributed cluster template.
# Start workers in separate shells, then uncomment the simulate block.
# python -m sansqrit.cluster --host 127.0.0.1 --port 9101
# python -m sansqrit.cluster --host 127.0.0.1 --port 9102
# simulate(12, engine="distributed", addresses=[("127.0.0.1", 9101), ("127.0.0.1", 9102)]) {
#     H(0)
#     CNOT(0, 11)
#     print(measure_all(shots=4))
# }
print("distributed cluster template included; start workers before enabling")

244. 244_gpu_cuda_template.sq — 244 gpu cuda template

# Example 244: GPU/CuPy backend template.
# Install CUDA/CuPy extra, then uncomment.
# simulate(6, engine="gpu", seed=244) {
#     H(0)
#     CNOT(0, 5)
#     print(measure_all(shots=8))
# }
print("GPU template included; requires sansqrit[gpu] and CUDA")

245. 245_hybrid_backend_template.sq — 245 hybrid backend template

# Example 245: hybrid backend selection template.
simulate(150, engine="sharded", n_shards=12, seed=245) {
    X(149)
    H(0)
    CNOT(0, 149)
    print("hybrid-style sparse branch", engine_nnz())
}

246. 246_formal_verification_qasm_reference.sq — 246 formal verification qasm reference

# Example 246: verification through QASM export / external SDK comparison.
simulate(3, seed=246) {
    H(0)
    CNOT(0, 1)
    CNOT(1, 2)
    print(export_qasm3())
}

247. 247_optimizer_cancel_pairs.sq — 247 optimizer cancel pairs

# Example 247: write circuits so the optimizer can cancel inverse pairs.
simulate(4, seed=247) {
    X(0)
    X(0)
    H(1)
    H(1)
    Rz(2, PI/8)
    Rz(2, -PI/8)
    print("optimizer-friendly cancellation pattern")
    print(export_qasm3())
}

248. 248_ai_training_minimal_pair.sq — 248 ai training minimal pair

# Example 248: paired input-output style useful for AI training.
# Intent: create a Bell state and return probability dictionary.
simulate(2, seed=248) {
    H(0)
    CNOT(0, 1)
    print(probabilities())
}

249. 249_large_sparse_oracle_150q.sq — 249 large sparse oracle 150q

# Example 249: 150-qubit sparse oracle-style marker.
simulate(150, engine="sharded", n_shards=20, workers=4, seed=249) {
    let q = quantum_register(150)
    X(q[12])
    X(q[77])
    H(q[0])
    CNOT(q[0], q[149])
    MCZ(q[0], q[12], q[77], q[149])
    print("150q oracle marker nnz", engine_nnz())
    print(measure_all(q, shots=4))
}

250. 250_large_stabilizer_4096q.sq — 250 large stabilizer 4096q

# Example 250: 4096-qubit Clifford/stabilizer monitoring pattern.
simulate(4096, engine="stabilizer", seed=250) {
    H(0)
    CNOT(0, 4095)
    S(2048)
    CZ(2048, 4095)
    print("4096-qubit stabilizer circuit")
    print(list(measure_all(shots=1).keys())[0][0:64])
}

251. 251_precomputed_lookup_10q.sq — 251 precomputed lookup 10q

# 10-qubit packaged precomputed lookup demonstration
simulate(10) {
  let q = quantum_register(10)
  H(q[7])
  SX(q[3])
  SXdg(q[3])
  X(q[9])
  CNOT(q[7], q[9])
  let p = probabilities(q)
}

252. 252_lookup_vs_sparse_150q.sq — 252 lookup vs sparse 150q

# 150-qubit sparse program: primitive gate lookup + sparse runtime transitions.
# Full embedded transition tables are intentionally capped at 10 qubits.
simulate(150) {
  let q = quantum_register(150)
  X(q[149])
  H(q[0])
  CNOT(q[0], q[149])
  let p = probabilities(q)
}

253. 253_qec_bit_flip_correct.sq — 253 qec bit flip correct

simulate(5) {
  let q = quantum_register(5)
  let l = qec_logical("bit_flip", base=0)
  qec_encode(l)
  qec_inject_error(l, "X", 1)
  let result = qec_syndrome_and_correct(l, ancilla_base=3)
  qec_decode(l)
  let counts = measure_all(q)
}

254. 254_qec_phase_flip_correct.sq — 254 qec phase flip correct

simulate(5) {
  let q = quantum_register(5)
  let l = qec_logical("phase_flip", base=0)
  qec_encode(l)
  qec_inject_error(l, "Z", 2)
  let syndrome = qec_syndrome(l, ancilla_base=3)
  let corrections = qec_correct(l, syndrome)
  qec_decode(l)
  let counts = measure_all(q)
}

255. 255_qec_repetition5_layout.sq — 255 qec repetition5 layout

let code = qec_code("repetition", distance=5)
let l = qec_logical("repetition", base=0, distance=5)
let stabs = l.stabilizers()
let sx = l.logical_x_term()
let sz = l.logical_z_term()

256. 256_qec_shor9_encode.sq — 256 qec shor9 encode

simulate(12) {
  let q = quantum_register(12)
  let l = qec_logical("shor9", base=0)
  qec_encode(l)
  logical_x(l)
  let stabs = l.stabilizers()
  let profile = lookup_profile()
}

257. 257_qec_steane7_syndrome_circuit.sq — 257 qec steane7 syndrome circuit

let l = qec_logical("steane7", base=0)
let circuit = qec_syndrome_circuit(l, ancilla_base=7)
let code = qec_code("steane7")

258. 258_qec_five_qubit_lookup_decoder.sq — 258 qec five qubit lookup decoder

let code = qec_code("five_qubit")
let l = qec_logical("five_qubit", base=0)
let stabs = l.stabilizers()
let lx = l.logical_x_term()
let lz = l.logical_z_term()

259. 259_qec_surface3_lattice.sq — 259 qec surface3 lattice

let lattice = qec_surface_lattice(3)
let data = lattice.data_qubits
let xchecks = lattice.x_checks
let zchecks = lattice.z_checks
let stabs = lattice.stabilizers()

260. 260_qec_surface3_code.sq — 260 qec surface3 code

let code = qec_code("surface", distance=3)
let l = qec_logical("surface", base=0, distance=3)
let stabs = l.stabilizers()
let circuit = qec_syndrome_circuit(l, ancilla_base=9)

261. 261_qec_logical_cnot_bitflip.sq — 261 qec logical cnot bitflip

simulate(8) {
  let q = quantum_register(8)
  let a = qec_logical("bit_flip", base=0, name="a")
  let b = qec_logical("bit_flip", base=3, name="b")
  qec_encode(a)
  qec_encode(b)
  logical_x(a)
  logical_cx(a, b)
  let counts = measure_all(q)
}

262. 262_qec_noise_density_bitflip.sq — 262 qec noise density bitflip

simulate(5, engine="density") {
  let q = quantum_register(5)
  let l = qec_logical("bit_flip", base=0)
  qec_encode(l)
  noise_bit_flip(q[1], 0.1)
  let tr = current_engine().trace()
}

263. 263_qec_codes_index.sq — 263 qec codes index

let codes = qec_codes()
let has_surface = "surface" in codes
let has_shor = "shor9" in codes

264. 264_auto_backend_plan_120q.sq — 264 auto backend plan 120q

let plan = plan_backend(120, [])

265. 265_lookup_profile_10q.sq — 265 lookup profile 10q

simulate(10) {
  let q = quantum_register(10)
  H(q[7])
  SX(q[3])
  SXdg(q[3])
  CNOT(q[7], q[9])
  let profile = lookup_profile()
}

266. 266_qec_stabilizer_syndrome_terms.sq — 266 qec stabilizer syndrome terms

let code = qec_code("bit_flip")
let l = qec_logical("bit_flip")
let stabs = l.stabilizers()
let syndrome_ops = qec_syndrome_circuit(l, ancilla_base=3)

267. 267_qec_repetition7_terms.sq — 267 qec repetition7 terms

let code = qec_code("repetition", distance=7)
let l = qec_logical("repetition", distance=7)
let stabs = l.stabilizers()
let lx = l.logical_x_term()

268. 268_qec_surface5_metadata.sq — 268 qec surface5 metadata

let code = qec_code("surface", distance=5)
let lattice = qec_surface_lattice(5)
let data_count = len(lattice.data_qubits)
let x_count = len(lattice.x_checks)
let z_count = len(lattice.z_checks)

269. 269_qec_bitflip_manual_syndrome.sq — 269 qec bitflip manual syndrome

simulate(5) {
  let q = quantum_register(5)
  let l = qec_logical("bit_flip")
  qec_encode(l)
  qec_inject_error(l, "X", 0)
  let syndrome = qec_syndrome(l, ancilla_base=3)
  let corrections = qec_correct(l, syndrome)
}

270. 270_qec_logical_gates.sq — 270 qec logical gates

simulate(5) {
  let q = quantum_register(5)
  let l = qec_logical("bit_flip")
  qec_encode(l)
  logical_x(l)
  logical_z(l)
  logical_h(l)
  logical_s(l)
  let counts = measure_all(q)
}

271. 271_qec_shor9_terms.sq — 271 qec shor9 terms

let l = qec_logical("shor9")
let stabs = l.stabilizers()
let lx = l.logical_x_term()
let lz = l.logical_z_term()

272. 272_qec_steane7_terms.sq — 272 qec steane7 terms

let l = qec_logical("steane7")
let stabs = l.stabilizers()
let lx = l.logical_x_term()
let lz = l.logical_z_term()

273. 273_qec_five_qubit_terms.sq — 273 qec five qubit terms

let l = qec_logical("five_qubit")
let stabs = l.stabilizers()
let lx = l.logical_x_term()
let lz = l.logical_z_term()

274. 274_qec_surface_decoder_interface.sq — 274 qec surface decoder interface

let code = qec_code("surface", distance=3)
let l = qec_logical("surface", distance=3)
let ops = qec_syndrome_circuit(l, ancilla_base=9)

275. 275_qec_ai_training_record.sq — 275 qec ai training record

let record = {"task": "qec_bit_flip_correction", "dsl": "qec_logical plus qec_syndrome_and_correct", "code": qec_code("bit_flip").description}

276. 276_hierarchical_120q_local_blocks.sq — 276 hierarchical 120q local blocks

# 120-qubit hierarchical tensor shards: local dense 10-qubit blocks.
simulate(120, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0) {
    q = quantum_register(120)
    shard block_A [0..9]
    shard block_B [10..19]
    shard block_L [110..119]

    apply H on block_A
    apply X on block_B
    apply Z on block_L

    print(hierarchical_report())
}

277. 277_hierarchical_120q_bridge_mps.sq — 277 hierarchical 120q bridge mps

# 120-qubit hierarchical tensor shards with a cross-block bridge.
simulate(120, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0) {
    q = quantum_register(120)
    shard block_A [0..9]
    shard block_B [10..19]

    H(q[9])
    apply CNOT on q[9], q[10] bridge_mode=sparse
    Z(q[10])

    print(hierarchical_report())
}

278. 278_climate_128q_sparse_sensors.sq — 278 climate 128q sparse sensors

# 128-qubit climate sensor anomaly encoding using sparse/sharded execution.
simulate(128, engine="sharded", n_shards=16, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[3])
    X(q[41])
    X(q[90])
    H(q[0])
    CNOT(q[0], q[3])
    Rz(q[41], PI / 8)
    print("climate nnz", engine_nnz())
    print(lookup_profile())
}

279. 279_supply_chain_160q_route_flags.sq — 279 supply chain 160q route flags

# 160-qubit sparse route flags for supply-chain risk analysis.
simulate(160, engine="sharded", n_shards=20, workers=4, use_lookup=true) {
    q = quantum_register(160)
    for i in range(0, 160, 32) {
        X(q[i])
    }
    H(q[1])
    CNOT(q[1], q[33])
    Rz(q[64], PI / 6)
    print("supply chain shards", shards())
}

280. 280_finance_128q_portfolio_sparse_risk.sq — 280 finance 128q portfolio sparse risk

# 128-qubit portfolio risk flags with sparse rotations.
simulate(128, engine="sharded", n_shards=16, workers=4) {
    q = quantum_register(128)
    X(q[7])
    X(q[31])
    X(q[88])
    H(q[0])
    CNOT(q[0], q[7])
    RZZ(q[31], q[88], PI / 12)
    print("finance plan", estimate_qubits(128))
}

281. 281_cyber_144q_stabilizer_threat_graph.sq — 281 cyber 144q stabilizer threat graph

# 144-qubit Clifford threat graph, safe for stabilizer execution.
simulate(144, engine="stabilizer") {
    q = quantum_register(144)
    for i in range(0, 143, 12) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
    }
    print("cyber sample", measure_all(shots=3))
}

282. 282_telecom_130q_hierarchical_blocks.sq — 282 telecom 130q hierarchical blocks

# 130-qubit telecom channel model using 10-qubit hierarchical tensor blocks.
simulate(130, engine="hierarchical", block_size=10, use_lookup=true) {
    q = quantum_register(130)
    shard tower_0 [0..9]
    shard tower_1 [10..19]
    shard tower_2 [20..29]
    apply H on tower_0
    apply X on tower_1
    apply Z on tower_2
    print(hierarchical_report())
}

283. 283_hierarchical_120q_bridge_iot.sq — 283 hierarchical 120q bridge iot

# 120-qubit IoT bridge entanglement between adjacent 10-qubit blocks.
simulate(120, engine="hierarchical", block_size=10, cutoff=0.0, max_bond_dim=null) {
    q = quantum_register(120)
    H(q[9])
    apply CNOT on q[9], q[10] bridge_mode=sparse
    Z(q[10])
    print(hierarchical_report())
}

284. 284_drug_discovery_124q_mps_feature_map.sq — 284 drug discovery 124q mps feature map

# 124-qubit low-entanglement molecule feature map using MPS.
simulate(124, engine="mps", max_bond_dim=32, cutoff=1e-12) {
    q = quantum_register(124)
    for i in range(0, 12) {
        Ry(q[i], 0.01 * (i + 1))
    }
    for i in range(0, 11) {
        CNOT(q[i], q[i + 1])
    }
    print("drug discovery backend", sansqrit_backends())
}

285. 285_satellite_132q_qec_link.sq — 285 satellite 132q qec link

# Satellite link QEC control plane in a larger 132-qubit sparse register.
simulate(132, engine="sparse") {
    q = quantum_register(132)
    logical = qec_logical("bit_flip", base=0)
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    print(qec_syndrome_and_correct(logical, ancilla_base=3))
    X(q[131])
    print(engine_nnz())
}

286. 286_hardware_export_121q_openqasm3.sq — 286 hardware export 121q openqasm3

# 121-qubit sparse circuit exported as provider-neutral OpenQASM 3 payload.
simulate(121, engine="sparse") {
    q = quantum_register(121)
    X(q[120])
    H(q[0])
    CNOT(q[0], q[1])
    payload = export_hardware("azure")
    print(payload["provider"])
    print(payload["format"])
}

287. 287_distributed_120q_readiness_report.sq — 287 distributed 120q readiness report

# Distributed-readiness diagnostics without requiring live workers.
print(sansqrit_doctor())
print(troubleshooting("distributed"))
print(hardware_targets())

288. 288_troubleshooting_lookup_profile.sq — 288 troubleshooting lookup profile

# Lookup and troubleshooting introspection.
simulate(10, engine="sparse", use_lookup=true) {
    q = quantum_register(10)
    H(q[0])
    SX(q[3])
    CNOT(q[0], q[1])
    print(lookup_profile())
    print(lookup_architecture())
}

289. 289_ai_training_dataset_record.sq — 289 ai training dataset record

# Generate AI/ML training metadata.
print(research_gaps())
print("training helpers available")

290. 290_surface_code_121q_control_register.sq — 290 surface code 121q control register

# Surface-code helper embedded in a 121-qubit control register.
simulate(121, engine="sparse") {
    q = quantum_register(121)
    logical = qec_logical("surface", base=0, distance=3)
    print(logical.stabilizers())
    print(qec_stim_syndrome_text(logical, ancilla_base=9))
}

291. 291_robotics_150q_sparse_path_flags.sq — 291 robotics 150q sparse path flags

# 150-qubit sparse robot path flags.
simulate(150, engine="sharded", n_shards=15, workers=4) {
    q = quantum_register(150)
    X(q[12])
    X(q[77])
    X(q[149])
    H(q[2])
    CNOT(q[2], q[12])
    print("robotics", engine_nnz())
}

292. 292_power_grid_150q_fault_localization.sq — 292 power grid 150q fault localization

# 150-qubit grid fault localization with sparse flags.
simulate(150, engine="sharded", n_shards=15) {
    q = quantum_register(150)
    X(q[5])
    X(q[60])
    H(q[0])
    CNOT(q[0], q[5])
    Rz(q[60], PI / 5)
    print(shards())
}

293. 293_port_logistics_150q_hierarchical_yards.sq — 293 port logistics 150q hierarchical yards

# 150-qubit port logistics model as 15 independent 10-qubit yards.
simulate(150, engine="hierarchical", block_size=10) {
    q = quantum_register(150)
    shard yard_0 [0..9]
    shard yard_1 [10..19]
    shard yard_2 [20..29]
    apply H on yard_0
    apply X on yard_1
    apply S on yard_2
    print(hierarchical_report())
}

294. 294_qkd_128q_stabilizer_network.sq — 294 qkd 128q stabilizer network

# 128-qubit Clifford QKD network skeleton.
simulate(128, engine="stabilizer") {
    q = quantum_register(128)
    for i in range(0, 64, 8) {
        H(q[i])
        CNOT(q[i], q[i + 64])
    }
    print(measure_all(shots=4))
}

295. 295_aerospace_140q_sensor_fusion.sq — 295 aerospace 140q sensor fusion

# Aerospace sensor-fusion sparse feature map.
simulate(140, engine="sharded", n_shards=14) {
    q = quantum_register(140)
    X(q[13])
    X(q[72])
    X(q[139])
    H(q[1])
    CNOT(q[1], q[13])
    print(explain_120_qubits_dense())
}

296. 296_lookup_profile_10q_block_kernel.sq — 296 lookup profile 10q block kernel

# Explicit 10-qubit lookup-profile demonstration.
simulate(10, engine="sparse", use_lookup=true) {
    q = quantum_register(10)
    for i in range(0, 10) {
        H(q[i])
    }
    print(lookup_profile())
}

297. 297_openqasm2_3_export_122q.sq — 297 openqasm2 3 export 122q

# Export both OpenQASM 2 and OpenQASM 3 for a 122-qubit sparse circuit.
simulate(122, engine="sparse") {
    q = quantum_register(122)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[121])
    q3 = export_qasm3()
    q2 = export_qasm2()
    print(len(q3))
    print(len(q2))
}

298. 298_azure_payload_123q_sparse.sq — 298 azure payload 123q sparse

# Azure-style OpenQASM 3 payload metadata.
simulate(123, engine="sparse") {
    q = quantum_register(123)
    H(q[0])
    CNOT(q[0], q[2])
    payload = export_hardware("azure")
    print(payload["provider"])
    print(payload["notes"])
}

299. 299_pennylane_export_124q_fallback.sq — 299 pennylane export 124q fallback

# PennyLane target listing and payload summary without requiring PennyLane install.
simulate(124, engine="sparse") {
    q = quantum_register(124)
    H(q[0])
    CNOT(q[0], q[1])
    print(hardware_payload_summary())
}

300. 300_city_1000q_stabilizer_graph.sq — 300 city 1000q stabilizer graph

# 1000-qubit Clifford city graph, safe for stabilizer tableau mode.
simulate(1000, engine="stabilizer") {
    q = quantum_register(1000)
    for i in range(0, 999, 50) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
    }
    print("city graph stabilizer sample", measure_all(shots=2))
}

301. 301_scenario_climate_risk_01.sq — 301 scenario climate risk 01

# Scenario 001: Climate risk and extreme-weather sensor triage: scenario 01
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[13])
    X(q[68])
    X(q[59])
    H(q[75])
    CNOT(q[75], q[94])
    Rz(q[75], PI / 5)
    CZ(q[94], q[121])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

302. 302_scenario_climate_risk_02.sq — 302 scenario climate risk 02

# Scenario 002: Climate risk and extreme-weather sensor triage: scenario 02
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[20])
    X(q[97])
    X(q[50])
    H(q[44])
    CNOT(q[44], q[23])
    Rz(q[44], PI / 6)
    CZ(q[23], q[58])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

303. 303_scenario_climate_risk_03.sq — 303 scenario climate risk 03

# Scenario 003: Climate risk and extreme-weather sensor triage: scenario 03
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[81])
    X(q[36])
    X(q[61])
    H(q[53])
    CNOT(q[53], q[18])
    Rz(q[53], PI / 7)
    CZ(q[18], q[1])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

304. 304_scenario_climate_risk_04.sq — 304 scenario climate risk 04

# Scenario 004: Climate risk and extreme-weather sensor triage: scenario 04
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[66])
    X(q[115])
    X(q[48])
    H(q[94])
    CNOT(q[94], q[33])
    Rz(q[94], PI / 8)
    CZ(q[33], q[72])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

305. 305_scenario_climate_risk_05.sq — 305 scenario climate risk 05

# Scenario 005: Climate risk and extreme-weather sensor triage: scenario 05
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[119])
    X(q[32])
    X(q[109])
    H(q[19])
    CNOT(q[19], q[102])
    Rz(q[19], PI / 4)
    CZ(q[102], q[125])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

306. 306_scenario_climate_risk_06.sq — 306 scenario climate risk 06

# Scenario 006: Climate risk and extreme-weather sensor triage: scenario 06
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[128])
    X(q[83])
    X(q[44])
    H(q[20])
    CNOT(q[20], q[19])
    Rz(q[20], PI / 5)
    CZ(q[19], q[66])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

307. 307_scenario_climate_risk_07.sq — 307 scenario climate risk 07

# Scenario 007: Climate risk and extreme-weather sensor triage: scenario 07
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[61])
    X(q[126])
    X(q[19])
    H(q[1])
    CNOT(q[1], q[28])
    Rz(q[1], PI / 6)
    CZ(q[28], q[39])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

308. 308_scenario_climate_risk_08.sq — 308 scenario climate risk 08

# Scenario 008: Climate risk and extreme-weather sensor triage: scenario 08
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[52])
    X(q[131])
    X(q[64])
    H(q[80])
    CNOT(q[80], q[119])
    Rz(q[80], PI / 7)
    CZ(q[119], q[86])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

309. 309_scenario_climate_risk_09.sq — 309 scenario climate risk 09

# Scenario 009: Climate risk and extreme-weather sensor triage: scenario 09
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[107])
    X(q[52])
    X(q[105])
    H(q[95])
    CNOT(q[95], q[58])
    Rz(q[95], PI / 8)
    CZ(q[58], q[17])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

310. 310_scenario_climate_risk_10.sq — 310 scenario climate risk 10

# Scenario 010: Climate risk and extreme-weather sensor triage: scenario 10
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[56])
    X(q[49])
    X(q[78])
    H(q[28])
    CNOT(q[28], q[63])
    Rz(q[28], PI / 4)
    CZ(q[63], q[38])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

311. 311_scenario_climate_risk_11.sq — 311 scenario climate risk 11

# Scenario 011: Climate risk and extreme-weather sensor triage: scenario 11
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[113])
    X(q[98])
    X(q[29])
    H(q[95])
    CNOT(q[95], q[74])
    Rz(q[95], PI / 5)
    CZ(q[74], q[11])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

312. 312_scenario_climate_risk_12.sq — 312 scenario climate risk 12

# Scenario 012: Climate risk and extreme-weather sensor triage: scenario 12
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[102])
    X(q[23])
    X(q[120])
    H(q[90])
    CNOT(q[90], q[33])
    Rz(q[90], PI / 6)
    CZ(q[33], q[20])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

313. 313_scenario_climate_risk_13.sq — 313 scenario climate risk 13

# Scenario 013: Climate risk and extreme-weather sensor triage: scenario 13
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[23])
    X(q[92])
    X(q[67])
    H(q[107])
    CNOT(q[107], q[86])
    Rz(q[107], PI / 7)
    CZ(q[86], q[37])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

314. 314_scenario_climate_risk_14.sq — 314 scenario climate risk 14

# Scenario 014: Climate risk and extreme-weather sensor triage: scenario 14
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[12])
    X(q[125])
    X(q[26])
    H(q[96])
    CNOT(q[96], q[83])
    Rz(q[96], PI / 8)
    CZ(q[83], q[98])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

315. 315_scenario_climate_risk_15.sq — 315 scenario climate risk 15

# Scenario 015: Climate risk and extreme-weather sensor triage: scenario 15
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[121])
    X(q[66])
    X(q[47])
    H(q[37])
    CNOT(q[37], q[24])
    Rz(q[37], PI / 4)
    CZ(q[24], q[79])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

316. 316_scenario_climate_risk_16.sq — 316 scenario climate risk 16

# Scenario 016: Climate risk and extreme-weather sensor triage: scenario 16
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[98])
    X(q[113])
    X(q[14])
    H(q[40])
    CNOT(q[40], q[129])
    Rz(q[40], PI / 5)
    CZ(q[129], q[86])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

317. 317_scenario_climate_risk_17.sq — 317 scenario climate risk 17

# Scenario 017: Climate risk and extreme-weather sensor triage: scenario 17
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[11])
    X(q[52])
    X(q[89])
    H(q[47])
    CNOT(q[47], q[38])
    Rz(q[47], PI / 6)
    CZ(q[38], q[1])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

318. 318_scenario_climate_risk_18.sq — 318 scenario climate risk 18

# Scenario 018: Climate risk and extreme-weather sensor triage: scenario 18
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[128])
    X(q[53])
    X(q[122])
    H(q[0])
    CNOT(q[0], q[70])
    Rz(q[0], PI / 7)
    CZ(q[70], q[49])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

319. 319_scenario_climate_risk_19.sq — 319 scenario climate risk 19

# Scenario 019: Climate risk and extreme-weather sensor triage: scenario 19
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[53])
    X(q[62])
    X(q[83])
    H(q[97])
    CNOT(q[97], q[108])
    Rz(q[97], PI / 8)
    CZ(q[108], q[43])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

320. 320_scenario_climate_risk_20.sq — 320 scenario climate risk 20

# Scenario 020: Climate risk and extreme-weather sensor triage: scenario 20
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[58])
    X(q[83])
    X(q[16])
    H(q[46])
    CNOT(q[46], q[113])
    Rz(q[46], PI / 4)
    CZ(q[113], q[120])
    print("scenario", "climate_risk", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

321. 321_scenario_smart_grid_01.sq — 321 scenario smart grid 01

# Scenario 021: Smart-grid fault localization and energy routing: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[87])
    X(q[120])
    X(q[45])
    H(q[3])
    CNOT(q[3], q[14])
    Rz(q[3], PI / 5)
    CZ(q[14], q[62])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

322. 322_scenario_smart_grid_02.sq — 322 scenario smart grid 02

# Scenario 022: Smart-grid fault localization and energy routing: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[30])
    X(q[81])
    X(q[102])
    H(q[70])
    CNOT(q[70], q[131])
    Rz(q[70], PI / 6)
    CZ(q[131], q[4])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

323. 323_scenario_smart_grid_03.sq — 323 scenario smart grid 03

# Scenario 023: Smart-grid fault localization and energy routing: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[77])
    X(q[82])
    X(q[71])
    H(q[41])
    CNOT(q[41], q[128])
    Rz(q[41], PI / 7)
    CZ(q[128], q[139])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

324. 324_scenario_smart_grid_04.sq — 324 scenario smart grid 04

# Scenario 024: Smart-grid fault localization and energy routing: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[76])
    X(q[45])
    X(q[102])
    H(q[54])
    CNOT(q[54], q[37])
    Rz(q[54], PI / 8)
    CZ(q[37], q[124])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

325. 325_scenario_smart_grid_05.sq — 325 scenario smart grid 05

# Scenario 025: Smart-grid fault localization and energy routing: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[97])
    X(q[144])
    X(q[73])
    H(q[67])
    CNOT(q[67], q[82])
    Rz(q[67], PI / 4)
    CZ(q[82], q[33])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

326. 326_scenario_smart_grid_06.sq — 326 scenario smart grid 06

# Scenario 026: Smart-grid fault localization and energy routing: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[64])
    X(q[65])
    X(q[6])
    H(q[148])
    CNOT(q[148], q[103])
    Rz(q[148], PI / 5)
    CZ(q[103], q[86])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

327. 327_scenario_smart_grid_07.sq — 327 scenario smart grid 07

# Scenario 027: Smart-grid fault localization and energy routing: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[137])
    X(q[22])
    X(q[5])
    H(q[27])
    CNOT(q[27], q[136])
    Rz(q[27], PI / 6)
    CZ(q[136], q[7])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

328. 328_scenario_smart_grid_08.sq — 328 scenario smart grid 08

# Scenario 028: Smart-grid fault localization and energy routing: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[10])
    X(q[123])
    X(q[4])
    H(q[142])
    CNOT(q[142], q[1])
    Rz(q[142], PI / 7)
    CZ(q[1], q[84])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

329. 329_scenario_smart_grid_09.sq — 329 scenario smart grid 09

# Scenario 029: Smart-grid fault localization and energy routing: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[151])
    X(q[138])
    X(q[53])
    H(q[157])
    CNOT(q[157], q[32])
    Rz(q[157], PI / 8)
    CZ(q[32], q[23])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

330. 330_scenario_smart_grid_10.sq — 330 scenario smart grid 10

# Scenario 030: Smart-grid fault localization and energy routing: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[102])
    X(q[89])
    X(q[78])
    H(q[132])
    CNOT(q[132], q[117])
    Rz(q[132], PI / 4)
    CZ(q[117], q[98])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

331. 331_scenario_smart_grid_11.sq — 331 scenario smart grid 11

# Scenario 031: Smart-grid fault localization and energy routing: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[41])
    X(q[10])
    X(q[119])
    H(q[141])
    CNOT(q[141], q[40])
    Rz(q[141], PI / 5)
    CZ(q[40], q[127])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

332. 332_scenario_smart_grid_12.sq — 332 scenario smart grid 12

# Scenario 032: Smart-grid fault localization and energy routing: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[90])
    X(q[117])
    X(q[62])
    H(q[138])
    CNOT(q[138], q[141])
    Rz(q[138], PI / 6)
    CZ(q[141], q[10])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

333. 333_scenario_smart_grid_13.sq — 333 scenario smart grid 13

# Scenario 033: Smart-grid fault localization and energy routing: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[99])
    X(q[8])
    X(q[93])
    H(q[87])
    CNOT(q[87], q[30])
    Rz(q[87], PI / 7)
    CZ(q[30], q[29])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

334. 334_scenario_smart_grid_14.sq — 334 scenario smart grid 14

# Scenario 034: Smart-grid fault localization and energy routing: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[68])
    X(q[73])
    X(q[4])
    H(q[102])
    CNOT(q[102], q[27])
    Rz(q[102], PI / 8)
    CZ(q[27], q[80])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

335. 335_scenario_smart_grid_15.sq — 335 scenario smart grid 15

# Scenario 035: Smart-grid fault localization and energy routing: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[107])
    X(q[34])
    X(q[83])
    H(q[47])
    CNOT(q[47], q[2])
    Rz(q[47], PI / 4)
    CZ(q[2], q[13])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

336. 336_scenario_smart_grid_16.sq — 336 scenario smart grid 16

# Scenario 036: Smart-grid fault localization and energy routing: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[18])
    X(q[107])
    X(q[80])
    H(q[134])
    CNOT(q[134], q[129])
    Rz(q[134], PI / 5)
    CZ(q[129], q[16])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

337. 337_scenario_smart_grid_17.sq — 337 scenario smart grid 17

# Scenario 037: Smart-grid fault localization and energy routing: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[43])
    X(q[58])
    X(q[119])
    H(q[95])
    CNOT(q[95], q[146])
    Rz(q[95], PI / 6)
    CZ(q[146], q[13])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

338. 338_scenario_smart_grid_18.sq — 338 scenario smart grid 18

# Scenario 038: Smart-grid fault localization and energy routing: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[32])
    X(q[59])
    X(q[130])
    H(q[49])
    CNOT(q[49], q[26])
    Rz(q[49], PI / 7)
    CZ(q[26], q[95])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

339. 339_scenario_smart_grid_19.sq — 339 scenario smart grid 19

# Scenario 039: Smart-grid fault localization and energy routing: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[143])
    X(q[8])
    X(q[113])
    H(q[47])
    CNOT(q[47], q[22])
    Rz(q[47], PI / 8)
    CZ(q[22], q[137])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

340. 340_scenario_smart_grid_20.sq — 340 scenario smart grid 20

# Scenario 040: Smart-grid fault localization and energy routing: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[112])
    X(q[37])
    X(q[78])
    H(q[129])
    CNOT(q[129], q[88])
    Rz(q[129], PI / 4)
    CZ(q[88], q[115])
    print("scenario", "smart_grid", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

341. 341_scenario_portfolio_01.sq — 341 scenario portfolio 01

# Scenario 041: Portfolio risk and scenario flagging: scenario 01
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[23])
    X(q[58])
    X(q[69])
    H(q[25])
    CNOT(q[25], q[14])
    Rz(q[25], PI / 5)
    CZ(q[14], q[71])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

342. 342_scenario_portfolio_02.sq — 342 scenario portfolio 02

# Scenario 042: Portfolio risk and scenario flagging: scenario 02
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[84])
    X(q[65])
    X(q[66])
    H(q[96])
    CNOT(q[96], q[63])
    Rz(q[96], PI / 6)
    CZ(q[63], q[38])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

343. 343_scenario_portfolio_03.sq — 343 scenario portfolio 03

# Scenario 043: Portfolio risk and scenario flagging: scenario 03
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[117])
    X(q[126])
    X(q[85])
    H(q[1])
    CNOT(q[1], q[22])
    Rz(q[1], PI / 7)
    CZ(q[22], q[11])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

344. 344_scenario_portfolio_04.sq — 344 scenario portfolio 04

# Scenario 044: Portfolio risk and scenario flagging: scenario 04
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[122])
    X(q[19])
    X(q[96])
    H(q[102])
    CNOT(q[102], q[97])
    Rz(q[102], PI / 8)
    CZ(q[97], q[40])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

345. 345_scenario_portfolio_05.sq — 345 scenario portfolio 05

# Scenario 045: Portfolio risk and scenario flagging: scenario 05
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[127])
    X(q[40])
    X(q[117])
    H(q[91])
    CNOT(q[91], q[46])
    Rz(q[91], PI / 4)
    CZ(q[46], q[69])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

346. 346_scenario_portfolio_06.sq — 346 scenario portfolio 06

# Scenario 046: Portfolio risk and scenario flagging: scenario 06
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[8])
    X(q[73])
    X(q[54])
    H(q[100])
    CNOT(q[100], q[69])
    Rz(q[100], PI / 5)
    CZ(q[69], q[16])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

347. 347_scenario_portfolio_07.sq — 347 scenario portfolio 07

# Scenario 047: Portfolio risk and scenario flagging: scenario 07
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[125])
    X(q[94])
    X(q[35])
    H(q[53])
    CNOT(q[53], q[68])
    Rz(q[53], PI / 6)
    CZ(q[68], q[19])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

348. 348_scenario_portfolio_08.sq — 348 scenario portfolio 08

# Scenario 048: Portfolio risk and scenario flagging: scenario 08
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[88])
    X(q[87])
    X(q[96])
    H(q[28])
    CNOT(q[28], q[123])
    Rz(q[28], PI / 7)
    CZ(q[123], q[27])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

349. 349_scenario_portfolio_09.sq — 349 scenario portfolio 09

# Scenario 049: Portfolio risk and scenario flagging: scenario 09
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[27])
    X(q[92])
    X(q[17])
    H(q[103])
    CNOT(q[103], q[122])
    Rz(q[103], PI / 8)
    CZ(q[122], q[121])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

350. 350_scenario_portfolio_10.sq — 350 scenario portfolio 10

# Scenario 050: Portfolio risk and scenario flagging: scenario 10
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[64])
    X(q[57])
    X(q[86])
    H(q[100])
    CNOT(q[100], q[7])
    Rz(q[100], PI / 4)
    CZ(q[7], q[110])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

351. 351_scenario_portfolio_11.sq — 351 scenario portfolio 11

# Scenario 051: Portfolio risk and scenario flagging: scenario 11
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[123])
    X(q[88])
    X(q[39])
    H(q[45])
    CNOT(q[45], q[124])
    Rz(q[45], PI / 5)
    CZ(q[124], q[91])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

352. 352_scenario_portfolio_12.sq — 352 scenario portfolio 12

# Scenario 052: Portfolio risk and scenario flagging: scenario 12
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[34])
    X(q[123])
    X(q[4])
    H(q[10])
    CNOT(q[10], q[73])
    Rz(q[10], PI / 6)
    CZ(q[73], q[0])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

353. 353_scenario_portfolio_13.sq — 353 scenario portfolio 13

# Scenario 053: Portfolio risk and scenario flagging: scenario 13
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[59])
    X(q[48])
    X(q[91])
    H(q[55])
    CNOT(q[55], q[90])
    Rz(q[55], PI / 7)
    CZ(q[90], q[47])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

354. 354_scenario_portfolio_14.sq — 354 scenario portfolio 14

# Scenario 054: Portfolio risk and scenario flagging: scenario 14
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[68])
    X(q[29])
    X(q[74])
    H(q[104])
    CNOT(q[104], q[11])
    Rz(q[104], PI / 8)
    CZ(q[11], q[66])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

355. 355_scenario_portfolio_15.sq — 355 scenario portfolio 15

# Scenario 055: Portfolio risk and scenario flagging: scenario 15
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[1])
    X(q[74])
    X(q[55])
    H(q[109])
    CNOT(q[109], q[96])
    Rz(q[109], PI / 4)
    CZ(q[96], q[23])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

356. 356_scenario_portfolio_16.sq — 356 scenario portfolio 16

# Scenario 056: Portfolio risk and scenario flagging: scenario 16
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[108])
    X(q[103])
    X(q[24])
    H(q[120])
    CNOT(q[120], q[49])
    Rz(q[120], PI / 5)
    CZ(q[49], q[36])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

357. 357_scenario_portfolio_17.sq — 357 scenario portfolio 17

# Scenario 057: Portfolio risk and scenario flagging: scenario 17
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[75])
    X(q[20])
    X(q[105])
    H(q[99])
    CNOT(q[99], q[78])
    Rz(q[99], PI / 6)
    CZ(q[78], q[113])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

358. 358_scenario_portfolio_18.sq — 358 scenario portfolio 18

# Scenario 058: Portfolio risk and scenario flagging: scenario 18
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[30])
    X(q[9])
    X(q[94])
    H(q[82])
    CNOT(q[82], q[57])
    Rz(q[82], PI / 7)
    CZ(q[57], q[132])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

359. 359_scenario_portfolio_19.sq — 359 scenario portfolio 19

# Scenario 059: Portfolio risk and scenario flagging: scenario 19
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[109])
    X(q[102])
    X(q[131])
    H(q[105])
    CNOT(q[105], q[36])
    Rz(q[105], PI / 8)
    CZ(q[36], q[11])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

360. 360_scenario_portfolio_20.sq — 360 scenario portfolio 20

# Scenario 060: Portfolio risk and scenario flagging: scenario 20
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[66])
    X(q[91])
    X(q[24])
    H(q[118])
    CNOT(q[118], q[57])
    Rz(q[118], PI / 4)
    CZ(q[57], q[64])
    print("scenario", "portfolio", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

361. 361_scenario_cybersecurity_01.sq — 361 scenario cybersecurity 01

# Scenario 061: Network intrusion and cryptographic health monitoring: scenario 01
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1002, engine="stabilizer") {
    q = quantum_register(1002)
    for i in range(0, 220, 21) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1002, []))
    print("sample", measure_all(shots=2))
}

362. 362_scenario_cybersecurity_02.sq — 362 scenario cybersecurity 02

# Scenario 062: Network intrusion and cryptographic health monitoring: scenario 02
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1004, engine="stabilizer") {
    q = quantum_register(1004)
    for i in range(0, 220, 22) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1004, []))
    print("sample", measure_all(shots=2))
}

363. 363_scenario_cybersecurity_03.sq — 363 scenario cybersecurity 03

# Scenario 063: Network intrusion and cryptographic health monitoring: scenario 03
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1006, engine="stabilizer") {
    q = quantum_register(1006)
    for i in range(0, 220, 23) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1006, []))
    print("sample", measure_all(shots=2))
}

364. 364_scenario_cybersecurity_04.sq — 364 scenario cybersecurity 04

# Scenario 064: Network intrusion and cryptographic health monitoring: scenario 04
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1008, engine="stabilizer") {
    q = quantum_register(1008)
    for i in range(0, 220, 24) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1008, []))
    print("sample", measure_all(shots=2))
}

365. 365_scenario_cybersecurity_05.sq — 365 scenario cybersecurity 05

# Scenario 065: Network intrusion and cryptographic health monitoring: scenario 05
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1000, engine="stabilizer") {
    q = quantum_register(1000)
    for i in range(0, 220, 25) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1000, []))
    print("sample", measure_all(shots=2))
}

366. 366_scenario_cybersecurity_06.sq — 366 scenario cybersecurity 06

# Scenario 066: Network intrusion and cryptographic health monitoring: scenario 06
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1002, engine="stabilizer") {
    q = quantum_register(1002)
    for i in range(0, 220, 26) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1002, []))
    print("sample", measure_all(shots=2))
}

367. 367_scenario_cybersecurity_07.sq — 367 scenario cybersecurity 07

# Scenario 067: Network intrusion and cryptographic health monitoring: scenario 07
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1004, engine="stabilizer") {
    q = quantum_register(1004)
    for i in range(0, 220, 20) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1004, []))
    print("sample", measure_all(shots=2))
}

368. 368_scenario_cybersecurity_08.sq — 368 scenario cybersecurity 08

# Scenario 068: Network intrusion and cryptographic health monitoring: scenario 08
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1006, engine="stabilizer") {
    q = quantum_register(1006)
    for i in range(0, 220, 21) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1006, []))
    print("sample", measure_all(shots=2))
}

369. 369_scenario_cybersecurity_09.sq — 369 scenario cybersecurity 09

# Scenario 069: Network intrusion and cryptographic health monitoring: scenario 09
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1008, engine="stabilizer") {
    q = quantum_register(1008)
    for i in range(0, 220, 22) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1008, []))
    print("sample", measure_all(shots=2))
}

370. 370_scenario_cybersecurity_10.sq — 370 scenario cybersecurity 10

# Scenario 070: Network intrusion and cryptographic health monitoring: scenario 10
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1000, engine="stabilizer") {
    q = quantum_register(1000)
    for i in range(0, 220, 23) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1000, []))
    print("sample", measure_all(shots=2))
}

371. 371_scenario_cybersecurity_11.sq — 371 scenario cybersecurity 11

# Scenario 071: Network intrusion and cryptographic health monitoring: scenario 11
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1002, engine="stabilizer") {
    q = quantum_register(1002)
    for i in range(0, 220, 24) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1002, []))
    print("sample", measure_all(shots=2))
}

372. 372_scenario_cybersecurity_12.sq — 372 scenario cybersecurity 12

# Scenario 072: Network intrusion and cryptographic health monitoring: scenario 12
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1004, engine="stabilizer") {
    q = quantum_register(1004)
    for i in range(0, 220, 25) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1004, []))
    print("sample", measure_all(shots=2))
}

373. 373_scenario_cybersecurity_13.sq — 373 scenario cybersecurity 13

# Scenario 073: Network intrusion and cryptographic health monitoring: scenario 13
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1006, engine="stabilizer") {
    q = quantum_register(1006)
    for i in range(0, 220, 26) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1006, []))
    print("sample", measure_all(shots=2))
}

374. 374_scenario_cybersecurity_14.sq — 374 scenario cybersecurity 14

# Scenario 074: Network intrusion and cryptographic health monitoring: scenario 14
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1008, engine="stabilizer") {
    q = quantum_register(1008)
    for i in range(0, 220, 20) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1008, []))
    print("sample", measure_all(shots=2))
}

375. 375_scenario_cybersecurity_15.sq — 375 scenario cybersecurity 15

# Scenario 075: Network intrusion and cryptographic health monitoring: scenario 15
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1000, engine="stabilizer") {
    q = quantum_register(1000)
    for i in range(0, 220, 21) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1000, []))
    print("sample", measure_all(shots=2))
}

376. 376_scenario_cybersecurity_16.sq — 376 scenario cybersecurity 16

# Scenario 076: Network intrusion and cryptographic health monitoring: scenario 16
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1002, engine="stabilizer") {
    q = quantum_register(1002)
    for i in range(0, 220, 22) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1002, []))
    print("sample", measure_all(shots=2))
}

377. 377_scenario_cybersecurity_17.sq — 377 scenario cybersecurity 17

# Scenario 077: Network intrusion and cryptographic health monitoring: scenario 17
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1004, engine="stabilizer") {
    q = quantum_register(1004)
    for i in range(0, 220, 23) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1004, []))
    print("sample", measure_all(shots=2))
}

378. 378_scenario_cybersecurity_18.sq — 378 scenario cybersecurity 18

# Scenario 078: Network intrusion and cryptographic health monitoring: scenario 18
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1006, engine="stabilizer") {
    q = quantum_register(1006)
    for i in range(0, 220, 24) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1006, []))
    print("sample", measure_all(shots=2))
}

379. 379_scenario_cybersecurity_19.sq — 379 scenario cybersecurity 19

# Scenario 079: Network intrusion and cryptographic health monitoring: scenario 19
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1008, engine="stabilizer") {
    q = quantum_register(1008)
    for i in range(0, 220, 25) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1008, []))
    print("sample", measure_all(shots=2))
}

380. 380_scenario_cybersecurity_20.sq — 380 scenario cybersecurity 20

# Scenario 080: Network intrusion and cryptographic health monitoring: scenario 20
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(1000, engine="stabilizer") {
    q = quantum_register(1000)
    for i in range(0, 220, 26) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "cybersecurity", "backend", plan_backend(1000, []))
    print("sample", measure_all(shots=2))
}

381. 381_scenario_supply_chain_01.sq — 381 scenario supply chain 01

# Scenario 081: Supply-chain route disruption and inventory risk: scenario 01
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

382. 382_scenario_supply_chain_02.sq — 382 scenario supply chain 02

# Scenario 082: Supply-chain route disruption and inventory risk: scenario 02
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

383. 383_scenario_supply_chain_03.sq — 383 scenario supply chain 03

# Scenario 083: Supply-chain route disruption and inventory risk: scenario 03
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

384. 384_scenario_supply_chain_04.sq — 384 scenario supply chain 04

# Scenario 084: Supply-chain route disruption and inventory risk: scenario 04
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

385. 385_scenario_supply_chain_05.sq — 385 scenario supply chain 05

# Scenario 085: Supply-chain route disruption and inventory risk: scenario 05
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

386. 386_scenario_supply_chain_06.sq — 386 scenario supply chain 06

# Scenario 086: Supply-chain route disruption and inventory risk: scenario 06
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

387. 387_scenario_supply_chain_07.sq — 387 scenario supply chain 07

# Scenario 087: Supply-chain route disruption and inventory risk: scenario 07
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

388. 388_scenario_supply_chain_08.sq — 388 scenario supply chain 08

# Scenario 088: Supply-chain route disruption and inventory risk: scenario 08
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

389. 389_scenario_supply_chain_09.sq — 389 scenario supply chain 09

# Scenario 089: Supply-chain route disruption and inventory risk: scenario 09
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 6)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

390. 390_scenario_supply_chain_10.sq — 390 scenario supply chain 10

# Scenario 090: Supply-chain route disruption and inventory risk: scenario 10
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 7)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

391. 391_scenario_supply_chain_11.sq — 391 scenario supply chain 11

# Scenario 091: Supply-chain route disruption and inventory risk: scenario 11
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 8)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

392. 392_scenario_supply_chain_12.sq — 392 scenario supply chain 12

# Scenario 092: Supply-chain route disruption and inventory risk: scenario 12
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 3)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

393. 393_scenario_supply_chain_13.sq — 393 scenario supply chain 13

# Scenario 093: Supply-chain route disruption and inventory risk: scenario 13
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

394. 394_scenario_supply_chain_14.sq — 394 scenario supply chain 14

# Scenario 094: Supply-chain route disruption and inventory risk: scenario 14
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

395. 395_scenario_supply_chain_15.sq — 395 scenario supply chain 15

# Scenario 095: Supply-chain route disruption and inventory risk: scenario 15
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

396. 396_scenario_supply_chain_16.sq — 396 scenario supply chain 16

# Scenario 096: Supply-chain route disruption and inventory risk: scenario 16
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

397. 397_scenario_supply_chain_17.sq — 397 scenario supply chain 17

# Scenario 097: Supply-chain route disruption and inventory risk: scenario 17
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

398. 398_scenario_supply_chain_18.sq — 398 scenario supply chain 18

# Scenario 098: Supply-chain route disruption and inventory risk: scenario 18
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

399. 399_scenario_supply_chain_19.sq — 399 scenario supply chain 19

# Scenario 099: Supply-chain route disruption and inventory risk: scenario 19
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

400. 400_scenario_supply_chain_20.sq — 400 scenario supply chain 20

# Scenario 100: Supply-chain route disruption and inventory risk: scenario 20
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "supply_chain", hierarchical_report())
    print("lookup", lookup_profile())
}

401. 401_scenario_traffic_01.sq — 401 scenario traffic 01

# Scenario 101: Urban traffic signal optimization: scenario 01
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 61) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

402. 402_scenario_traffic_02.sq — 402 scenario traffic 02

# Scenario 102: Urban traffic signal optimization: scenario 02
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 62) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

403. 403_scenario_traffic_03.sq — 403 scenario traffic 03

# Scenario 103: Urban traffic signal optimization: scenario 03
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 63) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

404. 404_scenario_traffic_04.sq — 404 scenario traffic 04

# Scenario 104: Urban traffic signal optimization: scenario 04
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 64) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

405. 405_scenario_traffic_05.sq — 405 scenario traffic 05

# Scenario 105: Urban traffic signal optimization: scenario 05
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 65) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

406. 406_scenario_traffic_06.sq — 406 scenario traffic 06

# Scenario 106: Urban traffic signal optimization: scenario 06
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 66) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

407. 407_scenario_traffic_07.sq — 407 scenario traffic 07

# Scenario 107: Urban traffic signal optimization: scenario 07
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 67) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

408. 408_scenario_traffic_08.sq — 408 scenario traffic 08

# Scenario 108: Urban traffic signal optimization: scenario 08
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 68) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

409. 409_scenario_traffic_09.sq — 409 scenario traffic 09

# Scenario 109: Urban traffic signal optimization: scenario 09
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 69) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

410. 410_scenario_traffic_10.sq — 410 scenario traffic 10

# Scenario 110: Urban traffic signal optimization: scenario 10
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 70) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

411. 411_scenario_traffic_11.sq — 411 scenario traffic 11

# Scenario 111: Urban traffic signal optimization: scenario 11
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 71) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

412. 412_scenario_traffic_12.sq — 412 scenario traffic 12

# Scenario 112: Urban traffic signal optimization: scenario 12
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 72) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

413. 413_scenario_traffic_13.sq — 413 scenario traffic 13

# Scenario 113: Urban traffic signal optimization: scenario 13
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 73) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

414. 414_scenario_traffic_14.sq — 414 scenario traffic 14

# Scenario 114: Urban traffic signal optimization: scenario 14
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 74) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

415. 415_scenario_traffic_15.sq — 415 scenario traffic 15

# Scenario 115: Urban traffic signal optimization: scenario 15
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 75) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

416. 416_scenario_traffic_16.sq — 416 scenario traffic 16

# Scenario 116: Urban traffic signal optimization: scenario 16
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 76) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

417. 417_scenario_traffic_17.sq — 417 scenario traffic 17

# Scenario 117: Urban traffic signal optimization: scenario 17
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 77) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

418. 418_scenario_traffic_18.sq — 418 scenario traffic 18

# Scenario 118: Urban traffic signal optimization: scenario 18
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 78) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

419. 419_scenario_traffic_19.sq — 419 scenario traffic 19

# Scenario 119: Urban traffic signal optimization: scenario 19
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 79) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

420. 420_scenario_traffic_20.sq — 420 scenario traffic 20

# Scenario 120: Urban traffic signal optimization: scenario 20
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 80) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "traffic", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

421. 421_scenario_satellite_01.sq — 421 scenario satellite 01

# Scenario 121: Satellite telemetry anomaly isolation: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[83])
    X(q[84])
    X(q[25])
    H(q[15])
    CNOT(q[15], q[122])
    Rz(q[15], PI / 5)
    CZ(q[122], q[105])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

422. 422_scenario_satellite_02.sq — 422 scenario satellite 02

# Scenario 122: Satellite telemetry anomaly isolation: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[14])
    X(q[133])
    X(q[10])
    H(q[134])
    CNOT(q[134], q[77])
    Rz(q[134], PI / 6)
    CZ(q[77], q[64])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

423. 423_scenario_satellite_03.sq — 423 scenario satellite 03

# Scenario 123: Satellite telemetry anomaly isolation: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[141])
    X(q[122])
    X(q[135])
    H(q[33])
    CNOT(q[33], q[84])
    Rz(q[33], PI / 7)
    CZ(q[84], q[131])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

424. 424_scenario_satellite_04.sq — 424 scenario satellite 04

# Scenario 124: Satellite telemetry anomaly isolation: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[154])
    X(q[9])
    X(q[70])
    H(q[60])
    CNOT(q[60], q[95])
    Rz(q[60], PI / 8)
    CZ(q[95], q[0])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

425. 425_scenario_satellite_05.sq — 425 scenario satellite 05

# Scenario 125: Satellite telemetry anomaly isolation: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[47])
    X(q[94])
    X(q[23])
    H(q[17])
    CNOT(q[17], q[32])
    Rz(q[17], PI / 4)
    CZ(q[32], q[133])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

426. 426_scenario_satellite_06.sq — 426 scenario satellite 06

# Scenario 126: Satellite telemetry anomaly isolation: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[60])
    X(q[29])
    X(q[138])
    H(q[8])
    CNOT(q[8], q[59])
    Rz(q[8], PI / 5)
    CZ(q[59], q[146])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

427. 427_scenario_satellite_07.sq — 427 scenario satellite 07

# Scenario 127: Satellite telemetry anomaly isolation: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[121])
    X(q[74])
    X(q[67])
    H(q[91])
    CNOT(q[91], q[82])
    Rz(q[91], PI / 6)
    CZ(q[82], q[84])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

428. 428_scenario_satellite_08.sq — 428 scenario satellite 08

# Scenario 128: Satellite telemetry anomaly isolation: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[74])
    X(q[7])
    X(q[68])
    H(q[134])
    CNOT(q[134], q[113])
    Rz(q[134], PI / 7)
    CZ(q[113], q[76])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

429. 429_scenario_satellite_09.sq — 429 scenario satellite 09

# Scenario 129: Satellite telemetry anomaly isolation: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[71])
    X(q[102])
    X(q[21])
    H(q[5])
    CNOT(q[5], q[90])
    Rz(q[5], PI / 8)
    CZ(q[90], q[57])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

430. 430_scenario_satellite_10.sq — 430 scenario satellite 10

# Scenario 130: Satellite telemetry anomaly isolation: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[52])
    X(q[39])
    X(q[28])
    H(q[82])
    CNOT(q[82], q[67])
    Rz(q[82], PI / 4)
    CZ(q[67], q[48])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

431. 431_scenario_satellite_11.sq — 431 scenario satellite 11

# Scenario 131: Satellite telemetry anomaly isolation: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[37])
    X(q[126])
    X(q[99])
    H(q[1])
    CNOT(q[1], q[148])
    Rz(q[1], PI / 5)
    CZ(q[148], q[35])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

432. 432_scenario_satellite_12.sq — 432 scenario satellite 12

# Scenario 132: Satellite telemetry anomaly isolation: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[74])
    X(q[15])
    X(q[124])
    H(q[48])
    CNOT(q[48], q[87])
    Rz(q[48], PI / 6)
    CZ(q[87], q[70])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

433. 433_scenario_satellite_13.sq — 433 scenario satellite 13

# Scenario 133: Satellite telemetry anomaly isolation: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[7])
    X(q[48])
    X(q[1])
    H(q[79])
    CNOT(q[79], q[142])
    Rz(q[79], PI / 7)
    CZ(q[142], q[21])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

434. 434_scenario_satellite_14.sq — 434 scenario satellite 14

# Scenario 134: Satellite telemetry anomaly isolation: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[146])
    X(q[37])
    X(q[130])
    H(q[108])
    CNOT(q[108], q[85])
    Rz(q[108], PI / 8)
    CZ(q[85], q[114])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

435. 435_scenario_satellite_15.sq — 435 scenario satellite 15

# Scenario 135: Satellite telemetry anomaly isolation: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[57])
    X(q[134])
    X(q[33])
    H(q[147])
    CNOT(q[147], q[102])
    Rz(q[147], PI / 4)
    CZ(q[102], q[113])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

436. 436_scenario_satellite_16.sq — 436 scenario satellite 16

# Scenario 136: Satellite telemetry anomaly isolation: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[14])
    X(q[71])
    X(q[60])
    H(q[146])
    CNOT(q[146], q[85])
    Rz(q[146], PI / 5)
    CZ(q[85], q[76])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

437. 437_scenario_satellite_17.sq — 437 scenario satellite 17

# Scenario 137: Satellite telemetry anomaly isolation: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[27])
    X(q[110])
    X(q[73])
    H(q[5])
    CNOT(q[5], q[92])
    Rz(q[5], PI / 6)
    CZ(q[92], q[60])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

438. 438_scenario_satellite_18.sq — 438 scenario satellite 18

# Scenario 138: Satellite telemetry anomaly isolation: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[96])
    X(q[89])
    X(q[90])
    H(q[24])
    CNOT(q[24], q[15])
    Rz(q[24], PI / 7)
    CZ(q[15], q[122])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

439. 439_scenario_satellite_19.sq — 439 scenario satellite 19

# Scenario 139: Satellite telemetry anomaly isolation: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[63])
    X(q[130])
    X(q[81])
    H(q[53])
    CNOT(q[53], q[80])
    Rz(q[53], PI / 8)
    CZ(q[80], q[13])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

440. 440_scenario_satellite_20.sq — 440 scenario satellite 20

# Scenario 140: Satellite telemetry anomaly isolation: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[62])
    X(q[137])
    X(q[28])
    H(q[79])
    CNOT(q[79], q[38])
    Rz(q[79], PI / 4)
    CZ(q[38], q[65])
    print("scenario", "satellite", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

441. 441_scenario_telecom_01.sq — 441 scenario telecom 01

# Scenario 141: Telecom routing and spectrum allocation: scenario 01
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(132, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(132)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

442. 442_scenario_telecom_02.sq — 442 scenario telecom 02

# Scenario 142: Telecom routing and spectrum allocation: scenario 02
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(134, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(134)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

443. 443_scenario_telecom_03.sq — 443 scenario telecom 03

# Scenario 143: Telecom routing and spectrum allocation: scenario 03
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(136, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(136)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

444. 444_scenario_telecom_04.sq — 444 scenario telecom 04

# Scenario 144: Telecom routing and spectrum allocation: scenario 04
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(138, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(138)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

445. 445_scenario_telecom_05.sq — 445 scenario telecom 05

# Scenario 145: Telecom routing and spectrum allocation: scenario 05
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(130, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(130)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

446. 446_scenario_telecom_06.sq — 446 scenario telecom 06

# Scenario 146: Telecom routing and spectrum allocation: scenario 06
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(132, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(132)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

447. 447_scenario_telecom_07.sq — 447 scenario telecom 07

# Scenario 147: Telecom routing and spectrum allocation: scenario 07
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(134, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(134)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

448. 448_scenario_telecom_08.sq — 448 scenario telecom 08

# Scenario 148: Telecom routing and spectrum allocation: scenario 08
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(136, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(136)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

449. 449_scenario_telecom_09.sq — 449 scenario telecom 09

# Scenario 149: Telecom routing and spectrum allocation: scenario 09
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(138, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(138)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 6)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

450. 450_scenario_telecom_10.sq — 450 scenario telecom 10

# Scenario 150: Telecom routing and spectrum allocation: scenario 10
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(130, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(130)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 7)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

451. 451_scenario_telecom_11.sq — 451 scenario telecom 11

# Scenario 151: Telecom routing and spectrum allocation: scenario 11
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(132, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(132)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 8)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

452. 452_scenario_telecom_12.sq — 452 scenario telecom 12

# Scenario 152: Telecom routing and spectrum allocation: scenario 12
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(134, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(134)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 3)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

453. 453_scenario_telecom_13.sq — 453 scenario telecom 13

# Scenario 153: Telecom routing and spectrum allocation: scenario 13
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(136, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(136)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

454. 454_scenario_telecom_14.sq — 454 scenario telecom 14

# Scenario 154: Telecom routing and spectrum allocation: scenario 14
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(138, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(138)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

455. 455_scenario_telecom_15.sq — 455 scenario telecom 15

# Scenario 155: Telecom routing and spectrum allocation: scenario 15
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(130, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(130)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

456. 456_scenario_telecom_16.sq — 456 scenario telecom 16

# Scenario 156: Telecom routing and spectrum allocation: scenario 16
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(132, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(132)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

457. 457_scenario_telecom_17.sq — 457 scenario telecom 17

# Scenario 157: Telecom routing and spectrum allocation: scenario 17
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(134, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(134)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

458. 458_scenario_telecom_18.sq — 458 scenario telecom 18

# Scenario 158: Telecom routing and spectrum allocation: scenario 18
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(136, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(136)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

459. 459_scenario_telecom_19.sq — 459 scenario telecom 19

# Scenario 159: Telecom routing and spectrum allocation: scenario 19
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(138, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(138)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

460. 460_scenario_telecom_20.sq — 460 scenario telecom 20

# Scenario 160: Telecom routing and spectrum allocation: scenario 20
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(130, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(130)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "telecom", hierarchical_report())
    print("lookup", lookup_profile())
}

461. 461_scenario_drug_discovery_01.sq — 461 scenario drug discovery 01

# Scenario 161: Drug-discovery feature-map screening: scenario 01
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 61) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

462. 462_scenario_drug_discovery_02.sq — 462 scenario drug discovery 02

# Scenario 162: Drug-discovery feature-map screening: scenario 02
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 62) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

463. 463_scenario_drug_discovery_03.sq — 463 scenario drug discovery 03

# Scenario 163: Drug-discovery feature-map screening: scenario 03
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 63) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

464. 464_scenario_drug_discovery_04.sq — 464 scenario drug discovery 04

# Scenario 164: Drug-discovery feature-map screening: scenario 04
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 64) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

465. 465_scenario_drug_discovery_05.sq — 465 scenario drug discovery 05

# Scenario 165: Drug-discovery feature-map screening: scenario 05
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(124, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(124)
    H(q[0])
    for i in range(0, 65) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(124))
}

466. 466_scenario_drug_discovery_06.sq — 466 scenario drug discovery 06

# Scenario 166: Drug-discovery feature-map screening: scenario 06
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 66) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

467. 467_scenario_drug_discovery_07.sq — 467 scenario drug discovery 07

# Scenario 167: Drug-discovery feature-map screening: scenario 07
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 67) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

468. 468_scenario_drug_discovery_08.sq — 468 scenario drug discovery 08

# Scenario 168: Drug-discovery feature-map screening: scenario 08
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 68) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

469. 469_scenario_drug_discovery_09.sq — 469 scenario drug discovery 09

# Scenario 169: Drug-discovery feature-map screening: scenario 09
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 69) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

470. 470_scenario_drug_discovery_10.sq — 470 scenario drug discovery 10

# Scenario 170: Drug-discovery feature-map screening: scenario 10
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(124, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(124)
    H(q[0])
    for i in range(0, 70) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(124))
}

471. 471_scenario_drug_discovery_11.sq — 471 scenario drug discovery 11

# Scenario 171: Drug-discovery feature-map screening: scenario 11
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 71) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

472. 472_scenario_drug_discovery_12.sq — 472 scenario drug discovery 12

# Scenario 172: Drug-discovery feature-map screening: scenario 12
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 72) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

473. 473_scenario_drug_discovery_13.sq — 473 scenario drug discovery 13

# Scenario 173: Drug-discovery feature-map screening: scenario 13
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 73) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

474. 474_scenario_drug_discovery_14.sq — 474 scenario drug discovery 14

# Scenario 174: Drug-discovery feature-map screening: scenario 14
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 74) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

475. 475_scenario_drug_discovery_15.sq — 475 scenario drug discovery 15

# Scenario 175: Drug-discovery feature-map screening: scenario 15
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(124, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(124)
    H(q[0])
    for i in range(0, 75) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(124))
}

476. 476_scenario_drug_discovery_16.sq — 476 scenario drug discovery 16

# Scenario 176: Drug-discovery feature-map screening: scenario 16
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 76) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

477. 477_scenario_drug_discovery_17.sq — 477 scenario drug discovery 17

# Scenario 177: Drug-discovery feature-map screening: scenario 17
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 77) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

478. 478_scenario_drug_discovery_18.sq — 478 scenario drug discovery 18

# Scenario 178: Drug-discovery feature-map screening: scenario 18
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 78) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

479. 479_scenario_drug_discovery_19.sq — 479 scenario drug discovery 19

# Scenario 179: Drug-discovery feature-map screening: scenario 19
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 79) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

480. 480_scenario_drug_discovery_20.sq — 480 scenario drug discovery 20

# Scenario 180: Drug-discovery feature-map screening: scenario 20
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(124, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(124)
    H(q[0])
    for i in range(0, 80) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "drug_discovery", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(124))
}

481. 481_scenario_materials_01.sq — 481 scenario materials 01

# Scenario 181: Battery and materials candidate screening: scenario 01
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 61) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

482. 482_scenario_materials_02.sq — 482 scenario materials 02

# Scenario 182: Battery and materials candidate screening: scenario 02
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 62) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

483. 483_scenario_materials_03.sq — 483 scenario materials 03

# Scenario 183: Battery and materials candidate screening: scenario 03
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 63) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

484. 484_scenario_materials_04.sq — 484 scenario materials 04

# Scenario 184: Battery and materials candidate screening: scenario 04
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 64) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

485. 485_scenario_materials_05.sq — 485 scenario materials 05

# Scenario 185: Battery and materials candidate screening: scenario 05
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 65) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

486. 486_scenario_materials_06.sq — 486 scenario materials 06

# Scenario 186: Battery and materials candidate screening: scenario 06
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 66) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

487. 487_scenario_materials_07.sq — 487 scenario materials 07

# Scenario 187: Battery and materials candidate screening: scenario 07
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 67) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

488. 488_scenario_materials_08.sq — 488 scenario materials 08

# Scenario 188: Battery and materials candidate screening: scenario 08
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 68) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

489. 489_scenario_materials_09.sq — 489 scenario materials 09

# Scenario 189: Battery and materials candidate screening: scenario 09
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 69) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

490. 490_scenario_materials_10.sq — 490 scenario materials 10

# Scenario 190: Battery and materials candidate screening: scenario 10
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 70) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

491. 491_scenario_materials_11.sq — 491 scenario materials 11

# Scenario 191: Battery and materials candidate screening: scenario 11
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 71) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

492. 492_scenario_materials_12.sq — 492 scenario materials 12

# Scenario 192: Battery and materials candidate screening: scenario 12
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 72) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

493. 493_scenario_materials_13.sq — 493 scenario materials 13

# Scenario 193: Battery and materials candidate screening: scenario 13
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 73) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

494. 494_scenario_materials_14.sq — 494 scenario materials 14

# Scenario 194: Battery and materials candidate screening: scenario 14
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 74) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

495. 495_scenario_materials_15.sq — 495 scenario materials 15

# Scenario 195: Battery and materials candidate screening: scenario 15
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 75) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

496. 496_scenario_materials_16.sq — 496 scenario materials 16

# Scenario 196: Battery and materials candidate screening: scenario 16
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(128, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(128)
    H(q[0])
    for i in range(0, 76) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(128))
}

497. 497_scenario_materials_17.sq — 497 scenario materials 17

# Scenario 197: Battery and materials candidate screening: scenario 17
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(130, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(130)
    H(q[0])
    for i in range(0, 77) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(130))
}

498. 498_scenario_materials_18.sq — 498 scenario materials 18

# Scenario 198: Battery and materials candidate screening: scenario 18
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(132, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(132)
    H(q[0])
    for i in range(0, 78) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(132))
}

499. 499_scenario_materials_19.sq — 499 scenario materials 19

# Scenario 199: Battery and materials candidate screening: scenario 19
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(134, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(134)
    H(q[0])
    for i in range(0, 79) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(134))
}

500. 500_scenario_materials_20.sq — 500 scenario materials 20

# Scenario 200: Battery and materials candidate screening: scenario 20
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(126, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(126)
    H(q[0])
    for i in range(0, 80) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "materials", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(126))
}

501. 501_scenario_genomics_01.sq — 501 scenario genomics 01

# Scenario 201: Genomic variant prioritization: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[19])
    X(q[116])
    X(q[9])
    H(q[55])
    CNOT(q[55], q[26])
    Rz(q[55], PI / 5)
    CZ(q[26], q[1])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

502. 502_scenario_genomics_02.sq — 502 scenario genomics 02

# Scenario 202: Genomic variant prioritization: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[32])
    X(q[113])
    X(q[152])
    H(q[62])
    CNOT(q[62], q[3])
    Rz(q[62], PI / 6)
    CZ(q[3], q[112])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

503. 503_scenario_genomics_03.sq — 503 scenario genomics 03

# Scenario 203: Genomic variant prioritization: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[5])
    X(q[154])
    X(q[155])
    H(q[89])
    CNOT(q[89], q[80])
    Rz(q[89], PI / 7)
    CZ(q[80], q[31])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

504. 504_scenario_genomics_04.sq — 504 scenario genomics 04

# Scenario 204: Genomic variant prioritization: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[90])
    X(q[75])
    X(q[76])
    H(q[128])
    CNOT(q[128], q[15])
    Rz(q[128], PI / 8)
    CZ(q[15], q[122])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

505. 505_scenario_genomics_05.sq — 505 scenario genomics 05

# Scenario 205: Genomic variant prioritization: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[127])
    X(q[114])
    X(q[103])
    H(q[7])
    CNOT(q[7], q[142])
    Rz(q[7], PI / 4)
    CZ(q[142], q[123])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

506. 506_scenario_genomics_06.sq — 506 scenario genomics 06

# Scenario 206: Genomic variant prioritization: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[148])
    X(q[61])
    X(q[122])
    H(q[48])
    CNOT(q[48], q[115])
    Rz(q[48], PI / 5)
    CZ(q[115], q[42])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

507. 507_scenario_genomics_07.sq — 507 scenario genomics 07

# Scenario 207: Genomic variant prioritization: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[139])
    X(q[54])
    X(q[55])
    H(q[19])
    CNOT(q[19], q[8])
    Rz(q[19], PI / 6)
    CZ(q[8], q[115])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

508. 508_scenario_genomics_08.sq — 508 scenario genomics 08

# Scenario 208: Genomic variant prioritization: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[94])
    X(q[39])
    X(q[88])
    H(q[34])
    CNOT(q[34], q[109])
    Rz(q[34], PI / 7)
    CZ(q[109], q[132])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

509. 509_scenario_genomics_09.sq — 509 scenario genomics 09

# Scenario 209: Genomic variant prioritization: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[7])
    X(q[10])
    X(q[21])
    H(q[73])
    CNOT(q[73], q[27])
    Rz(q[73], PI / 8)
    CZ(q[27], q[74])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

510. 510_scenario_genomics_10.sq — 510 scenario genomics 10

# Scenario 210: Genomic variant prioritization: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[132])
    X(q[59])
    X(q[108])
    H(q[72])
    CNOT(q[72], q[27])
    Rz(q[72], PI / 4)
    CZ(q[27], q[38])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

511. 511_scenario_genomics_11.sq — 511 scenario genomics 11

# Scenario 211: Genomic variant prioritization: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[125])
    X(q[6])
    X(q[83])
    H(q[41])
    CNOT(q[41], q[52])
    Rz(q[41], PI / 5)
    CZ(q[52], q[100])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

512. 512_scenario_genomics_12.sq — 512 scenario genomics 12

# Scenario 212: Genomic variant prioritization: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[92])
    X(q[149])
    X(q[112])
    H(q[130])
    CNOT(q[130], q[13])
    Rz(q[130], PI / 6)
    CZ(q[13], q[118])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

513. 513_scenario_genomics_13.sq — 513 scenario genomics 13

# Scenario 213: Genomic variant prioritization: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[27])
    X(q[80])
    X(q[21])
    H(q[135])
    CNOT(q[135], q[138])
    Rz(q[135], PI / 7)
    CZ(q[138], q[77])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

514. 514_scenario_genomics_14.sq — 514 scenario genomics 14

# Scenario 214: Genomic variant prioritization: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[82])
    X(q[103])
    X(q[136])
    H(q[18])
    CNOT(q[18], q[5])
    Rz(q[18], PI / 8)
    CZ(q[5], q[78])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

515. 515_scenario_genomics_15.sq — 515 scenario genomics 15

# Scenario 215: Genomic variant prioritization: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[137])
    X(q[62])
    X(q[103])
    H(q[4])
    CNOT(q[4], q[113])
    Rz(q[4], PI / 4)
    CZ(q[113], q[140])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

516. 516_scenario_genomics_16.sq — 516 scenario genomics 16

# Scenario 216: Genomic variant prioritization: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[102])
    X(q[103])
    X(q[44])
    H(q[34])
    CNOT(q[34], q[141])
    Rz(q[34], PI / 5)
    CZ(q[141], q[124])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

517. 517_scenario_genomics_17.sq — 517 scenario genomics 17

# Scenario 217: Genomic variant prioritization: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[45])
    X(q[90])
    X(q[15])
    H(q[87])
    CNOT(q[87], q[18])
    Rz(q[87], PI / 6)
    CZ(q[18], q[121])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

518. 518_scenario_genomics_18.sq — 518 scenario genomics 18

# Scenario 218: Genomic variant prioritization: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[116])
    X(q[121])
    X(q[110])
    H(q[80])
    CNOT(q[80], q[11])
    Rz(q[80], PI / 7)
    CZ(q[11], q[22])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

519. 519_scenario_genomics_19.sq — 519 scenario genomics 19

# Scenario 219: Genomic variant prioritization: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[157])
    X(q[38])
    X(q[87])
    H(q[121])
    CNOT(q[121], q[0])
    Rz(q[121], PI / 8)
    CZ(q[0], q[135])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

520. 520_scenario_genomics_20.sq — 520 scenario genomics 20

# Scenario 220: Genomic variant prioritization: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[142])
    X(q[99])
    X(q[118])
    H(q[52])
    CNOT(q[52], q[97])
    Rz(q[52], PI / 4)
    CZ(q[97], q[18])
    print("scenario", "genomics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

521. 521_scenario_healthcare_01.sq — 521 scenario healthcare 01

# Scenario 221: Hospital triage and resource allocation: scenario 01
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[3])
    X(q[78])
    X(q[49])
    H(q[125])
    CNOT(q[125], q[44])
    Rz(q[125], PI / 5)
    CZ(q[44], q[41])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

522. 522_scenario_healthcare_02.sq — 522 scenario healthcare 02

# Scenario 222: Hospital triage and resource allocation: scenario 02
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[108])
    X(q[53])
    X(q[6])
    H(q[0])
    CNOT(q[0], q[111])
    Rz(q[0], PI / 6)
    CZ(q[111], q[14])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

523. 523_scenario_healthcare_03.sq — 523 scenario healthcare 03

# Scenario 223: Hospital triage and resource allocation: scenario 03
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[11])
    X(q[62])
    X(q[59])
    H(q[35])
    CNOT(q[35], q[40])
    Rz(q[35], PI / 7)
    CZ(q[40], q[123])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

524. 524_scenario_healthcare_04.sq — 524 scenario healthcare 04

# Scenario 224: Hospital triage and resource allocation: scenario 04
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[102])
    X(q[63])
    X(q[108])
    H(q[2])
    CNOT(q[2], q[45])
    Rz(q[2], PI / 8)
    CZ(q[45], q[100])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

525. 525_scenario_healthcare_05.sq — 525 scenario healthcare 05

# Scenario 225: Hospital triage and resource allocation: scenario 05
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[35])
    X(q[12])
    X(q[25])
    H(q[31])
    CNOT(q[31], q[50])
    Rz(q[31], PI / 4)
    CZ(q[50], q[9])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

526. 526_scenario_healthcare_06.sq — 526 scenario healthcare 06

# Scenario 226: Hospital triage and resource allocation: scenario 06
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[118])
    X(q[93])
    X(q[34])
    H(q[70])
    CNOT(q[70], q[99])
    Rz(q[70], PI / 5)
    CZ(q[99], q[116])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

527. 527_scenario_healthcare_07.sq — 527 scenario healthcare 07

# Scenario 227: Hospital triage and resource allocation: scenario 07
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[17])
    X(q[82])
    X(q[107])
    H(q[89])
    CNOT(q[89], q[116])
    Rz(q[89], PI / 6)
    CZ(q[116], q[127])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

528. 528_scenario_healthcare_08.sq — 528 scenario healthcare 08

# Scenario 228: Hospital triage and resource allocation: scenario 08
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[116])
    X(q[23])
    X(q[74])
    H(q[62])
    CNOT(q[62], q[7])
    Rz(q[62], PI / 7)
    CZ(q[7], q[29])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

529. 529_scenario_healthcare_09.sq — 529 scenario healthcare 09

# Scenario 229: Hospital triage and resource allocation: scenario 09
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[7])
    X(q[0])
    X(q[29])
    H(q[3])
    CNOT(q[3], q[70])
    Rz(q[3], PI / 8)
    CZ(q[70], q[45])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

530. 530_scenario_healthcare_10.sq — 530 scenario healthcare 10

# Scenario 230: Hospital triage and resource allocation: scenario 10
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[100])
    X(q[29])
    X(q[122])
    H(q[40])
    CNOT(q[40], q[11])
    Rz(q[40], PI / 4)
    CZ(q[11], q[50])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

531. 531_scenario_healthcare_11.sq — 531 scenario healthcare 11

# Scenario 231: Hospital triage and resource allocation: scenario 11
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[103])
    X(q[108])
    X(q[19])
    H(q[15])
    CNOT(q[15], q[24])
    Rz(q[15], PI / 5)
    CZ(q[24], q[61])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

532. 532_scenario_healthcare_12.sq — 532 scenario healthcare 12

# Scenario 232: Hospital triage and resource allocation: scenario 12
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[58])
    X(q[111])
    X(q[76])
    H(q[46])
    CNOT(q[46], q[121])
    Rz(q[46], PI / 6)
    CZ(q[121], q[108])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

533. 533_scenario_healthcare_13.sq — 533 scenario healthcare 13

# Scenario 233: Hospital triage and resource allocation: scenario 13
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[87])
    X(q[118])
    X(q[65])
    H(q[89])
    CNOT(q[89], q[108])
    Rz(q[89], PI / 7)
    CZ(q[108], q[25])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

534. 534_scenario_healthcare_14.sq — 534 scenario healthcare 14

# Scenario 234: Hospital triage and resource allocation: scenario 14
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[48])
    X(q[73])
    X(q[86])
    H(q[4])
    CNOT(q[4], q[95])
    Rz(q[4], PI / 8)
    CZ(q[95], q[126])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

535. 535_scenario_healthcare_15.sq — 535 scenario healthcare 15

# Scenario 235: Hospital triage and resource allocation: scenario 15
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[37])
    X(q[46])
    X(q[91])
    H(q[49])
    CNOT(q[49], q[100])
    Rz(q[49], PI / 4)
    CZ(q[100], q[108])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

536. 536_scenario_healthcare_16.sq — 536 scenario healthcare 16

# Scenario 236: Hospital triage and resource allocation: scenario 16
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[88])
    X(q[123])
    X(q[4])
    H(q[90])
    CNOT(q[90], q[79])
    Rz(q[90], PI / 5)
    CZ(q[79], q[6])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

537. 537_scenario_healthcare_17.sq — 537 scenario healthcare 17

# Scenario 237: Hospital triage and resource allocation: scenario 17
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[99])
    X(q[8])
    X(q[45])
    H(q[3])
    CNOT(q[3], q[126])
    Rz(q[3], PI / 6)
    CZ(q[126], q[89])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

538. 538_scenario_healthcare_18.sq — 538 scenario healthcare 18

# Scenario 238: Hospital triage and resource allocation: scenario 18
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[58])
    X(q[79])
    X(q[68])
    H(q[116])
    CNOT(q[116], q[75])
    Rz(q[116], PI / 7)
    CZ(q[75], q[110])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

539. 539_scenario_healthcare_19.sq — 539 scenario healthcare 19

# Scenario 239: Hospital triage and resource allocation: scenario 19
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[89])
    X(q[10])
    X(q[7])
    H(q[5])
    CNOT(q[5], q[120])
    Rz(q[5], PI / 8)
    CZ(q[120], q[71])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

540. 540_scenario_healthcare_20.sq — 540 scenario healthcare 20

# Scenario 240: Hospital triage and resource allocation: scenario 20
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[102])
    X(q[63])
    X(q[60])
    H(q[58])
    CNOT(q[58], q[61])
    Rz(q[58], PI / 4)
    CZ(q[61], q[4])
    print("scenario", "healthcare", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

541. 541_scenario_aerospace_01.sq — 541 scenario aerospace 01

# Scenario 241: Aerospace sensor-fusion fault tree: scenario 01
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(142, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(142)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

542. 542_scenario_aerospace_02.sq — 542 scenario aerospace 02

# Scenario 242: Aerospace sensor-fusion fault tree: scenario 02
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(144, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(144)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

543. 543_scenario_aerospace_03.sq — 543 scenario aerospace 03

# Scenario 243: Aerospace sensor-fusion fault tree: scenario 03
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(146, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(146)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

544. 544_scenario_aerospace_04.sq — 544 scenario aerospace 04

# Scenario 244: Aerospace sensor-fusion fault tree: scenario 04
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(148, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(148)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

545. 545_scenario_aerospace_05.sq — 545 scenario aerospace 05

# Scenario 245: Aerospace sensor-fusion fault tree: scenario 05
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(140, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(140)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

546. 546_scenario_aerospace_06.sq — 546 scenario aerospace 06

# Scenario 246: Aerospace sensor-fusion fault tree: scenario 06
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(142, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(142)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

547. 547_scenario_aerospace_07.sq — 547 scenario aerospace 07

# Scenario 247: Aerospace sensor-fusion fault tree: scenario 07
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(144, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(144)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

548. 548_scenario_aerospace_08.sq — 548 scenario aerospace 08

# Scenario 248: Aerospace sensor-fusion fault tree: scenario 08
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(146, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(146)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

549. 549_scenario_aerospace_09.sq — 549 scenario aerospace 09

# Scenario 249: Aerospace sensor-fusion fault tree: scenario 09
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(148, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(148)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 6)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

550. 550_scenario_aerospace_10.sq — 550 scenario aerospace 10

# Scenario 250: Aerospace sensor-fusion fault tree: scenario 10
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(140, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(140)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 7)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

551. 551_scenario_aerospace_11.sq — 551 scenario aerospace 11

# Scenario 251: Aerospace sensor-fusion fault tree: scenario 11
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(142, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(142)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 8)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

552. 552_scenario_aerospace_12.sq — 552 scenario aerospace 12

# Scenario 252: Aerospace sensor-fusion fault tree: scenario 12
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(144, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(144)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 3)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

553. 553_scenario_aerospace_13.sq — 553 scenario aerospace 13

# Scenario 253: Aerospace sensor-fusion fault tree: scenario 13
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(146, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(146)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

554. 554_scenario_aerospace_14.sq — 554 scenario aerospace 14

# Scenario 254: Aerospace sensor-fusion fault tree: scenario 14
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(148, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(148)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

555. 555_scenario_aerospace_15.sq — 555 scenario aerospace 15

# Scenario 255: Aerospace sensor-fusion fault tree: scenario 15
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(140, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(140)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

556. 556_scenario_aerospace_16.sq — 556 scenario aerospace 16

# Scenario 256: Aerospace sensor-fusion fault tree: scenario 16
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(142, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(142)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

557. 557_scenario_aerospace_17.sq — 557 scenario aerospace 17

# Scenario 257: Aerospace sensor-fusion fault tree: scenario 17
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(144, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(144)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

558. 558_scenario_aerospace_18.sq — 558 scenario aerospace 18

# Scenario 258: Aerospace sensor-fusion fault tree: scenario 18
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(146, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(146)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

559. 559_scenario_aerospace_19.sq — 559 scenario aerospace 19

# Scenario 259: Aerospace sensor-fusion fault tree: scenario 19
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(148, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(148)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

560. 560_scenario_aerospace_20.sq — 560 scenario aerospace 20

# Scenario 260: Aerospace sensor-fusion fault tree: scenario 20
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(140, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(140)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "aerospace", hierarchical_report())
    print("lookup", lookup_profile())
}

561. 561_scenario_robotics_01.sq — 561 scenario robotics 01

# Scenario 261: Robotics path planning and collision flags: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[47])
    X(q[64])
    X(q[149])
    H(q[123])
    CNOT(q[123], q[30])
    Rz(q[123], PI / 5)
    CZ(q[30], q[37])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

562. 562_scenario_robotics_02.sq — 562 scenario robotics 02

# Scenario 262: Robotics path planning and collision flags: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[84])
    X(q[21])
    X(q[66])
    H(q[8])
    CNOT(q[8], q[63])
    Rz(q[8], PI / 6)
    CZ(q[63], q[148])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

563. 563_scenario_robotics_03.sq — 563 scenario robotics 03

# Scenario 263: Robotics path planning and collision flags: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[137])
    X(q[22])
    X(q[131])
    H(q[53])
    CNOT(q[53], q[116])
    Rz(q[53], PI / 7)
    CZ(q[116], q[151])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

564. 564_scenario_robotics_04.sq — 564 scenario robotics 04

# Scenario 264: Robotics path planning and collision flags: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[42])
    X(q[85])
    X(q[120])
    H(q[100])
    CNOT(q[100], q[113])
    Rz(q[100], PI / 8)
    CZ(q[113], q[16])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

565. 565_scenario_robotics_05.sq — 565 scenario robotics 05

# Scenario 265: Robotics path planning and collision flags: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[37])
    X(q[112])
    X(q[3])
    H(q[54])
    CNOT(q[54], q[13])
    Rz(q[54], PI / 4)
    CZ(q[13], q[40])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

566. 566_scenario_robotics_06.sq — 566 scenario robotics 06

# Scenario 266: Robotics path planning and collision flags: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[24])
    X(q[9])
    X(q[110])
    H(q[116])
    CNOT(q[116], q[119])
    Rz(q[116], PI / 5)
    CZ(q[119], q[78])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

567. 567_scenario_robotics_07.sq — 567 scenario robotics 07

# Scenario 267: Robotics path planning and collision flags: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[37])
    X(q[116])
    X(q[123])
    H(q[119])
    CNOT(q[119], q[68])
    Rz(q[119], PI / 6)
    CZ(q[68], q[151])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

568. 568_scenario_robotics_08.sq — 568 scenario robotics 08

# Scenario 268: Robotics path planning and collision flags: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[70])
    X(q[63])
    X(q[64])
    H(q[154])
    CNOT(q[154], q[145])
    Rz(q[154], PI / 7)
    CZ(q[145], q[96])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

569. 569_scenario_robotics_09.sq — 569 scenario robotics 09

# Scenario 269: Robotics path planning and collision flags: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[117])
    X(q[20])
    X(q[71])
    H(q[45])
    CNOT(q[45], q[108])
    Rz(q[45], PI / 8)
    CZ(q[108], q[73])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

570. 570_scenario_robotics_10.sq — 570 scenario robotics 10

# Scenario 270: Robotics path planning and collision flags: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[42])
    X(q[149])
    X(q[18])
    H(q[102])
    CNOT(q[102], q[147])
    Rz(q[102], PI / 4)
    CZ(q[147], q[68])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

571. 571_scenario_robotics_11.sq — 571 scenario robotics 11

# Scenario 271: Robotics path planning and collision flags: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[1])
    X(q[106])
    X(q[71])
    H(q[109])
    CNOT(q[109], q[56])
    Rz(q[109], PI / 5)
    CZ(q[56], q[119])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

572. 572_scenario_robotics_12.sq — 572 scenario robotics 12

# Scenario 272: Robotics path planning and collision flags: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[144])
    X(q[57])
    X(q[26])
    H(q[76])
    CNOT(q[76], q[73])
    Rz(q[76], PI / 6)
    CZ(q[73], q[0])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

573. 573_scenario_robotics_13.sq — 573 scenario robotics 13

# Scenario 273: Robotics path planning and collision flags: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[3])
    X(q[104])
    X(q[153])
    H(q[99])
    CNOT(q[99], q[18])
    Rz(q[99], PI / 7)
    CZ(q[18], q[41])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

574. 574_scenario_robotics_14.sq — 574 scenario robotics 14

# Scenario 274: Robotics path planning and collision flags: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[34])
    X(q[113])
    X(q[22])
    H(q[148])
    CNOT(q[148], q[103])
    Rz(q[148], PI / 8)
    CZ(q[103], q[130])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

575. 575_scenario_robotics_15.sq — 575 scenario robotics 15

# Scenario 275: Robotics path planning and collision flags: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[47])
    X(q[94])
    X(q[23])
    H(q[17])
    CNOT(q[17], q[32])
    Rz(q[17], PI / 4)
    CZ(q[32], q[133])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

576. 576_scenario_robotics_16.sq — 576 scenario robotics 16

# Scenario 276: Robotics path planning and collision flags: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[130])
    X(q[51])
    X(q[32])
    H(q[102])
    CNOT(q[102], q[145])
    Rz(q[102], PI / 5)
    CZ(q[145], q[8])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

577. 577_scenario_robotics_17.sq — 577 scenario robotics 17

# Scenario 277: Robotics path planning and collision flags: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[97])
    X(q[152])
    X(q[83])
    H(q[33])
    CNOT(q[33], q[78])
    Rz(q[33], PI / 6)
    CZ(q[78], q[3])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

578. 578_scenario_robotics_18.sq — 578 scenario robotics 18

# Scenario 278: Robotics path planning and collision flags: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[92])
    X(q[145])
    X(q[86])
    H(q[44])
    CNOT(q[44], q[47])
    Rz(q[44], PI / 7)
    CZ(q[47], q[142])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

579. 579_scenario_robotics_19.sq — 579 scenario robotics 19

# Scenario 279: Robotics path planning and collision flags: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[109])
    X(q[48])
    X(q[131])
    H(q[93])
    CNOT(q[93], q[98])
    Rz(q[93], PI / 8)
    CZ(q[98], q[29])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

580. 580_scenario_robotics_20.sq — 580 scenario robotics 20

# Scenario 280: Robotics path planning and collision flags: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[52])
    X(q[39])
    X(q[28])
    H(q[82])
    CNOT(q[82], q[67])
    Rz(q[82], PI / 4)
    CZ(q[67], q[48])
    print("scenario", "robotics", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

581. 581_scenario_water_network_01.sq — 581 scenario water network 01

# Scenario 281: Water-network leakage localization: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[107])
    X(q[148])
    X(q[145])
    H(q[95])
    CNOT(q[95], q[82])
    Rz(q[95], PI / 5)
    CZ(q[82], q[49])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

582. 582_scenario_water_network_02.sq — 582 scenario water network 02

# Scenario 282: Water-network leakage localization: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[50])
    X(q[93])
    X(q[140])
    H(q[144])
    CNOT(q[144], q[83])
    Rz(q[144], PI / 6)
    CZ(q[83], q[6])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

583. 583_scenario_water_network_03.sq — 583 scenario water network 03

# Scenario 283: Water-network leakage localization: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[25])
    X(q[30])
    X(q[19])
    H(q[145])
    CNOT(q[145], q[76])
    Rz(q[145], PI / 7)
    CZ(q[76], q[87])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

584. 584_scenario_water_network_04.sq — 584 scenario water network 04

# Scenario 284: Water-network leakage localization: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[26])
    X(q[141])
    X(q[82])
    H(q[38])
    CNOT(q[38], q[93])
    Rz(q[38], PI / 8)
    CZ(q[93], q[86])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

585. 585_scenario_water_network_05.sq — 585 scenario water network 05

# Scenario 285: Water-network leakage localization: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[57])
    X(q[134])
    X(q[33])
    H(q[147])
    CNOT(q[147], q[102])
    Rz(q[147], PI / 4)
    CZ(q[102], q[113])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

586. 586_scenario_water_network_06.sq — 586 scenario water network 06

# Scenario 286: Water-network leakage localization: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[84])
    X(q[93])
    X(q[106])
    H(q[88])
    CNOT(q[88], q[19])
    Rz(q[88], PI / 5)
    CZ(q[19], q[90])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

587. 587_scenario_water_network_07.sq — 587 scenario water network 07

# Scenario 287: Water-network leakage localization: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[3])
    X(q[34])
    X(q[43])
    H(q[101])
    CNOT(q[101], q[88])
    Rz(q[101], PI / 6)
    CZ(q[88], q[9])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

588. 588_scenario_water_network_08.sq — 588 scenario water network 08

# Scenario 288: Water-network leakage localization: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[114])
    X(q[71])
    X(q[108])
    H(q[90])
    CNOT(q[90], q[105])
    Rz(q[90], PI / 7)
    CZ(q[105], q[32])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

589. 589_scenario_water_network_09.sq — 589 scenario water network 09

# Scenario 289: Water-network leakage localization: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[101])
    X(q[76])
    X(q[33])
    H(q[141])
    CNOT(q[141], q[88])
    Rz(q[141], PI / 8)
    CZ(q[88], q[143])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

590. 590_scenario_water_network_10.sq — 590 scenario water network 10

# Scenario 290: Water-network leakage localization: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[62])
    X(q[137])
    X(q[28])
    H(q[79])
    CNOT(q[79], q[38])
    Rz(q[79], PI / 4)
    CZ(q[38], q[65])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

591. 591_scenario_water_network_11.sq — 591 scenario water network 11

# Scenario 291: Water-network leakage localization: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[61])
    X(q[38])
    X(q[67])
    H(q[81])
    CNOT(q[81], q[108])
    Rz(q[81], PI / 5)
    CZ(q[108], q[131])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

592. 592_scenario_water_network_12.sq — 592 scenario water network 12

# Scenario 292: Water-network leakage localization: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[110])
    X(q[129])
    X(q[100])
    H(q[58])
    CNOT(q[58], q[93])
    Rz(q[58], PI / 6)
    CZ(q[93], q[12])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

593. 593_scenario_water_network_13.sq — 593 scenario water network 13

# Scenario 293: Water-network leakage localization: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[47])
    X(q[112])
    X(q[41])
    H(q[35])
    CNOT(q[35], q[134])
    Rz(q[35], PI / 7)
    CZ(q[134], q[133])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

594. 594_scenario_water_network_14.sq — 594 scenario water network 14

# Scenario 294: Water-network leakage localization: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[18])
    X(q[11])
    X(q[142])
    H(q[86])
    CNOT(q[86], q[83])
    Rz(q[86], PI / 8)
    CZ(q[83], q[42])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

595. 595_scenario_water_network_15.sq — 595 scenario water network 15

# Scenario 295: Water-network leakage localization: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[67])
    X(q[24])
    X(q[43])
    H(q[127])
    CNOT(q[127], q[22])
    Rz(q[127], PI / 4)
    CZ(q[22], q[93])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

596. 596_scenario_water_network_16.sq — 596 scenario water network 16

# Scenario 296: Water-network leakage localization: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[38])
    X(q[135])
    X(q[28])
    H(q[74])
    CNOT(q[74], q[45])
    Rz(q[74], PI / 5)
    CZ(q[45], q[20])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

597. 597_scenario_water_network_17.sq — 597 scenario water network 17

# Scenario 297: Water-network leakage localization: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[63])
    X(q[70])
    X(q[3])
    H(q[15])
    CNOT(q[15], q[98])
    Rz(q[15], PI / 6)
    CZ(q[98], q[138])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

598. 598_scenario_water_network_18.sq — 598 scenario water network 18

# Scenario 298: Water-network leakage localization: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[136])
    X(q[7])
    X(q[78])
    H(q[153])
    CNOT(q[153], q[130])
    Rz(q[153], PI / 7)
    CZ(q[130], q[43])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

599. 599_scenario_water_network_19.sq — 599 scenario water network 19

# Scenario 299: Water-network leakage localization: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[93])
    X(q[104])
    X(q[99])
    H(q[31])
    CNOT(q[31], q[78])
    Rz(q[31], PI / 8)
    CZ(q[78], q[80])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

600. 600_scenario_water_network_20.sq — 600 scenario water network 20

# Scenario 300: Water-network leakage localization: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[72])
    X(q[119])
    X(q[48])
    H(q[42])
    CNOT(q[42], q[57])
    Rz(q[42], PI / 4)
    CZ(q[57], q[8])
    print("scenario", "water_network", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

601. 601_scenario_agriculture_01.sq — 601 scenario agriculture 01

# Scenario 301: Precision-agriculture irrigation scheduling: scenario 01
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[23])
    X(q[58])
    X(q[69])
    H(q[25])
    CNOT(q[25], q[14])
    Rz(q[25], PI / 5)
    CZ(q[14], q[71])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

602. 602_scenario_agriculture_02.sq — 602 scenario agriculture 02

# Scenario 302: Precision-agriculture irrigation scheduling: scenario 02
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[104])
    X(q[59])
    X(q[106])
    H(q[121])
    CNOT(q[121], q[38])
    Rz(q[121], PI / 6)
    CZ(q[38], q[71])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

603. 603_scenario_agriculture_03.sq — 603 scenario agriculture 03

# Scenario 303: Precision-agriculture irrigation scheduling: scenario 03
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[83])
    X(q[108])
    X(q[107])
    H(q[65])
    CNOT(q[65], q[48])
    Rz(q[65], PI / 7)
    CZ(q[48], q[9])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

604. 604_scenario_agriculture_04.sq — 604 scenario agriculture 04

# Scenario 304: Precision-agriculture irrigation scheduling: scenario 04
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[78])
    X(q[7])
    X(q[68])
    H(q[18])
    CNOT(q[18], q[37])
    Rz(q[18], PI / 8)
    CZ(q[37], q[36])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

605. 605_scenario_agriculture_05.sq — 605 scenario agriculture 05

# Scenario 305: Precision-agriculture irrigation scheduling: scenario 05
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[51])
    X(q[28])
    X(q[41])
    H(q[47])
    CNOT(q[47], q[66])
    Rz(q[47], PI / 4)
    CZ(q[66], q[25])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

606. 606_scenario_agriculture_06.sq — 606 scenario agriculture 06

# Scenario 306: Precision-agriculture irrigation scheduling: scenario 06
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[8])
    X(q[73])
    X(q[54])
    H(q[100])
    CNOT(q[100], q[69])
    Rz(q[100], PI / 5)
    CZ(q[69], q[16])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

607. 607_scenario_agriculture_07.sq — 607 scenario agriculture 07

# Scenario 307: Precision-agriculture irrigation scheduling: scenario 07
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[13])
    X(q[18])
    X(q[7])
    H(q[61])
    CNOT(q[61], q[64])
    Rz(q[61], PI / 6)
    CZ(q[64], q[87])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

608. 608_scenario_agriculture_08.sq — 608 scenario agriculture 08

# Scenario 308: Precision-agriculture irrigation scheduling: scenario 08
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[54])
    X(q[69])
    X(q[110])
    H(q[92])
    CNOT(q[92], q[15])
    Rz(q[92], PI / 7)
    CZ(q[15], q[94])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

609. 609_scenario_agriculture_09.sq — 609 scenario agriculture 09

# Scenario 309: Precision-agriculture irrigation scheduling: scenario 09
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[119])
    X(q[80])
    X(q[125])
    H(q[19])
    CNOT(q[19], q[62])
    Rz(q[19], PI / 8)
    CZ(q[62], q[117])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

610. 610_scenario_agriculture_10.sq — 610 scenario agriculture 10

# Scenario 310: Precision-agriculture irrigation scheduling: scenario 10
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[116])
    X(q[45])
    X(q[10])
    H(q[56])
    CNOT(q[56], q[27])
    Rz(q[56], PI / 4)
    CZ(q[27], q[66])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

611. 611_scenario_agriculture_11.sq — 611 scenario agriculture 11

# Scenario 311: Precision-agriculture irrigation scheduling: scenario 11
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[123])
    X(q[88])
    X(q[39])
    H(q[45])
    CNOT(q[45], q[124])
    Rz(q[45], PI / 5)
    CZ(q[124], q[91])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

612. 612_scenario_agriculture_12.sq — 612 scenario agriculture 12

# Scenario 312: Precision-agriculture irrigation scheduling: scenario 12
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[54])
    X(q[47])
    X(q[108])
    H(q[18])
    CNOT(q[18], q[69])
    Rz(q[18], PI / 6)
    CZ(q[69], q[68])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

613. 613_scenario_agriculture_13.sq — 613 scenario agriculture 13

# Scenario 313: Precision-agriculture irrigation scheduling: scenario 13
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[25])
    X(q[30])
    X(q[113])
    H(q[119])
    CNOT(q[119], q[116])
    Rz(q[119], PI / 7)
    CZ(q[116], q[45])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

614. 614_scenario_agriculture_14.sq — 614 scenario agriculture 14

# Scenario 314: Precision-agriculture irrigation scheduling: scenario 14
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[24])
    X(q[17])
    X(q[46])
    H(q[20])
    CNOT(q[20], q[87])
    Rz(q[20], PI / 8)
    CZ(q[87], q[62])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

615. 615_scenario_agriculture_15.sq — 615 scenario agriculture 15

# Scenario 315: Precision-agriculture irrigation scheduling: scenario 15
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[53])
    X(q[62])
    X(q[107])
    H(q[65])
    CNOT(q[65], q[116])
    Rz(q[65], PI / 4)
    CZ(q[116], q[124])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

616. 616_scenario_agriculture_16.sq — 616 scenario agriculture 16

# Scenario 316: Precision-agriculture irrigation scheduling: scenario 16
# Strategy: sparse + sharded execution for 130 logical qubits.
simulate(130, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(130)
    X(q[108])
    X(q[103])
    X(q[24])
    H(q[120])
    CNOT(q[120], q[49])
    Rz(q[120], PI / 5)
    CZ(q[49], q[36])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(130))
}

617. 617_scenario_agriculture_17.sq — 617 scenario agriculture 17

# Scenario 317: Precision-agriculture irrigation scheduling: scenario 17
# Strategy: sparse + sharded execution for 132 logical qubits.
simulate(132, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(132)
    X(q[95])
    X(q[76])
    X(q[77])
    H(q[107])
    CNOT(q[107], q[74])
    Rz(q[107], PI / 6)
    CZ(q[74], q[49])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(132))
}

618. 618_scenario_agriculture_18.sq — 618 scenario agriculture 18

# Scenario 318: Precision-agriculture irrigation scheduling: scenario 18
# Strategy: sparse + sharded execution for 134 logical qubits.
simulate(134, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(134)
    X(q[130])
    X(q[125])
    X(q[116])
    H(q[12])
    CNOT(q[12], q[83])
    Rz(q[12], PI / 7)
    CZ(q[83], q[97])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(134))
}

619. 619_scenario_agriculture_19.sq — 619 scenario agriculture 19

# Scenario 319: Precision-agriculture irrigation scheduling: scenario 19
# Strategy: sparse + sharded execution for 136 logical qubits.
simulate(136, engine="sharded", n_shards=13, workers=4, use_lookup=true) {
    q = quantum_register(136)
    X(q[65])
    X(q[90])
    X(q[103])
    H(q[21])
    CNOT(q[21], q[112])
    Rz(q[21], PI / 8)
    CZ(q[112], q[7])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(136))
}

620. 620_scenario_agriculture_20.sq — 620 scenario agriculture 20

# Scenario 320: Precision-agriculture irrigation scheduling: scenario 20
# Strategy: sparse + sharded execution for 128 logical qubits.
simulate(128, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(128)
    X(q[118])
    X(q[79])
    X(q[76])
    H(q[74])
    CNOT(q[74], q[77])
    Rz(q[74], PI / 4)
    CZ(q[77], q[20])
    print("scenario", "agriculture", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(128))
}

621. 621_scenario_manufacturing_01.sq — 621 scenario manufacturing 01

# Scenario 321: Manufacturing quality-control root-cause graph: scenario 01
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(152, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(152)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

622. 622_scenario_manufacturing_02.sq — 622 scenario manufacturing 02

# Scenario 322: Manufacturing quality-control root-cause graph: scenario 02
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(154, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(154)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

623. 623_scenario_manufacturing_03.sq — 623 scenario manufacturing 03

# Scenario 323: Manufacturing quality-control root-cause graph: scenario 03
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(156, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(156)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

624. 624_scenario_manufacturing_04.sq — 624 scenario manufacturing 04

# Scenario 324: Manufacturing quality-control root-cause graph: scenario 04
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(158, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(158)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

625. 625_scenario_manufacturing_05.sq — 625 scenario manufacturing 05

# Scenario 325: Manufacturing quality-control root-cause graph: scenario 05
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(150, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(150)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

626. 626_scenario_manufacturing_06.sq — 626 scenario manufacturing 06

# Scenario 326: Manufacturing quality-control root-cause graph: scenario 06
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(152, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(152)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

627. 627_scenario_manufacturing_07.sq — 627 scenario manufacturing 07

# Scenario 327: Manufacturing quality-control root-cause graph: scenario 07
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(154, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(154)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

628. 628_scenario_manufacturing_08.sq — 628 scenario manufacturing 08

# Scenario 328: Manufacturing quality-control root-cause graph: scenario 08
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(156, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(156)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

629. 629_scenario_manufacturing_09.sq — 629 scenario manufacturing 09

# Scenario 329: Manufacturing quality-control root-cause graph: scenario 09
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(158, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(158)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 6)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

630. 630_scenario_manufacturing_10.sq — 630 scenario manufacturing 10

# Scenario 330: Manufacturing quality-control root-cause graph: scenario 10
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(150, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(150)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 7)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

631. 631_scenario_manufacturing_11.sq — 631 scenario manufacturing 11

# Scenario 331: Manufacturing quality-control root-cause graph: scenario 11
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(152, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(152)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 8)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

632. 632_scenario_manufacturing_12.sq — 632 scenario manufacturing 12

# Scenario 332: Manufacturing quality-control root-cause graph: scenario 12
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(154, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(154)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 3)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

633. 633_scenario_manufacturing_13.sq — 633 scenario manufacturing 13

# Scenario 333: Manufacturing quality-control root-cause graph: scenario 13
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(156, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(156)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

634. 634_scenario_manufacturing_14.sq — 634 scenario manufacturing 14

# Scenario 334: Manufacturing quality-control root-cause graph: scenario 14
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(158, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(158)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

635. 635_scenario_manufacturing_15.sq — 635 scenario manufacturing 15

# Scenario 335: Manufacturing quality-control root-cause graph: scenario 15
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(150, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(150)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

636. 636_scenario_manufacturing_16.sq — 636 scenario manufacturing 16

# Scenario 336: Manufacturing quality-control root-cause graph: scenario 16
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(152, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(152)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

637. 637_scenario_manufacturing_17.sq — 637 scenario manufacturing 17

# Scenario 337: Manufacturing quality-control root-cause graph: scenario 17
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(154, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(154)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

638. 638_scenario_manufacturing_18.sq — 638 scenario manufacturing 18

# Scenario 338: Manufacturing quality-control root-cause graph: scenario 18
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(156, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(156)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

639. 639_scenario_manufacturing_19.sq — 639 scenario manufacturing 19

# Scenario 339: Manufacturing quality-control root-cause graph: scenario 19
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(158, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(158)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

640. 640_scenario_manufacturing_20.sq — 640 scenario manufacturing 20

# Scenario 340: Manufacturing quality-control root-cause graph: scenario 20
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(150, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(150)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "manufacturing", hierarchical_report())
    print("lookup", lookup_profile())
}

641. 641_scenario_fraud_01.sq — 641 scenario fraud 01

# Scenario 341: Payments fraud graph screening: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[135])
    X(q[96])
    X(q[133])
    H(q[11])
    CNOT(q[11], q[86])
    Rz(q[11], PI / 5)
    CZ(q[86], q[85])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

642. 642_scenario_fraud_02.sq — 642 scenario fraud 02

# Scenario 342: Payments fraud graph screening: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[102])
    X(q[1])
    X(q[54])
    H(q[90])
    CNOT(q[90], q[143])
    Rz(q[90], PI / 6)
    CZ(q[143], q[42])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

643. 643_scenario_fraud_03.sq — 643 scenario fraud 03

# Scenario 343: Payments fraud graph screening: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[1])
    X(q[54])
    X(q[151])
    H(q[109])
    CNOT(q[109], q[112])
    Rz(q[109], PI / 7)
    CZ(q[112], q[51])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

644. 644_scenario_fraud_04.sq — 644 scenario fraud 04

# Scenario 344: Payments fraud graph screening: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[136])
    X(q[151])
    X(q[126])
    H(q[10])
    CNOT(q[10], q[33])
    Rz(q[10], PI / 8)
    CZ(q[33], q[138])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

645. 645_scenario_fraud_05.sq — 645 scenario fraud 05

# Scenario 345: Payments fraud graph screening: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[117])
    X(q[74])
    X(q[93])
    H(q[27])
    CNOT(q[27], q[72])
    Rz(q[27], PI / 4)
    CZ(q[72], q[143])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

646. 646_scenario_fraud_06.sq — 646 scenario fraud 06

# Scenario 346: Payments fraud graph screening: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[112])
    X(q[41])
    X(q[94])
    H(q[4])
    CNOT(q[4], q[23])
    Rz(q[4], PI / 5)
    CZ(q[23], q[126])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

647. 647_scenario_fraud_07.sq — 647 scenario fraud 07

# Scenario 347: Payments fraud graph screening: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[55])
    X(q[96])
    X(q[111])
    H(q[47])
    CNOT(q[47], q[148])
    Rz(q[47], PI / 6)
    CZ(q[148], q[45])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

648. 648_scenario_fraud_08.sq — 648 scenario fraud 08

# Scenario 348: Payments fraud graph screening: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[90])
    X(q[95])
    X(q[84])
    H(q[54])
    CNOT(q[54], q[141])
    Rz(q[54], PI / 7)
    CZ(q[141], q[152])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

649. 649_scenario_fraud_09.sq — 649 scenario fraud 09

# Scenario 349: Payments fraud graph screening: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[53])
    X(q[86])
    X(q[77])
    H(q[113])
    CNOT(q[113], q[28])
    Rz(q[113], PI / 8)
    CZ(q[28], q[37])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

650. 650_scenario_fraud_10.sq — 650 scenario fraud 10

# Scenario 350: Payments fraud graph screening: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[122])
    X(q[19])
    X(q[98])
    H(q[92])
    CNOT(q[92], q[107])
    Rz(q[92], PI / 4)
    CZ(q[107], q[58])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

651. 651_scenario_fraud_11.sq — 651 scenario fraud 11

# Scenario 351: Payments fraud graph screening: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[89])
    X(q[138])
    X(q[55])
    H(q[149])
    CNOT(q[149], q[112])
    Rz(q[149], PI / 5)
    CZ(q[112], q[15])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

652. 652_scenario_fraud_12.sq — 652 scenario fraud 12

# Scenario 352: Payments fraud graph screening: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[8])
    X(q[37])
    X(q[14])
    H(q[4])
    CNOT(q[4], q[153])
    Rz(q[4], PI / 6)
    CZ(q[153], q[48])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

653. 653_scenario_fraud_13.sq — 653 scenario fraud 13

# Scenario 353: Payments fraud graph screening: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[23])
    X(q[136])
    X(q[17])
    H(q[155])
    CNOT(q[155], q[14])
    Rz(q[155], PI / 7)
    CZ(q[14], q[97])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

654. 654_scenario_fraud_14.sq — 654 scenario fraud 14

# Scenario 354: Payments fraud graph screening: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[128])
    X(q[21])
    X(q[28])
    H(q[58])
    CNOT(q[58], q[23])
    Rz(q[58], PI / 8)
    CZ(q[23], q[94])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

655. 655_scenario_fraud_15.sq — 655 scenario fraud 15

# Scenario 355: Payments fraud graph screening: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[127])
    X(q[114])
    X(q[103])
    H(q[7])
    CNOT(q[7], q[142])
    Rz(q[7], PI / 4)
    CZ(q[142], q[123])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

656. 656_scenario_fraud_16.sq — 656 scenario fraud 16

# Scenario 356: Payments fraud graph screening: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[66])
    X(q[83])
    X(q[16])
    H(q[142])
    CNOT(q[142], q[49])
    Rz(q[142], PI / 5)
    CZ(q[49], q[56])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

657. 657_scenario_fraud_17.sq — 657 scenario fraud 17

# Scenario 357: Payments fraud graph screening: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[115])
    X(q[4])
    X(q[51])
    H(q[132])
    CNOT(q[132], q[71])
    Rz(q[132], PI / 6)
    CZ(q[71], q[148])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

658. 658_scenario_fraud_18.sq — 658 scenario fraud 18

# Scenario 358: Payments fraud graph screening: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[112])
    X(q[21])
    X(q[106])
    H(q[100])
    CNOT(q[100], q[43])
    Rz(q[100], PI / 7)
    CZ(q[43], q[42])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

659. 659_scenario_fraud_19.sq — 659 scenario fraud 19

# Scenario 359: Payments fraud graph screening: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[45])
    X(q[114])
    X(q[137])
    H(q[3])
    CNOT(q[3], q[18])
    Rz(q[3], PI / 8)
    CZ(q[18], q[151])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

660. 660_scenario_fraud_20.sq — 660 scenario fraud 20

# Scenario 360: Payments fraud graph screening: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[132])
    X(q[59])
    X(q[108])
    H(q[72])
    CNOT(q[72], q[27])
    Rz(q[72], PI / 4)
    CZ(q[27], q[38])
    print("scenario", "fraud", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

661. 661_scenario_iot_edge_01.sq — 661 scenario iot edge 01

# Scenario 361: IoT edge fleet anomaly grouping: scenario 01
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(122, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(122)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

662. 662_scenario_iot_edge_02.sq — 662 scenario iot edge 02

# Scenario 362: IoT edge fleet anomaly grouping: scenario 02
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(124, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(124)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

663. 663_scenario_iot_edge_03.sq — 663 scenario iot edge 03

# Scenario 363: IoT edge fleet anomaly grouping: scenario 03
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(126, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(126)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

664. 664_scenario_iot_edge_04.sq — 664 scenario iot edge 04

# Scenario 364: IoT edge fleet anomaly grouping: scenario 04
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(128, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(128)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

665. 665_scenario_iot_edge_05.sq — 665 scenario iot edge 05

# Scenario 365: IoT edge fleet anomaly grouping: scenario 05
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(120, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(120)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

666. 666_scenario_iot_edge_06.sq — 666 scenario iot edge 06

# Scenario 366: IoT edge fleet anomaly grouping: scenario 06
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(122, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(122)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

667. 667_scenario_iot_edge_07.sq — 667 scenario iot edge 07

# Scenario 367: IoT edge fleet anomaly grouping: scenario 07
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(124, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(124)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

668. 668_scenario_iot_edge_08.sq — 668 scenario iot edge 08

# Scenario 368: IoT edge fleet anomaly grouping: scenario 08
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(126, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(126)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

669. 669_scenario_iot_edge_09.sq — 669 scenario iot edge 09

# Scenario 369: IoT edge fleet anomaly grouping: scenario 09
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(128, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(128)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 6)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

670. 670_scenario_iot_edge_10.sq — 670 scenario iot edge 10

# Scenario 370: IoT edge fleet anomaly grouping: scenario 10
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(120, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(120)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 7)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

671. 671_scenario_iot_edge_11.sq — 671 scenario iot edge 11

# Scenario 371: IoT edge fleet anomaly grouping: scenario 11
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(122, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(122)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 8)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

672. 672_scenario_iot_edge_12.sq — 672 scenario iot edge 12

# Scenario 372: IoT edge fleet anomaly grouping: scenario 12
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(124, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(124)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 3)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

673. 673_scenario_iot_edge_13.sq — 673 scenario iot edge 13

# Scenario 373: IoT edge fleet anomaly grouping: scenario 13
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(126, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(126)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

674. 674_scenario_iot_edge_14.sq — 674 scenario iot edge 14

# Scenario 374: IoT edge fleet anomaly grouping: scenario 14
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(128, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(128)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

675. 675_scenario_iot_edge_15.sq — 675 scenario iot edge 15

# Scenario 375: IoT edge fleet anomaly grouping: scenario 15
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(120, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(120)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

676. 676_scenario_iot_edge_16.sq — 676 scenario iot edge 16

# Scenario 376: IoT edge fleet anomaly grouping: scenario 16
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(122, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(122)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

677. 677_scenario_iot_edge_17.sq — 677 scenario iot edge 17

# Scenario 377: IoT edge fleet anomaly grouping: scenario 17
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(124, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(124)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

678. 678_scenario_iot_edge_18.sq — 678 scenario iot edge 18

# Scenario 378: IoT edge fleet anomaly grouping: scenario 18
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(126, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(126)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

679. 679_scenario_iot_edge_19.sq — 679 scenario iot edge 19

# Scenario 379: IoT edge fleet anomaly grouping: scenario 19
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(128, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(128)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

680. 680_scenario_iot_edge_20.sq — 680 scenario iot edge 20

# Scenario 380: IoT edge fleet anomaly grouping: scenario 20
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(120, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(120)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "iot_edge", hierarchical_report())
    print("lookup", lookup_profile())
}

681. 681_scenario_quantum_network_01.sq — 681 scenario quantum network 01

# Scenario 381: Quantum-network repeater and QKD planning: scenario 01
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(514, engine="stabilizer") {
    q = quantum_register(514)
    for i in range(0, 220, 21) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(514, []))
    print("sample", measure_all(shots=2))
}

682. 682_scenario_quantum_network_02.sq — 682 scenario quantum network 02

# Scenario 382: Quantum-network repeater and QKD planning: scenario 02
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(516, engine="stabilizer") {
    q = quantum_register(516)
    for i in range(0, 220, 22) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(516, []))
    print("sample", measure_all(shots=2))
}

683. 683_scenario_quantum_network_03.sq — 683 scenario quantum network 03

# Scenario 383: Quantum-network repeater and QKD planning: scenario 03
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(518, engine="stabilizer") {
    q = quantum_register(518)
    for i in range(0, 220, 23) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(518, []))
    print("sample", measure_all(shots=2))
}

684. 684_scenario_quantum_network_04.sq — 684 scenario quantum network 04

# Scenario 384: Quantum-network repeater and QKD planning: scenario 04
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(520, engine="stabilizer") {
    q = quantum_register(520)
    for i in range(0, 220, 24) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(520, []))
    print("sample", measure_all(shots=2))
}

685. 685_scenario_quantum_network_05.sq — 685 scenario quantum network 05

# Scenario 385: Quantum-network repeater and QKD planning: scenario 05
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(512, engine="stabilizer") {
    q = quantum_register(512)
    for i in range(0, 220, 25) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(512, []))
    print("sample", measure_all(shots=2))
}

686. 686_scenario_quantum_network_06.sq — 686 scenario quantum network 06

# Scenario 386: Quantum-network repeater and QKD planning: scenario 06
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(514, engine="stabilizer") {
    q = quantum_register(514)
    for i in range(0, 220, 26) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(514, []))
    print("sample", measure_all(shots=2))
}

687. 687_scenario_quantum_network_07.sq — 687 scenario quantum network 07

# Scenario 387: Quantum-network repeater and QKD planning: scenario 07
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(516, engine="stabilizer") {
    q = quantum_register(516)
    for i in range(0, 220, 20) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(516, []))
    print("sample", measure_all(shots=2))
}

688. 688_scenario_quantum_network_08.sq — 688 scenario quantum network 08

# Scenario 388: Quantum-network repeater and QKD planning: scenario 08
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(518, engine="stabilizer") {
    q = quantum_register(518)
    for i in range(0, 220, 21) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(518, []))
    print("sample", measure_all(shots=2))
}

689. 689_scenario_quantum_network_09.sq — 689 scenario quantum network 09

# Scenario 389: Quantum-network repeater and QKD planning: scenario 09
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(520, engine="stabilizer") {
    q = quantum_register(520)
    for i in range(0, 220, 22) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(520, []))
    print("sample", measure_all(shots=2))
}

690. 690_scenario_quantum_network_10.sq — 690 scenario quantum network 10

# Scenario 390: Quantum-network repeater and QKD planning: scenario 10
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(512, engine="stabilizer") {
    q = quantum_register(512)
    for i in range(0, 220, 23) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(512, []))
    print("sample", measure_all(shots=2))
}

691. 691_scenario_quantum_network_11.sq — 691 scenario quantum network 11

# Scenario 391: Quantum-network repeater and QKD planning: scenario 11
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(514, engine="stabilizer") {
    q = quantum_register(514)
    for i in range(0, 220, 24) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(514, []))
    print("sample", measure_all(shots=2))
}

692. 692_scenario_quantum_network_12.sq — 692 scenario quantum network 12

# Scenario 392: Quantum-network repeater and QKD planning: scenario 12
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(516, engine="stabilizer") {
    q = quantum_register(516)
    for i in range(0, 220, 25) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(516, []))
    print("sample", measure_all(shots=2))
}

693. 693_scenario_quantum_network_13.sq — 693 scenario quantum network 13

# Scenario 393: Quantum-network repeater and QKD planning: scenario 13
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(518, engine="stabilizer") {
    q = quantum_register(518)
    for i in range(0, 220, 26) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(518, []))
    print("sample", measure_all(shots=2))
}

694. 694_scenario_quantum_network_14.sq — 694 scenario quantum network 14

# Scenario 394: Quantum-network repeater and QKD planning: scenario 14
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(520, engine="stabilizer") {
    q = quantum_register(520)
    for i in range(0, 220, 20) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(520, []))
    print("sample", measure_all(shots=2))
}

695. 695_scenario_quantum_network_15.sq — 695 scenario quantum network 15

# Scenario 395: Quantum-network repeater and QKD planning: scenario 15
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(512, engine="stabilizer") {
    q = quantum_register(512)
    for i in range(0, 220, 21) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(512, []))
    print("sample", measure_all(shots=2))
}

696. 696_scenario_quantum_network_16.sq — 696 scenario quantum network 16

# Scenario 396: Quantum-network repeater and QKD planning: scenario 16
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(514, engine="stabilizer") {
    q = quantum_register(514)
    for i in range(0, 220, 22) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(514, []))
    print("sample", measure_all(shots=2))
}

697. 697_scenario_quantum_network_17.sq — 697 scenario quantum network 17

# Scenario 397: Quantum-network repeater and QKD planning: scenario 17
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(516, engine="stabilizer") {
    q = quantum_register(516)
    for i in range(0, 220, 23) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(516, []))
    print("sample", measure_all(shots=2))
}

698. 698_scenario_quantum_network_18.sq — 698 scenario quantum network 18

# Scenario 398: Quantum-network repeater and QKD planning: scenario 18
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(518, engine="stabilizer") {
    q = quantum_register(518)
    for i in range(0, 220, 24) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(518, []))
    print("sample", measure_all(shots=2))
}

699. 699_scenario_quantum_network_19.sq — 699 scenario quantum network 19

# Scenario 399: Quantum-network repeater and QKD planning: scenario 19
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(520, engine="stabilizer") {
    q = quantum_register(520)
    for i in range(0, 220, 25) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(520, []))
    print("sample", measure_all(shots=2))
}

700. 700_scenario_quantum_network_20.sq — 700 scenario quantum network 20

# Scenario 400: Quantum-network repeater and QKD planning: scenario 20
# Strategy: Clifford-only large circuit via stabilizer tableau.
simulate(512, engine="stabilizer") {
    q = quantum_register(512)
    for i in range(0, 220, 26) {
        H(q[i])
        CNOT(q[i], q[i + 1])
        CZ(q[i + 1], q[i + 2])
        S(q[i + 2])
    }
    print("scenario", "quantum_network", "backend", plan_backend(512, []))
    print("sample", measure_all(shots=2))
}

701. 701_scenario_pqc_migration_01.sq — 701 scenario pqc migration 01

# Scenario 401: Post-quantum cryptography migration audit: scenario 01
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[11])
    X(q[44])
    X(q[121])
    H(q[79])
    CNOT(q[79], q[90])
    Rz(q[79], PI / 5)
    CZ(q[90], q[138])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

702. 702_scenario_pqc_migration_02.sq — 702 scenario pqc migration 02

# Scenario 402: Post-quantum cryptography migration audit: scenario 02
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[0])
    X(q[63])
    X(q[122])
    H(q[36])
    CNOT(q[36], q[49])
    Rz(q[36], PI / 6)
    CZ(q[49], q[78])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

703. 703_scenario_pqc_migration_03.sq — 703 scenario pqc migration 03

# Scenario 403: Post-quantum cryptography migration audit: scenario 03
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[133])
    X(q[78])
    X(q[127])
    H(q[73])
    CNOT(q[73], q[148])
    Rz(q[73], PI / 7)
    CZ(q[148], q[15])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

704. 704_scenario_pqc_migration_04.sq — 704 scenario pqc migration 04

# Scenario 404: Post-quantum cryptography migration audit: scenario 04
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[88])
    X(q[3])
    X(q[12])
    H(q[140])
    CNOT(q[140], q[131])
    Rz(q[140], PI / 8)
    CZ(q[131], q[32])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

705. 705_scenario_pqc_migration_05.sq — 705 scenario pqc migration 05

# Scenario 405: Post-quantum cryptography migration audit: scenario 05
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[27])
    X(q[14])
    X(q[3])
    H(q[57])
    CNOT(q[57], q[42])
    Rz(q[57], PI / 4)
    CZ(q[42], q[23])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

706. 706_scenario_pqc_migration_06.sq — 706 scenario pqc migration 06

# Scenario 406: Post-quantum cryptography migration audit: scenario 06
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[140])
    X(q[141])
    X(q[82])
    H(q[72])
    CNOT(q[72], q[27])
    Rz(q[72], PI / 5)
    CZ(q[27], q[10])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

707. 707_scenario_pqc_migration_07.sq — 707 scenario pqc migration 07

# Scenario 407: Post-quantum cryptography migration audit: scenario 07
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[107])
    X(q[4])
    X(q[25])
    H(q[147])
    CNOT(q[147], q[54])
    Rz(q[147], PI / 6)
    CZ(q[54], q[81])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

708. 708_scenario_pqc_migration_08.sq — 708 scenario pqc migration 08

# Scenario 408: Post-quantum cryptography migration audit: scenario 08
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[66])
    X(q[119])
    X(q[60])
    H(q[18])
    CNOT(q[18], q[21])
    Rz(q[18], PI / 7)
    CZ(q[21], q[116])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

709. 709_scenario_pqc_migration_09.sq — 709 scenario pqc migration 09

# Scenario 409: Post-quantum cryptography migration audit: scenario 09
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[5])
    X(q[96])
    X(q[121])
    H(q[85])
    CNOT(q[85], q[126])
    Rz(q[85], PI / 8)
    CZ(q[126], q[89])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

710. 710_scenario_pqc_migration_10.sq — 710 scenario pqc migration 10

# Scenario 410: Post-quantum cryptography migration audit: scenario 10
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[32])
    X(q[109])
    X(q[8])
    H(q[122])
    CNOT(q[122], q[77])
    Rz(q[122], PI / 4)
    CZ(q[77], q[88])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

711. 711_scenario_pqc_migration_11.sq — 711 scenario pqc migration 11

# Scenario 411: Post-quantum cryptography migration audit: scenario 11
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[117])
    X(q[86])
    X(q[43])
    H(q[65])
    CNOT(q[65], q[116])
    Rz(q[65], PI / 5)
    CZ(q[116], q[51])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

712. 712_scenario_pqc_migration_12.sq — 712 scenario pqc migration 12

# Scenario 412: Post-quantum cryptography migration audit: scenario 12
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[60])
    X(q[99])
    X(q[82])
    H(q[104])
    CNOT(q[104], q[59])
    Rz(q[104], PI / 6)
    CZ(q[59], q[84])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

713. 713_scenario_pqc_migration_13.sq — 713 scenario pqc migration 13

# Scenario 413: Post-quantum cryptography migration audit: scenario 13
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[155])
    X(q[4])
    X(q[149])
    H(q[119])
    CNOT(q[119], q[50])
    Rz(q[119], PI / 7)
    CZ(q[50], q[61])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

714. 714_scenario_pqc_migration_14.sq — 714 scenario pqc migration 14

# Scenario 414: Post-quantum cryptography migration audit: scenario 14
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[80])
    X(q[31])
    X(q[72])
    H(q[30])
    CNOT(q[30], q[121])
    Rz(q[30], PI / 8)
    CZ(q[121], q[146])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

715. 715_scenario_pqc_migration_15.sq — 715 scenario pqc migration 15

# Scenario 415: Post-quantum cryptography migration audit: scenario 15
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[37])
    X(q[112])
    X(q[3])
    H(q[54])
    CNOT(q[54], q[13])
    Rz(q[54], PI / 4)
    CZ(q[13], q[40])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

716. 716_scenario_pqc_migration_16.sq — 716 scenario pqc migration 16

# Scenario 416: Post-quantum cryptography migration audit: scenario 16
# Strategy: sparse + sharded execution for 152 logical qubits.
simulate(152, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(152)
    X(q[94])
    X(q[31])
    X(q[4])
    H(q[58])
    CNOT(q[58], q[53])
    Rz(q[58], PI / 5)
    CZ(q[53], q[92])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(152))
}

717. 717_scenario_pqc_migration_17.sq — 717 scenario pqc migration 17

# Scenario 417: Post-quantum cryptography migration audit: scenario 17
# Strategy: sparse + sharded execution for 154 logical qubits.
simulate(154, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(154)
    X(q[13])
    X(q[40])
    X(q[139])
    H(q[61])
    CNOT(q[61], q[64])
    Rz(q[61], PI / 6)
    CZ(q[64], q[87])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(154))
}

718. 718_scenario_pqc_migration_18.sq — 718 scenario pqc migration 18

# Scenario 418: Post-quantum cryptography migration audit: scenario 18
# Strategy: sparse + sharded execution for 156 logical qubits.
simulate(156, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(156)
    X(q[88])
    X(q[45])
    X(q[82])
    H(q[64])
    CNOT(q[64], q[79])
    Rz(q[64], PI / 7)
    CZ(q[79], q[6])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(156))
}

719. 719_scenario_pqc_migration_19.sq — 719 scenario pqc migration 19

# Scenario 419: Post-quantum cryptography migration audit: scenario 19
# Strategy: sparse + sharded execution for 158 logical qubits.
simulate(158, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(158)
    X(q[155])
    X(q[124])
    X(q[23])
    H(q[133])
    CNOT(q[133], q[116])
    Rz(q[133], PI / 8)
    CZ(q[116], q[45])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(158))
}

720. 720_scenario_pqc_migration_20.sq — 720 scenario pqc migration 20

# Scenario 420: Post-quantum cryptography migration audit: scenario 20
# Strategy: sparse + sharded execution for 150 logical qubits.
simulate(150, engine="sharded", n_shards=15, workers=4, use_lookup=true) {
    q = quantum_register(150)
    X(q[42])
    X(q[149])
    X(q[18])
    H(q[102])
    CNOT(q[102], q[147])
    Rz(q[102], PI / 4)
    CZ(q[147], q[68])
    print("scenario", "pqc_migration", "nnz", engine_nnz())
    print("lookup", lookup_profile())
    print("estimate", estimate_qubits(150))
}

721. 721_scenario_qec_satellite_01.sq — 721 scenario qec satellite 01

# Scenario 421: Quantum error correction for satellite links: scenario 01
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("phase_flip", base=0, name="satellite_link_1")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "phase_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

722. 722_scenario_qec_satellite_02.sq — 722 scenario qec satellite 02

# Scenario 422: Quantum error correction for satellite links: scenario 02
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("shor9", base=0, name="satellite_link_2")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "shor9", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

723. 723_scenario_qec_satellite_03.sq — 723 scenario qec satellite 03

# Scenario 423: Quantum error correction for satellite links: scenario 03
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("steane7", base=0, name="satellite_link_3")
    qec_encode(logical)
    qec_inject_error(logical, "X", 0)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "steane7", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

724. 724_scenario_qec_satellite_04.sq — 724 scenario qec satellite 04

# Scenario 424: Quantum error correction for satellite links: scenario 04
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("five_qubit", base=0, name="satellite_link_4")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "five_qubit", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

725. 725_scenario_qec_satellite_05.sq — 725 scenario qec satellite 05

# Scenario 425: Quantum error correction for satellite links: scenario 05
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("bit_flip", base=0, name="satellite_link_5")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "bit_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

726. 726_scenario_qec_satellite_06.sq — 726 scenario qec satellite 06

# Scenario 426: Quantum error correction for satellite links: scenario 06
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("phase_flip", base=0, name="satellite_link_6")
    qec_encode(logical)
    qec_inject_error(logical, "X", 0)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "phase_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

727. 727_scenario_qec_satellite_07.sq — 727 scenario qec satellite 07

# Scenario 427: Quantum error correction for satellite links: scenario 07
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("shor9", base=0, name="satellite_link_7")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "shor9", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

728. 728_scenario_qec_satellite_08.sq — 728 scenario qec satellite 08

# Scenario 428: Quantum error correction for satellite links: scenario 08
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("steane7", base=0, name="satellite_link_8")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "steane7", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

729. 729_scenario_qec_satellite_09.sq — 729 scenario qec satellite 09

# Scenario 429: Quantum error correction for satellite links: scenario 09
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("five_qubit", base=0, name="satellite_link_9")
    qec_encode(logical)
    qec_inject_error(logical, "X", 0)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "five_qubit", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

730. 730_scenario_qec_satellite_10.sq — 730 scenario qec satellite 10

# Scenario 430: Quantum error correction for satellite links: scenario 10
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("bit_flip", base=0, name="satellite_link_10")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "bit_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

731. 731_scenario_qec_satellite_11.sq — 731 scenario qec satellite 11

# Scenario 431: Quantum error correction for satellite links: scenario 11
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("phase_flip", base=0, name="satellite_link_11")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "phase_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

732. 732_scenario_qec_satellite_12.sq — 732 scenario qec satellite 12

# Scenario 432: Quantum error correction for satellite links: scenario 12
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("shor9", base=0, name="satellite_link_12")
    qec_encode(logical)
    qec_inject_error(logical, "X", 0)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "shor9", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

733. 733_scenario_qec_satellite_13.sq — 733 scenario qec satellite 13

# Scenario 433: Quantum error correction for satellite links: scenario 13
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("steane7", base=0, name="satellite_link_13")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "steane7", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

734. 734_scenario_qec_satellite_14.sq — 734 scenario qec satellite 14

# Scenario 434: Quantum error correction for satellite links: scenario 14
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("five_qubit", base=0, name="satellite_link_14")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "five_qubit", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

735. 735_scenario_qec_satellite_15.sq — 735 scenario qec satellite 15

# Scenario 435: Quantum error correction for satellite links: scenario 15
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("bit_flip", base=0, name="satellite_link_15")
    qec_encode(logical)
    qec_inject_error(logical, "X", 0)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "bit_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

736. 736_scenario_qec_satellite_16.sq — 736 scenario qec satellite 16

# Scenario 436: Quantum error correction for satellite links: scenario 16
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("phase_flip", base=0, name="satellite_link_16")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "phase_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

737. 737_scenario_qec_satellite_17.sq — 737 scenario qec satellite 17

# Scenario 437: Quantum error correction for satellite links: scenario 17
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("shor9", base=0, name="satellite_link_17")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "shor9", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

738. 738_scenario_qec_satellite_18.sq — 738 scenario qec satellite 18

# Scenario 438: Quantum error correction for satellite links: scenario 18
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("steane7", base=0, name="satellite_link_18")
    qec_encode(logical)
    qec_inject_error(logical, "X", 0)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "steane7", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

739. 739_scenario_qec_satellite_19.sq — 739 scenario qec satellite 19

# Scenario 439: Quantum error correction for satellite links: scenario 19
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("five_qubit", base=0, name="satellite_link_19")
    qec_encode(logical)
    qec_inject_error(logical, "X", 1)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "five_qubit", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

740. 740_scenario_qec_satellite_20.sq — 740 scenario qec satellite 20

# Scenario 440: Quantum error correction for satellite links: scenario 20
# Strategy: logical qubit QEC workflow with syndrome extraction and correction.
simulate(27, engine="sparse", use_lookup=true) {
    q = quantum_register(27)
    logical = qec_logical("bit_flip", base=0, name="satellite_link_20")
    qec_encode(logical)
    qec_inject_error(logical, "X", 2)
    syndrome = qec_syndrome_and_correct(logical)
    logical_z(logical)
    print("scenario", "qec_satellite", "code", "bit_flip", "syndrome", syndrome)
    print("stim", qec_stim_syndrome_text(logical))
}

741. 741_scenario_hardware_calibration_01.sq — 741 scenario hardware calibration 01

# Scenario 441: Quantum hardware calibration export and verification: scenario 01
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(123, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(123)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[122])
    Rz(q[1], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("qiskit"))
}

742. 742_scenario_hardware_calibration_02.sq — 742 scenario hardware calibration 02

# Scenario 442: Quantum hardware calibration export and verification: scenario 02
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(125, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(125)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[124])
    Rz(q[2], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("braket"))
}

743. 743_scenario_hardware_calibration_03.sq — 743 scenario hardware calibration 03

# Scenario 443: Quantum hardware calibration export and verification: scenario 03
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(127, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(127)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[126])
    Rz(q[3], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("azure"))
}

744. 744_scenario_hardware_calibration_04.sq — 744 scenario hardware calibration 04

# Scenario 444: Quantum hardware calibration export and verification: scenario 04
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(129, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(129)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[128])
    Rz(q[4], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("cirq"))
}

745. 745_scenario_hardware_calibration_05.sq — 745 scenario hardware calibration 05

# Scenario 445: Quantum hardware calibration export and verification: scenario 05
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(121, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(121)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[120])
    Rz(q[5], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("pennylane"))
}

746. 746_scenario_hardware_calibration_06.sq — 746 scenario hardware calibration 06

# Scenario 446: Quantum hardware calibration export and verification: scenario 06
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(123, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(123)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[122])
    Rz(q[6], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("openqasm3"))
}

747. 747_scenario_hardware_calibration_07.sq — 747 scenario hardware calibration 07

# Scenario 447: Quantum hardware calibration export and verification: scenario 07
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(125, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(125)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[124])
    Rz(q[7], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("qiskit"))
}

748. 748_scenario_hardware_calibration_08.sq — 748 scenario hardware calibration 08

# Scenario 448: Quantum hardware calibration export and verification: scenario 08
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(127, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(127)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[126])
    Rz(q[8], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("braket"))
}

749. 749_scenario_hardware_calibration_09.sq — 749 scenario hardware calibration 09

# Scenario 449: Quantum hardware calibration export and verification: scenario 09
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(129, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(129)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[128])
    Rz(q[9], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("azure"))
}

750. 750_scenario_hardware_calibration_10.sq — 750 scenario hardware calibration 10

# Scenario 450: Quantum hardware calibration export and verification: scenario 10
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(121, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(121)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[120])
    Rz(q[10], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("cirq"))
}

751. 751_scenario_hardware_calibration_11.sq — 751 scenario hardware calibration 11

# Scenario 451: Quantum hardware calibration export and verification: scenario 11
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(123, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(123)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[122])
    Rz(q[11], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("pennylane"))
}

752. 752_scenario_hardware_calibration_12.sq — 752 scenario hardware calibration 12

# Scenario 452: Quantum hardware calibration export and verification: scenario 12
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(125, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(125)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[124])
    Rz(q[12], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("openqasm3"))
}

753. 753_scenario_hardware_calibration_13.sq — 753 scenario hardware calibration 13

# Scenario 453: Quantum hardware calibration export and verification: scenario 13
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(127, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(127)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[126])
    Rz(q[13], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("qiskit"))
}

754. 754_scenario_hardware_calibration_14.sq — 754 scenario hardware calibration 14

# Scenario 454: Quantum hardware calibration export and verification: scenario 14
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(129, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(129)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[128])
    Rz(q[14], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("braket"))
}

755. 755_scenario_hardware_calibration_15.sq — 755 scenario hardware calibration 15

# Scenario 455: Quantum hardware calibration export and verification: scenario 15
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(121, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(121)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[120])
    Rz(q[15], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("azure"))
}

756. 756_scenario_hardware_calibration_16.sq — 756 scenario hardware calibration 16

# Scenario 456: Quantum hardware calibration export and verification: scenario 16
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(123, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(123)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[122])
    Rz(q[16], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("cirq"))
}

757. 757_scenario_hardware_calibration_17.sq — 757 scenario hardware calibration 17

# Scenario 457: Quantum hardware calibration export and verification: scenario 17
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(125, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(125)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[124])
    Rz(q[17], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("pennylane"))
}

758. 758_scenario_hardware_calibration_18.sq — 758 scenario hardware calibration 18

# Scenario 458: Quantum hardware calibration export and verification: scenario 18
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(127, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(127)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[126])
    Rz(q[18], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("openqasm3"))
}

759. 759_scenario_hardware_calibration_19.sq — 759 scenario hardware calibration 19

# Scenario 459: Quantum hardware calibration export and verification: scenario 19
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(129, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(129)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[128])
    Rz(q[19], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("qiskit"))
}

760. 760_scenario_hardware_calibration_20.sq — 760 scenario hardware calibration 20

# Scenario 460: Quantum hardware calibration export and verification: scenario 20
# Strategy: generate a scalable sparse circuit and export the hardware payload.
simulate(121, engine="sharded", n_shards=12, workers=4, use_lookup=true) {
    q = quantum_register(121)
    H(q[0])
    CNOT(q[0], q[1])
    X(q[120])
    Rz(q[20], PI / 8)
    print("scenario", "hardware_calibration", hardware_payload_summary())
    print(export_hardware("braket"))
}

761. 761_scenario_semiconductor_01.sq — 761 scenario semiconductor 01

# Scenario 461: Semiconductor process-control anomaly map: scenario 01
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

762. 762_scenario_semiconductor_02.sq — 762 scenario semiconductor 02

# Scenario 462: Semiconductor process-control anomaly map: scenario 02
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

763. 763_scenario_semiconductor_03.sq — 763 scenario semiconductor 03

# Scenario 463: Semiconductor process-control anomaly map: scenario 03
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

764. 764_scenario_semiconductor_04.sq — 764 scenario semiconductor 04

# Scenario 464: Semiconductor process-control anomaly map: scenario 04
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

765. 765_scenario_semiconductor_05.sq — 765 scenario semiconductor 05

# Scenario 465: Semiconductor process-control anomaly map: scenario 05
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

766. 766_scenario_semiconductor_06.sq — 766 scenario semiconductor 06

# Scenario 466: Semiconductor process-control anomaly map: scenario 06
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

767. 767_scenario_semiconductor_07.sq — 767 scenario semiconductor 07

# Scenario 467: Semiconductor process-control anomaly map: scenario 07
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

768. 768_scenario_semiconductor_08.sq — 768 scenario semiconductor 08

# Scenario 468: Semiconductor process-control anomaly map: scenario 08
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

769. 769_scenario_semiconductor_09.sq — 769 scenario semiconductor 09

# Scenario 469: Semiconductor process-control anomaly map: scenario 09
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 6)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

770. 770_scenario_semiconductor_10.sq — 770 scenario semiconductor 10

# Scenario 470: Semiconductor process-control anomaly map: scenario 10
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 7)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

771. 771_scenario_semiconductor_11.sq — 771 scenario semiconductor 11

# Scenario 471: Semiconductor process-control anomaly map: scenario 11
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 8)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

772. 772_scenario_semiconductor_12.sq — 772 scenario semiconductor 12

# Scenario 472: Semiconductor process-control anomaly map: scenario 12
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 3)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

773. 773_scenario_semiconductor_13.sq — 773 scenario semiconductor 13

# Scenario 473: Semiconductor process-control anomaly map: scenario 13
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 4)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

774. 774_scenario_semiconductor_14.sq — 774 scenario semiconductor 14

# Scenario 474: Semiconductor process-control anomaly map: scenario 14
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 5)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

775. 775_scenario_semiconductor_15.sq — 775 scenario semiconductor 15

# Scenario 475: Semiconductor process-control anomaly map: scenario 15
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 6)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

776. 776_scenario_semiconductor_16.sq — 776 scenario semiconductor 16

# Scenario 476: Semiconductor process-control anomaly map: scenario 16
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(162, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(162)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 7)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

777. 777_scenario_semiconductor_17.sq — 777 scenario semiconductor 17

# Scenario 477: Semiconductor process-control anomaly map: scenario 17
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(164, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(164)
    block_A = shard("block_A", 10, 19)
    block_B = shard("block_B", 20, 29)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[19], q[20])
    Rz(q[21], PI / 8)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

778. 778_scenario_semiconductor_18.sq — 778 scenario semiconductor 18

# Scenario 478: Semiconductor process-control anomaly map: scenario 18
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(166, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(166)
    block_A = shard("block_A", 20, 29)
    block_B = shard("block_B", 30, 39)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[29], q[30])
    Rz(q[31], PI / 3)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

779. 779_scenario_semiconductor_19.sq — 779 scenario semiconductor 19

# Scenario 479: Semiconductor process-control anomaly map: scenario 19
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(168, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(168)
    block_A = shard("block_A", 30, 39)
    block_B = shard("block_B", 40, 49)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[39], q[40])
    Rz(q[41], PI / 4)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

780. 780_scenario_semiconductor_20.sq — 780 scenario semiconductor 20

# Scenario 480: Semiconductor process-control anomaly map: scenario 20
# Strategy: 10-qubit dense local blocks with safe MPS promotion for bridge gates.
simulate(160, engine="hierarchical", block_size=10, max_bond_dim=null, cutoff=0.0, use_lookup=true) {
    q = quantum_register(160)
    block_A = shard("block_A", 0, 9)
    block_B = shard("block_B", 10, 19)
    apply_block("H", block_A)
    apply_block("X", block_B)
    CNOT(q[9], q[10])
    Rz(q[11], PI / 5)
    print("scenario", "semiconductor", hierarchical_report())
    print("lookup", lookup_profile())
}

781. 781_scenario_seismology_01.sq — 781 scenario seismology 01

# Scenario 481: Seismic event correlation screening: scenario 01
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 61) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

782. 782_scenario_seismology_02.sq — 782 scenario seismology 02

# Scenario 482: Seismic event correlation screening: scenario 02
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 62) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

783. 783_scenario_seismology_03.sq — 783 scenario seismology 03

# Scenario 483: Seismic event correlation screening: scenario 03
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(142, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(142)
    H(q[0])
    for i in range(0, 63) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(142))
}

784. 784_scenario_seismology_04.sq — 784 scenario seismology 04

# Scenario 484: Seismic event correlation screening: scenario 04
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(144, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(144)
    H(q[0])
    for i in range(0, 64) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(144))
}

785. 785_scenario_seismology_05.sq — 785 scenario seismology 05

# Scenario 485: Seismic event correlation screening: scenario 05
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 65) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

786. 786_scenario_seismology_06.sq — 786 scenario seismology 06

# Scenario 486: Seismic event correlation screening: scenario 06
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 66) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

787. 787_scenario_seismology_07.sq — 787 scenario seismology 07

# Scenario 487: Seismic event correlation screening: scenario 07
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 67) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

788. 788_scenario_seismology_08.sq — 788 scenario seismology 08

# Scenario 488: Seismic event correlation screening: scenario 08
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(142, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(142)
    H(q[0])
    for i in range(0, 68) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(142))
}

789. 789_scenario_seismology_09.sq — 789 scenario seismology 09

# Scenario 489: Seismic event correlation screening: scenario 09
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(144, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(144)
    H(q[0])
    for i in range(0, 69) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(144))
}

790. 790_scenario_seismology_10.sq — 790 scenario seismology 10

# Scenario 490: Seismic event correlation screening: scenario 10
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 70) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

791. 791_scenario_seismology_11.sq — 791 scenario seismology 11

# Scenario 491: Seismic event correlation screening: scenario 11
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 71) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

792. 792_scenario_seismology_12.sq — 792 scenario seismology 12

# Scenario 492: Seismic event correlation screening: scenario 12
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 72) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

793. 793_scenario_seismology_13.sq — 793 scenario seismology 13

# Scenario 493: Seismic event correlation screening: scenario 13
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(142, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(142)
    H(q[0])
    for i in range(0, 73) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(142))
}

794. 794_scenario_seismology_14.sq — 794 scenario seismology 14

# Scenario 494: Seismic event correlation screening: scenario 14
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(144, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(144)
    H(q[0])
    for i in range(0, 74) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(144))
}

795. 795_scenario_seismology_15.sq — 795 scenario seismology 15

# Scenario 495: Seismic event correlation screening: scenario 15
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 75) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

796. 796_scenario_seismology_16.sq — 796 scenario seismology 16

# Scenario 496: Seismic event correlation screening: scenario 16
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(138, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(138)
    H(q[0])
    for i in range(0, 76) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(138))
}

797. 797_scenario_seismology_17.sq — 797 scenario seismology 17

# Scenario 497: Seismic event correlation screening: scenario 17
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(140, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(140)
    H(q[0])
    for i in range(0, 77) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 6)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(140))
}

798. 798_scenario_seismology_18.sq — 798 scenario seismology 18

# Scenario 498: Seismic event correlation screening: scenario 18
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(142, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(142)
    H(q[0])
    for i in range(0, 78) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 7)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(142))
}

799. 799_scenario_seismology_19.sq — 799 scenario seismology 19

# Scenario 499: Seismic event correlation screening: scenario 19
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(144, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(144)
    H(q[0])
    for i in range(0, 79) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 8)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(144))
}

800. 800_scenario_seismology_20.sq — 800 scenario seismology 20

# Scenario 500: Seismic event correlation screening: scenario 20
# Strategy: MPS/tensor-network for low-entanglement neighbor structure.
simulate(136, engine="mps", max_bond_dim=64, cutoff=1e-12, use_lookup=true) {
    q = quantum_register(136)
    H(q[0])
    for i in range(0, 80) {
        CNOT(q[i], q[i + 1])
        Rz(q[i + 1], PI / 5)
    }
    print("scenario", "seismology", "mps_low_entanglement_chain")
    print("estimate", estimate_qubits(136))
}

Project details

Verified details

These details have been verified by PyPI
Project links
Maintainers
Avatar for sansqrit from gravatar.com sansqrit

Unverified details

These details have not been verified by PyPI
Project links
Meta
  • License Expression: MIT
    SPDX License Expression
  • Author: Karthik V
  • Maintainer: Karthik V
  • Tags quantum , dsl , simulator , sparse , sharding , lookup , stabilizer , qec , surface-code , tensor-network , hierarchical-tensor , mps , qasm , qiskit , braket , cirq , pennylane , education , research , ai-training
  • Requires: Python >=3.10
  • Provides-Extra: dev , qec , tensor , gpu , qiskit , cirq , braket , pennylane , interop , all
Classifiers

Release history Release notifications | RSS feed

0.3.6

This version

0.3.5

0.3.3

0.3.1

0.3.0

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

sansqrit-0.3.5.tar.gz (2.6 MB view details)

Uploaded Source

Built Distribution

If you're not sure about the file name format, learn more about wheel file names.

sansqrit-0.3.5-py3-none-any.whl (2.7 MB view details)

Uploaded Python 3

File details

Details for the file sansqrit-0.3.5.tar.gz.

File metadata

  • Download URL: sansqrit-0.3.5.tar.gz
  • Upload date:
  • Size: 2.6 MB
  • Tags: Source
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/6.2.0 CPython/3.14.2

File hashes

Hashes for sansqrit-0.3.5.tar.gz
Algorithm Hash digest
SHA256 742dc6ef2b9c3470150a93be8ab0d3968b0b71019143de244625c7b31313ddec
MD5 4f5af16b14a7afa953f0dd193efc96fa
BLAKE2b-256 648488f6948c41491b478761418a2b941e6ec194bad297e054aca0894e6a2de9

See more details on using hashes here.

File details

Details for the file sansqrit-0.3.5-py3-none-any.whl.

File metadata

  • Download URL: sansqrit-0.3.5-py3-none-any.whl
  • Upload date:
  • Size: 2.7 MB
  • Tags: Python 3
  • Uploaded using Trusted Publishing? No
  • Uploaded via: twine/6.2.0 CPython/3.14.2

File hashes

Hashes for sansqrit-0.3.5-py3-none-any.whl
Algorithm Hash digest
SHA256 6426510fc51bd41a740a0d28dc48d64194661e1c2d7f4842ad7f6a03b2828bb4
MD5 02b92ca36306158bc831493ca672e2c2
BLAKE2b-256 0d58c156829dd7cd5db6190c284e4e080dd5c1a4a7a880ec09ea1d99b5a08ccb

See more details on using hashes here.

Supported by

AWS Cloud computing and Security Sponsor Datadog Monitoring Depot Continuous Integration Fastly CDN Google Download Analytics Pingdom Monitoring Sentry Error logging StatusPage Status page