Release News: Aug-Sep 2026

​

Fault-Tolerance Engine

​

Choosing a Noise Model and Routing

from classiq import *
from classiq.error_correction import get_logical_noise, route_circuit

# Loading a public logical noise model; any public model name works here
logical_noise = get_logical_noise("public/depolarize_1e-3")

# Transpiling the synthesized program (qprog) to Clifford+T
clifford_t_qasm = export(
    qprog,
    target_language=TargetLanguage.QASM2,
    transpilation_config=FaultTolerantTranspilationConfig(
        # Setting the maximum total approximation error allowed for the rotations
        clifford_t_approximation_error=1e-3
    ),
)

# Routing the Clifford+T circuit onto the surface-code lattice
topological_program = route_circuit(clifford_t_qasm)

​

Visualizing the Routed Program

​

Estimating the Total Logical Error

from classiq.error_correction import estimate_total_errors

# Estimating the total logical error at each given code distance
total_errors = estimate_total_errors(
    topological_program, logical_noise, code_distances=[11, 13, 15]
)

​

Quantum Engineering Interface

​

One AI Layer, Two Entry Points

​

Enhancements

​

Composable Block Encodings

• Create an encoding: From a dense matrix (optionally with the FABLE algorithm), a sparse Pauli operator (encoded by default with the new unary_select open library function), or constant diagonals.
• Combine encodings: Add, multiply, scale, or take tensor products of encodings to get an encoding of the sum, product, scaled matrix, or tensor product of the encoded matrices. A single encoding can also be turned into an encoding of the inverse matrix or into its qubitized walk operator.
• Check the implemented matrix: to_matrix reconstructs the encoded matrix by simulation, up to a global phase, so you can compare it with the matrix you expect.

from classiq import *
from classiq.applications.block_encoding import BlockEncoding

# Create: encodings of two sparse Pauli operators
be_a = BlockEncoding.from_sparse_pauli_op(0.5 * Pauli.X(0) + 0.5 * Pauli.Z(0))
be_b = BlockEncoding.from_sparse_pauli_op(Pauli.Z(0))

# Combine: an encoding of the product of the two encoded matrices
product = be_a @ be_b

# Check: the encoded product matrix, up to a global phase
print(product.to_matrix())

​

Faster Batched Observable Estimation

• ExecutionSession.observe and ExecutionSession.submit_observe now take an estimate argument, matching the standalone observe. Pass estimate=False on the Classiq simulator to compute the exact expectation value from the state vector, free of shot noise, for noiseless programs of up to 26 qubits.
• An observable can now act on fewer qubits than the program, and is automatically padded with identities on the remaining qubits.

​

Optimized Comparisons and Increments

• Constant comparisons: Comparisons with <, <=, >, or >=, such as x < 5, no longer need an auxiliary quantum variable as wide as the operand:
  • Optimizing for width (the default): The comparison uses no auxiliary qubits.
  • Optimizing for CX count: The comparison uses auxiliary qubits to keep its CX count growing linearly with the operand’s width, instead of quadratically as in the auxiliary-free variant. In addition, under a control, each control qubit adds only 6 CX gates.
• Increment by 1: For an in-place increment or decrement by 1 (x += 1, x += -1), including inside a control block, optimizing for width selects a QFT-based variant with no auxiliary qubits, and optimizing for CX count selects a fault-tolerant, Toffoli-based variant with far fewer CX gates. The Discrete Quantum Walk tutorial now compares the new increment with a hand-built one.

​

Earlier Qubit Release in Uncomputation

​

Upgraded Quantum Layer for QNNs

• QLayer now builds the new, faster quantum layer, previously available only as QLayerV2. Pass observables=... to output expectation values, or use the new readout argument with SamplingReadout to sample the program and apply your own post-processing. The older call forms still build the classic QLayerV1, which is now deprecated, as described in Deprecations below.
• The layer trains in any environment where the SDK runs, not only in Classiq Studio. In Studio, it runs on the in-process simulator for circuits of up to 26 qubits, up from 12, and computes exact gradients for expectation-value outputs. Outside Studio, it runs the circuits on an execution backend instead.

​

State Vectors of Up to 24 Qubits

​

Parsing Results from Other Platforms

​

Documentation Additions

• Quantum Engineering Interface Guide: Covers how to open the new web interface, run a task from idea to analyzed results in a single thread, work with the artifacts each step produces, and write effective prompts, expanding on the Quantum Engineering Interface section above.
• Fault-Tolerance Engine Guides: Six pages covering every aspect of the engine, from publicly available and custom noise models to routing, visualization, and total-error estimation, complemented by an end-to-end tutorial notebook listed under Library Additions below. For a quick tour of the workflow, see the Fault-Tolerance Engine section above.
• Block Encoding Guides: Three pages introducing the new BlockEncoding class. Constructing Block Encodings covers building block encodings from a dense matrix, a sparse Pauli operator, or constant diagonals, and Composing Block Encodings covers combining them and verifying the result, expanding on the example in the Composable Block Encodings section above.
• Revamped Qmod Tutorial: The two-part, hands-on Qmod tutorial was rewritten from the ground up, as part of a broader revision of Classiq’s tutorials, with new tutorials on the way. Part I covers the language foundations, from quantum variables and types to arithmetic and control, and Part II covers the statements and operators used to express real quantum algorithms, from phase statements to hybrid execution.

​

Library Additions

• Fault-Tolerance Engine: End-to-End Tutorial: Walks you through the full fault-tolerance workflow step by step; it starts from a synthesized quantum program transpiled to Clifford+T, moves through noise-model selection, routing onto the surface-code lattice, and visualization, and ends with the estimated total logical error and physical-qubit count at each code distance.
• Block-Encoding Notebooks Revisited: Thirteen library notebooks now use the new BlockEncoding class, including QSVT matrix inversion, VQLS with LCU, Hamiltonian simulation with QSVT, GQSP, and qubitization, the quantum linear solvers for CFD, and the Vlasov-Ampère and cooling systems optimization applications.

​

Bug Fixes

• Uncomputation keeps rolled loops and skip_control bodies: Automatic uncomputation now preserves a rolled repeat or foreach loop, or a skip_control body, in a function that has a variable to uncompute.
• power and invert handle repeat and foreach loops correctly: power now raises the whole loop to the power, where it previously raised each iteration to the power separately, and invert now reverses the iteration order, where it previously kept the original order.
• Output variable names can match result column names: An output variable of main can now share a name with a column of the result DataFrame. In case of a name clash with a built-in column, such as phase in calculate_state_vector, your variable keeps its name, the built-in column is renamed to result_<name>, and a warning is issued.

​

Deprecations

• observable parameter renamed to observables in observe: The second parameter of the standalone observe function is now named observables, and it also accepts a list, as covered in the Faster Batched Observable Estimation section above. Calls that use the old keyword, observable=..., raise a TypeError; use observables=... instead, or pass the argument without a keyword.
• hamiltonian parameter deprecated in favor of observables in ExecutionSession: The session’s observe and submit_observe now also take observables, which accepts a single observable or a list. Calls that use the old keyword, hamiltonian=..., still run with a deprecation warning, and hamiltonian will be removed in an upcoming release. For details, see the dedicated section of the observe user guide.
• ExecutionSession estimate aliases removed: The deprecated ExecutionSession aliases estimate, submit_estimate, batch_estimate, and submit_batch_estimate have been removed. Use the session’s observe or submit_observe instead, passing a list of parameter dicts for batched execution.
• QLayer now builds QLayerV2, and QLayerV1 is deprecated: Calling QLayer with the observables or readout keyword arguments now builds the new QLayerV2. The older call forms, QLayer(qprog, post_process, ...) and QLayer(qprog, execute, post_process, ...), still build the classic QLayerV1, now with a deprecation warning. QLayerV1 will be removed in a future release.
• Qubit-layout check extended to control, invert, and function bodies: A quantum variable must now end a control or invert block (or a function body) with the same qubit layout it started with, extending the check added in July for power, repeat, foreach, and if blocks. Programs that break this raise an error. To avoid the error, use bind to re-join the variable’s parts in their original order, as described in Qubit Layout Stability.
• inplace_binary_to_one_hot in-out parameter split into source and target: The open library function inplace_binary_to_one_hot now takes separate input and output parameters (source: Input[QArray], target: Output[QArray]) instead of a single in-out array parameter.
• Run via Classiq restricted and emulation paused on Azure Quantum: Run via Classiq is no longer available for Azure Quantum backends in the IDE, for both execution and benchmarking. The SDK also rejects it for Azure QPUs and for all Quantinuum targets, so pass your own Azure Quantum credentials to run on them. In addition, emulation on Azure is temporarily unavailable; to simulate IonQ hardware noise, use the IonQ provider’s emulate option instead.
• C12 backend preference field ininoisy renamed to ininoise: The C12BackendPreferences field now matches the C12 Callisto API. The old name is ignored without an error, so replace ininoisy with ininoise in any code that sets it.

​

Announcements