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

classiq/interface/generator/hardware/hardware_data.py

@@ -1,10 +1,13 @@
 import itertools
 from collections import defaultdict
-from typing import Any, Dict, List, MutableSet, Optional
+from collections.abc import MutableSet
+from typing import Any, Optional
 
 import pydantic
+from typing_extensions import Self
 
 from classiq.interface.backend.backend_preferences import BackendPreferences
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import (
     DEFAULT_BASIS_GATES,
     DEFAULT_ROUTING_BASIS_GATES,
@@ -14,14 +17,32 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-ConnectivityMap = List[PydanticNonNegIntTuple]
+ConnectivityMap = list[PydanticNonNegIntTuple]
 BACKEND_VALIDATION_ERROR_MESSAGE = (
     "Backend service provider and backend name should be specified together."
 )
 
 
 class HardwareData(pydantic.BaseModel):
-    basis_gates: List[str] = pydantic.Field(
+    """
+    Hardware-specific settings used in quantum circuit synthesis,
+    including basis gates, connectivity map, and connectivity symmetry.
+
+    Attributes:
+        basis_gates (List[str]):
+            The basis gates of the hardware, used during model optimization.
+            If not provided, default values are used based on the connectivity map's symmetry.
+
+        connectivity_map(Optional[ConnectivityMap]):
+            The qubit connectivity map, defined as a list of qubit pairs [[q0, q1], [q1, q2],...].
+            If not provided, the hardware is assumed to be fully connected.
+
+        is_symmetric_connectivity(bool):
+            Indicates whether the coupling map forms an undirected graph, meaning
+            that both qubits in each pair can act as control and target. Defaults to True.
+    """
+
+    basis_gates: list[str] = pydantic.Field(
         default=list(),
         description="The basis gates of the hardware. "
         "This set will be used during the model optimization. "
@@ -41,73 +62,79 @@ class HardwareData(pydantic.BaseModel):
         "If false, the first / second qubit denotes the control / target, respectively",
     )
 
-    @pydantic.validator("connectivity_map")
+    @pydantic.field_validator("connectivity_map")
+    @classmethod
     def _validate_connectivity_map(
         cls, connectivity_map: Optional[ConnectivityMap]
     ) -> Optional[ConnectivityMap]:
         if connectivity_map is None:
             return connectivity_map
         if not connectivity_map:
-            raise ValueError("Connectivity map cannot be empty")
+            raise ClassiqValueError("Connectivity map cannot be empty")
         connectivity_map = _reindex_qubits(connectivity_map)
         return connectivity_map
 
-    @pydantic.root_validator()
-    def _symmetrize_connectivity_map(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        connectivity_map = values.get("connectivity_map")
+    @pydantic.model_validator(mode="after")
+    def _symmetrize_connectivity_map(self) -> Self:
+        connectivity_map = self.connectivity_map
         if connectivity_map is None:
-            return values
+            return self
 
-        is_symmetric = values.get("is_symmetric_connectivity")
+        is_symmetric = self.is_symmetric_connectivity
         if is_symmetric:
             connectivity_map = _symmetrize_connectivity_map(connectivity_map)
-            values["connectivity_map"] = connectivity_map
+            self.connectivity_map = connectivity_map
 
         if not _is_connected_map(connectivity_map):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Connectivity map must be connected: {connectivity_map} is not connected."
             )
-        return values
+        return self
 
-    @pydantic.root_validator()
-    def _validate_basis_gates(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        connectivity_map = values.get("connectivity_map")
-        specified_basis_gates = values.get("basis_gates", [])
+    @pydantic.model_validator(mode="after")
+    def _validate_basis_gates(self) -> Self:
+        connectivity_map = self.connectivity_map
+        specified_basis_gates = self.basis_gates
         if connectivity_map is None:
-            values["basis_gates"] = specified_basis_gates or list(DEFAULT_BASIS_GATES)
-            return values
+            self.basis_gates = specified_basis_gates or list(DEFAULT_BASIS_GATES)
+            return self
 
-        is_symmetric_connectivity = values.get("is_symmetric")
+        is_symmetric_connectivity = self.is_symmetric_connectivity
         if is_symmetric_connectivity or _check_symmetry(connectivity_map):
-            values["basis_gates"] = specified_basis_gates or list(DEFAULT_BASIS_GATES)
-            return values
+            self.basis_gates = specified_basis_gates or list(DEFAULT_BASIS_GATES)
+            return self
 
-        values["basis_gates"] = specified_basis_gates or list(
-            DEFAULT_ROUTING_BASIS_GATES
-        )
+        self.basis_gates = specified_basis_gates or list(DEFAULT_ROUTING_BASIS_GATES)
         invalid_gates = [
             gate
             for gate in specified_basis_gates
             if gate in TWO_QUBIT_GATES and gate not in ROUTING_TWO_QUBIT_BASIS_GATES
         ]
         if invalid_gates:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Connectivity-aware synthesis with non-symmetric coupling map "
                 "is currently supported for the following two-qubit gates only: cx, ecr, rzx."
             )
 
-        return values
+        return self
 
 
 class CustomHardwareSettings(HardwareData):
+    """
+    Custom hardware settings for quantum circuit synthesis.
+    This class inherits from HardwareData (please see class for more details)
+
+    """
+
     _width: Optional[int] = pydantic.PrivateAttr(default=None)
 
-    @pydantic.validator("basis_gates")
-    def validate_basis_gates(cls, basis_gates: List[str]) -> List[TranspilerBasisGates]:
+    @pydantic.field_validator("basis_gates", mode="after")
+    @classmethod
+    def validate_basis_gates(cls, basis_gates: list[str]) -> list[TranspilerBasisGates]:
         valid_gates = list(TranspilerBasisGates)
         invalid_gates = [gate for gate in basis_gates if gate not in valid_gates]
         if invalid_gates:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Invalid gates for hardware-aware synthesis: " + str(invalid_gates)
             )
 
@@ -128,7 +155,7 @@ class CustomHardwareSettings(HardwareData):
 
 def _is_connected_map(connectivity_map: ConnectivityMap) -> bool:
     nodes: MutableSet[int] = set()
-    node_to_neighbors: Dict[int, MutableSet[int]] = defaultdict(set)
+    node_to_neighbors: dict[int, MutableSet[int]] = defaultdict(set)
     for edge in connectivity_map:
         nodes.add(edge[0])
         nodes.add(edge[1])
@@ -141,7 +168,7 @@ def _is_connected_map(connectivity_map: ConnectivityMap) -> bool:
 
 
 def _node_dfs(
-    node: int, node_to_neighbors: Dict[int, MutableSet[int]], visited: MutableSet[int]
+    node: int, node_to_neighbors: dict[int, MutableSet[int]], visited: MutableSet[int]
 ) -> None:
     visited.add(node)
     neighbors = node_to_neighbors[node]
@@ -154,7 +181,7 @@ def _node_dfs(
 
 def _reindex_qubits(connectivity_map: ConnectivityMap) -> ConnectivityMap:
     qubits = sorted({q for pair in connectivity_map for q in pair})
-    return [(qubits.index(pair[0]), qubits.index(pair[1])) for pair in connectivity_map]
+    return [[qubits.index(pair[0]), qubits.index(pair[1])] for pair in connectivity_map]
 
 
 def _check_symmetry(connectivity_map: ConnectivityMap) -> bool:
@@ -166,17 +193,30 @@ def _symmetrize_connectivity_map(connectivity_map: ConnectivityMap) -> Connectiv
     # A more complicated implementation than using set to maintain the order
     connectivity_map_no_duplicates = []
     for edge in connectivity_map:
-        reversed_edge = (edge[1], edge[0])
+        reversed_edge = [edge[1], edge[0]]
         if (
             edge not in connectivity_map_no_duplicates
             and reversed_edge not in connectivity_map_no_duplicates
         ):
             connectivity_map_no_duplicates.append(edge)
     reversed_connectivity_map = [
-        (edge[1], edge[0]) for edge in connectivity_map_no_duplicates
+        [edge[1], edge[0]] for edge in connectivity_map_no_duplicates
     ]
     return connectivity_map_no_duplicates + reversed_connectivity_map
 
 
 class SynthesisHardwareData(HardwareData):
-    backend_data: Optional[BackendPreferences]
+    """
+    Represents the synthesis-specific hardware data for a quantum circuit.
+
+    This class extends `HardwareData` and includes additional attributes that
+    pertain specifically to the hardware used during the synthesis of a quantum circuit.
+
+    Attributes:
+        backend_data (Optional[BackendPreferences]):
+            Preferences for the backend used during the synthesis process.
+            This can include specific backend configurations or settings.
+            Defaults to `None`.
+    """
+
+    backend_data: Optional[BackendPreferences] = pydantic.Field(default=None)

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -1,8 +1,11 @@
 import itertools
-from typing import List, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
@@ -15,9 +18,7 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-from classiq._internals.enum_utils import StrEnum
-
-ConnectivityMap = List[PydanticNonNegIntTuple]
+ConnectivityMap = list[PydanticNonNegIntTuple]
 
 
 class SupportedConnectivityMaps(StrEnum):
@@ -44,16 +45,17 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         default=None,
         description="Number of qubits in the ansatz.",
+        validate_default=True,
     )
     reps: pydantic.PositiveInt = pydantic.Field(
         default=1, description="Number of layers in the Ansatz"
     )
 
-    one_qubit_gates: Union[str, List[str]] = pydantic.Field(
+    one_qubit_gates: Union[str, list[str]] = pydantic.Field(
         default=["x", "ry"],
         description='List of gates for the one qubit gates layer, e.g. ["x", "ry"]',
     )
-    two_qubit_gates: Union[str, List[str]] = pydantic.Field(
+    two_qubit_gates: Union[str, list[str]] = pydantic.Field(
         default=["cx"],
         description='List of gates for the two qubit gates entangling layer, e.g. ["cx", "cry"]',
     )
@@ -62,51 +64,70 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         description="Prefix for the generated parameters",
     )
 
-    @pydantic.validator("num_qubits", pre=True, always=True)
-    def validate_num_qubits(cls, num_qubits, values):
-        connectivity_map = values.get("connectivity_map")
+    @pydantic.field_validator("num_qubits", mode="before")
+    @classmethod
+    def validate_num_qubits(
+        cls, num_qubits: Optional[pydantic.PositiveInt], info: ValidationInfo
+    ) -> pydantic.PositiveInt:
+        connectivity_map = info.data.get("connectivity_map")
         conn_map_is_not_list = (
             isinstance(connectivity_map, SupportedConnectivityMaps)
             or connectivity_map is None
         )
 
         if num_qubits is None and conn_map_is_not_list:
-            raise ValueError(_NUM_QUBITS_NOT_PROVIDED_ERROR)
+            raise ClassiqValueError(_NUM_QUBITS_NOT_PROVIDED_ERROR)
         if num_qubits is None:
+            if conn_map_is_not_list:
+                raise ValueError(_NUM_QUBITS_NOT_PROVIDED_ERROR)
+
+            if TYPE_CHECKING:
+                assert connectivity_map is not None
+
             return len(set(itertools.chain.from_iterable(connectivity_map)))
+
         if conn_map_is_not_list:
             return num_qubits
 
+        if TYPE_CHECKING:
+            assert connectivity_map is not None
+
         invalid_qubits = {
             qubit
             for qubit in itertools.chain.from_iterable(connectivity_map)
             if qubit >= num_qubits
         }
         if invalid_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Invalid qubits: {invalid_qubits} "
                 f"out of range specified by num_qubits: [0, {num_qubits - 1}]"
             )
         return num_qubits
 
-    @pydantic.validator("one_qubit_gates")
-    def validate_one_qubit_gates(cls, one_qubit_gates):
+    @pydantic.field_validator("one_qubit_gates")
+    @classmethod
+    def validate_one_qubit_gates(
+        cls, one_qubit_gates: Union[str, list[str]]
+    ) -> Union[str, list[str]]:
         one_qubit_gates_list = (
             [one_qubit_gates] if isinstance(one_qubit_gates, str) else one_qubit_gates
         )
         for one_qubit_gate in one_qubit_gates_list:
             if one_qubit_gate not in SINGLE_QUBIT_GATES:
-                raise ValueError(f"Invalid one qubit gate: {one_qubit_gate}")
+                raise ClassiqValueError(f"Invalid one qubit gate: {one_qubit_gate}")
         return one_qubit_gates
 
-    @pydantic.validator("two_qubit_gates")
-    def validate_two_qubit_gates(cls, two_qubit_gates):
+    @pydantic.field_validator("two_qubit_gates")
+    @classmethod
+    def validate_two_qubit_gates(
+        cls, two_qubit_gates: Union[str, list[str]]
+    ) -> Union[str, list[str]]:
         two_qubit_gates_list = (
             [two_qubit_gates] if isinstance(two_qubit_gates, str) else two_qubit_gates
         )
         for two_qubit_gate in two_qubit_gates_list:
             if two_qubit_gate not in TWO_QUBIT_GATES:
-                raise ValueError(f"Invalid two qubit gate: {two_qubit_gate}")
+                raise ClassiqValueError(f"Invalid two qubit gate: {two_qubit_gate}")
         return two_qubit_gates
 
     def _create_ios(self) -> None:

classiq/interface/generator/hartree_fock.py

@@ -1,16 +1,26 @@
+from typing import Any, Union
+
 import pydantic
 
-from classiq.interface.chemistry.ground_state_problem import CHEMISTRY_PROBLEMS
+from classiq.interface.chemistry.ground_state_problem import (
+    CHEMISTRY_PROBLEMS,
+    HamiltonianProblem,
+    MoleculeProblem,
+)
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.chemistry_function_params import (
     ChemistryFunctionParams,
 )
 
 
 class HartreeFock(ChemistryFunctionParams):
-    @pydantic.validator("gs_problem")
-    def validate_gs_problem(cls, gs_problem):
+    @pydantic.field_validator("gs_problem")
+    @classmethod
+    def validate_gs_problem(
+        cls, gs_problem: Any
+    ) -> Union[MoleculeProblem, HamiltonianProblem]:
         if not isinstance(gs_problem, CHEMISTRY_PROBLEMS):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"ground state problem must be of type {CHEMISTRY_PROBLEMS}"
             )
         return gs_problem

classiq/interface/generator/identity.py

@@ -1,14 +1,17 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Annotated
 
 import pydantic
+from pydantic import Field
 
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import FunctionParams
 
 if TYPE_CHECKING:
-    NonEmptyRegisterUserInputList = List[RegisterUserInput]
+    NonEmptyRegisterUserInputList = list[RegisterUserInput]
 else:
-    NonEmptyRegisterUserInputList = pydantic.conlist(RegisterUserInput, min_items=1)
+    NonEmptyRegisterUserInputList = Annotated[
+        list[RegisterUserInput], Field(min_length=1)
+    ]
 
 
 class Identity(FunctionParams):
@@ -16,10 +19,11 @@ class Identity(FunctionParams):
         description="registers describing the state (ordered)"
     )
 
-    @pydantic.validator("arguments")
+    @pydantic.field_validator("arguments")
+    @classmethod
     def _validate_argument_names(
-        cls, arguments: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
+        cls, arguments: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
         return [
             arg if arg.name else arg.revalued(name=cls._get_default_arg_name(index))
             for index, arg in enumerate(arguments)

classiq/interface/generator/linear_pauli_rotations.py

@@ -1,22 +1,28 @@
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic
+from pydantic import StringConstraints
+from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
 STATE = "state"
 TARGET = "target"
 
-LENGTH_ERROR_MESSAGE = "Slopes, offsets and basis values must have the same length"
+LENGTH_ERROR_MESSAGE = "Field required"
 
 if TYPE_CHECKING:
     PydanticPauliBasisStr = str
 else:
-    PydanticPauliBasisStr = pydantic.constr(
-        to_lower=True,
-        regex=r"[xyz]",
-    )
+    PydanticPauliBasisStr = Annotated[
+        str,
+        StringConstraints(
+            to_lower=True,
+            pattern=r"[xyz]",
+        ),
+    ]
 
 
 class LinearPauliRotations(function_params.FunctionParams):
@@ -45,30 +51,38 @@ class LinearPauliRotations(function_params.FunctionParams):
     num_state_qubits: pydantic.PositiveInt = pydantic.Field(
         description="The number of input qubits"
     )
-    bases: List[PydanticPauliBasisStr] = pydantic.Field(
+    bases: list[PydanticPauliBasisStr] = pydantic.Field(
         description="The types of Pauli rotations ('X', 'Y', 'Z')."
     )
-    slopes: List[float] = pydantic.Field(
+    slopes: list[float] = pydantic.Field(
         description="The slopes of the controlled rotations."
     )
-    offsets: List[float] = pydantic.Field(
+    offsets: list[float] = pydantic.Field(
         description="The offsets of the controlled rotations."
     )
 
-    @pydantic.validator("bases", "slopes", "offsets", pre=True, always=True)
-    def as_list(cls, v: Any) -> List[Any]:
+    @pydantic.field_validator("bases", "slopes", "offsets", mode="before")
+    @classmethod
+    def as_list(cls, v: Any) -> list[Any]:
         if not isinstance(v, list):
             v = [v]
-        return v
+        res = []
+        for x in v:
+            element = x
+            if isinstance(x, str):
+                res.append(element.lower())
+            else:
+                res.append(element)
+        return res
 
-    @pydantic.root_validator()
-    def validate_lists(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        offsets = values.get("offsets", list())
-        bases = values.get("bases", list())
-        slopes = values.get("slopes", list())
+    @pydantic.model_validator(mode="after")
+    def validate_lists(self) -> Self:
+        offsets = self.offsets or list()
+        bases = self.bases or list()
+        slopes = self.slopes or list()
         if len(slopes) == len(offsets) and len(offsets) == len(bases):
-            return values
-        raise ValueError(LENGTH_ERROR_MESSAGE)
+            return self
+        raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/mcmt_method.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class McmtMethod(StrEnum):

classiq/interface/generator/mcu.py

@@ -1,11 +1,14 @@
-from typing import Any, Dict, Optional, cast
+from typing import Any, Optional, cast
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.generator.parameters import ParameterFloatType
+from classiq.interface.generator.function_params import (
+    FunctionParams,
+    FunctionParamsNumericParameter,
+)
 
 CTRL = "CTRL"
 TARGET = "TARGET"
@@ -28,17 +31,17 @@ class Mcu(FunctionParams):
     e^(i*phi)*sin(theta/2)  &    e^(i*(phi+lam))*cos(theta/2) \\
     """
 
-    theta: ParameterFloatType = pydantic.Field(
-        default=0, description="Theta radian angle.", is_exec_param=True
+    theta: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Theta radian angle."
     )
-    phi: ParameterFloatType = pydantic.Field(
-        default=0, description="Phi radian angle.", is_exec_param=True
+    phi: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Phi radian angle."
     )
-    lam: ParameterFloatType = pydantic.Field(
-        default=0, description="Lambda radian angle.", is_exec_param=True
+    lam: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Lambda radian angle."
     )
-    gam: ParameterFloatType = pydantic.Field(
-        default=0, description="gam radian angle.", is_exec_param=True
+    gam: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="gam radian angle."
     )
 
     num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
@@ -48,8 +51,9 @@ class Mcu(FunctionParams):
         default=None, description="string of the control state"
     )
 
-    @pydantic.root_validator()
-    def _validate_control(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_control(cls, values: Any) -> dict[str, Any]:
         num_ctrl_qubits = values.get("num_ctrl_qubits")
         ctrl_state = values.get("ctrl_state")
 
@@ -58,7 +62,7 @@ class Mcu(FunctionParams):
             ControlState.validate_control_string(ctrl_state)
 
         if ctrl_state is None and num_ctrl_qubits is None:
-            raise ValueError("num_ctrl_qubits or ctrl_state must exist.")
+            raise ClassiqValueError("num_ctrl_qubits or ctrl_state must exist.")
 
         if ctrl_state is None and num_ctrl_qubits is not None:
             values["ctrl_state"] = "1" * num_ctrl_qubits
@@ -69,7 +73,7 @@ class Mcu(FunctionParams):
             values["num_ctrl_qubits"] = num_ctrl_qubits
 
         if len(ctrl_state) != num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "control state length should be equal to the number of control qubits"
             )
 
@@ -77,7 +81,7 @@ class Mcu(FunctionParams):
 
     def _create_ios(self) -> None:
         if self.num_ctrl_qubits is None:
-            raise ValueError("num_ctrl_qubits must have a valid value.")
+            raise ClassiqValueError("num_ctrl_qubits must have a valid value.")
         ctrl_register = RegisterUserInput(size=self.num_ctrl_qubits, name=CTRL)
         target_register = RegisterUserInput(size=1, name=TARGET)
         self._inputs = {reg.name: reg for reg in (ctrl_register, target_register)}