​

Bug Fixes

• Fixed incorrect gate arguments in QuantumProgram.qasm. Also affects simulation when transpilation_option=TranspilationOption.NONE.

​

Enhancements

• The Python SDK now collects telemetry to help us improve our product. This can be disabled by setting the environment variable CLASSIQ_TELEMETRY_MODE=disabled.

​

Bug Fixes

• fix an issue with nvidia-gpu worker, where it would fail on initialization

​

Interface Changes

• The pretty_qasm field was removed from Preferences. OpenQASM 2 outputs are now always formatted with line breaks inside gate declarations (the previous default behavior).
• ExecutionSession now accepts individual configuration parameters directly: ExecutionSession(qprog, backend=..., num_shots=..., random_seed=..., transpilation_option=..., run_via_classiq=..., config=...). The execution_preferences= keyword form still works but is deprecated and will be removed on 2026-06-22.

​

Enhancements

• Improved QP Visualization Support: Quantum program visualizations can now display much larger circuits and operations. The maximum number of child operations that can be expanded at once has been increased from 1,000 to 2,500. This means large composite gates, functions, and generated code blocks will now expand and render fully, improving visibility and debugging for more complex circuits.

​

Bug Fixes

• CombinatorialProblem: Fixed a KeyError raised when an inequality constraint became degenerate (collapsed to a single feasible value) after another constraint had fixed one of its variables.

​

Enhancements

• GitHub Copilot Integration: Added support for GitHub Copilot in Classiq Studio, including chat-based AI assistance, coding agent features, and code autocomplete. These features are now available in the browser-based IDE experience.

​

Bug Fixes

• Restored the Studio button to its original location in the left sidebar of the IDE.

​

Enhancements

• Faster synthesis for models containing very large hamiltonian objects.
• Added support for the C12 provider when using sample, observe, and related functions with backend='c12/<backend_name>'.
• Added support for large-scale models by uploading/downloading execution and synthesis inputs/outputs directly to S3 via pre-signed URLs, bypassing payload size limitations.

​

Bug Fixes

• prepare_amplitudes / inplace_prepare_amplitudes: Fixed a wrong global phase that affected the controlled version for some amplitude vectors.
• QP Visualization: Improved robustness of the QP Visualization feature by adding webGPU/webGL context loss recovery, preventing blank screens when the graphics context is lost.

​

Bug Fixes

• Fixed a bug in the infrastructure.

​

Enhancements

• Studio: latexmk and a TeX Live subset are now pre-installed, enabling the benchmarking application from the Classiq library to generate its PDF report directly in the Studio.

​

Bug Fixes

• Fix an issue where most models saved with older SDK versions cannot be synthesized.

​

Enhancements

• ExecutionSession.sample and ExecutionSession.estimate: These methods now accept a list of parameter dictionaries for batch execution, returning a list of results. The dedicated batch_sample, submit_batch_sample, batch_estimate, and submit_batch_estimate methods are deprecated — pass a list to the standard methods instead.
• variational_minimize function: Added a new public variational_minimize function for variational optimization of a cost function over the parameter values of a quantum program. Supports Hamiltonian and classical cost functions, run_via_classiq, and improved input validation. See the SDK reference for details.
• Added slice(array, start, stop) in classiq.qmod.symbolic as the Python alternative for array slice expressions on Python lists, analogous to subscript.
• classiq.print_diagnostics(): New function that prints a snapshot of the SDK version, Python environment, backend host and version, authentication status, and user ID - for easy inclusion in support tickets.

​

Bug Fixes

• Execution: Sample jobs started with execute() now persist submitted-circuit metadata so ExecutionJob.get_submitted_circuits() matches the documented behavior.
• Studio - Light mode not saved for users preferences
• IDE - Synthesize button keeps showing and disappearing
• Fix synthesis of nested concatenations in control condition.

​

API Changes

• The theta parameter of function phase was renamed to coefficient. The old name is deprecated and will no longer be supported starting on 2026-05-04 at the earliest.
• Function randomized_benchmarking is deprecated and will no longer be supported starting on 2026-05-11 at the earliest.

​

Enhancements

• sample function: Added a new top-level sample function for executing a quantum program and retrieving results as a DataFrame directly, without managing a job object. Supports single and batch execution — pass a list of parameter dictionaries to parameters to run multiple parameter sets and receive a list of DataFrames. Also supports run_via_classiq=True to run using Classiq’s provider credentials against your allocated budget. See the SDK reference for details.
• observe function: Added a new public observe function that computes the expectation value of a Hermitian observable with respect to a quantum program’s output state. Supports exact statevector calculation or shot-based estimation, batch execution, and run_via_classiq. See the SDK reference for details.
• get_backend_details function: Added a get_backend_details function that returns a DataFrame of all supported quantum backends, including provider, backend name, type (hardware or simulator), qubit count, availability, pending jobs, and queue time.
• calculate_state_vector function: Added a new public calculate_state_vector function that returns the full state vector of a quantum program as a DataFrame. Supports batch execution by passing a list of parameter dictionaries. Available on Classiq simulators (e.g. classiq/simulator).
• minimize function: Added a new public minimize function for variational optimization of a cost function over the parameter values of a quantum program. Supports Hamiltonian and classical cost functions, run_via_classiq, and improved input validation. See the SDK reference for details.
• OpenQASM in sample and ExecutionSession: You can pass OpenQASM 2.0 or 3.0 source as a string to sample() (first argument) or to ExecutionSession instead of a synthesized QuantumProgram. Results use the same histogram DataFrame shape (bitstring, counts, etc.). The parameters argument is not supported for OpenQASM strings (use a QuantumProgram for Qmod main parameters, or bind parameters inside the QASM circuit). See the Execution section of the user guide.
• Improve error messages related to qfunc arguments.
• Add emulate on AzureBackendPreferences to enable IonQ hardware noise simulation on Azure Quantum when using an IonQ QPU target (ionq.qpu.*); ignored for other Azure targets.
• Add a QSVM application with a QSVM class that provides train, test, and predict methods for easy implementation of Quantum Support Vector Machine training and data classification. The relevant notebooks in the classiq-library will be updated accordingly.

​

Enhancements

• Upgrade infrastructure to enable future support in AWS Marketplace.

​

Enhancements

• IBM execution – emulate: Add optional emulate on IBMBackendPreferences and IBMConfig. Set emulate=True (default False) to run on Classiq AerSimulator with an IBM noise model derived from the backend name (e.g. ibm_pittsburgh, ibm_boston). Only valid for real IBM hardware backends (not fake backends); backend name must be in CLASSIQ_NOISE_MODELS. See IBM backends for details.
• Add ExecutionJob.get_submitted_circuits() to return the final quantum circuits submitted to the provider (sample jobs only). The returned circuits reflect the actual QASM after transpilation and parameter assignment. Each circuit can be converted to QASM via to_qasm() or to a Qiskit QuantumCircuit via to_qiskit().
• Amplitude threshold for state vector simulation: Added amplitude_threshold to ExecutionPreferences. When running state vector simulation, only states with amplitude magnitude strictly greater than the threshold are included in the result. Defaults to 0 (filters exactly zero-amplitude states, same as before). Setting a higher threshold reduces the size of the result for circuits where most amplitudes are negligibly small. include_zero_amplitude_outputs=True overrides this and includes all states regardless of amplitude. See State Vector Filtering for details.
• QP Visualization: Fixed bug in the visualization of split operations
• Add estimate_sample_cost and estimate_sample_batch_cost to the Python SDK for user-facing cost estimation before executing quantum programs. These functions return a CostEstimateResult with cost and currency fields. See SDK execution reference for details.

​

Bug Fixes

• Fix error messages when calling built-in operations with the wrong number of arguments.
• IonQ execution: Replaced explicit noise_model with an emulate flag on IonqBackendPreferences and IonQConfig. Set emulate=True (default False) to run on the IonQ simulator with a noise model derived from the backend name (e.g. qpu.aria-1 → aria-1). Only valid when the backend is a QPU. See IonQ backends for details.
• QLayer check-pointing: Prefer saving only weights with torch.save(model.state_dict(), path) and model.load_state_dict(torch.load(path)). For whole-model save/load, if post_process is not picklable it is omitted and a warning is logged; after load call layer.register_post_process(your_post_process) before using the model. New constructor option serializable_post_process=False skips pickling post_process and suppresses the warning when you know it is not serializable.
• Add estimate_sample_cost and estimate_sample_batch_cost to the Python SDK for user-facing cost estimation before executing quantum programs. These functions return a CostEstimateResult with cost and currency fields. See SDK execution reference for details.

​

Bug Fixes

• Execution – transpilation_level = None: When execution is run with no transpilation, the circuit is now submitted to the provider without any backend transpilation when it already uses only the provider’s basis gates. If the circuit contains gates not supported by the provider, an error is raised that lists the provider’s supported gates, the invalid gates in the program, and suggests using transpilation_level = "decompose" (or transpile_to_hardware = "decompose" in ExecutionPreferences).
• Re-enable negative indices for classical arrays.
• Fix user not getting redirected to login page when they try to synthesize but are logged out
• IDE - result page - change exported csv to be identical to shown tables
• QLayer: Fix saving models that contain a QLayer when post_process or the execution path use local functions or lambdas (e.g. torch.save(model, path) or saving an epoch state dict). Such callables are now omitted from the pickled state and re-created or restored after load so that save/load no longer raises “Can’t pickle local object”.
• Add indicative error message when calling a classical function with quantum arguments in an arithmetic expression.

​

Enhancements

• Predefined noise models for Classiq simulators: Add optional noise_model on ClassiqBackendPreferences to run Classiq Aer, Nvidia, and Braket Nvidia simulators with a device-style noise model. The value is a predefined name in the form <provider>_<target> (e.g. ibm_pittsburgh, ibm_boston). Supported names are listed in CLASSIQ_NOISE_MODELS; initially IBM backend names are supported. The noise model is built from the provider (e.g. via IBM Runtime) and passed to the underlying AerSimulator.
• IonQ execution: Replaced explicit noise_model with an emulate flag on IonqBackendPreferences and IonQConfig. Set emulate=True (default False) to run on the IonQ simulator with a noise model derived from the backend name (e.g. qpu.aria-1 → aria-1). Only valid when the backend is a QPU. See IonQ backends for details.
• QLayer check-pointing: Prefer saving only weights with torch.save(model.state_dict(), path) and model.load_state_dict(torch.load(path)). For whole-model save/load, if post_process is not picklable it is omitted and a warning is logged; after load call layer.register_post_process(your_post_process) before using the model. New constructor option serializable_post_process=False skips pickling post_process and suppresses the warning when you know it is not serializable.

​

Bug Fixes

• Fix an incorrect compilation when an arithmetic operation appears inside a repeat statement and the left-hand side uses the repeat index as a subscript.
• Change default vendor from Azure to Classiq

​

Enhancements

• Added use_double_precision to ClassiqBackendPreferences to control numerical precision on Nvidia and Braket Nvidia simulators. Default is False (single precision). Set use_double_precision=True for double precision. See Classiq backends for details.
• Removed max_depth and max_gate_count from Constraints. These fields were deprecated since 0.52 and are no longer supported.

​

Bug Fixes

• Fix a bug causing an internal error during synthesis when calling a function containing foreach twice or more.

​

Enhancements

• Updated the Classiq Platform home page.

​

Enhancements

• The function poly_inversion now supports error_type ("relative" default or "uniform") to choose between minimizing relative error |xp(x)-1| or absolute uniform error |p(x)-1/x| over x in [1/kappa,1]. The same error_type option is also available in poly_inversion_degree and poly_inversion_error.
• Add the foreach statement to Qmod. Foreach iterates efficiently through the elements of a classical array.
• Support QBits in addition to QNums in lookup_table.

​

API Changes

1. Renamed sample to cmain_sample in legacy cscope. This does not affect any usage of ExecutionSession.

​

Enhancements

• Introduce CUDA-Q Integration, enabling translation of synthesized Qmod programs into Python CUDA-Q kernels, to leverage CUDA-Q’s high-performance simulation and hybrid quantum–classical workflows.

​

Bug Fixes

• Fix compilation of symbolic values in concatenations (for example, [q[i], q[j]] where i and j are of type CInt).

​

API Changes

• Rename parameter run_through_classiq of BackendPreferences to run_via_classiq. run_through_classiq is deprecated and will no longer be supported starting on 2026-03-09 at the earliest.

​

Bug Fixes

• IDE - Phase legend mismatches actual phase
• Fix compilation of the I (identity) gate.
• Fix evaluation of constants in main function parameter types.
• Remove previously deprecated "count" column from execution result dataframe. Use "counts" column instead.

​

Enhancements

• IDE - Adjustments to the table shown in “State Vector” jobs
• IDE - Add table in “Measurement Results” jobs
• Noise models are now available for IonQ Simulators.

​

Enhancements

• Reduce CX count and circuit depth for multi-controlled Pauli rotations (RX, RY, RZ).

• IDE - Improve the appearance of the histograms / bar-plots shown for results
• IDE - Improve native Qmod library usability
• Classiq Studio - Added support for light mode visualization in the Quantum Program (QP) visualizer within Classiq Studio. Users can now switch between light and dark themes for an improved viewing experience.
• C12 Cloud is now available. See Cloud Providers section in the user guide.

​

Bug Fixes

• Fixed error message for a measurement under unitary context.

​

Enhancements

• Support array subscripts with missing slices (e.g., arr[1:] and arr[:9]) in Python Qmod.
• Add qmod_to_qubit_op function to convert from SparsePauliOp to OpenFermion’s QubitOp data structure.

​

Bug Fixes

• IDE - Fix selection in Quantum Program Execution Jobs tab - Make the first job on the jobs list be selected
• Fix synthesis of functions with Output quantum parameters called under invert.

​

Bug Fixes

• IDE - Fix expand / collapse of backend details in the HW Catalogue
• In the dataframe, change the count field to counts so as not to override the built-in count method on pandas dataframes. The current count field is deprecated and will be removed in the next release.
• Fix multi-value Boolean operations in Native Qmod (e.g., a or b or c).
• Fix synthesis error when controlling X with >=13 control qubits.
• Raise indicative errors when overriding internal functions (for example, when re-defining prepare_state).

​

Enhancements

• Support QArray[QBit] assignment statements, for example, qarr |= [1, 0, 0, 1].
• Improve implementation of in-place quantum subscript assignments (e.g., x ^= subscript([1, 2, 3, 4], y)).
• IDE - Execution in the IDE now supports running through Classiq account for Amazon Braket, Microsoft Azure Quantum, and IonQ backends. Authorized users can enable this option using the “Run through Classiq” switch, which eliminates the need to provide their own credentials for these backends. This feature also includes spending tracking and budget management capabilities.
• Support assignments of non-scalar variables, for example, qarr1 |= qarr2. Both variables must have the same type.
• Improve error message when assigning a symbolic value to a generative parameter.

​

Deprecation

• IDE - Removed support for max depth and max gate count synthesis constraints in the model

​

Interface Changes

• Violations of uncomputation rules are now flagged as errors instead of warnings.
• The function qubit_op_to_pauli_terms in the chemistry module is deprecated due to incorrect order of qubits in its result. Please use qubit_op_to_qmod instead.

​

Bug Fixes

• Resolved an issue with labeling CX gate inputs in QP visualization, so that the correct qubit labels are now displayed.
• Fixed qfuncs being expanded declaratively (symbolically) when passed as arguments to other qfuncs.
• Improved the error message for type errors with function arrays.
• Fixed error message for nan values.
• Fix mapping from output registers to measured qubits on parametrized repeat circuits with HW aware synthesis.
• Fix phase applied with an execution parameter under multiple controls.
• Fix unscheduled_suzuki_trotter and qdrift implementations.
• Fix SDK function get_execution_actions
  • Flattened the cost field. The result holds now cost, currency_code
  • Add session_id in the result
• Fix compilation of unused variables defined in nested blocks.

​

Studio

• Classiq Studio now includes built-in AI integration, allowing users to generate, optimize, and execute quantum models directly within the Studio. This capability leverages Classiq’s quantum resources and requires no external API tokens.

​

Enhancements

• Add quantum modular arithmetic functions to the open library, enabling modular quantum operations: modular addition, multiplication, squaring, negation, and inversion: modular_add_inplace, modular_double_inplace, modular_negate_inplace, modular_multiply, modular_square, modular_multiply_constant, modular_multiply_constant_inplace, modular_to_montgomery_inplace, modular_montgomery_to_standard_inplace, modular_inverse_inplace, kaliski_iteration, and modular_rsub_inplace.
• Change precision of GPU simulators to single-precision to make better use of hardware.
• Add functions get_execution_actions and get_execution_actions_async return a pandas DataFrame of execution actions. Filter by id, session_id, status, name, provider, backend, program_id, cost range (total_cost_min/max), and time ranges (start_time_min/max, end_time_min/max). All filters are combined with AND logic.
• Add functions get_synthesis_actions and get_synthesis_actions_async return a pandas DataFrame of synthesis actions. Filter by id, status, backend, program_id, backend_name, optimization_parameter, random_seed, max_width, max_gate_count, cost range (total_cost_min/max), and time ranges (start_time_min/max, end_time_min/max). All filters are combined with AND logic.

​

Bug Fixes

• Fix uncomputation of function calls with input or output concatenations.
• Fix within-apply bug caused by variable declarations nested in the “within” block.

​

Bug Fixes

• Fix memory issue in Synthesis queue mechanism.

​

Interface Changes

• Function exponentiation_with_depth_constraint is deprecated and will no longer be supported starting on 2025-12-10 at the earliest. Instead, use exponentiate.

​

Enhancements

• Add functions for encoding conversions between binary, unary, and one-hot representations: binary_to_one_hot, binary_to_unary, one_hot_to_unary, one_hot_to_binary, unary_to_one_hot, unary_to_binary, inplace_binary_to_one_hot, and inplace_one_hot_to_unary.
• Change precision of GPU simulators to single-precision to make better use of hardware.

​

Bug Fixes

• Fixed a bug in Hardware-Aware Quantum Program.
• Fixed concatenations arguments to input and output quantum parameters.

​

IDE

• Fixed a bug in Jobs page after Executing on several hardwares.
• Added a better labeling in the QP visualization. Now on “Show label” user will see label as on the closed box. On hover user will see full label.
• Fixed issue with duplicate error snackbar in the Jobs page.

​

Interface Changes

• Function exponentiation_with_depth_constraint is deprecated and will no longer be supported starting on 2025-12-10 at the earliest. Instead, use exponentiate.

​

Enhancements

• Add SX gate to Qmod core functions

​

IDE

• Basis Gates field under “Hardware Aware” now starts empty. If left empty, synthesis applies default basis gates automatically based on connectivity; select one or more gates to override.

​

Interface Changes

• Update the QSVT functions to use Capturing. See the following example.

​

Enhancements

• Add functions for getting polynomial approximations for common use cases - poly_jacobi_anger_<> for Hamiltonian Simulation and poly_inversion for matrix inversion.

​

Bug Fixes

• Fix an issue that caused certain execution runs to fail due to incompatible gates

​

Bug Fixes

• Fixed minor issues in registration flow

​

Enhancements

• Qmod now supports automatic uncomputation of local variables and enforces rules that guarantee their correct uncomputation. Similar rules are enforced on variables initialized inside a within-apply statement. For more details, see Uncomputation. Currently, violations of uncomputation rules are issued as warnings for backward compatibility. These will become compilation errors no earlier than 2025-12-03.
• Add the assign_amplitude_table and assign_amplitude_poly_sin open-library functions, to replace the *= operator and the assign_amplitude function.
• Add unscheduled_suzuki_trotter, a variant of multi_suzuki_trotter that doesn’t re-order the Pauli terms.
• Improve synthesis of controlled phase with theta=pi.
• This release includes initial support of classical local variables, assignment of mid-circuit measurements, and runtime if statements. Currently, only variables of type QBit can be measured, and only the classical bool type is supported for local variable declaration and assignment. This enables simple algorithms such as the quantum teleportation protocol. These constructs have the corresponding dedicated graphics in the quantum program visualization. See more details under Classical variables) and Mid-circuit measurement.

​

Interface Changes

• The *= operator and the assign_amplitude function are deprecated and will no longer be supported starting on 2025-12-03 at the earliest. Use assign_amplitude_table instead.
• Function qdrift now receives a sparse Hamiltonian (SparsePauliOp) instead of a list of non-sparse Pauli terms (CArray[PauliTerm]). Non-sparse pauli terms in qdrift will no longer be supported starting on 2025-12-03 at the earliest.

​

Bug Fixes

• Fix multi_suzuki_trotter synthesis with symbolic evolution coefficients raising an internal error.
• Fix a bug where an internal error is raised when synthesizing with a maximum width constraint a model that contains control on a function, or a statement block, that allocates and frees qubits.

​

Security

• Internal dependencies have been upgraded to address security vulnerabilities.

​

Bug Fixes

• Fix transpilation and execution of unitary functions when compiling to QASM2.

​

Enhancements

• We’ve changed our AWS Braket integration, now AWS credentials consist of an access key ID and a secret access key. For more information, see AWS Credentials.
• Added the function prepare_select for the definition of structured Linear Combination of Unitaries primitive (LCU) schemes.

​

Bug Fixes

• Report assignments into non-numeric variables.
• Fix concatenation operator on single variable not casting to QArray.
• Fix lambda list (QCallableList) scoping issue causing a bug when a lambda list item is invoked in a different lambda.
• Fix error which caused execution jobs on IonQ to fail if they took more than 5 minutes.

​

Interface Changes

• The debug_info field was removed from the QuantumProgram class

​

Bug Fixes

• Report quantum types instantiated with execution parameters.

​

Deprecations

1. Python 3.9 is no longer supported in the Python SDK. The minimum supported version is now Python 3.10.

​

Enhancements

• Added the skip_control statement to the Qmod language. skip_control applies a quantum statements unconditionally.
• Add pauli_operator_to_matrix, the sparse counterpart of hamiltonian_to_matrix.
• Add new quantum functions for modular arithmetics: modular_add_qft_space, modular_multiply, and inplace_modular_multiply. Those functions use skip_control statements for specifying their efficient controlled version.

​

Bug Fixes

• Fix a bug where an error is raised when synthesizing with a maximum width constraint, even though a solution exists.
• Fix qasm_to_qmod quantum argument size calculations (resulting in, for instance, illegal control statements generated from mcx gates).

​

Deprecations

• SDK versions below 0.92 will be deprecated as planned from October 13, 2025 (at the earliest). As a one-time exception, the version deprecation error message will not be as usual. Instead of “You are using an unsupported version of Classiq SDK—… “, users will experience a “504 Gateway Timeout ERROR” or a similar message. We apologize for the inconvenience.

​

Bug Fixes

• Fix a bug where an internal error occurred during hardware-aware synthesis with a basis gate set of Clifford + T.
• Fix allocate with floating-point size when the max_width constraint is set.

​

Classiq Studio Updates

• A progress bar was added to the classiq studio start up page.

​

Deprecations

• Python version 3.9 will no longer be supported starting on 2025-10-01 at the earliest.

​

Enhancements

• The new qasm_to_qmod function de-compiles QASM 2 or 3 into Python/Native Qmod source code.
• Added methods for execution budget management.
• Classiq’s AI agent is now installed in Classiq Studio, providing seamless AI-powered quantum development. See the AI documentation for setup instructions.
• Remove negligibly small amplitudes from state vectors when the auxiliary (non-output) qubits are non-zero. These amplitudes are caused by numeric error during simulation, but they result in multiple states with the same assignment for the variables, which caused confusion.
• Added several Quantum Signal Processing (QSP) related functions to the SDK: qsvt_phases for obtaining QSVT phases, qsp_approximate for approximating QSP-compatible Chebyshev polynomials, gqsp_phases for calculating Generalized-QSP (GQSP) phases, and a quantum gqsp function that implements GQSP. To use these functions the user should pip install classiq[qsp]. The existing QSVT examples and a new GQSP example will be updated in the library towards the next version release.

​

Bug Fixes

• Fix a bug where the visualization generated unnecessary variable splits and assigned incorrect variable names in certain cases.
• Support classical functions in the cost expression of minimize.
• Prevent invisible blocks from being collapsed.
• Adjust CZ gate boundaries to align with disconnected variable lines.
• Fix Studio loading stuck until page reload.

​

Bug Fixes

• Visualization tooltips are now supported and displayed in the Studio. This enhancement improves the user experience by providing helpful information directly within visualizations, making it easier to understand and interact with your data.

​

Enhancements

• Add magnitude and phase to the dataframe for state vector simulations.
• Increase the limit of the number of qubits that can be simulated on Classiq’s Simulator from 25 to 28. Note that wider circuits take longer to simulate, so Classiq’s Nvidia Simulator will likely have improved performance for wide/deep circuits. Also, increase the limit on Classiq’s State Vector Simulator to 28 qubits, as long as State Vector Filtering reduces the number of output (unfiltered) qubits to 18 or less, the previous limit. For example, it is now possible to get the state vector from a quantum program of 20 qubits with a 2-qubit QNum filtered out.
• Add support for bitwise operators in phase statements.

​

Documentation Enhancements

• A new tutorial on execution is now available under The Classiq Tutorial
• New explanations on visualization features in the Synthesis Tutorial
• Search results have been improved to show the most relevant information at the top.

​

QP Visualization: Improved Handling of Long Function Blocks Sub-labels

​

Enhancements

• Loading of large Pandas Dataframes is now available in the studio, up to 200MB files.
• Use non-blocking flow for execution jobs on the Classiq Nvidia Simulator. This allows for longer-running jobs.
• The ‘phase’ statement has been generalized to support a fixed (classically specified) rotation angle, that is, to insert a global phase. A global phase across an entire circuit is undetectable in quantum hardware, but when applied in a controlled context, it introduces a relative phase between positive and negative condition states. This variant of the ‘phase’ statement is useful to directly express key idioms in quantum algorithms such as phase oracles, reflections, and relative-phase computations.

​

QP Visualization: Improved Handling of Long Function Blocks Sub-labels

​

Deprecations

• The following functions and classes have been deprecated and will no longer be supported starting on 2025-09-18 at the earliest: construct_chemistry_model, molecule_ucc, molecule_hva, molecule_hartree_fock, fock_hamiltonian_hva, fock_hamiltonian_hartree_fock, GroundStateProblem, MoleculeProblem and HamiltonianProblem. For more information on Classiq’s chemistry application, see here.

​

Bug Fixes

• Fix a bug where allocating quantum variables in disallowed blocks was not always reported.
• Fix a bug where controlled free operations could cause the visualization to crash. The visualization now handles these cases correctly and no longer fails when such operations are present.

​

Interface Changes

• Parameter expr of function ‘phase’ has been renamed to phase_expr. Parameter expr will no longer be supported starting on 2025-09-19 at the earliest. Change phase(expr=..., theta=...) to phase(phase_expr=..., theta=...) or phase(..., ...).

​

Studio Enhancements

• You can now install and import Torch, PyQSP, and CUDA-Q packages in the Classiq Studio environment. Previously, these imports failed due to environment limitations, but they are now supported for your workflows.
• PyGLPK package is installed and usable in the Classiq Studio.
• Uploading files up to 1 GB to the user persistent workspace in the Classiq Studio is now enabled.

​

Enhancements

• Added the functions prepare_sparse_amplitudes and inplace_prepare_sparse_amplitudes to the function library.
• Add support for numpy 2.2.6 (Python >=3.10) and numpy 2.3.2 (Python >=3.11)
• Shared QP links now come with the actual visualization image previews.

​

Security

• Improved web application security

​

Enhancements

• Added the function prepare_linear_amplitudes for preparing the state $|\psi\rangle = \frac\{1\}\{Z\}\sum_\{x=0\}^\{2^n-1\}\{x|x\rangle\}$.
• Extended the visualization of controlled functions as transparent boxes displaying control lines to all Qmod statements.
• Support state vector filtering for Classiq’s simulator_statevector.
• Added tolerance parameter to the minimize method of the execution session.

​

Enhancements

• Concatenations can now also be used as control expressions.
• Added the functions lcu and lcu_pauli for creating the Linear Combination of Unitaries primitive (LCU).
• IBM Cloud is now available. See Cloud Providers section in the user guide.
• The default optimization level in the synthesis preferences has been changed from OptimizationLevel.HIGH (3) to OptimizationLevel.LIGHT (1). For more information about optimization level see the optimization level section in the user guide.

​

Fixes

​

Bug Fixes

• Fix a synthesis bug that causes, in some cases, the function under power to have a separate power for each function, instead of sharing it as a whole.
• Fix a failure in hardware-aware synthesis of parametric models for the Azure Quantum provider.
• Fix a bug in get_hf_state when using qubit tapering.

​

Visualization

​

Introducing “Variables View”

​

Classiq Studio

​

Memory monitor

​

Enhancements

• Concatenations can now also be used as control expressions.
• Lower model creation and synthesis run times for large models.

​

Bug Fixes

• Classical if statements are now supported in QP visualization, where they previously caused a failure.
• Fix synthesis bug which caused wrong results when using the bitwise invert (~) operator.
• Fix bug relating to classical struct arguments (such as Hamiltonians).
• Use the Solovay-Kitaev algorithm in more cases when transpiling. Previously, we used the algorithm when transpiling with respect to a particular fixed set of basis gates. Now, we use this algorithm whenever the basis gate set contains the Clifford gates X, Z, H, T, and CX but does not contain arbitrary-angle rotation gates such as RX or CRZ.

​

Classiq IDE

1. Add mechanism to allow more models to be visualized in new visualization.

2. ​

   Visualization: Data Tab Removal

3. ​

   Deprecation: QP Visualization Basic View Mode

4. ​

   Visualization: Focused Search

​

Bug Fixes

• Fix the value range analysis of numerical variables declared with specified size.

​

Deprecations

• The Qmod function allocate_num has been removed.

​

Classiq IDE

​

New Feature: QP Visualization Enhancements

• The transparent section represents the control mechanism.
• The filled block highlights the controlled function.

​

Enhancements

• Added new chemistry functions to the Python SDK for using Hartree-Fock and UCC ansatz in Qmod. In order to use them, it is required to install the Python SDK with the extra chemistry dependency.
• Qmod functions are represented with a single symbolic definition throughout the compilation process when their use of classical parameters allows it. This improves compilation time and output QASM code size in many cases.
• Added a new function, multi_suzuki_trotter, that applies the Suzuki-Trotter decomposition jointly to a sum of Hamiltonians.
• Added a new syntax for specifying sparse Hamiltonians (SparsePauliOp) in Qmod’s Python embedding. For example: 0.5 * Pauli.Z(0) * Pauli.Y(1) * Pauli.X(2) + 0.8 * Pauli.X(1). Check out the documentation for more details.
• Added a dataframe property to ExecutionDetails object. Example usage:
  with ExecutionSession(qprog) as es:
      result = es.sample()
  
  df = result.dataframe
  
• Added a new execution primitive ExecutionSession.minimize that encapsulates classical optimization of ansatz parameters. The cost function to minimize is specified either as a quantum observable (Hamiltonian) or an arithmetic expression. This offers a significant performance advantage compared to executing the same logic on the client side, as it eliminates communication overhead. Note that it utilizes a fixed generic minimization scheme (scipy-COBYLA). In non-trivial cases, you may still need to implement your own optimization logic.
• The total size of quantum structs can be retrieved using the new

​

Interface Changes

• Function sparse_suzuki_trotter will no longer be supported starting on 21/7/25 at the earliest. Instead, use suzuki_trotter.
• Function parametric_suzuki_trotter will no longer be supported starting on 21/7/25 at the earliest. Instead, use multi_suzuki_trotter.
• Function suzuki_trotter now receives a sparse Hamiltonian (SparsePauliOp) instead of a list of non-sparse Pauli terms (CArray[PauliTerm]). Non-sparse pauli terms in suzuki_trotter are deprecated, use SparsePauliOp instead.
• ExecutionSession’s estimate methods now accept a sparse Hamiltonian (SparsePauliOp) instead of a list of non-sparse Pauli terms (CArray[PauliTerm]). Non-sparse pauli terms in ExecutionSession will no longer be supported starting on 21/7/25 at the earliest. Use SparsePauliOp instead.

​

Enhancements

• Added the concatenation operator to Qmod. This operator packs a sequence of quantum variables (or their parts) into a qubit array. For example, hadamard_transform([my_qnum, my_qarray[1:3]]) passes an array of the respective qubits to the function. See more under concatenation operator.
• Width constraints are now treated more systematically for optimization levels 0-2 (partitioning the model into separate synthesis steps), yielding solutions in cases where previously no solution was found. See more under Optimization Level.

​

Interface Changes

• The type SerailizedQuantumProgram and method QuantumProgram.get_qprog are no longer available.

​

Fixes

• Removed the “Login required” error message when not authenticated

​

Enhancements

• In Quantum Program visualization, engine-level (grey) boxes are flattened when they are single children.

​

Deprecations

1. The Qmod function allocate_num is deprecated and will no longer be supported starting on 16/06/2025 at the earliest. Instead, use

​

Fixes

• Updated dependencies to fix security vulnerabilities.

​

Enhancements

1. Value range analysis of arithmetic expressions is now generalized to apply across statements, optimizing quantum variables sizes and arithmetic expressions implementation in more cases.
2. Quantum functions inside a control statement get a c- prefix
3. Added the functions prepare_dicke_state and prepare_dicke_state_unary_input.
4. A new exponentiation function, sparse_suzuki_trotter, has been added to the core library, performing Suzuki-Trotter decomposition using a sparse representation of the Hamiltonian. It is recommended to use this function instead of suzuki_trotter when you handle a sparse Hamiltonian, as it is more efficient.
5. Include classiq.execution in the top level classiq package in the SDK. Old:
   from classiq.execution import ExecutionPreferences
   
   New:
   from classiq import ExecutionPreferences
   
6. allocate now supports specifying numeric attributes of the allocated variable.

​

Bug Fixes

1. Fix a system bug that caused execution jobs to fail with an “insufficient resources” message.
2. Fix a bug related to execution parameters.

​

Enhancements

1. Value range analysis of arithmetic expressions is now generalized to apply across statements, optimizing quantum variables sizes and arithmetic expressions implementation in more cases.

​

Enhancements

1. A new IQAE application has been added to the SDK. It allows you to define iqae problems in terms of Qmod function, and directly estimate the amplitude of the state you prepared.

​

Bug Fixes

1. Fixed an issue where the “Basic” view was always empty; it now correctly renders the circuit as intended.
2. Fixed bugs causing several example models to not be supported in the “New” circuit visualization, including “Shor’s Algorithm Modular Exponentiation”.

​

Enhancements

1. In Qmod’s Python embedding, you can now declare quantum functions with classical parameters of Python builtin types such as int, float, and list. These variables can be used in expressions that require Python values, such as Python for loops and 3rd party library functions, as is shown in the example below. See more on this under the new reference page on

@qfunc
def rotate(ratio: float, qa: QArray[QBit]):
    for i in range(qa.len):  # 'qa.len' is a Python integer
        PHASE(math.asin(ratio * i), qa[i])  # 'ratio * i' evaluates to a Python float

​

Interface Changes

1. With Enhancement 1 described above, Python-type parameters supersede classical Qmod-type parameters in generative functions. Hence, the use of the function decorator @qfunc(generative=True) is no longer required. Qmod-type parameters are treated symbolically in Python, and their use in Python expressions is deprecated.

​

Classiq IDE

1. Improved UX in Quantum program visualization: collapsing a Quantum operation block will scroll the viewport into the parent operation block position

​

Enhancements

1. It is now legal to out-of-place assign to a variable whose declared size is larger than the minimal size required to fit the range of possible expression values.

​

Interface Changes

1. The function synthesize now returns an object of type QuantumProgram, and its fields can be accessed directly. The type SerailizedQuantumProgram and method QuantumProgram.get_qprog are no longer needed, they are deprecated and will be removed in a future version.
2. Email Service Update - We’ve replaced the Community button with a new dropdown menu. Users can now select “Contact Us”, which opens a form. Once the form is submitted with user details, an email is sent directly to Classiq.
3. Layout Fixes - Resolved an issue with inconsistent padding across the layout to ensure a cleaner, more polished UI.
4. Enhanced Sharing Options - In addition to existing platforms, users can now share content to LinkedIn and Reddit with a single click.

​

Classiq Studio Updates

​

Classiq IDE

​

Enhancements

​

Interface Changes

1. The functions construct_qsvm_model, construct_finance_model, and construct_grover_model have been removed from the SDK. Check out our Qmod implementations of the QSVM, finance, and Grover algorithms on the Classiq library.

​

Enhancements

• QuantumProgram objects have been optimized to be significantly leaner, improving performance across all actions that handle them.
• Visualizing Quantum Programs is now significantly faster.
• Added the functions prepare_complex_amplitudes and inplace_prepare_complex_amplitudes.

Quantum Program Visualization

• Auto-expand QMOD statements without expressions (e.g. power).
• Statements with quantum expressions now display their corresponding expression directly on the block.

​

Interface Changes

1. The functions construct_qsvm_model, construct_finance_model, and construct_grover_model have been removed from the SDK. Check out our Qmod implementations of the QSVM, finance, and Grover algorithms in the Classiq library.

​

Enhancements

1. Improve control statement visualization to distinguish control qubits from target qubits.

​

Enhancements

1. Add new execution backends BRAKET_NVIDIA_SIMULATOR and BRAKET_NVIDIA_SIMULATOR_STATEVECTOR. These simulators run on Amazon Braket’s infrastructure and provide faster execution for single circuits. See Execution on Classiq Backends for more information.
2. Improve prepare_amplitudes and prepare_state performance for bound=0.
3. Add RESET, an atomic function that resets a qubit to the |0> state.
4. Intel simulator is now available as a backend for execution. See Cloud Providers section in the user guide.

​

IDE Updates

1. Models page is now open to non-signed-up users.

​

Classiq Studio Updates

1. Trust Classiq Library workspace by default.

​

Enhancements

1. Improve depth and gate count for transpilation options “intensive” and “custom”.
2. Improve the synthesis of the suzuki_trotter function for small hamiltonians.

​

Bug Fixes

1. Fixed a bug where arithmetic expressions that classically evaluate to constant boolean values could not be used.
2. Fixed a bug where using the show function in the Python SDK would open the IDE with a “Not Authorized” error.
3. Fixed a bug where certain operations in the Quantum Program visualization are displayed with very long name that describes the operation’s hierarchy.

​

UI Fixes

1. Updated the Quantum program icon in the drawer to a newer version

​

New Features

​

We’re launching Classiq Studio!

​

Enhancements

1. Improve the synthesis of the molecule_ucc function for small molecules.
2. Introduce a new QMOD core-library function commuting_paulis_exponent.
3. Social Sharing is now available. You can share circuits to various social platforms.
4. Add SLSQP optimizer for use in VQE.

​

Support

1. Error messages now include a link to our support system for reporting bugs or opening support tickets. You can also reach us on our Slack community channel.
2. Fix unexpected resets when using Classiq Studio.

​

Enhancements

1. Arithmetic assignments and control conditions now support quantum subscript expressions. A quantum subscript expression comprises a classical list accessed by a quantum subscript, e.g., x |= subscript([1, 2, 3, 4], y) (in Native Qmod: x = [1, 2, 3, 4][y];).
2. Report an indicative error when not releasing local variables inside control, invert and power statements.
3. When running VQE using the ClassiqSimulatorBackendNames.SIMULATOR_STATEVECTOR backend, compute the expectation value directly from the state vector instead of running shots.
4. In the Python SDK, arguments of type CArray can now be NumPy arrays, tuples, and similar sequential objects. For example, the following statements are equivalent: prepare_state([0.25, 0.25, 0.25, 0.25], 0, q) and prepare_state(np.ones(4) / 4, 0, q).

​

Interface Changes

1. The synthesize and write_qmod functions now accept a quantum entry point. Instead of synthesize(create_model(main)), write synthesize(main).

​

Enhancements

1. Unreleased local variables of a function are now un-computed and released when calling the function under a compute block of a

​

Bug Fixes

1. Fix control optimization for constant equality conditions (e.g., control(x == 1, ...)) producing wrong circuits under certain conditions.
2. Fix in-place XOR optimization for classical values (e.g., x ^= -0.5) producing wrong circuits under certain conditions.
3. Fix in-place XOR optimization for Boolean expressions (e.g., x ^= (y > 0) & (z > 0)) producing wrong circuits under certain conditions.
4. Fix a bug causing an internal error in arithmetic expression that use comparison, subtraction, or negation (e.g. x > 0.3, 0.2 - x, -x) when synthesizing models with the machine precision set to higher than 8.

​

Library Additions

1. Add the functions amplitude_amplification and exact_amplitude_amplification to the function library.

​

Enhancements

1. The num_qubits argument of function allocate is now optional. If it is not specified, it is inferred automatically according to the quantum type of the allocated variable. Example:
   q = QBit()
   allocate(q)  # allocates one qubit for variable 'q'
   
2. The execute parameter of the QLayer object is now optional. Example:
   QLayer(quantum_program, post_process)
   

​

Deprecations

​

IDE Changes

1. The Application Configuration Panel used for editing examples in the Built-in Apps folder has been removed.
2. Patched dependencies: Katex.

​

Performance Improvements

1. Increase jobs memory.

​

Bug Fixes

1. Fix failed execution jobs which stay in “running” status forever instead of reporting an indicative error.

​

Enhancements

1. Improve overall stability and performance.

​

Enhancements

1. The name argument of local quantum variables is now optional. If a name is not specified, it is inferred automatically from the Python code. For example, it is now possible to write q = QBit() instead of q = QBit("q").
2. Improve the performance of executing multiple primitives inside one ExecutionSession, such as in execute_qaoa.

​

IDE Improvements

​

Deprecations

​

Enhancements

1. Improve error messages.

​

Bug Fixes

1. Fix quantum bits raising an error when used in in-place assignments (^= and +=).
2. Fix quantum struct field access raising an error in lambdas.

​

IDE Improvements

1. Classiq Thumbnail: Updated the Classiq thumbnail image!
2. Links on the IDE model page now directing to Classiq Library.
3. Modify the Quantum Programs URL so that the circuit ID is embedded in its path

​

New Visualization:

• Clean up variable names in engine blocks.
• Corrected the spacing miscalculation for junction dots.
• Refined padding before allocation
• Hide labels in open functional blocks to create a more space-efficient display.
• Removed unnecessary dots and labels for low-level QC elements.

​

Enhancements

1. Generative functions have undergone a round of significant improvements. Check out our DQI notebook to see how generative functions are used to implement advanced quantum algorithms.
2. A new filed optimization_level has been added the Preferences of the synthesis. This field determines the trade-off between synthesis speed and the quality of the results, In terms of the optimization parameter and the constraints. For more information, see here.
3. State vector filtering is available. This is an important step for simulating large circuits with a state vector simulator. For more information, see this page

​

Bug Fixes

1. Fix usage of overlapping quantum array slices (e.g., qbv[1:3] and qbv[2]) in bodies of lambda expressions and control statements.

​

Enhancements

1. Added a new simulator under the Classiq provider, under the name ClassiqNvidiaBackendNames.SIMULATOR_STATEVECTOR. This simulator runs on a GPU and returns a state vector, similar to ClassiqSimulatorBackendNames.SIMULATOR_STATEVECTOR (which runs on a CPU). Thus, it can handle larger circuits. The name "nvidia_state_vector_simulator" is deprecated in favor of ClassiqNvidiaBackendNames.SIMULATOR. See here for more information.

​

Bug Fixes

1. Fix the connectivity map of the rigetti.qpu.ankaa-9q-3 backend in Azure Quantum.
2. Fix the connectivity map of Amazon Braket devices.
3. Fix a bug in the method from_id of ExecutionJob.

​

Deprecations

1. Parameters value and target of functions inplace_add and inplace_xor have been renamed to expression and target_var respectively.
   • In Native Qmod, use += and ^= instead of inplace_add and inplace_xor respectively.

​

IDE

1. Qmod examples on the Model page now contain direct links to their respective tutorials in the Classiq documentation. Simply hover over an algorithm list item from the QMODs list in the left panel and a tooltip will appear with link to the relevant tutorial.

​

New Visualization:

1. Captured variables are now shown as uninitialized.

​

Bug Fixes

1. Operands’ list elements can be used as operands (in expressions such as, e.g., [op_list[0]]).

​

Library Additions

1. Add a demonstration of the Decoded Quantum Interferometry (DQI) algorithm. See notebook.
2. Add the function qsvt_lcu for efficiently encoding QSVT polynomials with indefinite parity.
3. Subsequent invocations to execution primitives inside ExecutionSession now use different random seeds (depending on the initial seed) to avoid getting the exact same simulation results inside a session.

​

IDE Improvements

​

New Visualization:

1. Clean up variable names in engine blocks.

​

Interface Changes

1. ExecutionSession needs now to be explicitly closed, and it is recommended to use it as a context manager. See here for more information.

​

IDE Changes

1. Credentials for Alice & Bob hardware are now optional. Quantum programs run on Alice & Bob backends will use Classiq’s credentials by default.

​

Enhancements

1. Allow different parts of a quantum struct or array to be passed in different sections of a quantum statement:
   @qfunc
   def main() -> None:
       qbv = QArray("qbv")
       allocate(2, qbv)
       # The following line previously raised an exception, but is now valid
       control(qbv[0], lambda: H(qbv[1]))
   

​

Deprecations

1. Using control as a keyword parameter for standard gates (such as CX) is no longer supported. Use ctrl instead.

​

Bug Fixes

1. Fix package dependencies.

​

Enhancements

1. This release introduces a new version to the Quantum Program (QP) visualization tool in parallel to the legacy visualization.
2. The new visualization version offers advanced visualization capabilities that bridge high-level algorithmic descriptions (Qmod) with gate-level implementations, incorporating interactive hierarchical views and data flow analysis.

​

Feature Details

​

Visualization Versions:

• ‘New’ version: Advanced visualization that includes quantum data flow views and new hierarchical block structures.
• ‘Basic’ version: Legacy visualization.

​

Documentation & Support:

​

Known Issues and Limitations:

​

Usage Recommendations

​

Next Steps

​

Bug Fixes

1. Fix walkthrough bug in the IDE.
2. Change the default value of display_url in show(circuit, display_url) to True.

​

Bug Fixes

​

New Features

1. Add an optional else block to the control statement.

​

Bug Fixes

1. Fix Pauli feature map circuit visualization.
2. Add missing len property to QConstants of type CArray (Qmod/Python).

​

Enhancements

1. Qmod/Python: Functions assign, assign_amplitude, inplace_xor, and inplace_add are equivalent to the operators |=, *=, ^=, and += respectively except that they can be used in operands (Python lambda functions):

within(
    lambda: assign(x, y),  # y |= x
    lambda: inplace_xor(y, z),  # z ^= y
)

2. Support non-equation Boolean expressions as control conditions:

@qfunc
def main(a: Output[QBit], b: Output[QBit], res: Output[QBit]) -> None:
    allocate(1, a)
    allocate(1, b)
    allocate(1, res)
    control(a & b, lambda: X(res))

qfunc main(output a: qbit, output b: qbit, output res: qbit) {
  allocate(1, a);
  allocate(1, b);
  allocate(1, res);
  control (a & b) {
    X(res);
  }
}

​

Interface Changes

1. Parameters value and target of functions inplace_add and inplace_xor have been renamed to expression and target_var respectively. Parameters value and target will no longer be supported starting on 02/12/24 at the earliest.

​

Bug Fixes

1. Solve a within-apply bug.

​

Deprecations

1. Python 3.8 is no longer supported in the Python SDK. The minimum supported version is now Python 3.9.

​

Enhancements

1. Optimize in-place XOR variable assignments (x ^= y). (The implementation no longer uses auxiliary qubits.)
2. Improve error messages in CArray (array) parameter declaration.
3. Support array subscripts and struct field access on the left-hand side of in-place arithmetic assignments (qbv[0] ^= 1 and my_Struct.field += 2.5).
4. Optimize the controlled version of QFT arithmetic implementations by skipping controlling the QFT and QFT dagger.

​

Enhancements

1. Introducing generative functions to the Python SDK. Generative functions are @qfuncs that support Python control flow, integration with third-party libraries, and debugging.
2. Execution using IBM devices is available again.
3. New method estimation_cost in ExecutionSession evaluates a quantum circuit given a classical cost function.
4. A new += operator performs

struct_sample = sample.state["my_qstruct"]
field_sample = struct_sample.my_field

​

Library Additions

1. Add two new functions for encoding classical data, encode_in_angle and encode_on_bloch. See notebook.
2. Add a new example for hybrid classical-quantum neural network. See notebook.

​

Interface Changes

1. Parameter control of built-in functions such as CX has been renamed to ctrl. Parameter control will no longer be supported starting on 4/11/24 at the earliest.

​

Bug Fixes

1. Fix classical array slicing in the SDK (my_list[1:3][0]).
2. Fix synthesis of arithmetic operations nested in a within-apply statement when machine_precision is set.
3. Fix in-place arithmetic operations (^=/+=) when the value on the right-hand side is a signed variable that is not aligned with the target variable.

​

Enhancements

1. Optimize synthesis of variable and constant assignments (x ^= y, x += 3).
2. The behavior of synthesis with debug_mode set to False has been changed, such that synthesis process is up to 50% faster. However, the resulting visualized quantum program may lose much of its hierarchical structure. Note that the default value for debug_mode is still True, and this mode’s behavior remains unchanged.
3. The maximum number of shots in a single execution on Nvidia simulators has been increased to 1,000,000.

​

Bug Fixes

1. Improve circuit width estimation when machine_precision is set.
2. Removing the non-gate-based devices from the available AWS Bracket devices.
3. Fix n ^= 1 assignments where n has a single qubit (used to raise an exception).

​

Notice

• With the release of this version (0.52.0), execution with older SDK versions may result in errors or unexpected behavior. To ensure proper execution of your quantum programs via the SDK, please upgrade to the latest version (See instructions guide above).
• The Pydantic package dependency has been upgraded from version 1 to version 2. If you are using an older version of Pydantic in the same environment as our SDK, this may lead to compatibility issues. Note that installing or upgrading the SDK will also update your Pydantic version to V2. It is recommended to verify compatibility across your environment.

​

Bug Fixes

1. Allow the sign qubit of a quantum numeric variable to overlap the fraction digits (e.g., qnum[1, SIGNED, 1]).

​

Notice

• With the release of version 0.52 (scheduled for the week of 06-12.10.2024), execution with older SDK versions might result in errors or unexpected behavior. In order to make sure executions of your quantum programs via the SDK work properly upgrade your SDK to the latest version (See instructions guide above).

​

Enhancements

1. Improve qubit reuse in arithmetic operations when machine_precision is set.
2. Improve error messages when executing circuits on Amazon Braket.
3. Improve error messages when executing the VQE primitive.
4. Support constant assignments: x |= 3, x ^= 3, and x += 3.

​

Bug Fixes

1. Fix in-place XOR assignments (^=) of 1-qubit expressions into multi-qubit variables (used to raise an error).

​

SDK

1. Add a new function, quantum_program_from_qasm, to convert a QASM string into a Quantum Program.

​

Notice

• With the release of version 0.52 (scheduled for the week of 06-12.10.2024), execution with older SDK versions might result in errors or unexpected behavior. In order to make sure executions of your quantum programs via the SDK work properly upgrade your SDK to the latest version (See instructions guide above).

​

Notice

• With the release of version 0.52 (scheduled for the week of 06-12.10.2024), execution with older SDK versions might result in errors or unexpected behavior. In order to make sure executions of your quantum programs via the SDK work properly upgrade your SDK to the latest version (See instructions guide above).

​

Bug Fixes

1. Raise indicative error when circuit cannot be visualized.
2. Fixed synthesis of arithmetic operations nested in a within-apply statement when machine_precision is set.

​

Enhancements

1. Improved error messages.
2. Added SIGNED and UNSIGNED built-in constants to improve readability of QNum types. SDK: QNum[4, SIGNED, 1]. Native: qnum<4, SIGNED, 1>.
3. QNum types can specify just the size property. SDK: QNum[4] and QNum("n", 4). Native: qnum<4>. Such types are unsigned (is_signed=False) integers (fraction_digits=0) by default.
4. Execution on remote providers is no longer subject to any time limit when using ExecutionSession or executing models without classical execution code. Note: simulation on Classiq backends is still subject to time limit.
5. In-place add operations (inplace_add) now support signed variables.

​

Bug Fixes

1. Fixed an operand-related bug. Might occur when calling a function recursively in one of its operands (for example: foo(lambda: foo(...))).
2. Fixed an expression-related bug. Might occur when using the same variable in multiple expressions.
3. Fixed in-place XOR operations (^= / inplace_xor) in the presence of signed variables. The sign variable is now interpreted as part of the significand without special treatment.
4. Fixed synthesis of arithmetic operations nested in a within-apply statement.

​

Interface Changes

1. SDK: Deprecated parameter names in built-in operations were removed.
   • control(ctrl=..., operand=...) => control(ctrl=..., stmt_block=...)
   • within_apply(compute=..., action=...) => within_apply(within=..., apply=...)
   • power(power=..., operand=...) => power(exponent=..., stmt_block=...)
   • invert(operand=) => invert(stmt_block=...)

​

Library Additions

1. Added a new notebook for solving the Differential equation using the HHL Algorithm, to simulate war games.

​

Enhancements

1. Cancelling an execution job will now result in cancellation of any ongoing jobs sent to the provider during the execution. For more information, see Cancellation.

​

Library and Documentation

1. A new tutorial on the Oblivious Amplitude Amplification algorithm was added.

​

SDK

1. The Classiq SDK now supports Python 3.12.

​

Enhancements

1. Improve synthesis performance in unconstrained large models by lowering circuit width via qubit recycling.

​

Deprecations

1. The Classiq SDK will drop support for Python 3.8 near its end-of-life on October 2024.

​

Bug Fixes

1. Fixed nested quantum struct bug.

​

Enhancements

1. Add size attribute to quantum variables:

@qfunc
def main(my_struct: Output[MyStruct]) -> None:
    allocate(my_struct.size, my_struct)

qfunc main(output my_struct: MyStruct) {
  allocate(my_struct.size, my_struct);
}

​

Bug Fixes

1. Fixed a bug related to nested control operations.
2. Fixed a bug related to boolean arithmetic expressions with invert.
3. Fixed a bug related to arithmetic expressions inside within-apply.

​

IDE

1. Add back improved circuit nodes search.
2. Fix bug in Quantum Program page .qprog file extensions uploads.
3. New Quantum Program export option: Quantum programs can now be exported as .qprog files.
4. Poll all active jobs in the job list, not just the selected job.
5. Add support for Alice & Bob hardware configurations in the IDE.

​

Enhancements

1. Add support for arithmetic boolean expressions as conditionals for control statements; see here.
2. Add quantum structs.
3. The element type of quantum arrays can be any quantum type. N-dimensional quantum arrays are supported.
4. Operand parameter names are optional in both Native (qfunc (indicator: qbit) -> qfunc (qbit)) and Python (QCallable[QBit] -> QCallable[Annotated[QBit, "indicator"]]) Qmod.
5. Improve error messages.
6. Provide better circuits for certain boolean arithmetic expressions.
7. Improved qubit reuse and runtime performance for model without constraints.
8. Add solovay_kitaev_max_iterations field to the synthesis preferences, allowing for tuning the accuracy of the Solovay-Kitaev algorithm.
9. Built-in classical functions to decompose/compose a matrix into/from a Hamiltonian. Example of usage:

mat = np.array([[0, 1, 2, 3], [1, 4, 5, 6], [2, 5, 7, 8], [3, 6, 8, 9]])
hamiltonian = matrix_to_hamiltonian(mat)
mat = hamiltonian_to_matrix(hamiltonian)

10. parsed_states, parsed_counts, parsed_state_vector will contain the parsed execution details as lists if a quantum array was used in the model.

@qfunc
def main(qna: Output[QArray[QNum[3, True, 0]]]) -> None:
    allocate(6, qna)
    hadamard_transform(qna)

qp = synthesize(create_model(main))
res = execute(qp).result()
print(res[0].value.parsed_counts[0])

​

Library and Documentation

1. A new tutorial on Hamiltonian simulation for block-encoded Hamiltonians, using QSVT and Qubitization, was added to the library.
2. A new tutorial on solving the discrete Poisson’s equation using the HHL algorithm, combined with quantum sine and cosine transforms, was added to the library; see here.
3. New state preparation functions - prepare_unifrom_trimmed_state, prepare_unifrom_interval_state, see here.
4. Enhanced the Discrete logarithm example to the case where the order is not power of 2, see here.
5. Updated the Quantum Types documentation page.

​

Interface Changes

1. Some builtin operations parameters have been renamed:
   • control(ctrl=..., operand=...) => control(ctrl=..., stmt_block=...)
   • within_apply(compute=..., action=...) => within_apply(within=..., apply=...)
   • power(power=..., operand=...) => power(exponent=..., stmt_block=...)
   • invert(operand=) => invert(stmt_block=...)

​

Deprecations

1. SDK: The @struct decorator has been removed. Define classical structs using @dataclass.
2. The field variance in EstimationResult is deprecated, and will be populated with the value -1 until removed.
3. The field timeout_sec in ExecutionPreferences, and the field job_timeout in AwsBackendPreferences, have been removed.
4. classical arguments in the native language are now inside the parentheses section ((...)) alongside quantum variables and not inside the angle brackets (<...>), the angle brackets section is now considered deprecated. For example, you should migrate: qfunc <a: real> main{...} -> qfunc main(a: real) {...} for info refer to the language reference about functions. A Warning was added to the IDE in the case it is used.

​

Enhancements

• Error mitigation can now be enabled or disabled for IonQ through Azure in the SDK. Default is set to False.

​

IDE

1. Fix infinite loop bug in Quantum Program page.
2. Fix Quantum Program deletion bug on Quantum Program page.

​

Bug Fixes

1. Fixed a bug related to nested control operations.

​

IDE

1. Fix bug in .qprog files upload on Quantum Program page.
2. New Quantum Program export option: Quantum programs can now be exported as .qprog files.

​

Enhancements

1. Support signed quantum numerics in in-place-xor assignments (^=).
2. Support quantum array subscripts in quantum expressions.
3. Support quantum numeric arrays.
4. Improve synthesis performance.
5. Apply an automatic qubit reuse pass when the model is unconstrained.
6. Add user-defined enums.

@qfunc
def main(res: Output[QBit]) -> None:
    allocate(1, res)
    qnv: QArray = QArray("qnv", element_type=QNum[2, False, 0])  # quantum numeric array
    allocate(6, qnv)
    repeat(qnv.len, lambda i: inplace_prepare_int(i + 1, qnv[i]))
    res ^= qnv[0] + qnv[1] == qnv[2]  # array subscripts in expressions

qfunc main(output res: qbit) {
  allocate<1>(res);
  qnv: qnum<2, False, 0>[]; // quantum numeric array
  allocate<6>(qnv);
  repeat (i: qnv.len) { inplace_prepare_int<i + 1>(qnv[i]); }
  res ^= qnv[0] + qnv[1] == qnv[2];  // array subscripts in expressions
}

​

Interface Changes

1. The classical scope in Qmod no longer supports function definitions.
2. The aer_simulator, aer_simulator_statevector, aer_simulator_density_matrix, and aer_simulator_matrix_product_state Classiq backends are no longer accessible in the SDK. Use simulator, simulator_statevector, simulator_density_matrix, and simulator_matrix_product_state instead.
3. The @struct decorator is deprecated and will be removed in a future release. Use @dataclass instead.

​

Bug Fixes

1. Fixed a bug where multiple in-place assignment statements resulted in a 22102 error.
2. Fixed a bug where using the same variable in control operation for both the control operation and the body resulted in a non-indicative error.
3. Fix invert and within-apply variable initialization tracking in native Qmod.
4. Fix division with classical symbolic variables.
5. Fix rogue comma inserted to the chemistry model classical execution code after IDE form update.
6. Fix reporting uninitialized quantum variables in arithmetic expressions as undefined.
7. Fix double execution on devices requiring access tokens.
8. Fix execution configuration being applied only to the first selected device, when one of the selected devices requires an access token.
9. Fix a bug where Grover circuit was incorrect when reflecting about states different than uniform superposition.
10. Fix a synthesis bug that could appear in models that constrain the width and optimize depth or vice versa.

​

IDE

1. Graphical Model tab redesign of nodes (Function call, Output, Assignment).
2. Restructure of node categories (Graphical Model).
3. Fix countries list not loading sometimes during registration.
4. Prevent Qmod editor from crashing when compiler crashes.
5. Redesigned the Accordion and Icon status for jobs.
6. Quantum Program tabs moved to the left drawer.
7. Uploading Quantum Program can now be done using the Upload button on the left drawer.
8. 3 newly introduced tabs of Quantum Program data: Transpiled Info, Program Info, Data.

​

Library Additions

1. A new technology demonstration notebook, treating a discrete quantum walk on a circle, was added to the library; see here.
2. New rainbow options pricing notebooks in the public repository research folder.

​

Enhancements

• Add direct links of all examples from the documentation to Classiq’s library and IDE.

​

Bug fix

• fixed broken links.

​

Bug Fixes

1. Fixed an error related to the translation of certain circuits between synthesis and execution.
2. Fixed an error when calling a function with local variables multiple times.

​

Enhancements

1. HHL workshop was added to the public repository and to the User Guide.
2. It is now possible to use the execution primitives estimate and vqe with models with multiple output ports. The hamiltonian should match all the output ports by their order.
3. Amplitude encoding assignments (ind *= foo(n)) support all quantum numeric variables, not only unsigned fractions.
4. Add support for lookup tables in amplitude encoding assignments, e.g., ind *= [0, 0.5, 0.5, 1][n] where n is an unsigned quantum integer (ind *= subscript([0, 0.5, 0.5, 1], n) in the SDK).
5. A quantum COSINE and SINE transforms of types I and II were added to the open library, see Quantum COSINE and SINE Transforms.
6. New algorithm was added to the library: “Variational Quantum Linear Solver (VQLS) with Linear Combination of Unitaries (LCU) Block Encoding”

7. Alice & Bob provider is now accessible.

​

Interface Changes

1. compute_qaoa_initial_point is now exposed in the SDK directly from classiq package. from classiq import compute_qaoa_initial_point
2. The examples in IDE Flow page are replaced with a new arithmetics example.

​

Bug Fixes

1. Properly evaluate type attributes in main.
   • Native Qmod: qnum’s sign field can be specified with lowercase true/false in main’s signature.
2. Fix execution results received from running on Amazon Braket to be correct when the measured outputs are not all of the variables of the model.
3. Improve language error reporting.

​

IDE

1. Uniform drawer width for all pages
2. New way to trigger node options context menu on Graphical Model page: node options menu can now be triggered by right-clicking a selected node

​

Enhancements

• Performance of synthesis has been improved, most significantly for synthesis requests with no constraints.

​

Enhancements

• Add execution request and execution results to reference manual in the documentation

​

Bug fix

• Fix broken links in documentation

​

Enhancement

1. Hardware-aware synthesis will now use the Solovay-Kitaev algorithm to approximate single-qubit gates when the basis gate set is a specific variation of Clifford + T (X, Z, H, T, CX, and CCX).
2. qsvt function was added to the function library. See Quantum Singular Value Transformation.
3. A tutorial on discrete quantum walks was added to the tutorials library. See Discrete Quantum Walk.
4. SDK: Quantum functions (@qfunc) can be recursive.
5. SDK: PauliTerm can be used to declare a hamiltonian.

hamiltonian = [
    PauliTerm(pauli=[Pauli.I], coefficient=1),
    PauliTerm(pauli=[Pauli.Z, Pauli.X], coefficient=2),
]

6. Introducing ExecutionSession which will allow choosing the execution primitive in the SDK without the need of changing/synthesizing the quantum program once again.

model = create_model(main)
qprog = synthesize(model)
preferences = ExecutionPreferences(num_shots=1200)
execution_session = ExecutionSession(qprog, preferences)

# if the quantum program does not need any execution paramters:
execution_session.sample()

# if the quantum program needs execution parameters:
execution_session.sample({"phi": 1})

# if multiple samples are needed:
execution_session.batch_sample([{"phi": 1}, {"phi": 2}, {"phi": 3}])

# if an estimation is needed without execution parameters:
hamiltonian = [
    PauliTerm(pauli=[Pauli.I], coefficient=1),
    PauliTerm(pauli=[Pauli.Z], coefficient=2),
]
execution_parameters.estimate(hamiltonian)

# if an estimation is needed with execution paramters:
execution_parameters.estimate(hamiltonian, {"theta": 1})

# if multiple estimations are needed:
execution_parameters.batch_estimate(hamiltonian, [{"theta": 1}, {"theta": 2}])

7. A Qmod library reference, with usage examples for built-in and open library functions, can now be found in the function menu.

​

Interface Changes

1. SDK: In execute_qnn, the optional argument observables of type PauliOperators has been replaced with the optional argument observable of type PauliOperator.

​

Deprecations

1. SDK: The quantum_if operation and the old control syntax have been removed.

• quantum_if is removed. Use control instead.
• control(operand, ctrl) is no longer supported. Use control(ctrl, operand) instead.
• control(n, operand) does not support quantum numeric variables (n). Instead, use a bind operation to cast n into a quantum array, or compare n to an integer explicitly (e.g., n == 7).

2. SDK: The QParam type has been removed.

• Instead of QParam[int], use CInt.
• Instead of QParam[float], use CReal.
• Instead of QParam[bool], use CBool.
• Instead of QParam[List[...]], use CArray[...].
• Instead of QParam[Array[..., size]], use CArray[..., size].

3. Native Qmod: Accessing quantum variable properties (e.g., qbv.len or n.is_signed) via function call syntax (len(qbv), is_signed(qbv)) is no longer supported.
4. The field optimizer_preferences of ExecutionPreferences has been removed.
5. The function set_initial_values has been removed.

​

IDE

1. “Slack” and “Learn More” links were moved from the side drawer to the IDE header. New links were added as well: Community, User Guide.
2. Allow visualization of larger circuits and prolong the timeout for visualization
3. Users can now download a LaTeX format of their quantum programs directly from the IDE, allowing for easy sharing, publication, and presentation of their work.
4. Cookies settings are now available to adjust the given consent at any time.

​

Bug fixes

1. “selected example not found” error when opening the IDE
2. Resetting now clears preferences form instead of initializing from cache on the model page
3. Naming for exported files on the Graphical Editor
4. State vector measurement results ordering
5. Parameter names in lambda expressions don’t have to match the parameter names in operand declarations:

@qfunc
def my_H(qb: QBit) -> None:
    H(qb)


...
apply_to_all(my_H, qba)  # used to throw an error since "qb" != "target"

qfunc my_H(qb: qbit) {
    H(qb);
}
...
apply_to_all<my_H>(qba); // used to throw an error since "qb" != "target"

​

Interface Changes

1. The control and quantum_if statements have been unified into one statement in native Qmod and the SDK under the name control.
   • SDK: The unified control statement accepts a qbit (q), a q-array (qbv), or a comparison of a qnum and an integer (n == 5) as the first argument.
   • SDK: The old control syntax (with ctrl as the second argument) is deprecated and will be removed in the next release.
   • SDK: The quantum_if operator is deprecated and will be removed in the next release.
   • Native Qmod: quantum_if is no longer supported, use the new control statement instead.
2. SDK: The QParam and Array types are deprecated and will be removed in the next release.
   • Instead of QParam[int], use CInt.
   • Instead of QParam[float], use CReal.
   • Instead of QParam[bool], use CBool.
   • Instead of QParam[List[...]], use CArray[...].
   • Instead of QParam[Array[..., size]], use CArray[..., size].
3. SDK: Using Python types (int, bool, etc.) in struct declarations (@struct) is deprecated and will not be supported by the next release. Instead, use classical data types (CInt, CBool, etc., see above).
4. Default timeout for sending jobs to AWS changed from 5 minutes to 4 hours.

​

Deprecations

1. The error mitigation settings in the execution preferences are no longer available.
2. The aer_simulator backend has been removed. Use Classiq’s simulator backend instead (ClassiqSimulatorBackendNames.SIMULATOR).

​

Enhancements

1. Improved error messages.

​

Bug fixes

1. Fixed a bug preventing execution of circuits synthesized with hardware aware synthesis on Azure and IonQ.

​

Enhancements

1. Improved the native Qmod syntax of the repeat, if statements. For details, see Classical Control Flow.
2. Improved the native Qmod syntax of the control, power, and invert statements. For details, see Quantum Operators.
3. Added the classiq.execution.all_hardware_devices.get_all_hardware_devices function to the Python SDK.

​

Deprecations

1. In the SDK, the classiq.analyzer.analyzer.Analyzer.get_available_devices method is deprecated. Use classiq.execution.all_hardware_devices.get_all_hardware_devices instead.

​

Interface Changes

1. The len method for QArray, QCallableList, and QParam of lists, is now a property. use .len instead of .len().

​

Overview

1. In the IDE, Synthesis page is now removed. Writing and synthesizing models is now done exclusively in the Model page.
2. All pre-defined models previously available in the Synthesis page in Json format are now available in the Model page in native Qmod syntax.
3. Many Qmod language enhancements were introduced to enable the coding of all available models and applications, in both native Qmod and in its Python embedding (see detailed list below).
4. A new Qmod reference manual, covering all the language concepts and constructs in both input formats, is available Qmod-language-reference.
5. Documentation content covering old input formats - the Json input and the old SDK classes - has been removed

​

Language and SDK Enhancements

1. Native Qmod now supports classical POD struct declaration, initialization, and member access.
2. Native Qmod now supports within-apply statements.
3. Native Qmod now supports generalized in-place quantum assignment.
4. Add method parsed_counts_of_outputs to sample’s result in the Python SDK, see sample.
5. Constants can now be used in the qmod-python integration with the QConstant class.
6. Native Qmod now supports global constants.
7. The quantum numeric type can now receive sign and fraction digits as type arguments in parameter declarations, in both the SDK and native Qmod.
   • Native Qmod example: qnum<5, True, 2> to indicate a 5-bit signed number with 2 fraction digits.
   • SDK examples:
     • QNum[5, True, 2] to indicate a 5-bit signed number with 2 fraction digits (as a function argument)
     • QNum("x", 5, True, 2) to indicate a 5-bit signed number with 2 fraction digits (as a local variable)
8. The amplitude encoding flavor of quantum arithmetic (*= operator) is now an in-place operation in both the SDK and native Qmod.

​

Interface Changes

1. The QStruct decorator was renamed to struct in the qmod-python integration.
2. The qfunc decorator is renamed to quantum_function. The newer QFunc and ExternalQFunc decorator are now available as qfunc and qfunc(external=True). Using either classes as a decorator is deprecated, and this feature may be removed in a future release.
3. Similarly, a new cfunc decorator is now available, and using the class CFunc as a decorator is deprecated and may be removed in the future.
4. Renamed GeneratedCircuit to QuantumProgram in the SDK.
5. The QNum type does not accept size argument without sign and fraction digits.
6. QNum on the right-hand side of bind statements must have sign and fraction digits (inferred from initialization or declaration).
7. The Following async methods were removed from Analyzer class (The documented methods without the async suffix are still available and can be used instead):
   1. get_available_devices_async
   2. analyzer_app_async
   3. plot_hardware_connectivity_async
   4. get_hardware_comparison_table_async
8. The method show_multiple_hardware_data was removed from RBAnalysis class. The async equivalent show_multiple_hardware_data_async can be used instead.
9. Removed reinterpret_num operation (instead use QNum/allocate_num arguments).
10. Removed split and join operation (instead use bind operation).