classiq 0.32.1__py3-none-any.whl → 0.34.0__py3-none-any.whl

classiq/interface/backend/pydantic_backend.py

@@ -6,7 +6,9 @@ import pydantic
 AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"
 
 _IONQ_API_KEY_LENGTH: int = 32
+_ALICE_BOB_API_KEY_LENGTH: int = 72
 INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
+INVALID_API_KEY_ALICE_BOB: str = _ALICE_BOB_API_KEY_LENGTH * "a"
 MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
 
 if TYPE_CHECKING:
@@ -18,6 +20,7 @@ if TYPE_CHECKING:
     PydanticIonQApiKeyType = str
     PydanticArgumentNameType = str
     PydanticExecutionParameter = str
+    PydanticAliceBobApiKeyType = str
 else:
     # TODO Simplify regular expressions in this file
 
@@ -32,6 +35,11 @@ else:
     PydanticIonQApiKeyType = pydantic.constr(
         regex=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}"
     )
+
+    PydanticAliceBobApiKeyType = pydantic.constr(
+        regex=f"[A-Za-z0-9]{{{_ALICE_BOB_API_KEY_LENGTH}}}"
+    )
+
     PydanticExecutionTimeout = pydantic.conint(gt=0, le=MAX_EXECUTION_TIMEOUT_SECONDS)
 
     PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")

classiq/interface/backend/quantum_backend_providers.py

@@ -16,6 +16,7 @@ class ProviderVendor(StrEnum):
     AMAZON_BRAKET = "Amazon Braket"
     IONQ = "IonQ"
     GOOGLE = "Google"
+    ALICE_AND_BOB = "Alice and Bob"
 
 
 class ProviderTypeVendor:
@@ -25,6 +26,7 @@ class ProviderTypeVendor:
     AMAZON_BRAKET = Literal[ProviderVendor.AMAZON_BRAKET]
     IONQ = Literal[ProviderVendor.IONQ]
     GOOGLE = Literal[ProviderVendor.GOOGLE]
+    ALICE_BOB = Literal[ProviderVendor.ALICE_AND_BOB]
 
 
 class ClassiqAerBackendNames(StrEnum):
@@ -45,11 +47,13 @@ class AzureQuantumBackendNames(StrEnum):
     IONQ_ARIA_1 = "ionq.qpu.aria-1"
     IONQ_ARIA_2 = "ionq.qpu.aria-2"
     IONQ_QPU = "ionq.qpu"
+    IONQ_QPU_FORTE = "ionq.qpu.forte-1"
     IONQ_SIMULATOR = "ionq.simulator"
     MICROSOFT_ESTIMATOR = "microsoft.estimator"
     MICROSOFT_FULLSTATE_SIMULATOR = "microsoft.simulator.fullstate"
     RIGETTI_ASPEN3 = "rigetti.qpu.aspen-m-3"
     RIGETTI_SIMULATOR = "rigetti.sim.qvm"
+    RIGETTI_ANKAA2 = "rigetti.qpu.ankaa-2"
     QCI_MACHINE1 = "qci.machine1"
     QCI_NOISY_SIMULATOR = "qci.simulator.noisy"
     QCI_SIMULATOR = "qci.simulator"
@@ -141,6 +145,17 @@ class GoogleNvidiaBackendNames(StrEnum):
     CUQUANTUM = "cuquantum"
 
 
+class AliceBobBackendNames(StrEnum):
+    PHYSICAL_CATS_40 = "EMU:40Q:PHYSICAL_CATS"
+    PERFECT_QUBITS = "EMU:20Q:PERFECT_QUBITS"
+    LOGICAL_TARGET = "EMU:40Q:LOGICAL_TARGET"
+    PHYSICAL_CATS_6 = "EMU:6Q:PHYSICAL_CATS"
+    LOGICAL_EARLY = "EMU:15Q:LOGICAL_EARLY"
+    LESCANNE = "EMU:1Q:LESCANNE_2020"
+    TRANSMONS = "EMU:7Q:TRANSMONS"
+    FATCAT = "QPU:1Q:FATCAT_0"
+
+
 EXACT_SIMULATORS = {
     IonqBackendNames.SIMULATOR,
     AzureQuantumBackendNames.IONQ_SIMULATOR,
@@ -154,7 +169,6 @@ EXACT_SIMULATORS = {
 
 AllIBMQBackendNames = IBMQHardwareNames
 
-
 AllBackendsNameByVendor = Union[
     AllIBMQBackendNames,
     AzureQuantumBackendNames,

classiq/interface/chemistry/ground_state_problem.py

@@ -64,7 +64,7 @@ class GroundStateProblem(HashablePydanticBaseModel):
 
 
 class MoleculeProblem(GroundStateProblem):
-    molecule: Molecule = pydantic.Field(remove_hierarchy=True)
+    molecule: Molecule
     basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
     freeze_core: bool = pydantic.Field(default=False)
     remove_orbitals: List[int] = pydantic.Field(

classiq/interface/chemistry/operator.py

@@ -224,6 +224,204 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         frozen = True
 
 
+class PauliOperatorV1(HashablePydanticBaseModel):
+    """
+    Specification of a Pauli sum operator.
+    """
+
+    pauli_list: PydanticPauliList = pydantic.Field(
+        description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
+    )
+    is_hermitian: bool = pydantic.Field(default=False)
+    has_complex_coefficients: bool = pydantic.Field(default=True)
+
+    def show(self) -> str:
+        if self.is_hermitian:
+            # If the operator is hermitian then the coefficients must be numeric
+            return "\n".join(
+                f"{summand[1].real:+.3f} * {summand[0]}" for summand in self.pauli_list  # type: ignore[union-attr]
+            )
+        return "\n".join(
+            f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
+        )
+
+    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    def _validate_pauli_monomials(
+        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
+    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
+        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
+            monomial=monomial
+        )  # Validate the length of the monomial.
+        coeff = cls._validate_monomial_coefficient(monomial[1])
+        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
+        return (parsed_monomial.string, parsed_monomial.coeff)
+
+    @staticmethod
+    def _validate_monomial_coefficient(
+        coeff: Union[sympy.Expr, ParameterComplexType]
+    ) -> ParameterComplexType:
+        if isinstance(coeff, str):
+            validate_expression_str(coeff)
+        elif isinstance(coeff, sympy.Expr):
+            coeff = str(coeff)
+        return coeff
+
+    @pydantic.validator("pauli_list")
+    def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
+        if not all_equal(len(summand[0]) for summand in pauli_list):
+            raise ValueError("Pauli strings have incompatible lengths.")
+        return pauli_list
+
+    @pydantic.root_validator
+    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        pauli_list = values.get("pauli_list", [])
+        if all(isinstance(summand[1], complex) for summand in pauli_list):
+            values["is_hermitian"] = all(
+                np.isclose(complex(summand[1]).real, summand[1])
+                for summand in pauli_list
+            )
+        if values.get("is_hermitian", False):
+            values["has_complex_coefficients"] = False
+            values["pauli_list"] = [
+                (summand[0], complex(summand[1].real)) for summand in pauli_list
+            ]
+        else:
+            values["has_complex_coefficients"] = not all(
+                np.isclose(complex(summand[1]).real, summand[1])
+                for summand in pauli_list
+                if isinstance(summand[1], complex)
+            )
+        return values
+
+    def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
+        multiplied_ising = [
+            (monomial[0], self._multiply_monomial_coefficient(monomial[1], coefficient))
+            for monomial in self.pauli_list
+        ]
+        return self.__class__(pauli_list=multiplied_ising)
+
+    @staticmethod
+    def _multiply_monomial_coefficient(
+        monomial_coefficient: ParameterComplexType, coefficient: complex
+    ) -> ParameterComplexType:
+        if isinstance(monomial_coefficient, ParameterType):
+            return str(sympy.sympify(monomial_coefficient) * coefficient)
+        return monomial_coefficient * coefficient
+
+    @property
+    def is_commutative(self) -> bool:
+        return all(
+            self._is_sub_pauli_commutative(
+                [summand[0][qubit_num] for summand in self.pauli_list]
+            )
+            for qubit_num in range(self.num_qubits)
+        )
+
+    @staticmethod
+    def _is_sub_pauli_commutative(qubit_pauli_string: Union[List[str], str]) -> bool:
+        unique_paulis = set(qubit_pauli_string) - {"I"}
+        return len(unique_paulis) <= 1
+
+    @property
+    def num_qubits(self) -> int:
+        return len(self.pauli_list[0][0])
+
+    def to_matrix(self) -> np.ndarray:
+        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
+            raise ClassiqValueError(
+                "Supporting only Hamiltonian with numeric coefficients."
+            )
+        return sum(
+            cast(complex, summand[1]) * to_pauli_matrix(summand[0])
+            for summand in self.pauli_list
+        )  # type: ignore[return-value]
+
+    @staticmethod
+    def _extend_pauli_string(
+        pauli_string: PydanticPauliMonomialStr, num_extra_qubits: int
+    ) -> PydanticPauliMonomialStr:
+        return "I" * num_extra_qubits + pauli_string
+
+    def extend(self, num_extra_qubits: int) -> "PauliOperatorV1":
+        new_pauli_list = [
+            (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
+            for (pauli_string, coeff) in self.pauli_list
+        ]
+        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+
+    @staticmethod
+    def _reorder_pauli_string(
+        pauli_string: PydanticPauliMonomialStr,
+        order: Collection[int],
+        new_num_qubits: int,
+    ) -> PydanticPauliMonomialStr:
+        reversed_pauli_string = pauli_string[::-1]
+        reversed_new_pauli_string = ["I"] * new_num_qubits
+
+        for logical_pos, actual_pos in enumerate(order):
+            reversed_new_pauli_string[actual_pos] = reversed_pauli_string[logical_pos]
+
+        return "".join(reversed(reversed_new_pauli_string))
+
+    @staticmethod
+    def _validate_reorder(
+        order: Collection[int],
+        num_qubits: int,
+        num_extra_qubits: int,
+    ) -> None:
+        if num_extra_qubits < 0:
+            raise ValueError("Number of extra qubits cannot be negative")
+
+        if len(order) != num_qubits:
+            raise ValueError("The qubits order doesn't match the Pauli operator")
+
+        if len(order) != len(set(order)):
+            raise ValueError("The qubits order is not one-to-one")
+
+        if not all(pos < num_qubits + num_extra_qubits for pos in order):
+            raise ValueError("The qubits order contains qubits which do no exist")
+
+    @classmethod
+    def reorder(
+        cls,
+        operator: "PauliOperatorV1",
+        order: Collection[int],
+        num_extra_qubits: int = 0,
+    ) -> "PauliOperatorV1":
+        cls._validate_reorder(order, operator.num_qubits, num_extra_qubits)
+
+        new_num_qubits = operator.num_qubits + num_extra_qubits
+        new_pauli_list = [
+            (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
+            for pauli_string, coeff in operator.pauli_list
+        ]
+        return cls(pauli_list=new_pauli_list)
+
+    @classmethod
+    def from_unzipped_lists(
+        cls,
+        operators: List[List[Pauli]],
+        coefficients: Optional[List[complex]] = None,
+    ) -> "PauliOperatorV1":
+        if coefficients is None:
+            coefficients = [1] * len(operators)
+
+        if len(operators) != len(coefficients):
+            raise ValueError(
+                f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
+            )
+
+        return cls(
+            pauli_list=[
+                (pauli_integers_to_str(op), coeff)
+                for op, coeff in zip(operators, coefficients)
+            ]
+        )
+
+    class Config:
+        frozen = True
+
+
 # This class validates the length of a monomial.
 @pydantic.dataclasses.dataclass
 class _PauliMonomialLengthValidator:

classiq/interface/executor/execution_request.py

@@ -15,10 +15,7 @@ from classiq.interface.executor.quantum_program import (
 )
 from classiq.interface.executor.result import EstimationResult, ExecutionDetails
 from classiq.interface.executor.vqe_result import VQESolverResult
-from classiq.interface.generator.generated_circuit import (
-    ExecutionCircuit,
-    GeneratedCircuit,
-)
+from classiq.interface.generator.generated_circuit import GeneratedCircuit
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
@@ -29,10 +26,6 @@ class GeneratedCircuitExecution(GeneratedCircuit):
     execution_type: Literal["generated_circuit"] = "generated_circuit"
 
 
-class BareGeneratedCircuitExecution(ExecutionCircuit):
-    execution_type: Literal["bare_generated_circuit"] = "bare_generated_circuit"
-
-
 class QuantumProgramExecution(QuantumProgram):
     execution_type: Literal["quantum_program"] = "quantum_program"
 
@@ -42,10 +35,7 @@ class EstimateOperatorsExecution(OperatorsEstimation):
 
 
 ExecutionPayloads = Union[
-    GeneratedCircuitExecution,
-    BareGeneratedCircuitExecution,
-    QuantumProgramExecution,
-    EstimateOperatorsExecution,
+    GeneratedCircuitExecution, QuantumProgramExecution, EstimateOperatorsExecution
 ]
 
 
@@ -175,6 +165,9 @@ class ExecutionJobDetails(VersionedModel):
     status: JobStatus
 
     num_shots: Optional[int]
+    program_id: Optional[str]
+
+    error: Optional[str]
 
 
 class ExecutionJobsQueryResults(VersionedModel):

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -33,7 +33,7 @@ class QasmVersion(StrEnum):
 
 
 class LongStr(str):
-    def __repr__(self):
+    def __repr__(self) -> str:
         if len(self) > _MAXIMUM_STRING_LENGTH:
             length = len(self)
             return f'"{self[:4]}...{self[-4:]}" (length={length})'

classiq/interface/generator/complex_type.py

@@ -1,4 +1,7 @@
+from typing import Any
+
 import pydantic.json
+from typing_extensions import Self
 
 
 # Use this class as a type for complex data from the json, e.g., in the state_propagator function.
@@ -14,7 +17,7 @@ class Complex(complex):
         )
 
     @classmethod
-    def validate(cls, v):
+    def validate(cls, v: Any) -> Self:
         if isinstance(v, str):
             v = "".join(v.split())
 

classiq/interface/generator/functions/__init__.py

@@ -1,3 +1,5 @@
+from typing import List
+
 import classiq.interface.generator.functions.core_lib_declarations.quantum_functions
 import classiq.interface.generator.functions.core_lib_declarations.quantum_operators  # noqa: F401
 from classiq.interface.generator.functions.foreign_function_definition import *
@@ -17,5 +19,5 @@ __all__ = [  # noqa: F405
 ]
 
 
-def __dir__():
+def __dir__() -> List[str]:
     return __all__

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/__init__.py

@@ -3,7 +3,6 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 
-from .apps_lib_functions import *  # noqa: F403
 from .atomic_quantum_functions import *  # noqa: F403
 from .exponentiation_functions import *  # noqa: F403
 from .std_lib_functions import *  # noqa: F403

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/atomic_quantum_functions.py

@@ -225,13 +225,13 @@ RZZ_FUNCTION = QuantumFunctionDeclaration(
 CH_FUNCTION = QuantumFunctionDeclaration(
     name="CH",
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -242,13 +242,13 @@ CH_FUNCTION = QuantumFunctionDeclaration(
 CX_FUNCTION = QuantumFunctionDeclaration(
     name="CX",
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -259,13 +259,13 @@ CX_FUNCTION = QuantumFunctionDeclaration(
 CY_FUNCTION = QuantumFunctionDeclaration(
     name="CY",
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -276,13 +276,13 @@ CY_FUNCTION = QuantumFunctionDeclaration(
 CZ_FUNCTION = QuantumFunctionDeclaration(
     name="CZ",
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -296,13 +296,13 @@ CRX_FUNCTION = QuantumFunctionDeclaration(
         "theta": Real(),
     },
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -316,13 +316,13 @@ CRY_FUNCTION = QuantumFunctionDeclaration(
         "theta": Real(),
     },
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -336,13 +336,13 @@ CRZ_FUNCTION = QuantumFunctionDeclaration(
         "theta": Real(),
     },
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -356,13 +356,13 @@ CPHASE_FUNCTION = QuantumFunctionDeclaration(
         "theta": Real(),
     },
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
+        "control": PortDeclaration(
+            name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
-        "control": PortDeclaration(
-            name="control",
+        "target": PortDeclaration(
+            name="target",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="1"),
         ),
@@ -441,11 +441,11 @@ ADD_FUNCTION = QuantumFunctionDeclaration(
     port_declarations={
         "left": PortDeclaration(
             name="left",
-            direction=PortDeclarationDirection.Input,
+            direction=PortDeclarationDirection.Inout,
         ),
         "right": PortDeclaration(
             name="right",
-            direction=PortDeclarationDirection.Input,
+            direction=PortDeclarationDirection.Inout,
         ),
         "result": PortDeclaration(
             name="result",
@@ -472,16 +472,16 @@ U_FUNCTION = QuantumFunctionDeclaration(
 CCX_FUNCTION = QuantumFunctionDeclaration(
     name="CCX",
     port_declarations={
-        "target": PortDeclaration(
-            name="target",
-            direction=PortDeclarationDirection.Inout,
-            size=Expression(expr="1"),
-        ),
         "control": PortDeclaration(
             name="control",
             direction=PortDeclarationDirection.Inout,
             size=Expression(expr="2"),
         ),
+        "target": PortDeclaration(
+            name="target",
+            direction=PortDeclarationDirection.Inout,
+            size=Expression(expr="1"),
+        ),
     },
 )