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

classiq/_internals/api_wrapper.py

@@ -1,8 +1,7 @@
 import json
-from typing import Any, Dict, Optional, Protocol, Type, TypeVar, Union
+from typing import Dict, Optional, Protocol, Type, TypeVar
 
 import pydantic
-from pydantic import parse_obj_as
 
 import classiq.interface.pyomo_extension  # noqa: F401 - patches pyomo to add few features
 from classiq.interface.analyzer import analysis_params, result as analysis_result
@@ -19,10 +18,7 @@ from classiq._internals.enum_utils import StrEnum
 from classiq._internals.jobs import JobPoller
 from classiq.exceptions import ClassiqAPIError, ClassiqValueError
 
-_FAIL_FAST_INDICATOR = "{"
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
-OtherResultType = TypeVar("OtherResultType", bound=pydantic.BaseModel)
-_Circuit = Union[generator_result.GeneratedCircuit, generator_result.ExecutionCircuit]
 
 
 class HTTPMethod(StrEnum):
@@ -45,16 +41,6 @@ def _parse_job_response(
     return output_type.parse_obj(description)
 
 
-def _parse_job_response_multiple_outputs(
-    job_result: JobDescription[JSONObject],
-    output_type: Any,  # UnionType in Python 3.10,
-) -> Union[ResultType, OtherResultType]:
-    description = job_result.description
-    if job_result.status != JobStatus.COMPLETED:
-        raise ClassiqAPIError(description["details"])
-    return parse_obj_as(output_type, description)
-
-
 class ApiWrapper:
     @classmethod
     async def _call_task_pydantic(
@@ -82,15 +68,16 @@ class ApiWrapper:
         return res
 
     @classmethod
-    async def call_generation_task(cls, model: ModelInput) -> _Circuit:
+    async def call_generation_task(
+        cls, model: ModelInput
+    ) -> generator_result.GeneratedCircuit:
         poller = JobPoller(base_url=routes.TASKS_GENERATE_FULL_PATH)
         result = await poller.run_pydantic(model, timeout_sec=None)
-        return _parse_job_response_multiple_outputs(result, _Circuit)
+        return _parse_job_response(result, generator_result.GeneratedCircuit)
 
     @classmethod
     async def call_execute_generated_circuit(
-        cls,
-        circuit: _Circuit,
+        cls, circuit: generator_result.GeneratedCircuit
     ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
@@ -231,7 +218,9 @@ class ApiWrapper:
     async def call_generate_hamiltonian_task(
         cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE
     ) -> operator.PauliOperator:
-        poller = JobPoller(base_url=routes.CHEMISTRY_GENERATE_HAMILTONIAN_FULL_PATH)
+        poller = JobPoller(
+            base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH, use_versioned_url=False
+        )
         result = await poller.run_pydantic(problem, timeout_sec=None)
         return _parse_job_response(result, operator.PauliOperator)
 

classiq/_internals/jobs.py

@@ -52,11 +52,18 @@ class JobPoller:
     DEV_INTERVAL = 0.05
 
     def __init__(
-        self, base_url: str, required_headers: Optional[Set[str]] = None
+        self,
+        base_url: str,
+        required_headers: Optional[Set[str]] = None,
+        use_versioned_url: bool = True,
     ) -> None:
         self._required_headers = required_headers or set()
         client_instance = client()
-        self._base_url = client_instance.make_versioned_url(base_url)
+        self._base_url = (
+            client_instance.make_versioned_url(base_url)
+            if use_versioned_url
+            else base_url
+        )
         self._async_client = client_instance.async_client()
         self._mode = client_instance.config.mode
 

classiq/executor.py

@@ -3,7 +3,6 @@ import functools
 from typing import Optional, Tuple, Union
 
 import more_itertools
-from pydantic import parse_raw_as
 from typing_extensions import TypeAlias
 
 from classiq.interface.backend.backend_preferences import BackendPreferencesTypes
@@ -19,10 +18,7 @@ from classiq.interface.executor.execution_request import (
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.quantum_program import MultipleArguments, QuantumProgram
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.generated_circuit import (
-    ExecutionCircuit,
-    GeneratedCircuit,
-)
+from classiq.interface.generator.generated_circuit import GeneratedCircuit
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
@@ -40,11 +36,8 @@ _MAX_ARGUMENTS_SIZE = 1024
 
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
-) -> Union[GeneratedCircuit, ExecutionCircuit]:
-    return parse_raw_as(
-        Union[GeneratedCircuit, ExecutionCircuit],  # type:ignore[arg-type]
-        quantum_program,
-    )
+) -> GeneratedCircuit:
+    return GeneratedCircuit.parse_raw(quantum_program)
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.33.0'
+SEMVER_VERSION = '0.34.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -9,6 +9,7 @@ from pydantic import BaseModel, validator
 from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.quantum_backend_providers import (
     EXACT_SIMULATORS,
+    AliceBobBackendNames,
     AmazonBraketBackendNames,
     AzureQuantumBackendNames,
     ClassiqAerBackendNames,
@@ -55,6 +56,19 @@ class BackendPreferences(BaseModel):
 AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=5).total_seconds())
 
 
+class AliceBobBackendPreferences(BackendPreferences):
+    backend_service_provider: ProviderTypeVendor.ALICE_BOB
+    api_key: pydantic_backend.PydanticAliceBobApiKeyType = pydantic.Field(
+        ..., description="AliceBob API key"
+    )
+
+    @pydantic.root_validator(pre=True)
+    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(
+            values, "backend_service_provider", ProviderVendor.ALICE_AND_BOB
+        )
+
+
 class ClassiqBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.CLASSIQ
 
@@ -214,6 +228,7 @@ BackendPreferencesTypes = Union[
     AwsBackendPreferences,
     IonqBackendPreferences,
     GCPBackendPreferences,
+    AliceBobBackendPreferences,
 ]
 
 __all__ = [
@@ -230,6 +245,8 @@ __all__ = [
     "IonqBackendNames",
     "ClassiqNvidiaBackendNames",
     "GCPBackendPreferences",
+    "AliceBobBackendPreferences",
+    "AliceBobBackendNames",
 ]
 
 

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):
@@ -143,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,
@@ -156,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
 ]
 
 

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

@@ -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",