classiq 0.100.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

classiq/__init__.py

@@ -68,6 +68,8 @@ from classiq.synthesis import (
     update_execution_preferences,
     update_preferences,
 )
+from classiq.synthesis_action import *  # noqa: F403
+from classiq.synthesis_action import __all__ as _synthesis_all
 
 _application_constructors_all = [
     "construct_combinatorial_optimization_model",
@@ -124,6 +126,7 @@ __all__ = (
     + _application_constructors_all
     + _qmod_all
     + _execution_all
+    + _synthesis_all
     + _open_library_all
     + _be_all
 )

classiq/_internals/api_wrapper.py

@@ -20,6 +20,7 @@ from classiq.interface.executor.quantum_program_params import (
 )
 from classiq.interface.executor.user_budget import UserBudget
 from classiq.interface.generator import quantum_program as generator_result
+from classiq.interface.generator.generation_request import SynthesisActionsQueryResults
 from classiq.interface.generator.preferences.qasm_to_qmod_params import QasmToQmodParams
 from classiq.interface.hardware import HardwareInformation, Provider
 from classiq.interface.ide.visual_model import ProgramVisualModel
@@ -321,18 +322,42 @@ class ApiWrapper:
         offset: int,
         limit: int,
         http_client: httpx.AsyncClient | None = None,
+        **extra_query_params: Any,
     ) -> execution_request.ExecutionJobsQueryResults:
+        params: dict[str, Any] = {
+            "offset": offset,
+            "limit": limit,
+        }
+        params.update(extra_query_params)
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
-            params={
-                "offset": offset,
-                "limit": limit,
-            },
+            params=params,
             http_client=http_client,
         )
         return execution_request.ExecutionJobsQueryResults.model_validate(data)
 
+    @classmethod
+    async def call_query_synthesis_actions(
+        cls,
+        offset: int,
+        limit: int,
+        http_client: httpx.AsyncClient | None = None,
+        **extra_query_params: Any | None,
+    ) -> SynthesisActionsQueryResults:
+        params: dict[str, Any] = {
+            "offset": offset,
+            "limit": limit,
+        }
+        params.update(extra_query_params)
+        data = await cls._call_task(
+            http_method=HTTPMethod.GET,
+            url=f"{routes.TASKS_GENERATE_FULL_PATH}",
+            params=params,
+            http_client=http_client,
+        )
+        return SynthesisActionsQueryResults.model_validate(data)
+
     @classmethod
     async def call_analysis_task(
         cls,

classiq/applications/chemistry/op_utils.py

@@ -1,10 +1,11 @@
+import warnings
 from typing import cast
 
 import numpy as np
 from openfermion.ops.operators.qubit_operator import QubitOperator
 from openfermion.utils.operator_utils import count_qubits
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 
 from classiq.qmod.builtins.enums import Pauli
 from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp, SparsePauliTerm
@@ -25,6 +26,13 @@ def _get_n_qubits(qubit_op: QubitOperator, n_qubits: int | None) -> int:
 def qubit_op_to_pauli_terms(
     qubit_op: QubitOperator, n_qubits: int | None = None
 ) -> SparsePauliOp:
+    warnings.warn(
+        "The function 'qubit_op_to_pauli_terms' is deprecated due to incorrect order "
+        "of qubits in its result. It will no longer be supported starting on 2026-01-22 "
+        "at the earliest. Please use 'qubit_op_to_qmod' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=2,
+    )
     n_qubits = _get_n_qubits(qubit_op, n_qubits)
     return SparsePauliOp(
         terms=[
@@ -44,6 +52,60 @@ def qubit_op_to_pauli_terms(
     )
 
 
+def qubit_op_to_qmod(
+    qubit_op: QubitOperator, n_qubits: int | None = None
+) -> SparsePauliOp:
+    n_qubits = _get_n_qubits(qubit_op, n_qubits)
+    return SparsePauliOp(
+        terms=[
+            SparsePauliTerm(
+                paulis=[  # type:ignore[arg-type]
+                    IndexedPauli(
+                        pauli=getattr(Pauli, pauli),
+                        index=qubit,
+                    )
+                    for qubit, pauli in term
+                ],
+                coefficient=coeff,
+            )
+            for term, coeff in qubit_op.terms.items()
+        ],
+        num_qubits=n_qubits,
+    )
+
+
+def qmod_to_qubit_op(operator: SparsePauliOp) -> QubitOperator:
+    """
+    Transforms Qmod's SparsePauliOp data structure to OpenFermion's QubitOperator data structure.
+
+    Args:
+        operator (SparsePauliOp): The operator to be transformed
+
+    Returns:
+        QubitOperator: The operator in OpenFermion's data structure
+    """
+
+    # Initiating the QubitOperator as the 0 operator
+    qo = QubitOperator()
+    for sparse_pauli_term in operator.terms:
+        # loop over all the IndexedPaulis
+        coeff = sparse_pauli_term.coefficient
+        if sparse_pauli_term.paulis:
+            qo.terms[
+                tuple(
+                    [
+                        (p.index, p.pauli.name)
+                        for p in sparse_pauli_term.paulis  # type: ignore[attr-defined]
+                        if p.pauli is not Pauli.I
+                    ]
+                )
+            ] = coeff
+        # Operator is the identity
+        else:
+            qo.terms[()] = coeff
+    return qo
+
+
 _PAULIS_TO_XZ = {"I": (0, 0), "X": (1, 0), "Z": (0, 1), "Y": (1, 1)}
 _XZ_TO_PAULIS = {(0, 0): "I", (1, 0): "X", (0, 1): "Z", (1, 1): "Y"}
 

classiq/applications/chemistry/problems.py

@@ -1,3 +1,4 @@
+import warnings
 from collections.abc import Sequence
 from typing import cast
 
@@ -9,7 +10,7 @@ from openfermion.transforms import (
 )
 from openfermion.utils import count_qubits
 
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 
 
 class FermionHamiltonianProblem:
@@ -21,7 +22,7 @@ class FermionHamiltonianProblem:
     Attributes:
         fermion_hamiltonian (FermionOperator): The fermionic hamiltonian of the problem.
             Assumed to be in the block-spin labeling.
-        n_orbitals (int): Number of spatial orbitlas.
+        n_orbitals (int): Number of spatial orbitals.
         n_alpha (int): Number of alpha particles.
         n_beta (int): Number of beta particles.
         n_particles (tuple[int, int]): Number of alpha and beta particles.
@@ -116,6 +117,7 @@ class FermionHamiltonianProblem:
         molecule: MolecularData,
         first_active_index: int = 0,
         remove_orbitlas: Sequence[int] | None = None,
+        remove_orbitals: Sequence[int] | None = None,
         op_compression_tol: float = 1e-13,
     ) -> "FermionHamiltonianProblem":
         """
@@ -125,12 +127,22 @@ class FermionHamiltonianProblem:
             molecule (MolecularData): The molecule data.
             first_active_index (int): The first active index, indicates all prior
                 indices are freezed.
-            remove_orbitlas (Sequence[int], optional): Active indices to be removed.
+            remove_orbitals (Sequence[int], optional): Active indices to be removed.
             op_compression_tol (float): Tolerance for trimming the fermion operator.
 
         Returns:
             The fermion hamiltonian problem.
         """
+        if remove_orbitlas is not None:
+            warnings.warn(
+                "The `remove_orbitlas` parameter is deprecated and will not longer be "
+                "supported starting on 2026-01-15 at the earliest. Use the "
+                "'remove_orbitals' parameter instead",
+                ClassiqDeprecationWarning,
+                stacklevel=2,
+            )
+            remove_orbitals = remove_orbitlas
+
         if molecule.n_orbitals is None:
             raise ClassiqValueError(
                 "The molecular data is not populated. Hint: call `run_pyscf` with the molecule."
@@ -145,8 +157,8 @@ class FermionHamiltonianProblem:
 
         freezed_indices = list(range(first_active_index))
         active_indices = list(range(first_active_index, molecule.n_orbitals))
-        if remove_orbitlas:
-            active_indices = list(set(active_indices) - set(remove_orbitlas))
+        if remove_orbitals:
+            active_indices = list(set(active_indices) - set(remove_orbitals))
 
         molecular_hamiltonian = molecule.get_molecular_hamiltonian(
             occupied_indices=freezed_indices,
@@ -167,7 +179,7 @@ class FermionHamiltonianProblem:
                 f"and {n_particles} electrons. "
                 f"This can happen if too many orbitals were frozen."
                 f"Before freezing number of particle was ({n_alpha, n_beta})."
-                f"Consider adjusting `first_active_index` or `remove_orbitlas` "
+                f"Consider adjusting `first_active_index` or `remove_orbitals` "
                 f"to ensure the active space is non-empty."
             )
 

classiq/applications/chemistry/ucc.py

@@ -6,7 +6,7 @@ from openfermion.ops.operators.fermion_operator import FermionOperator
 from openfermion.ops.operators.qubit_operator import QubitOperator
 
 from classiq.applications.chemistry.mapping import FermionToQubitMapper
-from classiq.applications.chemistry.op_utils import qubit_op_to_pauli_terms
+from classiq.applications.chemistry.op_utils import qubit_op_to_qmod
 from classiq.applications.chemistry.problems import FermionHamiltonianProblem
 from classiq.qmod.builtins.structs import (
     SparsePauliOp,
@@ -44,7 +44,7 @@ def get_ucc_hamiltonians(
 
     n_qubits = mapper.get_num_qubits(problem)
     return [
-        qubit_op_to_pauli_terms(q_op, n_qubits)
+        qubit_op_to_qmod(q_op, n_qubits)
         for f_op in f_ops
         if (q_op := mapper.map(f_op))
         not in (

classiq/evaluators/parameter_types.py

@@ -133,9 +133,6 @@ def _evaluate_type_from_arg(
     # FIXME: Remove suzuki_trotter overloading (CLS-2912)
     if closure.name == "suzuki_trotter" and parameter.name == "pauli_operator":
         return parameter
-    # FIXME: Remove qdrift overloading (CLS-4347)
-    if closure.name == "qdrift" and parameter.name == "pauli_operator":
-        return parameter
     if isinstance(parameter, ClassicalParameterDeclaration):
         return _evaluate_classical_type_from_arg(parameter, argument, closure)
     if isinstance(parameter, PortDeclaration):
@@ -257,7 +254,7 @@ def _evaluate_op_type_from_arg(
             first_lambda = arg_val[0]
             if isinstance(first_lambda, FunctionClosure):
                 _raise_argument_type_error(
-                    arg_val,
+                    f"[{', '.join(['<lambda>'] * len(arg_val))}]",
                     first_lambda.as_operand_declaration(is_list=True),
                     parameter.name,
                     parameter,

classiq/evaluators/qmod_annotated_expression.py

@@ -207,7 +207,7 @@ class QmodAnnotatedExpression:
             node = id(node)
         return node in self._quantum_subscripts
 
-    def get_quantum_subcript(
+    def get_quantum_subscript(
         self, node: ast.AST | QmodExprNodeId
     ) -> QuantumSubscriptAnnotation:
         if isinstance(node, ast.AST):

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -77,7 +77,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         self,
         expr_val: QmodAnnotatedExpression,
         *,
-        treat_qnum_as_float: bool = False,
         machine_precision: int = DEFAULT_MACHINE_PRECISION,
         classical_struct_declarations: Sequence[StructDeclaration] | None = None,
         enum_declarations: Sequence[EnumDeclaration] | None = None,
@@ -88,7 +87,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
         scope: Mapping[str, Any] | None = None,
     ) -> None:
         self._expr_val = expr_val
-        self._treat_qnum_as_float = treat_qnum_as_float
         self._machine_precision = machine_precision
         self._classical_struct_decls = nameables_to_dict(
             classical_struct_declarations or []
@@ -114,9 +112,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit_BinOp(self, node: ast.BinOp) -> None:
         super().generic_visit(node)
-        eval_binary_op(
-            self._expr_val, node, self._treat_qnum_as_float, self._machine_precision
-        )
+        eval_binary_op(self._expr_val, node, self._machine_precision)
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> None:
         super().generic_visit(node)
@@ -164,7 +160,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
                 self._expr_val,
                 node,
                 func_name,
-                self._treat_qnum_as_float,
                 self._machine_precision,
             )
             return
@@ -256,7 +251,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 def evaluate_qmod_expression(
     expr: str,
     *,
-    treat_qnum_as_float: bool = False,
     machine_precision: int = DEFAULT_MACHINE_PRECISION,
     classical_struct_declarations: Sequence[StructDeclaration] | None = None,
     enum_declarations: Sequence[EnumDeclaration] | None = None,
@@ -270,7 +264,6 @@ def evaluate_qmod_expression(
     expr_value = QmodAnnotatedExpression(expr_ast)
     QmodExpressionEvaluator(
         expr_value,
-        treat_qnum_as_float=treat_qnum_as_float,
         machine_precision=machine_precision,
         classical_struct_declarations=classical_struct_declarations,
         enum_declarations=enum_declarations,

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -122,7 +122,7 @@ class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
 
 class _SympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
-        if len(node.values) != 2:
+        if len(node.values) < 2:
             raise ClassiqInternalExpansionError
         node = cast(ast.BoolOp, self.generic_visit(node))
         if isinstance(node.op, ast.Or):

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -107,7 +107,7 @@ def _eval_type_attribute(
     if isinstance(subject_type, QuantumNumeric):
         if attr == "is_signed":
             expr_val.set_type(node, Bool())
-            if subject_type.has_sign:
+            if subject_type.has_constant_sign:
                 expr_val.set_value(node, subject_type.sign_value)
                 _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
@@ -120,7 +120,7 @@ def _eval_type_attribute(
             return
         if attr == "fraction_digits":
             expr_val.set_type(node, Integer())
-            if subject_type.has_fraction_digits:
+            if subject_type.has_constant_fraction_digits:
                 expr_val.set_value(node, subject_type.fraction_digits_value)
                 _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -50,7 +50,6 @@ def _validate_binary_op(
     op: ast.AST,
     left_type: QmodType,
     right_type: QmodType,
-    treat_qnum_as_float: bool,
 ) -> None:
     if not _binary_op_allowed(left_type, right_type, op):
         raise ClassiqExpansionError(
@@ -76,20 +75,19 @@ def _validate_binary_op(
             f"Binary operation {type(op).__name__!r} is not supported"
         )
 
-    if not treat_qnum_as_float:
-        if isinstance(op, ast.FloorDiv) and (
-            not is_classical_type(left_type) or not is_classical_type(right_type)
-        ):
-            raise ClassiqExpansionError(
-                f"{type(op).__name__!r} with quantum variables is not supported"
-            )
+    if isinstance(op, ast.FloorDiv) and (
+        not is_classical_type(left_type) or not is_classical_type(right_type)
+    ):
+        raise ClassiqExpansionError(
+            f"{type(op).__name__!r} with quantum variables is not supported"
+        )
 
-        if not is_classical_type(right_type) and isinstance(
-            op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
-        ):
-            raise ClassiqExpansionError(
-                f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
-            )
+    if not is_classical_type(right_type) and isinstance(
+        op, (ast.Div, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+    ):
+        raise ClassiqExpansionError(
+            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+        )
 
 
 def _infer_binary_op_type(
@@ -98,7 +96,6 @@ def _infer_binary_op_type(
     left_type: QmodType,
     right_type: QmodType,
     machine_precision: int,
-    treat_qnum_as_float: bool,
 ) -> QmodType:
     op = node.op
 
@@ -113,19 +110,13 @@ def _infer_binary_op_type(
             return Integer()
         return Real()
 
-    left_attrs = get_numeric_attrs(
-        expr_val, node.left, left_type, machine_precision, treat_qnum_as_float
-    )
-    right_attrs = get_numeric_attrs(
-        expr_val, node.right, right_type, machine_precision, treat_qnum_as_float
-    )
+    left_attrs = get_numeric_attrs(expr_val, node.left, left_type, machine_precision)
+    right_attrs = get_numeric_attrs(expr_val, node.right, right_type, machine_precision)
 
     if left_attrs is None or right_attrs is None:
         return QuantumNumeric()
 
-    right_value = get_classical_value_for_arithmetic(
-        expr_val, node.right, right_type, treat_qnum_as_float
-    )
+    right_value = get_classical_value_for_arithmetic(expr_val, node.right, right_type)
 
     if isinstance(op, ast.Add):
         result_attrs = compute_result_attrs_add(
@@ -157,14 +148,14 @@ def _infer_binary_op_type(
         return QuantumNumeric()
 
     elif isinstance(op, ast.Mod):
-        if right_value is None or treat_qnum_as_float:
+        if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_modulo(
             left_attrs, right_attrs, machine_precision
         )
 
     elif isinstance(op, ast.Pow):
-        if right_value is None or treat_qnum_as_float:
+        if right_value is None:
             return QuantumNumeric()
         result_attrs = compute_result_attrs_power(
             left_attrs, right_attrs, machine_precision
@@ -252,7 +243,6 @@ def _eval_binary_op_constant(
 def eval_binary_op(
     expr_val: QmodAnnotatedExpression,
     node: ast.BinOp,
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> None:
     left = node.left
@@ -261,7 +251,7 @@ def eval_binary_op(
 
     left_type = expr_val.get_type(left)
     right_type = expr_val.get_type(right)
-    _validate_binary_op(op, left_type, right_type, treat_qnum_as_float)
+    _validate_binary_op(op, left_type, right_type)
 
     inferred_type = _infer_binary_op_type(
         expr_val,
@@ -269,7 +259,6 @@ def eval_binary_op(
         left_type,
         right_type,
         machine_precision,
-        treat_qnum_as_float,
     )
     expr_val.set_type(node, inferred_type)
 

classiq/evaluators/qmod_node_evaluators/min_max_evaluation.py

@@ -31,7 +31,6 @@ def _infer_min_max_op_type(
     node: ast.Call,
     func_name: str,
     args_types: list[QmodType],
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> QmodType:
     if all(is_classical_type(arg_type) for arg_type in args_types):
@@ -41,9 +40,7 @@ def _infer_min_max_op_type(
 
     args_attrs: list[NumericAttributes] = []
     for arg, arg_type in zip(node.args, args_types):
-        attrs = get_numeric_attrs(
-            expr_val, arg, arg_type, machine_precision, treat_qnum_as_float
-        )
+        attrs = get_numeric_attrs(expr_val, arg, arg_type, machine_precision)
         if attrs is None:
             return QuantumNumeric()
         args_attrs.append(attrs)
@@ -62,7 +59,6 @@ def eval_min_max_op(
     expr_val: QmodAnnotatedExpression,
     node: ast.Call,
     func_name: str,
-    treat_qnum_as_float: bool,
     machine_precision: int,
 ) -> None:
     if len(node.args) < 1:
@@ -79,7 +75,6 @@ def eval_min_max_op(
         node,
         func_name,
         args_types,
-        treat_qnum_as_float,
         machine_precision,
     )
     expr_val.set_type(node, inferred_type)

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -21,14 +21,11 @@ def get_numeric_attrs(
     node: ast.AST,
     qmod_type: QmodType,
     machine_precision: int,
-    treat_qnum_as_float: bool,
 ) -> NumericAttributes | None:
     if isinstance(qmod_type, Bool):
         return NumericAttributes.from_bounds(0, 1, 0, machine_precision)
     if is_classical_type(qmod_type):
-        value = get_classical_value_for_arithmetic(
-            expr_val, node, qmod_type, treat_qnum_as_float
-        )
+        value = get_classical_value_for_arithmetic(expr_val, node, qmod_type)
         if value is None:
             return None
         return NumericAttributes.from_constant(value, machine_precision)
@@ -44,7 +41,6 @@ def get_classical_value_for_arithmetic(
     expr_val: QmodAnnotatedExpression,
     node: ast.AST,
     qmod_type: QmodType,
-    treat_qnum_as_float: bool,
 ) -> float | None:
     if not is_classical_type(qmod_type):
         return None
@@ -55,8 +51,6 @@ def get_classical_value_for_arithmetic(
     if isinstance(value, sympy.Basic):
         value = get_sympy_val(value)
     if not isinstance(value, (int, float)):
-        if treat_qnum_as_float and isinstance(value, complex):
-            return None
         raise ClassiqExpansionError(
             "Arithmetic of quantum variables and non-real values is not supported"
         )

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -2,7 +2,10 @@ from typing import Union, cast
 
 import sympy
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
@@ -108,7 +111,7 @@ def get_sympy_val(val: sympy.Basic) -> bool | int | float | complex:
         hasattr(val, "is_imaginary") and val.is_imaginary
     ):
         return complex(val)
-    raise ClassiqInternalExpansionError("Unidentified sympy value")
+    raise ClassiqExpansionError(f"{str(val)!r} is not a number")
 
 
 def get_sympy_type(val: sympy.Basic) -> ClassicalType:
@@ -124,4 +127,4 @@ def get_sympy_type(val: sympy.Basic) -> ClassicalType:
         or (hasattr(val, "is_imaginary") and val.is_imaginary)
     ):
         return Real()
-    raise ClassiqInternalExpansionError("Unidentified sympy value")
+    raise ClassiqExpansionError(f"{str(val)!r} is not a number")

classiq/evaluators/qmod_type_inference/quantum_type_comparison.py

@@ -0,0 +1,52 @@
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+
+def _compare_expressions(expr1: Expression | None, expr2: Expression | None) -> bool:
+    if expr1 is None:
+        return expr2 is None
+    if expr2 is None:
+        return False
+    return expr1.expr == expr2.expr
+
+
+def compare_quantum_types(type_1: QuantumType, type_2: QuantumType) -> bool:
+    for qmod_type in (type_1, type_2):
+        if isinstance(qmod_type, TypeName) and not qmod_type.has_fields:
+            raise ClassiqInternalExpansionError("Quantum struct expected")
+    if isinstance(type_1, QuantumBit):
+        return isinstance(type_2, QuantumBit)
+    if isinstance(type_1, QuantumNumeric):
+        return (
+            isinstance(type_2, QuantumNumeric)
+            and _compare_expressions(type_1.size, type_2.size)
+            and _compare_expressions(type_1.is_signed, type_2.is_signed)
+            and _compare_expressions(type_1.fraction_digits, type_2.fraction_digits)
+        )
+    if isinstance(type_1, QuantumBitvector):
+        return (
+            isinstance(type_2, QuantumBitvector)
+            and _compare_expressions(type_1.length, type_2.length)
+            and compare_quantum_types(type_1.element_type, type_2.element_type)
+        )
+    if isinstance(type_1, TypeName):
+        return (
+            isinstance(type_2, TypeName)
+            and type_1.name == type_2.name
+            and all(
+                compare_quantum_types(field_type_1, field_type_2)
+                for field_type_1, field_type_2 in zip(
+                    type_1.fields.values(), type_2.fields.values(), strict=True
+                )
+            )
+        )
+    raise ClassiqInternalExpansionError(f"Unexpected type {type(type_1).__name__}")

classiq/execution/__init__.py

@@ -8,7 +8,14 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
 from .execution_session import ExecutionSession
-from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
+from .jobs import (
+    ExecutionJob,
+    ExecutionJobFilters,
+    get_execution_actions,
+    get_execution_actions_async,
+    get_execution_jobs,
+    get_execution_jobs_async,
+)
 from .qnn import execute_qnn
 from .user_budgets import (
     clear_budget_limit,
@@ -28,6 +35,9 @@ __all__ = (
         "VQESolverResult",
         "IQAEResult",
         "ExecutionJob",
+        "ExecutionJobFilters",
+        "get_execution_actions",
+        "get_execution_actions_async",
         "get_execution_jobs",
         "get_execution_jobs_async",
         "ExecutionSession",

classiq/execution/execution_session.py

@@ -365,7 +365,7 @@ class ExecutionSession:
              A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration. `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
 
         See Also:
-            The [Classiq Tutorial](https://docs.classiq.io/latest/getting-started/classiq_tutorial/execution_tutorial_part2/) has examples on using this method in variational quantum algorithms.
+            The [Execution Tutorial](https://docs.classiq.io/latest/getting-started/classiq_tutorial/execution_tutorial_part2/) has examples on using this method in variational quantum algorithms.
             More information about [Hamiltonians](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians).
         """
         _hamiltonian_deprecation_warning(cost_function)

classiq/execution/functions/__init__.py

@@ -0,0 +1,3 @@
+from classiq.execution.functions.sample import _new_sample
+
+__all__ = ["_new_sample"]