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

classiq/interface/backend/provider_config/provider_config.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class ProviderConfig(BaseModel):
+    """
+    Provider-specific configuration data for execution, such as API keys and
+    machine-specific parameters.
+    """

classiq/interface/backend/provider_config/providers/alice_bob.py

@@ -0,0 +1,47 @@
+import pydantic
+
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+
+
+class AliceBobConfig(ProviderConfig):
+    """
+    Configuration specific to Alice&Bob.
+
+    Attributes:
+        distance (int | None):
+            The number of times information is duplicated in the repetition code.
+            - **Tooltip**: Phase-flip probability decreases exponentially with this parameter, bit-flip probability increases linearly.
+            - **Supported Values**: 3 to 300, though practical values are usually lower than 30.
+            - **Default**: None.
+
+        kappa_1 (float | None):
+            The rate at which the cat qubit loses one photon, creating a bit-flip.
+            - **Tooltip**: Lower values mean lower error rates.
+            - **Supported Values**: 10 to 10^5. Current hardware is at ~10^3.
+            - **Default**: None.
+
+        kappa_2 (float | None):
+            The rate at which the cat qubit is stabilized using two-photon dissipation.
+            - **Tooltip**: Higher values mean lower error rates.
+            - **Supported Values**: 100 to 10^9. Current hardware is at ~10^5.
+            - **Default**: None.
+
+        average_nb_photons (float | None):
+            The average number of photons.
+            - **Tooltip**: Bit-flip probability decreases exponentially with this parameter, phase-flip probability increases linearly.
+            - **Supported Values**: 4 to 10^5, though practical values are usually lower than 30.
+            - **Default**: None.
+    """
+
+    distance: int | None = pydantic.Field(
+        default=None, description="Repetition code distance"
+    )
+    kappa_1: float | None = pydantic.Field(
+        default=None, description="One-photon dissipation rate (Hz)"
+    )
+    kappa_2: float | None = pydantic.Field(
+        default=None, description="Two-photon dissipation rate (Hz)"
+    )
+    average_nb_photons: float | None = pydantic.Field(
+        default=None, description="Average number of photons"
+    )

classiq/interface/backend/provider_config/providers/aqt.py

@@ -0,0 +1,16 @@
+import pydantic
+
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+
+
+class AQTConfig(ProviderConfig):
+    """
+    Configuration specific to AQT (Alpine Quantum Technologies).
+
+    Attributes:
+        api_key: The API key required to access AQT's quantum computing services.
+        workspace: The AQT workspace where the simulator/hardware is located.
+    """
+
+    api_key: str | None = pydantic.Field(default=None, description="AQT API key")
+    workspace: str = pydantic.Field(description="AQT workspace")

classiq/interface/backend/provider_config/providers/azure.py

@@ -0,0 +1,37 @@
+import pydantic
+
+from classiq.interface.backend import pydantic_backend
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+
+
+class AzureConfig(ProviderConfig):
+    """
+    Configuration specific to Azure.
+
+    Attributes:
+        location (str): Azure region. Defaults to `"East US"`.
+        tenant_id (str | None): Azure Tenant ID used to identify the directory in which the application is registered.
+        client_id (str | None): Azure Client ID, also known as the application ID, which is used to authenticate the application.
+        client_secret (str | None): Azure Client Secret associated with the application, used for authentication.
+        resource_id (str | None): Azure Resource ID, including the subscription ID, resource group, and workspace, typically used for personal resources.
+        ionq_error_mitigation (bool): Should use error mitigation when running on IonQ through Azure. Defaults to `False`.
+    """
+
+    location: str = pydantic.Field(
+        default="East US", description="Azure personal resource region"
+    )
+
+    tenant_id: str | None = pydantic.Field(default=None, description="Azure Tenant ID")
+    client_id: str | None = pydantic.Field(default=None, description="Azure Client ID")
+    client_secret: str | None = pydantic.Field(
+        default=None, description="Azure Client Secret"
+    )
+    resource_id: pydantic_backend.PydanticAzureResourceIDType | None = pydantic.Field(
+        default=None,
+        description="Azure Resource ID (including Azure subscription ID, resource "
+        "group and workspace), for personal resource",
+    )
+    ionq_error_mitigation: bool = pydantic.Field(
+        default=False,
+        description="Error mitigation configuration upon running on IonQ through Azure.",
+    )

classiq/interface/backend/provider_config/providers/braket.py

@@ -0,0 +1,39 @@
+import pydantic
+
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+
+
+class BraketConfig(ProviderConfig):
+    """
+    Configuration specific to Amazon Braket.
+
+    Attributes:
+        braket_access_key_id (str | None):
+            The access key id of user with full braket access
+
+        braket_secret_access_key (str | None):
+            The secret key assigned to the access key id for the user with full braket access.
+
+        s3_bucket_name (str | None):
+            The name of the S3 bucket where results and other related data will be stored.
+            This field should contain a valid S3 bucket name under your AWS account.
+
+        s3_folder (pydantic_backend.PydanticS3BucketKey | None):
+            The folder path within the specified S3 bucket. This allows for organizing
+            results and data under a specific directory within the S3 bucket.
+    """
+
+    braket_access_key_id: str | None = pydantic.Field(
+        default=None,
+        description="Key id assigned to user with credentials to access Braket service",
+    )
+    braket_secret_access_key: str | None = pydantic.Field(
+        default=None,
+        description="Secret access key assigned to user with credentials to access Braket service",
+    )
+    s3_bucket_name: str | None = pydantic.Field(
+        default=None, description="S3 Bucket Name"
+    )
+    s3_folder: str | None = pydantic.Field(
+        default=None, description="S3 Folder Path Within The S3 Bucket"
+    )

classiq/interface/backend/provider_config/providers/ibm.py

@@ -0,0 +1,26 @@
+import pydantic
+
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+
+
+class IBMConfig(ProviderConfig):
+    """
+    Configuration specific to IBM.
+
+    Attributes:
+        access_token (str | None): The IBM Cloud access token to be used with IBM Quantum hosted backends. Defaults to `None`.
+        channel (str): Channel to use for IBM cloud backends. Defaults to `"ibm_cloud"`.
+        instance_crn (str): The IBM Cloud instance CRN (Cloud Resource Name) for the IBM Quantum service.
+    """
+
+    access_token: str | None = pydantic.Field(
+        default=None,
+        description="IBM Cloud access token to be used"
+        " with IBM Quantum hosted backends.",
+    )
+    channel: str = pydantic.Field(
+        default="ibm_cloud", description="Channel to use for IBM cloud backends."
+    )
+    instance_crn: str | None = pydantic.Field(
+        default=None, description="IBM Cloud instance CRN."
+    )

classiq/interface/backend/provider_config/providers/ionq.py

@@ -0,0 +1,22 @@
+import pydantic
+
+from classiq.interface.backend import pydantic_backend
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+
+
+class IonQConfig(ProviderConfig):
+    """
+    Configuration specific to IonQ.
+
+     Attributes:
+         api_key (PydanticIonQApiKeyType | None): Key to access IonQ API.
+         error_mitigation (bool): A configuration option to enable or disable error mitigation during execution. Defaults to `False`.
+    """
+
+    api_key: pydantic_backend.PydanticIonQApiKeyType | None = pydantic.Field(
+        default=None, description="IonQ API key."
+    )
+    error_mitigation: bool = pydantic.Field(
+        default=False,
+        description="Enable error mitigation during execution.",
+    )

classiq/interface/backend/quantum_backend_providers.py

@@ -2,6 +2,8 @@ from typing import Literal, Union
 
 from classiq.interface.enum_utils import StrEnum
 
+__all__ = ["ProviderVendor"]
+
 
 class AnalyzerProviderVendor(StrEnum):
     IBM_QUANTUM = "IBM Quantum"
@@ -10,6 +12,10 @@ class AnalyzerProviderVendor(StrEnum):
 
 
 class ProviderVendor(StrEnum):
+    """
+    Enum representing various quantum computing service providers.
+    """
+
     CLASSIQ = "Classiq"
     IBM_QUANTUM = "IBM Quantum"
     AZURE_QUANTUM = "Azure Quantum"
@@ -20,7 +26,6 @@ class ProviderVendor(StrEnum):
     OQC = "OQC"
     INTEL = "Intel"
     AQT = "AQT"
-    IQCC = "IQCC"
     CINECA = "CINECA"
 
 
@@ -35,10 +40,23 @@ class ProviderTypeVendor:
     OQC = Literal[ProviderVendor.OQC]
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
-    IQCC = Literal[ProviderVendor.IQCC]
     CINECA = Literal[ProviderVendor.CINECA]
 
 
+PROVIDER_NAME_MAPPER = {
+    ProviderVendor.IONQ: "IONQ",
+    ProviderVendor.IBM_QUANTUM: "IBM_CLOUD",
+    ProviderVendor.AZURE_QUANTUM: "AZURE",
+    ProviderVendor.AMAZON_BRAKET: "AMAZON",
+    ProviderVendor.GOOGLE: "GOOGLE",
+    ProviderVendor.ALICE_AND_BOB: "ALICE_AND_BOB",
+    ProviderVendor.OQC: "OQC",
+    ProviderVendor.INTEL: "INTEL",
+    ProviderVendor.AQT: "AQT",
+    ProviderVendor.CLASSIQ: "CLASSIQ",
+}
+
+
 class ClassiqSimulatorBackendNames(StrEnum):
     """
 

classiq/interface/chemistry/ansatz_library.py

@@ -1,13 +1,11 @@
-from typing import Optional
-
 from pydantic import BaseModel
 
 
 class HardwareEfficientConstraints(BaseModel):
     num_qubits: int
-    num_two_qubit_gates: Optional[int] = None
-    num_one_qubit_gates: Optional[int] = None
-    max_depth: Optional[int] = None
+    num_two_qubit_gates: int | None = None
+    num_one_qubit_gates: int | None = None
+    max_depth: int | None = None
 
 
 class HardwareEfficient(BaseModel):

classiq/interface/chemistry/operator.py

@@ -1,7 +1,7 @@
 from collections.abc import Collection, Iterable
 from functools import reduce
 from itertools import combinations
-from typing import Any, Optional, Union, cast
+from typing import Any, cast
 
 import numpy as np
 import pydantic
@@ -65,7 +65,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
 
     @staticmethod
     def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType],
+        coeff: sympy.Expr | ParameterComplexType,
     ) -> ParameterComplexType:
         if isinstance(coeff, str):
             validate_expression_str(coeff)
@@ -219,7 +219,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     def from_unzipped_lists(
         cls,
         operators: list[list["Pauli"]],
-        coefficients: Optional[list[complex]] = None,
+        coefficients: list[complex] | None = None,
     ) -> "PauliOperator":
         if coefficients is None:
             coefficients = [1] * len(operators)

classiq/interface/combinatorial_optimization/examples/knapsack.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import numpy as np
 import pyomo.core as pyo
 
@@ -7,8 +5,8 @@ import pyomo.core as pyo
 def knapsack(
     values: list[int],
     upper_bound: int,
-    weights: Optional[list[int]] = None,
-    max_weight: Optional[int] = None,
+    weights: list[int] | None = None,
+    max_weight: int | None = None,
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
 

classiq/interface/combinatorial_optimization/examples/tsp_digraph.py

@@ -1,12 +1,11 @@
 import itertools
-from typing import Union
 
 import networkx as nx
 import pyomo.core as pyo
 
 
 def tsp_digraph(
-    graph: nx.DiGraph, source: Union[int, str], sink: Union[int, str], nonedge: int
+    graph: nx.DiGraph, source: int | str, sink: int | str, nonedge: int
 ) -> pyo.ConcreteModel:
     model = pyo.ConcreteModel()
 

classiq/interface/compression_utils.py

@@ -1,19 +1,18 @@
 import base64
 from collections.abc import Sequence
-from typing import Union
 
 import zstandard as zstd
 from pydantic import BaseModel
 from pydantic_core import from_json, to_json
 
 
-def compress_pydantic(obj: Union[BaseModel, Sequence[BaseModel]]) -> bytes:
+def compress_pydantic(obj: BaseModel | Sequence[BaseModel]) -> bytes:
     json_data = to_json(obj)
     compressed_data = _compress(json_data, level=22)  # max compression level
     return compressed_data
 
 
-def decompress(compressed_data: bytes) -> Union[dict, list[dict]]:
+def decompress(compressed_data: bytes) -> dict | list[dict]:
     decompressed_data = _decompress(compressed_data)
     return from_json(decompressed_data)
 

classiq/interface/debug_info/debug_info.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping, Sequence
-from typing import Optional, Union, cast
+from typing import Union, cast
 from uuid import UUID
 
 from pydantic import BaseModel, Field
@@ -20,11 +20,12 @@ ParameterValue = Union[float, int, str, None]
 
 class FunctionDebugInfo(BaseModel):
     name: str
-    statement_type: Union[StatementType, None] = None
+    statement_type: StatementType | None = None
     is_inverse: bool = Field(default=False)
-    control_variable: Optional[str] = Field(default=None)
+    is_daggered: bool = Field(default=False)
+    control_variable: str | None = Field(default=None)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
-    node: Optional[ConcreteQuantumStatement] = None
+    node: ConcreteQuantumStatement | None = None
 
     @property
     def is_allocate_or_free(self) -> bool:
@@ -61,7 +62,7 @@ class DebugInfoCollection(BaseModel):
     def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
         self.data[str(key)] = value
 
-    def get(self, key: UUID) -> Optional[FunctionDebugInfo]:
+    def get(self, key: UUID) -> FunctionDebugInfo | None:
         return self.data.get(str(key))
 
     def __getitem__(self, key: UUID) -> FunctionDebugInfo:
@@ -70,7 +71,7 @@ class DebugInfoCollection(BaseModel):
     def __contains__(self, key: UUID) -> bool:
         return str(key) in self.data
 
-    def get_blackbox_data(self, key: UUID) -> Optional[FunctionDebugInfoInterface]:
+    def get_blackbox_data(self, key: UUID) -> FunctionDebugInfoInterface | None:
         if (debug_info := self.get(key)) is None:
             return None
         return self.blackbox_data.get(debug_info.name)
@@ -103,7 +104,7 @@ def new_function_debug_info_by_node(
 
 
 def calculate_port_to_passed_variable_mapping(
-    arg_decls: Sequence[PositionalArg], args: Sequence[Union[ArgValue, None]]
+    arg_decls: Sequence[PositionalArg], args: Sequence[ArgValue | None]
 ) -> dict[str, str]:
     return {
         arg_decl.name: str(cast(ConcreteHandleBinding, arg))

classiq/interface/exceptions.py

@@ -1,6 +1,5 @@
 import logging
 from collections.abc import Iterable
-from typing import Optional
 
 _logger = logging.getLogger(__name__)
 
@@ -53,7 +52,7 @@ class ClassiqAnalyzerVisualizationError(ClassiqError):
 
 
 class ClassiqAPIError(ClassiqError):
-    def __init__(self, message: str, status_code: Optional[int] = None) -> None:
+    def __init__(self, message: str, status_code: int | None = None) -> None:
         self.status_code = status_code
         super().__init__(message)
 
@@ -66,6 +65,10 @@ class ClassiqValueError(ClassiqError, ValueError):
     pass
 
 
+class ClassiqTypeError(ClassiqError, TypeError):
+    pass
+
+
 class ClassiqArithmeticError(ClassiqValueError):
     pass
 
@@ -92,10 +95,6 @@ class ClassiqQFuncError(ClassiqValueError):
     pass
 
 
-class ClassiqQSVMError(ClassiqValueError):
-    pass
-
-
 class ClassiqQNNError(ClassiqValueError):
     pass
 
@@ -187,7 +186,7 @@ class ClassiqExpansionError(ClassiqError):
 
 
 class ClassiqInternalError(ClassiqError):
-    def __init__(self, message: Optional[str] = None) -> None:
+    def __init__(self, message: str | None = None) -> None:
         final_message = "Internal error occurred. Please contact Classiq support."
         if message is not None:
             final_message += f"\nError: {message}"
@@ -196,3 +195,7 @@ class ClassiqInternalError(ClassiqError):
 
 class ClassiqInternalExpansionError(ClassiqInternalError):
     pass
+
+
+class ClassiqInternalArithmeticError(ClassiqInternalError):
+    pass

classiq/interface/execution/primitives.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Union
 
 from pydantic import BaseModel, Field
 
@@ -17,7 +17,7 @@ class MinimizeCostInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     initial_params: Arguments
     max_iteration: int
     quantile: float
-    tolerance: Optional[float]
+    tolerance: float | None
 
 
 class MinimizeClassicalCostInput(MinimizeCostInput):
@@ -41,7 +41,7 @@ ConcreteMinimizeCostInput = Annotated[
 
 
 class PrimitivesInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
-    sample: Optional[list[Arguments]] = Field(default=None)
-    estimate: Optional[EstimateInput] = Field(default=None)
-    minimize: Optional[ConcreteMinimizeCostInput] = Field(default=None)
-    random_seed: Optional[int] = Field(default=None)
+    sample: list[Arguments] | None = Field(default=None)
+    estimate: EstimateInput | None = Field(default=None)
+    minimize: ConcreteMinimizeCostInput | None = Field(default=None)
+    random_seed: int | None = Field(default=None)

classiq/interface/executor/estimate_cost.py

@@ -1,4 +1,4 @@
-from typing import Callable
+from collections.abc import Callable
 
 import numpy as np
 

classiq/interface/executor/execution_preferences.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 
 from classiq.interface.backend.backend_preferences import (
@@ -43,7 +41,7 @@ class ExecutionPreferences(pydantic.BaseModel):
         job_name (Optional[str]): The name of the job, with a minimum length of 1 character.
     """
 
-    noise_properties: Optional[NoiseProperties] = pydantic.Field(
+    noise_properties: NoiseProperties | None = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
     random_seed: int = pydantic.Field(
@@ -53,13 +51,13 @@ class ExecutionPreferences(pydantic.BaseModel):
     backend_preferences: BackendPreferencesTypes = backend_preferences_field(
         backend_name=ClassiqSimulatorBackendNames.SIMULATOR
     )
-    num_shots: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
+    num_shots: pydantic.PositiveInt | None = pydantic.Field(default=None)
     transpile_to_hardware: TranspilationOption = pydantic.Field(
         default=TranspilationOption.DECOMPOSE,
         description="Transpile the circuit to the hardware basis gates before execution",
         title="Transpilation Option",
     )
-    job_name: Optional[str] = pydantic.Field(
+    job_name: str | None = pydantic.Field(
         min_length=1, description="The job name", default=None
     )
 

classiq/interface/executor/execution_request.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Union
 
 import pydantic
 from pydantic import BaseModel, Field
@@ -51,28 +51,28 @@ class ProviderJobs(BaseModel):
 class JobCost(BaseModel):
     total_cost: float = Field(default=0)
     currency_code: str = Field(default="USD")
-    organization: Optional[str] = Field(default=None)
+    organization: str | None = Field(default=None)
     jobs: list[ProviderJobs] = Field(default=[])
 
 
 class ExecutionJobDetails(VersionedModel):
     id: str
 
-    name: Optional[str] = Field(default=None)
+    name: str | None = Field(default=None)
     start_time: datetime
-    end_time: Optional[datetime] = Field(default=None)
+    end_time: datetime | None = Field(default=None)
 
-    provider: Optional[str] = Field(default=None)
-    backend_name: Optional[str] = Field(default=None)
+    provider: str | None = Field(default=None)
+    backend_name: str | None = Field(default=None)
 
     status: JobStatus
 
-    num_shots: Optional[int] = Field(default=None)
-    program_id: Optional[str] = Field(default=None)
+    num_shots: int | None = Field(default=None)
+    program_id: str | None = Field(default=None)
 
-    error: Optional[str] = Field(default=None)
+    error: str | None = Field(default=None)
 
-    cost: Optional[JobCost] = Field(default=None)
+    cost: JobCost | None = Field(default=None)
 
 
 class ExecutionJobsQueryResults(VersionedModel):

classiq/interface/executor/execution_result.py

@@ -1,7 +1,6 @@
-from typing import Annotated, Any, Literal, Union
+from typing import Annotated, Any, Literal, TypeAlias, Union
 
 from pydantic import BaseModel, ConfigDict, Field
-from typing_extensions import TypeAlias
 
 from classiq.interface.applications.iqae.iqae_result import IQAEResult
 from classiq.interface.enum_utils import StrEnum

classiq/interface/executor/quantum_code.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -35,7 +35,7 @@ class QuantumBaseCode(BaseModel):
     @pydantic.field_validator("code")
     @classmethod
     def load_quantum_program(
-        cls, code: Union[CodeType, IonqQuantumCircuit], values: ValidationInfo
+        cls, code: CodeType | IonqQuantumCircuit, values: ValidationInfo
     ) -> CodeType:
         syntax = values.data.get("syntax")
         if isinstance(code, IonqQuantumCircuit):
@@ -57,11 +57,11 @@ class QuantumCode(QuantumBaseCode):
         default_factory=dict,
         description="The map of outputs to their qubits in the circuit.",
     )
-    registers_initialization: Optional[RegistersInitialization] = pydantic.Field(
+    registers_initialization: RegistersInitialization | None = pydantic.Field(
         default=None,
         description="Initial conditions for the different registers in the circuit.",
     )
-    synthesis_execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
+    synthesis_execution_data: ExecutionData | None = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
     model_config = ConfigDict(validate_assignment=True)
 
@@ -90,9 +90,9 @@ class QuantumCode(QuantumBaseCode):
     @classmethod
     def validate_synthesis_execution_data(
         cls,
-        synthesis_execution_data: Optional[ExecutionData],
+        synthesis_execution_data: ExecutionData | None,
         values: ValidationInfo,
-    ) -> Optional[ExecutionData]:
+    ) -> ExecutionData | None:
         if (
             synthesis_execution_data is not None
             and synthesis_execution_data.function_execution
@@ -103,8 +103,8 @@ class QuantumCode(QuantumBaseCode):
 
     @staticmethod
     def from_file(
-        file_path: Union[str, Path],
-        syntax: Optional[Union[str, QuantumInstructionSet]] = None,
+        file_path: str | Path,
+        syntax: str | QuantumInstructionSet | None = None,
         arguments: MultipleArguments = (),
     ) -> QuantumCode:
         path = Path(file_path)