classiq 0.93.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/applications/combinatorial_helpers/transformations/encoding.py

@@ -1,6 +1,6 @@
 import copy
+from collections.abc import Callable
 from itertools import chain, product
-from typing import Callable, Union
 
 import pyomo.environ as pyo
 from pyomo.core.base.var import VarData
@@ -25,7 +25,7 @@ def _make_invalid_encoding_type_error(
     )
 
 
-def encoding_length(var: VarData, encoding_type: Union[EncodingType, None]) -> int:
+def encoding_length(var: VarData, encoding_type: EncodingType | None) -> int:
     if encoding_type is None:
         return 1
 
@@ -172,7 +172,7 @@ class ModelEncoder:
     def encode_expr(
         self,
         expr: pyo.Expression,
-        substitution_dict: Union[dict[int, pyo.Expression], None] = None,
+        substitution_dict: dict[int, pyo.Expression] | None = None,
     ) -> pyo.Expression:
         if substitution_dict is None:
             substitution_dict = self.vars_encoding_mapping.substitution_dict

classiq/applications/combinatorial_helpers/transformations/fixed_variables.py

@@ -1,5 +1,4 @@
 import copy
-from typing import Union
 
 from pyomo.core import ConcreteModel, Var
 from pyomo.core.base.constraint import _GeneralConstraintData
@@ -125,7 +124,7 @@ def add_fixed_variables_to_solution(
     return solution_with_fixed
 
 
-def _get_value_if_exists(var: VarData) -> Union[int, VarData]:
+def _get_value_if_exists(var: VarData) -> int | VarData:
     return var.value if var.value is not None else var
 
 

classiq/applications/combinatorial_optimization/combinatorial_optimization_config.py

@@ -1,6 +1,5 @@
 import dataclasses
 from dataclasses import dataclass
-from typing import Optional
 
 from classiq.interface.executor.optimizer_preferences import CostType, OptimizerType
 
@@ -14,10 +13,10 @@ class QAOAConfig:
 @dataclass
 class OptimizerConfig:
     opt_type: OptimizerType = OptimizerType.COBYLA
-    max_iteration: Optional[int] = None
+    max_iteration: int | None = None
     tolerance: float = 0.0
     step_size: float = 0.0
     skip_compute_variance: bool = False
     cost_type: CostType = CostType.CVAR
     alpha_cvar: float = 1.0
-    initial_point: Optional[list[float]] = dataclasses.field(default=None)
+    initial_point: list[float] | None = dataclasses.field(default=None)

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pyomo import environ as pyo
 from pyomo.core import Objective, maximize
 
@@ -47,8 +45,8 @@ with set_global_declarative_switch():
 
 def construct_combi_opt_py_model(
     pyo_model: pyo.ConcreteModel,
-    qaoa_config: Optional[QAOAConfig] = None,
-    optimizer_config: Optional[OptimizerConfig] = None,
+    qaoa_config: QAOAConfig | None = None,
+    optimizer_config: OptimizerConfig | None = None,
 ) -> Model:
     if qaoa_config is None:
         qaoa_config = QAOAConfig()
@@ -137,8 +135,8 @@ save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
 
 def construct_combinatorial_optimization_model(
     pyo_model: pyo.ConcreteModel,
-    qaoa_config: Optional[QAOAConfig] = None,
-    optimizer_config: Optional[OptimizerConfig] = None,
+    qaoa_config: QAOAConfig | None = None,
+    optimizer_config: OptimizerConfig | None = None,
 ) -> SerializedModel:
     converted_pyo_model = convert_pyomo_to_global_presentation(pyo_model)
     model = construct_combi_opt_py_model(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -1,11 +1,10 @@
 import math
 import re
-from typing import Callable, Optional, cast
+from collections.abc import Callable
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
-import pandas as pd
 import pyomo.core as pyo
-import scipy
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import ExecutionDetails
@@ -29,6 +28,9 @@ from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QVar
 from classiq.synthesis import synthesize
 
+if TYPE_CHECKING:
+    import pandas as pd
+
 
 class CombinatorialProblem:
     def __init__(
@@ -62,8 +64,8 @@ class CombinatorialProblem:
 
     def get_model(
         self,
-        constraints: Optional[Constraints] = None,
-        preferences: Optional[Preferences] = None,
+        constraints: Constraints | None = None,
+        preferences: Preferences | None = None,
     ) -> SerializedModel:
         @qfunc
         def main(
@@ -93,10 +95,10 @@ class CombinatorialProblem:
 
     def optimize(
         self,
-        execution_preferences: Optional[ExecutionPreferences] = None,
+        execution_preferences: ExecutionPreferences | None = None,
         maxiter: int = 20,
         quantile: float = 1.0,
-        initial_params: Optional[list[float]] = None,
+        initial_params: list[float] | None = None,
     ) -> list[float]:
         if self.qprog_ is None:
             self.get_qprog()
@@ -131,10 +133,12 @@ class CombinatorialProblem:
         self._es = _es
         return _optimized_params
 
-    def sample_uniform(self) -> pd.DataFrame:
+    def sample_uniform(self) -> "pd.DataFrame":
         return self.sample([0] * self.num_layers_ * 2)
 
-    def sample(self, params: list) -> pd.DataFrame:
+    def sample(self, params: list) -> "pd.DataFrame":
+        import pandas as pd
+
         assert self._es is not None
         res = self._es.sample({"params": params})
         parsed_result = [
@@ -161,7 +165,7 @@ def execute_qaoa(
     cost_func: Callable,
     num_layers: int,
     maxiter: int,
-    execution_preferences: Optional[ExecutionPreferences] = None,
+    execution_preferences: ExecutionPreferences | None = None,
 ) -> tuple[SerializedModel, QuantumProgram, ExecutionDetails]:
     """
     Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
@@ -178,6 +182,7 @@ def execute_qaoa(
         a tuple containing the model of the QAOA ansatz, the corresponding synthesized quantum program,
         and the result of the execution with the optimized parameters
     """
+    import scipy
 
     @qfunc
     def main(

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 import numpy as np
 from sympy import fwht
 
@@ -56,7 +54,7 @@ def _coefficents_for_set(mat: np.ndarray, set_index: int) -> list:
 
 def _get_signed_coefficient(
     c: complex, k: int, i: int, is_hermitian: bool
-) -> Union[complex, float]:
+) -> complex | float:
     # correct from iY to Y
     coef = complex((1j) ** ((i & k).bit_count()) * c)
     if is_hermitian:
@@ -131,7 +129,7 @@ def _sparse_pauli_to_list(operator: SparsePauliOp) -> list[PauliTerm]:
 
 # return matrix from hamiltonian
 def hamiltonian_to_matrix(
-    hamiltonian: Union[list[PauliTerm], SparsePauliOp],
+    hamiltonian: list[PauliTerm] | SparsePauliOp,
 ) -> np.ndarray:
     if isinstance(hamiltonian, SparsePauliOp):
         hamiltonian = _sparse_pauli_to_list(hamiltonian)
@@ -143,3 +141,7 @@ def hamiltonian_to_matrix(
         matrix += p.coefficient * pauli_string_to_mat(p.pauli)
 
     return matrix
+
+
+def pauli_operator_to_matrix(pauli_op: SparsePauliOp) -> np.ndarray:
+    return hamiltonian_to_matrix(_sparse_pauli_to_list(pauli_op))

classiq/applications/iqae/iqae.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, cast
+from typing import Literal, cast
 
 from classiq.interface.applications.iqae.generic_iqae import GenericIQAE
 from classiq.interface.applications.iqae.iqae_result import (
@@ -20,8 +20,10 @@ from classiq.qmod import (
     QCallable,
 )
 from classiq.qmod.builtins import Z, allocate, bind, within_apply
+from classiq.qmod.builtins.functions.allocation import drop
 from classiq.qmod.create_model_function import create_model
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
+from classiq.qmod.qmod_variable import Const
 from classiq.synthesis import synthesize
 
 
@@ -46,15 +48,15 @@ class IQAE:
         self,
         state_prep_op: QCallable[QArray[QBit, Literal["problem_vars_size"]], QBit],
         problem_vars_size: int,
-        constraints: Optional[Constraints] = None,
-        preferences: Optional[Preferences] = None,
+        constraints: Constraints | None = None,
+        preferences: Preferences | None = None,
     ) -> None:
         self._state_prep_op = state_prep_op
         self._problem_vars_size: int = problem_vars_size
-        self._constraints: Optional[Constraints] = constraints
-        self._preferences: Optional[Preferences] = preferences
-        self._model: Optional[SerializedModel] = None
-        self._qprog: Optional[QuantumProgram] = None
+        self._constraints: Constraints | None = constraints
+        self._preferences: Preferences | None = preferences
+        self._model: SerializedModel | None = None
+        self._qprog: QuantumProgram | None = None
 
         """
         Args:
@@ -83,8 +85,8 @@ class IQAE:
         def space_transform(est_reg: QArray) -> None:
             state_prep_op(est_reg[0 : est_reg.len - 1], est_reg[est_reg.len - 1])
 
-        @qfunc
-        def oracle(est_reg: QArray) -> None:
+        @qperm
+        def oracle(est_reg: Const[QArray]) -> None:
             Z(est_reg[est_reg.len - 1])
 
         @qfunc
@@ -105,6 +107,7 @@ class IQAE:
                     est_reg,
                 ),
             )
+            drop(problem_vars)
 
         if self._model is None:
             self._model = create_model(
@@ -133,7 +136,7 @@ class IQAE:
         self,
         epsilon: float,
         alpha: float,
-        execution_preferences: Optional[ExecutionPreferences] = None,
+        execution_preferences: ExecutionPreferences | None = None,
     ) -> IQAEResult:
         """
         Executes IQAE's quantum program with the provided epsilon, alpha, and execution

classiq/applications/qnn/datasets/dataset_base_classes.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Literal, Optional, TypeVar, Union
+from typing import Literal, TypeVar
 
 from torch import Tensor, tensor
 from torch.utils.data import Dataset
@@ -16,8 +16,8 @@ class MyDataset(Dataset, ABC):
     def __init__(
         self,
         n: int = 2,
-        transform: Optional[Transform] = None,
-        target_transform: Optional[Transform] = None,
+        transform: Transform | None = None,
+        target_transform: Transform | None = None,
     ) -> None:
         self._n = n
         self.transform = transform
@@ -55,9 +55,9 @@ class MySubsetDataset(MyDataset, ABC):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[list[int], Literal["all"]] = "all",
-        transform: Optional[Transform] = None,
-        target_transform: Optional[Transform] = None,
+        subset: list[int] | Literal["all"] = "all",
+        transform: Transform | None = None,
+        target_transform: Transform | None = None,
     ) -> None:
         super().__init__(n, transform, target_transform)
 

classiq/applications/qnn/datasets/dataset_parity.py

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

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -59,7 +59,7 @@ def _differentiate_tensor(
     # The minus comes from the way pytorch defines diff
     #   it diffs the second object minus the first
     #     where we want the first minus the second
-    diff = -tensor.diff(axis=axis).squeeze(axis)  # type: ignore[call-arg] # torch does accept `axis` keyword
+    diff = -tensor.diff(axis=axis).squeeze(axis)
     return diff / (2 * epsilon)
 
 

classiq/applications/qnn/qlayer.py

@@ -2,7 +2,8 @@ import functools
 import inspect
 import os
 import typing
-from typing import Any, Callable, Optional, Union, overload
+from collections.abc import Callable
+from typing import Any, overload
 
 import more_itertools
 import torch
@@ -41,14 +42,14 @@ from classiq.execution.qnn import _MAX_ARGUMENTS_SIZE, _execute_qnn_sample
 
 class QLayerFunction(torch.autograd.Function):
     @staticmethod
-    def forward(  # type: ignore[override]
+    def forward(
         ctx: Any,
         inputs: Tensor,
         weights: Tensor,
         quantum_program: QuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
-        epsilon: Optional[float] = EPSILON,
+        epsilon: float | None = EPSILON,
     ) -> Tensor:
         """
         This function receives:
@@ -103,9 +104,9 @@ class QLayerFunction(torch.autograd.Function):
         )
 
     @staticmethod
-    def backward(  # type: ignore[override]
+    def backward(
         ctx: Any, grad_output: Tensor
-    ) -> tuple[Optional[Tensor], Optional[Tensor], None, None, None, None]:
+    ) -> tuple[Tensor | None, Tensor | None, None, None, None, None]:
         """
         grad_output: Tensor
             is of shape (ctx.batch_size, ctx.num_out_features)
@@ -159,7 +160,7 @@ class QLayer(nn.Module):
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         # Optional parameters:
-        head_start: Union[float, Tensor, None] = None,
+        head_start: float | Tensor | None = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
@@ -172,7 +173,7 @@ class QLayer(nn.Module):
         post_process: PostProcessFunction,
         /,
         # Optional parameters:
-        head_start: Union[float, Tensor, None] = None,
+        head_start: float | Tensor | None = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
@@ -207,7 +208,7 @@ class QLayer(nn.Module):
         circuit: Circuit,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
-        head_start: Union[float, Tensor, None] = None,
+        head_start: float | Tensor | None = None,
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
     ) -> None:

classiq/applications/qnn/torch_utils.py

@@ -1,6 +1,5 @@
 from collections.abc import Sized
 from functools import reduce
-from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -24,7 +23,7 @@ def get_shape_second_dimension(shape: torch.Size) -> int:
     if len(shape) == 1:
         return 1
     elif len(shape) == 2:
-        return shape[1]
+        return shape[1]  # type: ignore[index]
     else:
         raise ClassiqValueError("Invalid shape dimension - must be 1D or 2D")
 
@@ -34,7 +33,7 @@ def get_shape_first_dimension(shape: torch.Size) -> int:
         raise ClassiqValueError("Invalid shape type - must have `__len__`")
 
     if len(shape) in (1, 2):
-        return shape[0]
+        return shape[0]  # type: ignore[index]
     else:
         raise ClassiqValueError("Invalid shape dimension - must be 1D or 2D")
 
@@ -52,8 +51,8 @@ def _result_to_tensor(
     all_results: list,
     inputs: Tensor,
     weights: Tensor,
-    expected_shape: Optional[Shape] = None,
-    requires_grad: Optional[bool] = None,
+    expected_shape: Shape | None = None,
+    requires_grad: bool | None = None,
 ) -> Tensor:
     default_shape = (
         torch.Size([inputs.shape[0]])
@@ -94,7 +93,7 @@ def iter_inputs_weights(
     post_process: PostProcessFunction,
     *,
     expected_shape: Shape = (),
-    requires_grad: Optional[bool] = None,
+    requires_grad: bool | None = None,
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))

classiq/applications/qnn/types.py

@@ -1,4 +1,5 @@
-from typing import Callable, Union
+from collections.abc import Callable
+from typing import Union
 
 import torch
 from torch import Tensor

classiq/applications/qsp/__init__.py

@@ -1,6 +1,24 @@
-from .qsp import gqsp_phases, qsp_approximate, qsvt_phases
+from .qsp import (
+    gqsp_phases,
+    poly_inversion,
+    poly_jacobi_anger_cos,
+    poly_jacobi_anger_exp_cos,
+    poly_jacobi_anger_exp_sin,
+    poly_jacobi_anger_sin,
+    qsp_approximate,
+    qsvt_phases,
+)
 
-__all__ = ["gqsp_phases", "qsp_approximate", "qsvt_phases"]
+__all__ = [
+    "gqsp_phases",
+    "poly_inversion",
+    "poly_jacobi_anger_cos",
+    "poly_jacobi_anger_exp_cos",
+    "poly_jacobi_anger_exp_sin",
+    "poly_jacobi_anger_sin",
+    "qsp_approximate",
+    "qsvt_phases",
+]
 
 
 def __dir__() -> list[str]: