classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

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.generated_circuit import GeneratedCircuit
 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)]
 
 
@@ -95,7 +95,7 @@ def _get_extracted_parameters(obj: CircuitOrExtractedParameters) -> ParametersTu
     # This `if` is for caching
     if isinstance(obj, tuple):
         weight_params, input_params = obj
-    elif isinstance(obj, GeneratedCircuit):
+    elif isinstance(obj, QuantumProgram):
         weight_params, input_params = extract_parameters(obj)
     else:
         raise ClassiqValueError("Invalid object passed to `map_parameters`")

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

@@ -4,7 +4,7 @@ from typing import Any
 
 from torch import Tensor
 
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.circuit_utils import extract_parameters, validate_circuit
 from classiq.applications.qnn.types import ExecuteFunction, PostProcessFunction
@@ -23,7 +23,7 @@ class QuantumGradient(abc.ABC):
         self._execute = execute
         self._post_process = post_process
 
-        circuit = GeneratedCircuit.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)

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -1,5 +1,6 @@
 import itertools
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 import torch
 from torch import Tensor

classiq/applications/qnn/qlayer.py

@@ -1,11 +1,13 @@
 import functools
-from typing import Any, Callable, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 import torch
 import torch.nn as nn
 from torch import Tensor
 from torch.nn.parameter import Parameter
 
+from classiq.interface.exceptions import ClassiqQNNError, ClassiqTorchError
+
 from classiq.applications.qnn.circuit_utils import (
     extract_parameters,
     is_single_layer_circuit,
@@ -13,6 +15,7 @@ from classiq.applications.qnn.circuit_utils import (
     validate_circuit,
 )
 from classiq.applications.qnn.gradients.simple_quantum_gradient import (
+    EPSILON,
     SimpleQuantumGradient,
 )
 from classiq.applications.qnn.torch_utils import (
@@ -26,7 +29,6 @@ from classiq.applications.qnn.types import (
     MultipleArguments,
     PostProcessFunction,
 )
-from classiq.exceptions import ClassiqQNNError, ClassiqTorchError
 from classiq.synthesis import SerializedQuantumProgram
 
 
@@ -39,6 +41,7 @@ class QLayerFunction(torch.autograd.Function):
         quantum_program: SerializedQuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
+        epsilon: Optional[float] = EPSILON,
     ) -> Tensor:
         """
         This function receives:
@@ -51,7 +54,9 @@ class QLayerFunction(torch.autograd.Function):
                 and returning a `Tensor`
 
         """
-        circuit = Circuit.parse_raw(quantum_program)
+        if epsilon is None:
+            epsilon = EPSILON
+        circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         # save for backward
@@ -60,7 +65,7 @@ class QLayerFunction(torch.autograd.Function):
         ctx.execute = execute
         ctx.post_process = post_process
         ctx.quantum_gradient = SimpleQuantumGradient(
-            quantum_program, execute, post_process
+            quantum_program, execute, post_process, epsilon
         )
 
         ctx.batch_size, ctx.num_in_features = inputs.shape
@@ -94,7 +99,7 @@ class QLayerFunction(torch.autograd.Function):
     @staticmethod
     def backward(  # type: ignore[override]
         ctx: Any, grad_output: Tensor
-    ) -> Tuple[Optional[Tensor], Optional[Tensor], None, None, None]:
+    ) -> tuple[Optional[Tensor], Optional[Tensor], None, None, None, None]:
         """
         grad_output: Tensor
             is of shape (ctx.batch_size, ctx.num_out_features)
@@ -103,6 +108,7 @@ class QLayerFunction(torch.autograd.Function):
 
         grad_weights = grad_inputs = None
         grad_circuit = grad_execute = grad_post_process = None
+        grad_epsilon = None
         is_single_layer = is_single_layer_circuit(weights)
 
         if ctx.needs_input_grad[1]:
@@ -118,7 +124,14 @@ class QLayerFunction(torch.autograd.Function):
                 f"Grad required for unknown type: {ctx.needs_input_grad}"
             )
 
-        return grad_inputs, grad_weights, grad_circuit, grad_execute, grad_post_process
+        return (
+            grad_inputs,
+            grad_weights,
+            grad_circuit,
+            grad_execute,
+            grad_post_process,
+            grad_epsilon,
+        )
 
 
 CalcNumOutFeatures = Callable[[SerializedQuantumProgram], int]
@@ -142,8 +155,9 @@ class QLayer(nn.Module):
         head_start: Union[float, Tensor, None] = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
+        epsilon: float = EPSILON,
     ) -> None:
-        circuit = Circuit.parse_raw(quantum_program)
+        circuit = Circuit.model_validate_json(quantum_program)
         validate_circuit(circuit)
 
         super().__init__()
@@ -151,6 +165,7 @@ class QLayer(nn.Module):
         self._execute = execute
         self._post_process = post_process
         self._head_start = head_start
+        self._epsilon = epsilon
 
         self.quantum_program = quantum_program
 
@@ -161,7 +176,7 @@ class QLayer(nn.Module):
         self._initialize_parameters()
 
     def _initialize_parameters(self) -> None:
-        shape: Tuple[int, ...] = (
+        shape: tuple[int, ...] = (
             (self.out_features, self.in_features)
             if self.out_features > 1
             else (self.in_features,)
@@ -181,6 +196,11 @@ class QLayer(nn.Module):
         self.weight = Parameter(value)
 
     def forward(self, x: Tensor) -> Tensor:
-        return QLayerFunction.apply(  # type: ignore[no-untyped-call]
-            x, self.weight, self.quantum_program, self._execute, self._post_process
+        return QLayerFunction.apply(
+            x,
+            self.weight,
+            self.quantum_program,
+            self._execute,
+            self._post_process,
+            self._epsilon,
         )

classiq/applications/qnn/torch_utils.py

@@ -1,11 +1,13 @@
 from collections.abc import Sized
 from functools import reduce
-from typing import Optional, Tuple
+from typing import Optional
 
 import torch
 import torch.nn as nn
 from torch import Tensor
 
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.applications.qnn.circuit_utils import is_single_layer_circuit
 from classiq.applications.qnn.types import (
     ExecuteFuncitonOnlyArguments,
@@ -13,7 +15,6 @@ from classiq.applications.qnn.types import (
     Shape,
     TensorToArgumentsCallable,
 )
-from classiq.exceptions import ClassiqValueError
 
 
 def get_shape_second_dimension(shape: torch.Size) -> int:
@@ -97,7 +98,7 @@ def iter_inputs_weights(
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))
-        inputs_weights_shape: Tuple[int, ...] = (inputs.shape[0],)
+        inputs_weights_shape: tuple[int, ...] = (inputs.shape[0],)
     else:
         iter_weights = weights
         inputs_weights_shape = (inputs.shape[0], weights.shape[0])

classiq/applications/qnn/types.py

@@ -1,17 +1,17 @@
-from typing import Callable, Dict, List, Tuple, Union
+from typing import Callable, Union
 
 import torch
 from torch import Tensor
 
 from classiq.interface.executor.execution_result import ResultsCollection, SavedResult
 
-from classiq import GeneratedCircuit
+from classiq import QuantumProgram
 from classiq.synthesis import SerializedQuantumProgram
 
-Arguments = Dict[str, float]
-MultipleArguments = Tuple[Arguments, ...]
+Arguments = dict[str, float]
+MultipleArguments = tuple[Arguments, ...]
 
-Circuit = GeneratedCircuit
+Circuit = QuantumProgram
 ExecuteFunction = Callable[
     [SerializedQuantumProgram, MultipleArguments], ResultsCollection
 ]
@@ -19,10 +19,10 @@ ExecuteFuncitonOnlyArguments = Callable[[MultipleArguments], ResultsCollection]
 PostProcessFunction = Callable[[SavedResult], Tensor]
 TensorToArgumentsCallable = Callable[[Tensor, Tensor], MultipleArguments]
 
-Shape = Union[torch.Size, Tuple[int, ...]]
+Shape = Union[torch.Size, tuple[int, ...]]
 
 GradientFunction = Callable[[Tensor, Tensor], Tensor]
 SimulateFunction = Callable[[Tensor, Tensor], Tensor]
 
-DataAndLabel = Tuple[List[int], Union[List[int], int]]
+DataAndLabel = tuple[list[int], Union[list[int], int]]
 Transform = Callable[[Tensor], Tensor]

classiq/applications/qsvm/__init__.py

@@ -1,8 +1,10 @@
-from classiq.interface.generator.expressions.enums.qsvm_feature_map_entanglement import (
-    QSVMFeatureMapEntanglement,
-)
+from classiq.qmod.builtins.enums import QSVMFeatureMapEntanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
+from .qsvm_model_constructor import construct_qsvm_model
 
-__all__ = ["QSVMFeatureMapEntanglement"]
+__all__ = [
+    "QSVMFeatureMapEntanglement",
+    "construct_qsvm_model",
+]

classiq/applications/qsvm/qsvm.py

@@ -1,17 +1,11 @@
-from typing import Any, List, Union
-
-import numpy as np
-
-from classiq.interface.applications.qsvm import DataList, QSVMData, QSVMPreferences
-
-Data = Union[DataList, np.ndarray]
-Labels = Union[List[Any], np.ndarray]
+from classiq.interface.applications.qsvm import Data, Labels, QSVMData
 
 __all__ = [
+    "Data",
+    "Labels",
     "QSVMData",
-    "QSVMPreferences",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/qsvm/qsvm_data_generation.py

@@ -1,6 +1,6 @@
 import logging
 from collections import defaultdict
-from typing import Dict, Optional, Tuple
+from typing import Optional
 
 import numpy as np
 
@@ -15,7 +15,7 @@ def generate_data(
     range_max: float = 2 * np.pi,
     std: float = 0.5,
     sources: Optional[np.ndarray] = None,
-) -> Dict[int, np.ndarray]:
+) -> dict[int, np.ndarray]:
     if sources is None:
         sources = np.random.uniform(
             range_min, range_max, (amount_of_sources, dimension)
@@ -24,11 +24,8 @@ def generate_data(
 
     results = {}
     for index, s in enumerate(sources):
-        temp = []
-        # for each dimension
-        for point in s:
-            # draw from a gaussian distribution
-            temp.append(np.random.normal(point, std, amount))
+        # for each dimension draw from a gaussian distribution
+        temp = [np.random.normal(point, std, amount) for point in s]
         # combine the list of np.arrays
         results[index] = np.array(list(zip(*temp)))
 
@@ -39,7 +36,7 @@ def generate_data(
     return results
 
 
-def data_dict_to_data_and_labels(data_dict: dict) -> Tuple[np.ndarray, np.ndarray]:
+def data_dict_to_data_and_labels(data_dict: dict) -> tuple[np.ndarray, np.ndarray]:
     data = []
     labels = []
     for k, v in data_dict.items():