classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/{applications_model_constructors → applications/finance}/finance_model_constructor.py

@@ -1,6 +1,7 @@
 from math import floor, log
 from typing import Union
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.finance.function_input import FinanceFunctionInput
 from classiq.interface.finance.gaussian_model_input import GaussianModelInput
 from classiq.interface.finance.log_normal_model_input import LogNormalModelInput
@@ -8,23 +9,22 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_type import QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
-from classiq.applications_model_constructors.libraries.ampltitude_estimation_library import (
-    AE_CLASSICAL_LIBRARY,
-)
-from classiq.applications_model_constructors.libraries.qmci_library import QMCI_LIBRARY
-from classiq.exceptions import ClassiqError
+from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
-_OUTPUT_VARIABLE_NAME = "result"
+_OUTPUT_VARIABLE_NAME = "payoff_estimation"
 
 
 def construct_finance_model(
@@ -58,7 +58,7 @@ def construct_finance_model(
     if finance_function_input.tail_probability is not None:
         tail_probability = finance_function_input.tail_probability
 
-    finance_function_object = f"struct_literal(FinanceFunction, f={finance_function_input.f}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
+    finance_function_object = f"struct_literal(FinanceFunction, f={qmod_val_to_expr_str(finance_function_input.f)}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
     num_unitary_qubits = total_num_qubits + 1
 
     model = Model(
@@ -66,57 +66,63 @@ def construct_finance_model(
             *QMCI_LIBRARY,
             NativeFunctionDefinition(
                 name="main",
-                port_declarations={
-                    "phase_port": PortDeclaration(
+                positional_arg_declarations=[
+                    PortDeclaration(
                         name="phase_port",
-                        size=Expression(expr=f"{phase_port_size}"),
+                        quantum_type=QuantumNumeric(
+                            size=Expression(expr=f"{phase_port_size}"),
+                            is_signed=Expression(expr="False"),
+                            fraction_digits=Expression(expr=f"{phase_port_size}"),
+                        ),
                         direction=PortDeclarationDirection.Output,
                     ),
-                },
+                ],
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
+                    Allocate(
+                        size=Expression(expr=f"{num_unitary_qubits}"),
+                        target=HandleBinding(name="unitary_port"),
+                    ),
+                    Allocate(
+                        size=Expression(expr=f"{phase_port_size}"),
+                        target=HandleBinding(name="phase_port"),
+                    ),
                     QuantumFunctionCall(
                         function="qmci",
-                        params={
-                            "num_phase_qubits": Expression(expr=f"{phase_port_size}"),
-                            "num_unitary_qubits": Expression(
-                                expr=f"{num_unitary_qubits}"
-                            ),
-                        },
-                        operands={
-                            "sp_op": QuantumLambdaFunction(
+                        positional_args=[
+                            QuantumLambdaFunction(
+                                pos_rename_params=["state", "ind"],
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
-                                        params={
-                                            "finance_model": Expression(
-                                                expr=finance_model
-                                            ),
-                                            "finance_function": Expression(
-                                                expr=finance_function_object
-                                            ),
-                                        },
-                                        inouts={
-                                            "func_port": HandleBinding(name="reg"),
-                                            "obj_port": HandleBinding(name="ind"),
-                                        },
+                                        positional_args=[
+                                            Expression(expr=finance_model),
+                                            Expression(expr=finance_function_object),
+                                            HandleBinding(name="state"),
+                                            HandleBinding(name="ind"),
+                                        ],
                                     ),
                                 ],
                             ),
-                        },
-                        outputs={
-                            "phase_port": HandleBinding(name="phase_port"),
-                            "unitary_port": HandleBinding(name="unitary_port"),
-                        },
+                            HandleBinding(name="phase_port"),
+                            HandleBinding(name="unitary_port"),
+                        ],
                     ),
                 ],
             ),
         ],
-        classical_execution_code=AE_CLASSICAL_LIBRARY
-        + f"""
-estimation = execute_amplitude_estimation({phase_port_size})
-{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, estimation)
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
+        classical_execution_code=f"""
+phase_port_size = {phase_port_size}
+counts = sample()
+save({{"counts": counts}})
+probability_estimation = qae_with_qpe_result_post_processing(
+    estimation_register_size=phase_port_size,
+    estimation_method=1,
+    result=counts
+)
+save({{"probability_estimation": probability_estimation}})
+{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, probability_estimation)
+save({{"{_OUTPUT_VARIABLE_NAME}": {_OUTPUT_VARIABLE_NAME}}})
+""".strip(),
     )
     return model.get_model()

classiq/applications/grover/__init__.py

@@ -0,0 +1,9 @@
+from .grover_model_constructor import construct_grover_model
+
+__all__ = [
+    "construct_grover_model",
+]
+
+
+def __dir__() -> list[str]:
+    return __all__

classiq/{applications_model_constructors → applications/grover}/grover_model_constructor.py

@@ -1,9 +1,8 @@
-from typing import Dict, List, Tuple
-
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
 from classiq.interface.model.model import Model, SerializedModel
@@ -11,31 +10,35 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
-from classiq.interface.model.quantum_type import QuantumNumeric
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
 from classiq import RegisterUserInput
+from classiq.open_library.functions.grover import grover_search, phase_oracle
 
 _OUTPUT_VARIABLE_NAME = "result"
 
 _PREDICATE_FUNCTION_NAME = "expr_predicate"
 
 
-def _arithmetic_oracle_io_dict(
-    definitions: List[Tuple[str, RegisterUserInput]], handle_name: str
-) -> Dict[str, HandleBinding]:
+def _arithmetic_oracle_ios(
+    definitions: list[tuple[str, RegisterUserInput]], handle_name: str
+) -> list[HandleBinding]:
     cursor = 0
-    ios: Dict[str, HandleBinding] = dict()
-    for reg_name, reg in definitions:
-        ios[reg_name] = SlicedHandleBinding(
-            name=handle_name,
-            start=Expression(expr=f"{cursor}"),
-            end=Expression(expr=f"{cursor + reg.size}"),
+    ios: list[HandleBinding] = []
+    for _, reg in definitions:
+        ios.append(
+            SlicedHandleBinding(
+                base_handle=HandleBinding(name=handle_name),
+                start=Expression(expr=f"{cursor}"),
+                end=Expression(expr=f"{cursor + reg.size}"),
+            )
         )
         cursor += reg.size
     return ios
@@ -43,36 +46,34 @@ def _arithmetic_oracle_io_dict(
 
 def _construct_arithmetic_oracle(
     predicate_function: str,
-    definitions: List[Tuple[str, RegisterUserInput]],
+    definitions: list[tuple[str, RegisterUserInput]],
 ) -> QuantumFunctionCall:
-    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "arg0")
-    predicate_var_binding["res"] = HandleBinding(name="arg1")
+    predicate_var_binding = _arithmetic_oracle_ios(definitions, "state")
+    predicate_var_binding.append(HandleBinding(name="oracle"))
     return QuantumFunctionCall(
         function="phase_oracle",
-        inouts={
-            "target": HandleBinding(name="arg0"),
-        },
-        operands={
-            "predicate": QuantumLambdaFunction(
+        positional_args=[
+            QuantumLambdaFunction(
+                pos_rename_params=["state", "oracle"],
                 body=[
                     QuantumFunctionCall(
                         function=predicate_function,
-                        inouts=predicate_var_binding,
+                        positional_args=predicate_var_binding,
                     ),
                 ],
             ),
-        },
+            HandleBinding(name="packed_vars"),
+        ],
     )
 
 
 def grover_main_port_declarations(
-    definitions: List[Tuple[str, RegisterUserInput]],
+    definitions: list[tuple[str, RegisterUserInput]],
     direction: PortDeclarationDirection,
-) -> Dict[str, PortDeclaration]:
-    return {
-        name: PortDeclaration(
+) -> list[PortDeclaration]:
+    return [
+        PortDeclaration(
             name=name,
-            size=Expression(expr=f"{reg.size}"),
             quantum_type=QuantumNumeric(
                 size=Expression(expr=f"{reg.size}"),
                 is_signed=Expression(expr=f"{reg.is_signed}"),
@@ -81,21 +82,23 @@ def grover_main_port_declarations(
             direction=direction,
         )
         for name, reg in definitions
-    }
+    ]
 
 
 def construct_grover_model(
-    definitions: List[Tuple[str, RegisterUserInput]],
+    definitions: list[tuple[str, RegisterUserInput]],
     expression: str,
     num_reps: int = 1,
 ) -> SerializedModel:
     predicate_port_decls = grover_main_port_declarations(
         definitions, PortDeclarationDirection.Inout
     )
-    predicate_port_decls["res"] = PortDeclaration(
-        name="res",
-        size=Expression(expr="1"),
-        direction=PortDeclarationDirection.Inout,
+    predicate_port_decls.append(
+        PortDeclaration(
+            name="res",
+            quantum_type=QuantumBitvector(length=Expression(expr="1")),
+            direction=PortDeclarationDirection.Inout,
+        )
     )
     num_qubits = sum(reg.size for _, reg in definitions)
 
@@ -103,45 +106,41 @@ def construct_grover_model(
         functions=[
             NativeFunctionDefinition(
                 name=_PREDICATE_FUNCTION_NAME,
-                port_declarations=predicate_port_decls,
+                positional_arg_declarations=predicate_port_decls,
                 body=[
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
-                        inplace_result=True,
+                        operation_kind=ArithmeticOperationKind.InplaceXor,
                     ),
                 ],
             ),
             NativeFunctionDefinition(
                 name="main",
-                port_declarations=grover_main_port_declarations(
+                positional_arg_declarations=grover_main_port_declarations(
                     definitions, PortDeclarationDirection.Output
                 ),
                 body=[
                     VariableDeclarationStatement(name="packed_vars"),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{num_qubits}"),
-                            HandleBinding(name="packed_vars"),
-                        ],
+                    Allocate(
+                        size=Expression(expr=f"{num_qubits}"),
+                        target=HandleBinding(name="packed_vars"),
                     ),
                     QuantumFunctionCall(
                         function="grover_search",
-                        params={
-                            "reps": Expression(expr=f"{num_reps}"),
-                        },
-                        inouts={"packed_vars": HandleBinding(name="packed_vars")},
-                        operands={
-                            "oracle": QuantumLambdaFunction(
+                        positional_args=[
+                            Expression(expr=f"{num_reps}"),
+                            QuantumLambdaFunction(
+                                pos_rename_params=["packed_vars"],
                                 body=[
                                     _construct_arithmetic_oracle(
                                         _PREDICATE_FUNCTION_NAME,
                                         definitions,
                                     )
-                                ]
-                            )
-                        },
+                                ],
+                            ),
+                            HandleBinding(name="packed_vars"),
+                        ],
                     ),
                     BindOperation(
                         in_handles=[HandleBinding(name="packed_vars")],
@@ -151,6 +150,8 @@ def construct_grover_model(
                     ),
                 ],
             ),
+            *[f for f in grover_search.create_model().functions if f.name != "main"],
+            *[f for f in phase_oracle.create_model().functions if f.name != "main"],
         ],
     )
     return grover_model.get_model()

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -0,0 +1,113 @@
+from typing import Union
+
+import numpy as np
+from sympy import fwht
+
+from classiq.qmod import (  # type:ignore[attr-defined]
+    Pauli,
+    PauliTerm,
+)
+
+ATOL = 1e-12
+PAULI_MATRICES_DICT = {
+    Pauli.I: np.array([[1, 0], [0, 1]], dtype=np.complex128),
+    Pauli.Z: np.array([[1, 0], [0, -1]], dtype=np.complex128),
+    Pauli.X: np.array([[0, 1], [1, 0]], dtype=np.complex128),
+    Pauli.Y: np.array([[0, -1j], [1j, 0]], dtype=np.complex128),
+}
+
+
+def _get_pauli_string(set_index: int, term_index: int, num_qubits: int) -> list[Pauli]:
+    """
+    The basis of 4^N Pauli strings on N qubits can be partitioned to 2^N sets, each contains 2^N Pauli strings.
+    In the k-th set we have Pauli strings of the form s_1s_2...s_N, where s_j is in {I,Z} if k_j is 0,
+    and in {X,iY} if k_j=1. The function get_pauli_string returns the m-th Pauli string in the k-th set of Pauli strings
+    """
+
+    # returns the Pauli (I,Z) or (iY, X) appearing in the pauli_index position for a given set
+    def _get_paulis_for_set(set_index: int, pauli_index: int) -> tuple[Pauli, Pauli]:
+        if (set_index >> pauli_index) & 1:
+            return Pauli.Y, Pauli.X
+        else:
+            return Pauli.Z, Pauli.I
+
+    return [
+        (
+            _get_paulis_for_set(set_index, s)[0]
+            if (term_index >> s) & 1
+            else _get_paulis_for_set(set_index, s)[1]
+        )
+        for s in range(num_qubits)
+    ][::-1]
+
+
+def _coefficents_for_set(mat: np.ndarray, set_index: int) -> list:
+    """
+    The 2^N coefficients in a 2^N x 2^N matrix that are decomposed to the elements
+    in the k-th set are the indices [i,j] such that i^j=k
+    The function coefficents_for_set returns the matrix entries that are decomposed to the same Pauli strigs set
+    """
+    return [mat[k, k ^ set_index] / len(mat) for k in range(len(mat))]
+
+
+def _get_signed_coefficient(
+    c: complex, k: int, i: int, is_hermitian: bool
+) -> Union[complex, float]:
+    # correct from iY to Y
+    coef = complex((1j) ** ((i & k).bit_count()) * c)
+    if is_hermitian:
+        return coef.real
+    else:
+        return coef
+
+
+def matrix_to_hamiltonian(
+    mat: np.ndarray, tol: float = ATOL, is_hermitian: bool = True
+) -> list[PauliTerm]:
+    """
+    The decomposition per set is done by the Walsh-Hadamard transform,
+    since the transformation between {e_0,e_3} ({e_1,e_2}) to {I,Z} ({X,iY}) is the Hadamard matrix.
+    """
+    mat.shape[0] != 0, "matrix is of size 0"
+    if is_hermitian:
+        assert np.allclose(
+            mat, np.conjugate(mat.T)
+        ), "Matrix is not hermitian, please pass is_hermitian=False"
+    assert mat.shape[0] == mat.shape[1], "Matrix is not square"
+    mat_dimension = mat.shape[0]
+    assert mat_dimension.bit_count() == 1, "Matrix dimension is not a power of 2"
+    num_qubits = (mat_dimension - 1).bit_length()
+    hamiltonian = []
+    for k in range(2**num_qubits):
+        coef = fwht(
+            _coefficents_for_set(mat, k)
+        )  # the transformation per set is given by the Walsh-Hadamard transform
+        hamiltonian += [
+            PauliTerm(
+                pauli=_get_pauli_string(k, i, num_qubits),
+                coefficient=_get_signed_coefficient(coef[i], k, i, is_hermitian),
+            )
+            for i in range(2**num_qubits)
+            if abs(coef[i]) > tol
+        ]
+    return hamiltonian
+
+
+# convert a single puali string of length N to 2**N X 2**N matrix
+def pauli_string_to_mat(seq: list[Pauli]) -> np.ndarray:
+    real_matrix = PAULI_MATRICES_DICT[seq[0]]
+    for p in seq[1:]:
+        real_matrix = np.kron(real_matrix, PAULI_MATRICES_DICT[p])
+    return real_matrix
+
+
+# return matrix from hamiltonian
+def hamiltonian_to_matrix(hamiltonian: list[PauliTerm]) -> np.ndarray:
+    matrix = np.zeros(
+        [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
+        dtype=np.complex_,
+    )
+    for p in hamiltonian:
+        matrix += p.coefficient * pauli_string_to_mat(p.pauli)
+
+    return matrix

classiq/applications/libraries/qmci_library.py

@@ -0,0 +1,22 @@
+from classiq.open_library.functions.amplitude_estimation import amplitude_estimation
+from classiq.qmod.builtins.functions import Z
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.quantum_callable import QCallable
+
+
+@qfunc
+def qmci(
+    space_transform: QCallable[QArray[QBit], QBit],
+    phase: QNum,
+    packed_vars: QArray[QBit],
+) -> None:
+    amplitude_estimation(
+        lambda reg: Z(reg[reg.len - 1]),
+        lambda reg: space_transform(reg[0 : reg.len - 1], reg[reg.len - 1]),
+        phase,
+        packed_vars,
+    )
+
+
+QMCI_LIBRARY = [func for func in qmci.create_model().functions if func.name != "main"]

classiq/applications/qnn/__init__.py

@@ -1,7 +1,5 @@
 # This file will be called first whenever any file from within this directory is imported.
 # Thus, we'll test dependencies only here, once.
-from typing import List
-
 try:
     import torch
 except ImportError as exc:
@@ -10,8 +8,8 @@ except ImportError as exc:
 from ..qnn import datasets, types
 from ..qnn.qlayer import QLayer
 
-__all__ = ["datasets", "types", "QLayer"]
+__all__ = ["QLayer", "datasets", "types"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/qnn/circuit_utils.py

@@ -1,21 +1,21 @@
 import itertools
-from collections.abc import Collection
-from typing import Iterable, List, Tuple, Union
+from collections.abc import Collection, Iterable
+from typing import Union
 
 from torch import Tensor
 
+from classiq.interface.exceptions import ClassiqQNNError, ClassiqValueError
 from classiq.interface.generator.circuit_code.types_and_constants import QasmVersion
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.types import Arguments, Circuit
-from classiq.exceptions import ClassiqQNNError, ClassiqValueError
 
 WEIGHT_INITIALS = ["weight_", "w_"]
 INPUT_INITIALS = ["input_", "i_"]
 
-Parameters = List[str]
-ParametersTuple = Tuple[Parameters, Parameters]
+Parameters = list[str]
+ParametersTuple = tuple[Parameters, Parameters]
 
 
 def _is_name_valid(name: str) -> bool:
@@ -46,7 +46,7 @@ def validate_circuit(circuit: Circuit) -> bool:
     return True
 
 
-def _extract_by_prefix(lst: Parameters, prefix: List[str]) -> Parameters:
+def _extract_by_prefix(lst: Parameters, prefix: list[str]) -> Parameters:
     return [s for s in lst if any(s.startswith(p) for p in prefix)]
 
 

classiq/applications/qnn/datasets/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ..datasets import builtin_datasets
 from ..datasets.builtin_datasets import (
     DATALOADER_NOT,
@@ -15,21 +13,21 @@ from ..datasets.dataset_xor import DatasetXor
 from ..datasets.datasets_utils import state_to_label, state_to_weights
 
 __all__ = [
-    "builtin_datasets",
-    "DatasetNot",
-    "DATASET_NOT",
     "DATALOADER_NOT",
-    "DatasetXor",
-    "DATASET_XOR",
+    "DATALOADER_SUBSET_PARITY",
     "DATALOADER_XOR",
-    "DatasetSubsetParity",
+    "DATASET_NOT",
     "DATASET_SUBSET_PARITY",
-    "DATALOADER_SUBSET_PARITY",
+    "DATASET_XOR",
+    "DatasetNot",
     "DatasetParity",
-    "state_to_weights",
+    "DatasetSubsetParity",
+    "DatasetXor",
+    "builtin_datasets",
     "state_to_label",
+    "state_to_weights",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/qnn/datasets/dataset_base_classes.py

@@ -1,11 +1,13 @@
 from abc import ABC, abstractmethod
-from typing import List, Literal, Optional, Sequence, Tuple, TypeVar, Union
+from collections.abc import Sequence
+from typing import Literal, Optional, TypeVar, Union
 
 from torch import Tensor, tensor
 from torch.utils.data import Dataset
 
+from classiq.interface.exceptions import ClassiqIndexError, ClassiqValueError
+
 from classiq.applications.qnn.types import DataAndLabel, Transform
-from classiq.exceptions import ClassiqIndexError, ClassiqValueError
 
 T = TypeVar("T")
 
@@ -29,7 +31,7 @@ class MyDataset(Dataset, ABC):
     def _get_data_and_label(self, index: int) -> DataAndLabel:
         pass
 
-    def __getitem__(self, index: int) -> Tuple[Tensor, Tensor]:
+    def __getitem__(self, index: int) -> tuple[Tensor, Tensor]:
         if index < 0 or index >= len(self):
             raise ClassiqIndexError(f"{self.__class__.__name__} out of range")
 
@@ -53,7 +55,7 @@ class MySubsetDataset(MyDataset, ABC):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[List[int], Literal["all"]] = "all",
+        subset: Union[list[int], Literal["all"]] = "all",
         transform: Optional[Transform] = None,
         target_transform: Optional[Transform] = None,
     ) -> None:
@@ -73,5 +75,5 @@ class MySubsetDataset(MyDataset, ABC):
                 'Invalid subset - please enter a `list` of `int`, or the string "all"'
             )
 
-    def _get_subset(self, coll: Sequence[T]) -> List[T]:
+    def _get_subset(self, coll: Sequence[T]) -> list[T]:
         return [coll[i] for i in self._subset]

classiq/applications/qnn/datasets/dataset_not.py

@@ -1,10 +1,11 @@
+from classiq.interface.exceptions import ClassiqIndexError
+
 from classiq.applications.qnn.datasets.dataset_base_classes import MyDataset
 from classiq.applications.qnn.datasets.datasets_utils import (
     all_bits_to_one,
     all_bits_to_zero,
 )
 from classiq.applications.qnn.types import DataAndLabel
-from classiq.exceptions import ClassiqIndexError
 
 
 class DatasetNot(MyDataset):

classiq/applications/qnn/datasets/dataset_parity.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Optional, Union
+from typing import Literal, Optional, Union
 
 from classiq.applications.qnn.datasets.dataset_base_classes import MySubsetDataset
 from classiq.applications.qnn.types import DataAndLabel, Transform
@@ -8,7 +8,7 @@ class DatasetSubsetParity(MySubsetDataset):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[List[int], Literal["all"]] = "all",
+        subset: Union[list[int], Literal["all"]] = "all",
         add_readout_qubit: bool = True,
         transform: Optional[Transform] = None,
         target_transform: Optional[Transform] = None,

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -23,7 +23,7 @@ class QuantumGradient(abc.ABC):
         self._execute = execute
         self._post_process = post_process
 
-        circuit = QuantumProgram.parse_raw(quantum_program)
+        circuit = QuantumProgram.model_validate_json(quantum_program)
         validate_circuit(circuit)
         self._quantum_program = quantum_program
         self._parameters_names = extract_parameters(circuit)