classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/evaluators/quantum_type_utils.py

@@ -3,15 +3,10 @@ from classiq.interface.exceptions import (
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
-from classiq.interface.generator.functions.type_name import (
-    TypeName,
-)
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.inplace_binary_operation import BinaryOperation
 from classiq.interface.model.quantum_type import (
     QuantumBit,
-    QuantumBitvector,
     QuantumNumeric,
     QuantumScalar,
     QuantumType,
@@ -20,129 +15,6 @@ from classiq.interface.model.quantum_type import (
 from classiq.model_expansions.scope import QuantumSymbol, Scope
 
 
-def copy_type_information(
-    from_type: QuantumType,
-    to_type: QuantumType,
-    to_param_name: str,
-) -> None:
-    if isinstance(to_type, QuantumBit):
-        set_size(to_type, from_type.size_in_bits, to_param_name)
-    elif isinstance(to_type, QuantumNumeric):
-        if to_type.size is None and isinstance(from_type, QuantumNumeric):
-            to_type.is_signed = Expression(expr=str(from_type.sign_value))
-            to_type.fraction_digits = Expression(
-                expr=str(from_type.fraction_digits_value)
-            )
-        set_size(to_type, from_type.size_in_bits, to_param_name)
-        set_bounds(from_type, to_type)
-    elif isinstance(to_type, QuantumBitvector):
-        if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
-            from_type.element_type
-        ) == type(to_type.element_type):
-            copy_type_information(
-                from_type.element_type, to_type.element_type, to_param_name
-            )
-        set_size(to_type, from_type.size_in_bits, to_param_name)
-    elif isinstance(to_type, TypeName):
-        if isinstance(from_type, TypeName) and from_type.name == to_type.name:
-            for field in from_type.fields:
-                copy_type_information(
-                    from_type.fields[field], to_type.fields[field], to_param_name
-                )
-        set_size(to_type, from_type.size_in_bits, to_param_name)
-    else:
-        raise ClassiqInternalExpansionError
-
-
-def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
-    if size <= 0:
-        raise ClassiqExpansionError(
-            f"Size for {param_name!r} was deduced to be non-positive: {size!r}"
-        )
-
-    if quantum_type.has_size_in_bits and quantum_type.size_in_bits != size:
-        raise ClassiqExpansionError(
-            f"Size mismatch for variable {param_name!r} between declared size {quantum_type.size_in_bits} and assigned size {size}"
-        )
-
-    if isinstance(quantum_type, QuantumNumeric):
-        quantum_type.size = Expression(expr=str(size))
-        if not quantum_type.has_sign or not quantum_type.has_fraction_digits:
-            quantum_type.is_signed = Expression(expr="False")
-            quantum_type.fraction_digits = Expression(expr="0")
-    elif isinstance(quantum_type, QuantumBitvector):
-        if quantum_type.has_length:
-            if size % quantum_type.length_value != 0:
-                raise ClassiqExpansionError(
-                    f"Size mismatch for variable {param_name!r}. Cannot fit {size} "
-                    f"qubits into an array of {quantum_type.length_value} elements."
-                )
-            set_size(
-                quantum_type.element_type,
-                size // quantum_type.length_value,
-                param_name,
-            )
-        set_length_by_size(quantum_type, size, param_name)
-    elif isinstance(quantum_type, TypeName):
-        fields_without_size = [
-            field_type
-            for field_type in quantum_type.fields.values()
-            if not field_type.has_size_in_bits
-        ]
-        if len(fields_without_size) > 1:
-            raise ClassiqInternalExpansionError(
-                f"QuantumStruct should have at most one field without "
-                f"predetermined size. Found {fields_without_size}."
-            )
-        if len(fields_without_size) == 1:
-            predetermined_size_part = sum(
-                field_type.size_in_bits if field_type.has_size_in_bits else 0
-                for field_type in quantum_type.fields.values()
-            )
-            set_size(fields_without_size[0], size - predetermined_size_part, param_name)
-
-
-def set_element_type(
-    quantum_array: QuantumBitvector, element_type: ConcreteQuantumType
-) -> None:
-    quantum_array.element_type = element_type
-
-
-def set_length(quantum_array: QuantumBitvector, length: int) -> None:
-    quantum_array.length = Expression(expr=str(length))
-
-
-def set_length_by_size(
-    quantum_array: QuantumBitvector, size: int, param_name: str
-) -> None:
-    if size <= 0:
-        raise ClassiqExpansionError(
-            f"Size for {param_name!r} was deduced to be non-positive: {size!r}"
-        )
-
-    if quantum_array.has_size_in_bits and quantum_array.size_in_bits != size:
-        raise ClassiqExpansionError(
-            f"Size mismatch for variable {param_name!r} between declared size "
-            f"{quantum_array.size_in_bits} ({quantum_array.length_value} elements of "
-            f"size {quantum_array.element_type.size_in_bits}) and assigned size {size}."
-        )
-
-    if not quantum_array.element_type.has_size_in_bits:
-        raise ClassiqExpansionError(
-            f"Could not infer element size for array {param_name!r}."
-        )
-    element_size = quantum_array.element_type.size_in_bits
-
-    if size % element_size != 0:
-        raise ClassiqExpansionError(
-            f"Size mismatch for variable {param_name!r}. Cannot fit elements of type "
-            f"{quantum_array.element_type.qmod_type_name} (size {element_size}) into "
-            f"{size} qubits."
-        )
-
-    quantum_array.length = Expression(expr=str(size // element_size))
-
-
 def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
     illegal_qnum_bind_targets = []
     for out_handle in bind.out_handles:
@@ -152,9 +24,6 @@ def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
             continue
         if not out_var_type.has_size_in_bits:
             illegal_qnum_bind_targets.append(str(out_var.handle))
-        elif not out_var_type.has_sign:
-            assert not out_var_type.has_fraction_digits
-            illegal_qnum_bind_targets.append(str(out_var.handle))
     if len(illegal_qnum_bind_targets) > 0:
         raise ClassiqExpansionError(
             f"QNum bind targets {illegal_qnum_bind_targets!r} must be declared or initialized with size, sign, and fraction digits"

classiq/evaluators/type_type_match.py

@@ -21,7 +21,7 @@ def check_signature_match(
 ) -> None:
     if len(decl_params) != len(op_params):
         raise ClassiqExpansionError(
-            f"{location_str} should have {len(decl_params)} parameters, "
+            f"{location_str.capitalize()} should have {len(decl_params)} parameters, "
             f"not {len(op_params)}"
         )
     for idx, (decl_param, op_param) in enumerate(zip(decl_params, op_params)):

classiq/execution/execution_session.py

@@ -340,6 +340,7 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        tolerance: Optional[float] = None,
     ) -> list[tuple[float, ExecutionParams]]:
         """
         Minimizes the given cost function using the quantum program.
@@ -355,6 +356,7 @@ class ExecutionSession:
                     - The value is either a float or a list of floats.
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
+            tolerance: The tolerance for the minimization.
         Returns:
             A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration.
             `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
@@ -365,6 +367,7 @@ class ExecutionSession:
             initial_params=initial_params,
             max_iteration=max_iteration,
             quantile=quantile,
+            tolerance=tolerance,
             _check_deprecation=False,
         )
         result = job.get_minimization_result(_http_client=self._async_client)
@@ -379,6 +382,7 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        tolerance: Optional[float] = None,
         *,
         _check_deprecation: bool = True,
     ) -> ExecutionJob:
@@ -400,6 +404,7 @@ class ExecutionSession:
                     - The value is either a float or a list of floats.
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
+            tolerance: The tolerance for the minimization.
 
         Returns:
             The execution job.
@@ -424,6 +429,7 @@ class ExecutionSession:
                 initial_params=_initial_params,
                 max_iteration=max_iteration,
                 quantile=quantile,
+                tolerance=tolerance,
             )
         else:
             _cost_function = self._hamiltonian_to_pauli_operator(cost_function)
@@ -432,6 +438,7 @@ class ExecutionSession:
                 initial_params=_initial_params,
                 max_iteration=max_iteration,
                 quantile=quantile,
+                tolerance=tolerance,
             )
 
         execution_primitives_input = PrimitivesInput(minimize=minimize)
@@ -530,7 +537,7 @@ class ExecutionSession:
             return PauliOperator(pauli_list=pauli_list)
         pauli_list = []
         for term in cast(list, hamiltonian.terms):
-            paulis = ["I"] * cast(int, hamiltonian.num_qubits)
+            paulis = ["I"] * hamiltonian.num_qubits
             for indexed_pauli in term.paulis:
                 paulis[len(paulis) - indexed_pauli.index - 1] = indexed_pauli.pauli.name
             pauli_list.append(("".join(paulis), term.coefficient))
@@ -545,10 +552,18 @@ class ExecutionSession:
             name: create_qvar_from_quantum_type(reg.quantum_types, name)
             for name, reg in circuit_output_types.items()
         }
-        for name in inspect.signature(qmod_expression_creator).parameters.keys():
+        creator_parameters = inspect.signature(
+            qmod_expression_creator
+        ).parameters.keys()
+        for name in creator_parameters:
             if name not in symbolic_output:
                 raise ClassiqValueError(
-                    f"The provided QVar: {name} does not match the model outputs: {tuple(circuit_output_types.keys())}. "
+                    f"Expected cost function with parameters {tuple(symbolic_output.keys())} corresponding to the quantum program outputs, but found '{name}'. "
+                )
+        for name in symbolic_output:
+            if name not in creator_parameters:
+                raise ClassiqValueError(
+                    f"Expected cost function with parameter '{name}' corresponding to the quantum program outputs. "
                 )
 
         qmod_expression = qmod_expression_creator(**symbolic_output)

classiq/execution/qnn.py

@@ -15,6 +15,7 @@ from classiq.interface.executor.quantum_code import Arguments, MultipleArguments
 
 from classiq import QuantumProgram
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    pauli_operator_to_hamiltonian,
     pauli_operator_to_sparse_hamiltonian,
 )
 from classiq.execution.execution_session import ExecutionSession
@@ -27,7 +28,9 @@ def _execute_qnn_estimate(
     arguments: list[Arguments],
     observable: PauliOperator,
 ) -> ResultsCollection:
-    hamiltonian = pauli_operator_to_sparse_hamiltonian(observable.pauli_list)
+    hamiltonian = pauli_operator_to_sparse_hamiltonian(
+        pauli_operator_to_hamiltonian(observable.pauli_list)
+    )
     return [
         TaggedEstimationResult(
             name=DEFAULT_RESULT_NAME,

classiq/execution/user_budgets.py

@@ -8,7 +8,7 @@ from classiq._internals.async_utils import syncify_function
 
 PROVIDER_MAPPER = {
     ProviderVendor.IONQ: "IONQ",
-    ProviderVendor.IBM_QUANTUM: "IBMQ",
+    ProviderVendor.IBM_QUANTUM: "IBM_CLOUD",
     ProviderVendor.AZURE_QUANTUM: "AZURE",
     ProviderVendor.AMAZON_BRAKET: "AMAZON",
     ProviderVendor.GOOGLE: "GOOGLE",

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.86.1'
+SEMVER_VERSION = '0.88.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -209,23 +209,6 @@ class AwsBackendPreferences(BackendPreferences):
     )
 
 
-class IBMBackendProvider(BaseModel):
-    """
-
-    Represents the provider specs for identifying an IBM Quantum backend.
-
-    Attributes:
-        hub (str): hub parameter of IBM Quantum provider. Defaults to `"ibm-q"`.
-        group (str): group parameter of IBM Quantum provider. Defaults to `"open"`.
-        project (str): project parameter of IBM Quantum provider. Defaults to `"main"`.
-
-    """
-
-    hub: str = "ibm-q"
-    group: str = "open"
-    project: str = "main"
-
-
 class IBMBackendPreferences(BackendPreferences):
     """
     Represents the backend preferences specific to IBM Quantum services.
@@ -234,30 +217,28 @@ class IBMBackendPreferences(BackendPreferences):
     specific to IBM Quantum backends.
 
     Attributes:
-        backend_service_provider (ProviderTypeVendor.IBM_QUANTUM): Indicates the backend service provider as IBM Quantum.
-        access_token (Optional[str]): The IBM Quantum access token to be used with IBM Quantum hosted backends. Defaults to `None`.
-        provider (IBMBackendProvider): Specifications for identifying a single IBM Quantum provider. Defaults to a new `IBMBackendProvider`.
-        qctrl_api_key (Optional[str]): QCTRL API key to access QCTRL optimization abilities.
+        backend_service_provider (ProviderTypeVendor.IBM_CLOUD): Indicates the backend service provider as IBM Cloud.
+        access_token (Optional[str]): 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.
         run_through_classiq (bool): Run through Classiq's credentials. Defaults to `False`.
 
     See examples in the [IBM Quantum Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ibm-backends/?h=).
     """
 
-    backend_service_provider: ProviderTypeVendor.IBM_QUANTUM = pydantic.Field(
+    backend_service_provider: ProviderTypeVendor.IBM_CLOUD = pydantic.Field(
         default=ProviderVendor.IBM_QUANTUM
     )
     access_token: Optional[str] = pydantic.Field(
         default=None,
-        description="IBM Quantum access token to be used"
+        description="IBM Cloud access token to be used"
         " with IBM Quantum hosted backends",
     )
-    provider: IBMBackendProvider = pydantic.Field(
-        default_factory=IBMBackendProvider,
-        description="Provider specs. for identifying a single IBM Quantum provider.",
+    channel: Optional[str] = pydantic.Field(
+        default=None, description="Channel to use for IBM cloud backends."
     )
-    qctrl_api_key: Optional[str] = pydantic.Field(
-        default=None,
-        description="QCTRL API key to access QCTRL optimization abilities",
+    instance_crn: Optional[str] = pydantic.Field(
+        default=None, description="IBM Cloud instance CRN."
     )
     run_through_classiq: bool = pydantic.Field(
         default=False,
@@ -544,7 +525,6 @@ __all__ = [
     "ClassiqSimulatorBackendNames",
     "GCPBackendPreferences",
     "IBMBackendPreferences",
-    "IBMBackendProvider",
     "IQCCBackendPreferences",
     "IntelBackendNames",
     "IntelBackendPreferences",

classiq/interface/backend/quantum_backend_providers.py

@@ -26,7 +26,7 @@ class ProviderVendor(StrEnum):
 
 class ProviderTypeVendor:
     CLASSIQ = Literal[ProviderVendor.CLASSIQ]
-    IBM_QUANTUM = Literal[ProviderVendor.IBM_QUANTUM]
+    IBM_CLOUD = Literal[ProviderVendor.IBM_QUANTUM]
     AZURE_QUANTUM = Literal[ProviderVendor.AZURE_QUANTUM]
     AMAZON_BRAKET = Literal[ProviderVendor.AMAZON_BRAKET]
     IONQ = Literal[ProviderVendor.IONQ]
@@ -108,63 +108,74 @@ class AmazonBraketBackendNames(StrEnum):
 
 
 # The IBM devices were taken from:
-#   from qiskit.providers.fake_provider import FakeProvider
-#   provider = FakeProvider()
+#   from qiskit_ibm_runtime.fake_provider import FakeProviderForBackendV2
+#   provider = FakeProviderForBackendV2()
 #   backends_list = provider.backends()
-#   # Using _normalize_backend_name from `ibm_hardware_graphs.py`
-#   the_devices = [_normalize_backend_name(str(backend)) for backend in backends_list]
+#   the_devices = ["ibm_" + backend.name.split('_')[1] for backend in backends_list.backends()]
 class IBMQHardwareNames(StrEnum):
     """
     IBM backend names which Classiq Supports running on.
     """
 
-    ALMADEN = "Almaden"
-    ARMONK = "Armonk"
-    ATHENS = "Athens"
-    BELEM = "Belem"
-    BOEBLINGEN = "Boeblingen"
-    BOGOTA = "Bogota"
-    BROOKLYN = "Brooklyn"
-    BURLINGTON = "Burlington"
-    CAIRO = "Cairo"
-    CAMBRIDGE = "Cambridge"
-    # CAMBRIDGEALTERNATIVEBASIS = "CambridgeAlternativeBasis"
-    CASABLANCA = "Casablanca"
-    ESSEX = "Essex"
-    GUADALUPE = "Guadalupe"
-    HANOI = "Hanoi"
-    JAKARTA = "Jakarta"
-    JOHANNESBURG = "Johannesburg"
-    KOLKATA = "Kolkata"
-    LAGOS = "Lagos"
-    LIMA = "Lima"
-    LONDON = "London"
-    MANHATTAN = "Manhattan"
-    MANILA = "Manila"
-    MELBOURNE = "Melbourne"
-    MONTREAL = "Montreal"
-    MUMBAI = "Mumbai"
-    NAIROBI = "Nairobi"
-    OPENPULSE2Q = "OpenPulse_2Q"
-    OPENPULSE3Q = "OpenPulse_3Q"
-    OURENSE = "Ourense"
-    PARIS = "Paris"
-    POUGHKEEPSIE = "Poughkeepsie"
-    QASM_SIMULATOR = "qasm_simulator"
-    QUITO = "Quito"
-    ROCHESTER = "Rochester"
-    ROME = "Rome"
-    RUESCHLIKON = "Rueschlikon"
-    SANTIAGO = "Santiago"
-    SINGAPORE = "Singapore"
-    SYDNEY = "Sydney"
-    TENERIFE = "Tenerife"
-    TOKYO = "Tokyo"
-    TORONTO = "Toronto"
-    VALENCIA = "Valencia"
-    VIGO = "Vigo"
-    WASHINGTON = "Washington"
-    YORKTOWN = "Yorktown"
+    IBM_ALGIERS = "ibm_algiers"
+    IBM_ALMADEN = "ibm_almaden"
+    IBM_ARMONK = "ibm_armonk"
+    IBM_ATHENS = "ibm_athens"
+    IBM_AUCKLAND = "ibm_auckland"
+    IBM_BELEM = "ibm_belem"
+    IBM_BOEBLINGEN = "ibm_boeblingen"
+    IBM_BOGOTA = "ibm_bogota"
+    IBM_BRISBANE = "ibm_brisbane"
+    IBM_BROOKLYN = "ibm_brooklyn"
+    IBM_BURLINGTON = "ibm_burlington"
+    IBM_CAIRO = "ibm_cairo"
+    IBM_CAMBRIDGE = "ibm_cambridge"
+    IBM_CASABLANCA = "ibm_casablanca"
+    IBM_CUSCO = "ibm_cusco"
+    IBM_ESSEX = "ibm_essex"
+    IBM_FEZ = "ibm_fez"
+    IBM_FRACTIONAL = "ibm_fractional"
+    IBM_GENEVA = "ibm_geneva"
+    IBM_GUADALUPE = "ibm_guadalupe"
+    IBM_HANOI = "ibm_hanoi"
+    IBM_JAKARTA = "ibm_jakarta"
+    IBM_JOHANNESBURG = "ibm_johannesburg"
+    IBM_KAWASAKI = "ibm_kawasaki"
+    IBM_KOLKATA = "ibm_kolkata"
+    IBM_KYIV = "ibm_kyiv"
+    IBM_KYOTO = "ibm_kyoto"
+    IBM_LAGOS = "ibm_lagos"
+    IBM_LIMA = "ibm_lima"
+    IBM_LONDON = "ibm_london"
+    IBM_MANHATTAN = "ibm_manhattan"
+    IBM_MANILA = "ibm_manila"
+    IBM_MELBOURNE = "ibm_melbourne"
+    IBM_MARRAKESH = "ibm_marrakesh"
+    IBM_MONTREAL = "ibm_montreal"
+    IBM_MUMBAI = "ibm_mumbai"
+    IBM_NAIROBI = "ibm_nairobi"
+    IBM_OSAKA = "ibm_osaka"
+    IBM_OSLO = "ibm_oslo"
+    IBM_OURENSE = "ibm_ourense"
+    IBM_PARIS = "ibm_paris"
+    IBM_PEEKSKILL = "ibm_peekskill"
+    IBM_PERTH = "ibm_perth"
+    IBM_PRAGUE = "ibm_prague"
+    IBM_POUGHKEEPSIE = "ibm_poughkeepsie"
+    IBM_QUEBEC = "ibm_quebec"
+    IBM_QUITO = "ibm_quito"
+    IBM_ROCHESTER = "ibm_rochester"
+    IBM_ROME = "ibm_rome"
+    IBM_SANTIAGO = "ibm_santiago"
+    IBM_SHERBROOKE = "ibm_sherbrooke"
+    IBM_SINGAPORE = "ibm_singapore"
+    IBM_SYDNEY = "ibm_sydney"
+    IBM_TORINO = "ibm_torino"
+    IBM_TORONTO = "ibm_toronto"
+    IBM_VALENCIA = "ibm_valencia"
+    IBM_VIGO = "ibm_vigo"
+    IBM_WASHINGTON = "ibm_washington"
+    IBM_YORKTOWN = "ibm_yorktown"
 
 
 class ClassiqNvidiaBackendNames(StrEnum):

classiq/interface/execution/primitives.py

@@ -17,6 +17,7 @@ class MinimizeCostInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     initial_params: Arguments
     max_iteration: int
     quantile: float
+    tolerance: Optional[float]
 
 
 class MinimizeClassicalCostInput(MinimizeCostInput):

classiq/interface/generator/application_apis/__init__.py

@@ -6,7 +6,6 @@ from .arithmetic_declarations import *  # noqa: F403
 from .chemistry_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
 from .entangler_declarations import *  # noqa: F403
-from .finance_declarations import *  # noqa: F403
 from .qsvm_declarations import *  # noqa: F403
 
 populate_builtin_declarations(vars().values())