classiq 0.86.0__py3-none-any.whl → 0.87.0__py3-none-any.whl

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -0,0 +1,188 @@
+from enum import IntEnum
+from typing import Any, Optional, Union
+
+import sympy
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.backward_compatibility import zip_strict
+
+
+def _copy_generative_flag(
+    from_type: ClassicalType, to_type: Optional[ClassicalType]
+) -> Optional[ClassicalType]:
+    if to_type is None:
+        return None
+    if from_type.is_generative:
+        return to_type.set_generative()
+    return to_type
+
+
+def infer_classical_type(value: Any) -> ClassicalType:
+    if isinstance(value, IntEnum):
+        return Enum(name=type(value).__name__)
+    if isinstance(value, bool):
+        return Bool()
+    if isinstance(value, int):
+        return Integer()
+    if isinstance(value, (float, complex)):
+        return Real()
+    if isinstance(value, list):
+        return ClassicalTuple(
+            element_types=[infer_classical_type(item) for item in value]
+        )
+    if isinstance(value, QmodStructInstance):
+        struct_name = value.struct_declaration.name
+        classical_type = Struct(name=struct_name)
+        classical_type.set_classical_struct_decl(
+            StructDeclaration(
+                name=struct_name,
+                variables={
+                    field_name: infer_classical_type(field_value)
+                    for field_name, field_value in value.fields.items()
+                },
+            )
+        )
+        return classical_type
+    # FIXME: Remove sympy compatibility (CLS-3214)
+    if (
+        isinstance(value, sympy.Basic)
+        and len(value.free_symbols) == 0
+        and value.is_complex
+    ):
+        return Real()
+    raise ClassiqInternalExpansionError
+
+
+def _inject_classical_array_attributes(
+    from_type: ClassicalType, to_type: Union[ClassicalArray, ClassicalTuple]
+) -> Optional[ClassicalType]:
+    if isinstance(to_type, ClassicalArray):
+        if isinstance(from_type, ClassicalArray):
+            length: Optional[Expression]
+            if from_type.has_length:
+                if (
+                    to_type.has_length
+                    and from_type.length_value != to_type.length_value
+                ):
+                    return None
+                length = from_type.length
+            else:
+                length = to_type.length
+            element_type = inject_classical_type_attributes(
+                from_type.element_type, to_type.element_type
+            )
+            if element_type is None:
+                return None
+            return ClassicalArray(element_type=element_type, length=length)
+        if isinstance(from_type, ClassicalTuple):
+            if (
+                to_type.has_length
+                and len(from_type.element_types) != to_type.length_value
+            ):
+                return None
+            element_types = [
+                inject_classical_type_attributes(element_type, to_type.element_type)
+                for element_type in from_type.element_types
+            ]
+            if None in element_types:
+                return None
+            return ClassicalTuple(element_types=element_types)
+        return None
+    if isinstance(from_type, ClassicalArray):
+        if from_type.has_length and from_type.length_value != len(
+            to_type.element_types
+        ):
+            return None
+        element_types = [
+            inject_classical_type_attributes(from_type.element_type, element_type)
+            for element_type in to_type.element_types
+        ]
+        if None in element_types:
+            return None
+        return ClassicalTuple(element_types=element_types)
+    if isinstance(from_type, ClassicalTuple):
+        if len(from_type.element_types) != len(to_type.element_types):
+            return None
+        element_types = [
+            inject_classical_type_attributes(from_element_type, to_element_type)
+            for from_element_type, to_element_type in zip_strict(
+                from_type.element_types, to_type.element_types, strict=True
+            )
+        ]
+        if None in element_types:
+            return None
+        return ClassicalTuple(element_types=element_types)
+    return None
+
+
+def _inject_classical_type_name_attributes(
+    from_type: ClassicalType, to_type: TypeName
+) -> Optional[ClassicalType]:
+    if to_type.is_enum:
+        if isinstance(from_type, Integer) or (
+            isinstance(from_type, TypeName) and from_type.name == to_type.name
+        ):
+            return Enum(name=to_type.name)
+        return None
+    if to_type.has_classical_struct_decl:
+        if not isinstance(from_type, TypeName) or from_type.name != to_type.name:
+            return None
+        classical_type = Struct(name=to_type.name)
+        field_types = {
+            field_name: inject_classical_type_attributes(
+                from_type.classical_struct_decl.variables[field_name],
+                to_type.classical_struct_decl.variables[field_name],
+            )
+            for field_name in to_type.classical_struct_decl.variables
+        }
+        if None in field_types.values():
+            return None
+        classical_type.set_classical_struct_decl(
+            StructDeclaration(name=to_type.name, variables=field_types)
+        )
+        return classical_type
+    return None
+
+
+def inject_classical_type_attributes(
+    from_type: ClassicalType, to_type: ClassicalType
+) -> Optional[ClassicalType]:
+    if isinstance(to_type, Bool):
+        if isinstance(from_type, Bool):
+            return _copy_generative_flag(to_type, Bool())
+        return None
+    if isinstance(to_type, Integer):
+        if isinstance(from_type, (Integer, Real)) or (
+            isinstance(from_type, TypeName) and from_type.is_enum
+        ):
+            return _copy_generative_flag(to_type, Integer())
+        return None
+    if isinstance(to_type, Real):
+        if isinstance(from_type, (Integer, Real)) or (
+            isinstance(from_type, TypeName) and from_type.is_enum
+        ):
+            return _copy_generative_flag(to_type, Real())
+        return None
+    if isinstance(to_type, (ClassicalArray, ClassicalTuple)):
+        return _copy_generative_flag(
+            to_type, _inject_classical_array_attributes(from_type, to_type)
+        )
+    if isinstance(to_type, TypeName):
+        return _copy_generative_flag(
+            to_type, _inject_classical_type_name_attributes(from_type, to_type)
+        )
+    return None

classiq/evaluators/qmod_type_inference/quantum_type_inference.py

@@ -0,0 +1,292 @@
+from typing import TYPE_CHECKING, Optional
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.evaluators.quantum_type_utils import set_bounds
+
+
+def _normalized_qnum(quantum_type: QuantumType) -> QuantumType:
+    if not isinstance(quantum_type, QuantumNumeric):
+        return quantum_type
+    normalized_qnum = QuantumNumeric(
+        size=quantum_type.size,
+        is_signed=(
+            quantum_type.is_signed
+            if quantum_type.is_signed is not None
+            else Expression(expr="False")
+        ),
+        fraction_digits=(
+            quantum_type.fraction_digits
+            if quantum_type.fraction_digits is not None
+            else Expression(expr="0")
+        ),
+    )
+    normalized_qnum.set_bounds(quantum_type.get_bounds())
+    return normalized_qnum
+
+
+def _same_shape(quantum_type_1: QuantumType, quantum_type_2: QuantumType) -> bool:
+    if isinstance(quantum_type_1, QuantumBit) and isinstance(
+        quantum_type_2, QuantumBit
+    ):
+        return True
+    if (
+        isinstance(quantum_type_1, QuantumNumeric)
+        and isinstance(quantum_type_2, QuantumNumeric)
+        and (
+            not quantum_type_1.has_size_in_bits
+            or not quantum_type_2.has_size_in_bits
+            or quantum_type_1.size_in_bits == quantum_type_2.size_in_bits
+        )
+    ):
+        return True
+    if (
+        isinstance(quantum_type_1, QuantumBitvector)
+        and isinstance(quantum_type_2, QuantumBitvector)
+        and (
+            not quantum_type_1.has_constant_length
+            or not quantum_type_2.has_constant_length
+            or quantum_type_1.length_value == quantum_type_2.length_value
+        )
+        and _same_shape(quantum_type_1.element_type, quantum_type_2.element_type)
+    ):
+        return True
+    return (
+        isinstance(quantum_type_1, TypeName)
+        and quantum_type_1.has_fields
+        and isinstance(quantum_type_2, TypeName)
+        and quantum_type_2.has_fields
+        and quantum_type_1.name == quantum_type_2.name
+        and all(
+            _same_shape(
+                quantum_type_1.fields[field_name], quantum_type_2.fields[field_name]
+            )
+            for field_name in quantum_type_1.fields
+        )
+    )
+
+
+def _inject_qnum_type_attributes(
+    from_type: QuantumType, to_type: QuantumNumeric
+) -> QuantumNumeric:
+    size: Optional[Expression]
+    if from_type.has_size_in_bits:
+        size = Expression(expr=str(from_type.size_in_bits))
+    else:
+        size = to_type.size
+    if to_type.is_signed is not None:
+        if to_type.is_signed.is_evaluated():
+            is_signed = Expression(expr=str(to_type.sign_value))
+        else:
+            is_signed = Expression(expr="False")
+    else:
+        is_signed = None
+    if to_type.fraction_digits is not None:
+        if to_type.fraction_digits.is_evaluated():
+            fraction_digits = Expression(expr=str(to_type.fraction_digits_value))
+        else:
+            fraction_digits = Expression(expr="0")
+    else:
+        fraction_digits = None
+    if isinstance(from_type, QuantumNumeric) and not to_type.has_size_in_bits:
+        if (
+            is_signed is None
+            and from_type.is_signed is not None
+            and from_type.is_signed.is_evaluated()
+        ):
+            is_signed = from_type.is_signed
+        if (
+            fraction_digits is None
+            and from_type.fraction_digits is not None
+            and from_type.fraction_digits.is_evaluated()
+        ):
+            fraction_digits = from_type.fraction_digits
+    if size is not None and is_signed is None:
+        is_signed = Expression(expr="False")
+    if size is not None and fraction_digits is None:
+        fraction_digits = Expression(expr="0")
+    updated_type = QuantumNumeric(
+        size=size, is_signed=is_signed, fraction_digits=fraction_digits
+    )
+    updated_type.set_bounds(to_type.get_bounds())
+    set_bounds(_normalized_qnum(from_type), updated_type)
+    return updated_type
+
+
+def _inject_qarray_type_attributes(
+    from_type: QuantumType, to_type: QuantumBitvector
+) -> Optional[QuantumBitvector]:
+    if _same_shape(from_type, to_type):
+        if TYPE_CHECKING:
+            assert isinstance(from_type, QuantumBitvector)
+        if to_type.has_length:
+            length = to_type.length
+        elif from_type.has_length:
+            length = from_type.length
+        elif from_type.has_size_in_bits:
+            raise ClassiqExpansionError(
+                f"Could not infer the length attribute of type {to_type.qmod_type_name}"
+            )
+        else:
+            length = None
+        element_type = inject_quantum_type_attributes(
+            from_type.element_type, to_type.element_type
+        )
+    else:
+        if to_type.has_constant_length:
+            if (
+                from_type.has_size_in_bits
+                and from_type.size_in_bits % to_type.length_value != 0
+            ):
+                return None
+            length = to_type.length
+        elif from_type.has_size_in_bits:
+            if not to_type.element_type.has_size_in_bits:
+                raise ClassiqExpansionError(
+                    f"Could not infer the length attribute of type "
+                    f"{to_type.qmod_type_name}"
+                )
+            if from_type.size_in_bits % to_type.element_type.size_in_bits != 0:
+                return None
+            length = Expression(
+                expr=str(from_type.size_in_bits // to_type.element_type.size_in_bits)
+            )
+        else:
+            length = None
+        if length is not None and from_type.has_size_in_bits:
+            element_type = inject_quantum_type_attributes(
+                QuantumBitvector(
+                    length=Expression(
+                        expr=str(from_type.size_in_bits // length.to_int_value())
+                    )
+                ),
+                to_type.element_type,
+            )
+        else:
+            element_type = inject_quantum_type_attributes(
+                QuantumBitvector(), to_type.element_type
+            )
+    return QuantumBitvector(element_type=element_type, length=length)
+
+
+def _inject_qstruct_type_attributes(
+    from_type: QuantumType, to_type: TypeName
+) -> Optional[TypeName]:
+    if isinstance(from_type, TypeName) and from_type.name == to_type.name:
+        fields = {
+            field_name: inject_quantum_type_attributes(
+                from_type.fields[field_name], to_type.fields[field_name]
+            )
+            for field_name in to_type.fields
+        }
+        if None in fields.values():
+            return None
+    elif not from_type.has_size_in_bits:
+        fields = {
+            field_name: inject_quantum_type_attributes(QuantumBitvector(), field_type)
+            for field_name, field_type in to_type.fields.items()
+        }
+    else:
+        initialized_fields = {
+            field_name: field_type.has_size_in_bits
+            for field_name, field_type in to_type.fields.items()
+        }
+        if sum(initialized_fields.values()) == len(initialized_fields) - 1:
+            flexible_field_name = [
+                field_name
+                for field_name, is_initialized in initialized_fields.items()
+                if not is_initialized
+            ][0]
+            flexible_field_size = from_type.size_in_bits - sum(
+                field_type.size_in_bits
+                for field_name, field_type in to_type.fields.items()
+                if initialized_fields[field_name]
+            )
+            flexible_field_type = inject_quantum_type_attributes(
+                QuantumBitvector(length=Expression(expr=str(flexible_field_size))),
+                to_type.fields[flexible_field_name],
+            )
+            if flexible_field_type is None:
+                return None
+            fields = {
+                field_name: (
+                    flexible_field_type
+                    if field_name == flexible_field_name
+                    else inject_quantum_type_attributes(QuantumBitvector(), field_type)
+                )
+                for field_name, field_type in to_type.fields.items()
+            }
+        else:
+            fields = {
+                field_name: inject_quantum_type_attributes(
+                    QuantumBitvector(), field_type
+                )
+                for field_name, field_type in to_type.fields.items()
+            }
+    classical_type = TypeName(name=to_type.name)
+    classical_type.set_fields(fields)  # type:ignore[arg-type]
+    return classical_type
+
+
+def inject_quantum_type_attributes(
+    from_type: QuantumType, to_type: QuantumType
+) -> Optional[QuantumType]:
+    for qmod_type in (from_type, to_type):
+        if isinstance(qmod_type, TypeName) and not qmod_type.has_fields:
+            raise ClassiqInternalExpansionError
+    if to_type.has_size_in_bits and (
+        (from_type.has_size_in_bits and to_type.size_in_bits != from_type.size_in_bits)
+        or (from_type.minimal_size_in_bits > to_type.size_in_bits)
+    ):
+        return None
+    if isinstance(to_type, QuantumBit):
+        return QuantumBit()
+    if isinstance(to_type, QuantumNumeric):
+        return _inject_qnum_type_attributes(from_type, to_type)
+    if isinstance(to_type, QuantumBitvector):
+        return _inject_qarray_type_attributes(from_type, to_type)
+    if isinstance(to_type, TypeName):
+        return _inject_qstruct_type_attributes(from_type, to_type)
+    raise ClassiqInternalExpansionError
+
+
+def inject_quantum_type_attributes_inplace(
+    from_type: QuantumType, to_type: QuantumType
+) -> bool:
+    updated_type = inject_quantum_type_attributes(from_type, to_type)
+    if updated_type is None:
+        return False
+    if isinstance(to_type, QuantumBit) and isinstance(updated_type, QuantumBit):
+        return True
+    if isinstance(to_type, QuantumNumeric) and isinstance(updated_type, QuantumNumeric):
+        to_type.size = updated_type.size
+        to_type.is_signed = updated_type.is_signed
+        to_type.fraction_digits = updated_type.fraction_digits
+        to_type.set_bounds(updated_type.get_bounds())
+        return True
+    if isinstance(to_type, QuantumBitvector) and isinstance(
+        updated_type, QuantumBitvector
+    ):
+        to_type.length = updated_type.length
+        to_type.element_type = updated_type.element_type
+        return True
+    if (
+        isinstance(to_type, TypeName)
+        and to_type.has_fields
+        and isinstance(updated_type, TypeName)
+        and updated_type.has_fields
+    ):
+        to_type.set_fields(updated_type.fields)
+        return True
+    raise ClassiqInternalExpansionError

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/execution/execution_session.py

@@ -530,7 +530,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))

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