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

classiq/interface/generator/circuit_code/types_and_constants.py

@@ -3,7 +3,6 @@ from typing_extensions import TypeAlias
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
-from classiq.interface.hardware import Provider
 
 Code: TypeAlias = str
 CodeAndSyntax: TypeAlias = tuple[Code, QuantumInstructionSet]
@@ -14,14 +13,6 @@ INSTRUCTION_SET_TO_FORMAT: dict[QuantumInstructionSet, QuantumFormat] = {
     QuantumInstructionSet.IONQ: QuantumFormat.IONQ,
     QuantumInstructionSet.INTERNAL: QuantumFormat.EXECUTION_SERIALIZATION,
 }
-VENDOR_TO_INSTRUCTION_SET: dict[Provider, QuantumInstructionSet] = {
-    Provider.CLASSIQ: QuantumInstructionSet.QASM,
-    Provider.IONQ: QuantumInstructionSet.IONQ,
-    Provider.AZURE_QUANTUM: QuantumInstructionSet.QSHARP,
-    Provider.IBM_QUANTUM: QuantumInstructionSet.QASM,
-    Provider.AMAZON_BRAKET: QuantumInstructionSet.QASM,
-}
-DEFAULT_INSTRUCTION_SET = QuantumInstructionSet.QASM
 _MAXIMUM_STRING_LENGTH = 250
 
 

classiq/interface/generator/compiler_keywords.py

@@ -2,6 +2,8 @@ EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
 INPLACE_ARITH_AUX_VAR_PREFIX = "_tmp"
+THEN_KEYWORD = "then"
+ELSE_KEYWORD = "else"
 
 
 def generate_original_function_name(name: str) -> str:

classiq/interface/generator/function_param_list.py

@@ -1,14 +1,142 @@
 import itertools
 
+from classiq.interface.generator.amplitude_loading import AmplitudeLoading
+from classiq.interface.generator.arith.arithmetic import Arithmetic
+from classiq.interface.generator.arith.binary_ops import (
+    Adder,
+    BitwiseAnd,
+    BitwiseOr,
+    BitwiseXor,
+    CyclicShift,
+    Equal,
+    GreaterEqual,
+    GreaterThan,
+    LessEqual,
+    LessThan,
+    LShift,
+    Modulo,
+    Multiplier,
+    NotEqual,
+    Power,
+    RShift,
+    Subtractor,
+)
+from classiq.interface.generator.arith.extremum_operations import Max, Min
+from classiq.interface.generator.arith.logical_ops import LogicalAnd, LogicalOr
+from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation, Sign
+from classiq.interface.generator.commuting_pauli_exponentiation import (
+    CommutingPauliExponentiation,
+)
+from classiq.interface.generator.copy import Copy
+from classiq.interface.generator.entangler_params import (
+    GridEntangler,
+    HypercubeEntangler,
+    TwoDimensionalEntangler,
+)
+from classiq.interface.generator.finance import Finance, FinanceModels, FinancePayoff
 from classiq.interface.generator.function_param_library import FunctionParamLibrary
-from classiq.interface.generator.function_param_list_without_self_reference import (
-    function_param_library_without_self_reference,
+from classiq.interface.generator.hadamard_transform import HadamardTransform
+from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
+    Exponentiation,
+)
+from classiq.interface.generator.hamiltonian_evolution.qdrift import QDrift
+from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (
+    SuzukiTrotter,
+)
+from classiq.interface.generator.hardware_efficient_ansatz import (
+    HardwareEfficientAnsatz,
+)
+from classiq.interface.generator.hartree_fock import HartreeFock
+from classiq.interface.generator.hva import HVA
+from classiq.interface.generator.identity import Identity
+from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
+from classiq.interface.generator.mcu import Mcu
+from classiq.interface.generator.mcx import Mcx
+from classiq.interface.generator.qft import QFT
+from classiq.interface.generator.qsvm import QSVMFeatureMap
+from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
+from classiq.interface.generator.reset import Reset
+from classiq.interface.generator.standard_gates.standard_gates_param_list import (
+    standard_gate_function_param_library,
+)
+from classiq.interface.generator.standard_gates.u_gate import UGate
+from classiq.interface.generator.state_preparation import (
+    BellStatePreparation,
+    ComputationalBasisStatePreparation,
+    ExponentialStatePreparation,
+    GHZStatePreparation,
+    StatePreparation,
+    UniformDistributionStatePreparation,
+    WStatePreparation,
 )
-from classiq.interface.generator.qpe import PhaseEstimation
+from classiq.interface.generator.ucc import UCC
+from classiq.interface.generator.unitary_gate import UnitaryGate
+from classiq.interface.generator.user_defined_function_params import CustomFunction
 
 function_param_library: FunctionParamLibrary = FunctionParamLibrary(
     param_list=itertools.chain(
-        function_param_library_without_self_reference.param_list,
-        {PhaseEstimation},
+        {
+            StatePreparation,
+            ComputationalBasisStatePreparation,
+            UniformDistributionStatePreparation,
+            BellStatePreparation,
+            GHZStatePreparation,
+            WStatePreparation,
+            ExponentialStatePreparation,
+            QFT,
+            BitwiseAnd,
+            BitwiseOr,
+            BitwiseXor,
+            BitwiseInvert,
+            Adder,
+            Arithmetic,
+            Sign,
+            Equal,
+            NotEqual,
+            GreaterThan,
+            GreaterEqual,
+            LessThan,
+            LessEqual,
+            Negation,
+            LogicalAnd,
+            LogicalOr,
+            Subtractor,
+            RShift,
+            LShift,
+            CyclicShift,
+            Modulo,
+            TwoDimensionalEntangler,
+            Finance,
+            FinanceModels,
+            FinancePayoff,
+            HypercubeEntangler,
+            GridEntangler,
+            Mcx,
+            Mcu,
+            CustomFunction,
+            HardwareEfficientAnsatz,
+            UnitaryGate,
+            LinearPauliRotations,
+            Multiplier,
+            Power,
+            HartreeFock,
+            UCC,
+            Min,
+            Max,
+            Exponentiation,
+            CommutingPauliExponentiation,
+            SuzukiTrotter,
+            QDrift,
+            Identity,
+            RandomizedBenchmarking,
+            HVA,
+            UGate,
+            AmplitudeLoading,
+            QSVMFeatureMap,
+            HadamardTransform,
+            Copy,
+            Reset,
+        },
+        standard_gate_function_param_library.param_list,
     )
 )

classiq/interface/generator/functions/classical_type.py

@@ -58,6 +58,14 @@ class ClassicalType(HashableASTNode):
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalScalarProxy(handle, self)
 
+    @property
+    def qmod_type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def raw_qmod_type_name(self) -> str:
+        return self.qmod_type_name
+
     @property
     def expressions(self) -> list[Expression]:
         return []
@@ -79,6 +87,10 @@ class Integer(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "int")
 
+    @property
+    def qmod_type_name(self) -> str:
+        return "CInt"
+
 
 class Real(ClassicalType):
     kind: Literal["real"]
@@ -88,6 +100,10 @@ class Real(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "real")
 
+    @property
+    def qmod_type_name(self) -> str:
+        return "CReal"
+
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
@@ -97,6 +113,10 @@ class Bool(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "bool")
 
+    @property
+    def qmod_type_name(self) -> str:
+        return "CBool"
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -163,6 +183,18 @@ class ClassicalArray(ClassicalType):
             raw_type.set_generative()
         return raw_type
 
+    @property
+    def qmod_type_name(self) -> str:
+        if self.length is None:
+            length = ""
+        else:
+            length = f", {self.length.expr}"
+        return f"CArray[{self.element_type.qmod_type_name}{length}]"
+
+    @property
+    def raw_qmod_type_name(self) -> str:
+        return "CArray"
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -196,10 +228,24 @@ class ClassicalTuple(ClassicalType):
             element_type.is_purely_generative for element_type in self.element_types
         )
 
-    def get_raw_type(self) -> "ConcreteClassicalType":
+    def get_raw_type(self, *, preserve_length: bool = False) -> "ConcreteClassicalType":
         if len(self.element_types) == 0:
             return self
-        raw_type = ClassicalArray(element_type=self.element_types[0].get_raw_type())
+        chosen_element = self.element_types[0]
+        for element in self.element_types:
+            if (
+                not isinstance(element, ClassicalTuple)
+                or len(element.element_types) > 0
+            ):
+                chosen_element = element
+                break
+        if preserve_length:
+            length = Expression(expr=str(len(self.element_types)))
+        else:
+            length = None
+        raw_type = ClassicalArray(
+            element_type=chosen_element.get_raw_type(), length=length
+        )
         if self._is_generative:
             raw_type.set_generative()
         return raw_type
@@ -208,6 +254,17 @@ class ClassicalTuple(ClassicalType):
     def length(self) -> int:
         return len(self.element_types)
 
+    @property
+    def qmod_type_name(self) -> str:
+        raw_type = self.get_raw_type(preserve_length=True)
+        if isinstance(raw_type, ClassicalTuple):
+            return "CArray[0]"
+        return raw_type.qmod_type_name
+
+    @property
+    def raw_qmod_type_name(self) -> str:
+        return "CArray"
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/qmod_python_interface.py

@@ -1,4 +1,19 @@
 from collections.abc import Mapping
 from typing import Any
 
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+
 QmodPyStruct = Mapping[str, Any]
+
+
+def qmod_value_to_dict(qmod_value: Any) -> Any:
+    if isinstance(qmod_value, QmodStructInstance):
+        return {
+            field_name: qmod_value_to_dict(field_value)
+            for field_name, field_value in qmod_value.fields.items()
+        }
+    if isinstance(qmod_value, list):
+        return [qmod_value_to_dict(item) for item in qmod_value]
+    return qmod_value

classiq/interface/generator/functions/type_name.py

@@ -177,6 +177,12 @@ class TypeName(ClassicalType, QuantumType):
         raw_type.set_classical_struct_decl(raw_decl)
         return raw_type
 
+    @property
+    def minimal_size_in_bits(self) -> int:
+        return sum(
+            field_type.minimal_size_in_bits for field_type in self.fields.values()
+        )
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/model/preferences/preferences.py

@@ -50,14 +50,6 @@ class QuantumFormat(StrEnum):
     EXECUTION_SERIALIZATION = "_execution_serialization"
 
 
-_SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {
-    Provider.CLASSIQ: QuantumFormat.QASM,
-    Provider.IONQ: QuantumFormat.IONQ,
-    Provider.AZURE_QUANTUM: QuantumFormat.QSHARP,
-    Provider.IBM_QUANTUM: QuantumFormat.QASM,
-    Provider.AMAZON_BRAKET: QuantumFormat.QASM,
-}
-
 if TYPE_CHECKING:
     PydanticConstrainedQuantumFormatList = list[QuantumFormat]
 else:
@@ -176,7 +168,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         deprecated=True,
     )
     optimization_level: OptimizationLevel = pydantic.Field(
-        default=OptimizationLevel.HIGH,
+        default=OptimizationLevel.LIGHT,
         description="The optimization level used during synthesis; determines the trade-off between synthesis speed and the quality of the results",
     )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
@@ -260,14 +252,6 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
                 "has at least one format that appears twice or more"
             )
 
-        service_provider = info.data.get("backend_service_provider")
-        if service_provider is None:
-            return output_format
-
-        provider_format = _SERVICE_PROVIDER_TO_FORMAT.get(service_provider)
-        if provider_format is not None and provider_format not in output_format:
-            output_format.append(provider_format)
-
         return output_format
 
     @pydantic.field_validator("backend_name")

classiq/interface/generator/quantum_program.py

@@ -19,9 +19,7 @@ from classiq.interface.executor.quantum_instruction_set import QuantumInstructio
 from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.circuit_code.circuit_code import CircuitCodeInterface
 from classiq.interface.generator.circuit_code.types_and_constants import (
-    DEFAULT_INSTRUCTION_SET,
     INSTRUCTION_SET_TO_FORMAT,
-    VENDOR_TO_INSTRUCTION_SET,
     CodeAndSyntax,
 )
 from classiq.interface.generator.generated_circuit_data import (
@@ -82,7 +80,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     def __str__(self) -> str:
         return self.model_dump_json(indent=2)
 
-    def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
+    def _default_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()
         if circuit_code is not None:
             return circuit_code
@@ -91,16 +89,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             missing_formats=list(INSTRUCTION_SET_TO_FORMAT.values())
         )
 
-    def _default_program_code(self) -> CodeAndSyntax:
-        if self.hardware_data.backend_data is None:
-            return self._hardware_agnostic_program_code()
-
-        backend_provider = self.hardware_data.backend_data.hw_provider
-        instruction_set: QuantumInstructionSet = VENDOR_TO_INSTRUCTION_SET.get(
-            backend_provider, DEFAULT_INSTRUCTION_SET
-        )
-        return self.program_circuit.get_code(instruction_set), instruction_set
-
     def to_base_program(self) -> quantum_code.QuantumBaseCode:
         code, syntax = self._default_program_code()
         return quantum_code.QuantumBaseCode(code=code, syntax=syntax)

classiq/interface/helpers/model_normalizer.py

@@ -37,8 +37,8 @@ class ModelNormalizer(Visitor):
 
 class ClearModelInternals(Transformer):
     def visit_Expression(self, expr: Expression) -> Expression:
-        if expr._evaluated_expr is not None and not expr._evaluated_expr.is_constant():
-            expr._evaluated_expr = None
+        expr._evaluated_expr = None
+        expr._try_to_immediate_evaluate()
         return expr
 
     def visit_ClassicalType(self, classical_type: ClassicalType) -> ClassicalType:

classiq/interface/helpers/text_utils.py

@@ -1,5 +1,10 @@
-def s(items: list) -> str:
-    return "" if len(items) == 1 else "s"
+from typing import Union
+
+
+def s(items: Union[list, int]) -> str:
+    if isinstance(items, list):
+        items = len(items)
+    return "" if items == 1 else "s"
 
 
 def are(items: list) -> str:

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "11"
+INTERFACE_VERSION = "12"

classiq/interface/model/classical_if.py

@@ -1,7 +1,11 @@
+import functools
+import operator
+from collections.abc import Mapping
 from typing import TYPE_CHECKING, Literal
 
 from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 if TYPE_CHECKING:
@@ -21,3 +25,39 @@ class ClassicalIf(QuantumOperation):
     @property
     def expressions(self) -> list[Expression]:
         return [self.condition]
+
+    @property
+    def wiring_inputs(self) -> Mapping[str, HandleBinding]:
+        return functools.reduce(
+            operator.ior,
+            (
+                op.wiring_inputs
+                for op in (*self.then, *self.else_)
+                if isinstance(op, QuantumOperation)
+            ),
+            dict(),
+        )
+
+    @property
+    def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
+        return functools.reduce(
+            operator.ior,
+            (
+                op.wiring_inouts
+                for op in (*self.then, *self.else_)
+                if isinstance(op, QuantumOperation)
+            ),
+            dict(),
+        )
+
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return functools.reduce(
+            operator.ior,
+            (
+                op.wiring_outputs
+                for op in (*self.then, *self.else_)
+                if isinstance(op, QuantumOperation)
+            ),
+            dict(),
+        )

classiq/interface/model/handle_binding.py

@@ -156,7 +156,12 @@ class SubscriptHandleBinding(NestedHandleBinding):
     def _get_collapsed_index(self) -> Expression:
         if TYPE_CHECKING:
             assert isinstance(self.base_handle, SlicedHandleBinding)
-        if self.index.is_evaluated() and self.base_handle.start.is_evaluated():
+        if (
+            self.index.is_evaluated()
+            and self.index.is_constant()
+            and self.base_handle.start.is_evaluated()
+            and self.base_handle.start.is_constant()
+        ):
             return Expression(
                 expr=str(
                     self.base_handle.start.to_int_value() + self.index.to_int_value()
@@ -170,7 +175,8 @@ class SubscriptHandleBinding(NestedHandleBinding):
         if (
             isinstance(other_handle, SlicedHandleBinding)
             and self.index.is_evaluated()
-            and other_handle._is_evaluated()
+            and self.index.is_constant()
+            and other_handle.is_constant()
         ):
             return (
                 other_handle.start.to_int_value()
@@ -186,7 +192,8 @@ class SubscriptHandleBinding(NestedHandleBinding):
             isinstance(prefix, SlicedHandleBinding)
             and self.base_handle == prefix.base_handle
             and self.index.is_evaluated()
-            and prefix._is_evaluated()
+            and self.index.is_constant()
+            and prefix.is_constant()
             and prefix.start.to_int_value()
             <= self.index.to_int_value()
             < prefix.end.to_int_value()
@@ -243,19 +250,17 @@ class SlicedHandleBinding(NestedHandleBinding):
         )
 
     def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
-        if not self._is_evaluated():
+        if not self.is_constant():
             return False
         start = self.start.to_int_value()
         end = self.end.to_int_value()
         if (
             isinstance(other_handle, SubscriptHandleBinding)
             and other_handle.index.is_evaluated()
+            and other_handle.index.is_constant()
         ):
             return start <= other_handle.index.to_int_value() < end
-        if (
-            isinstance(other_handle, SlicedHandleBinding)
-            and other_handle._is_evaluated()
-        ):
+        if isinstance(other_handle, SlicedHandleBinding) and other_handle.is_constant():
             other_start = other_handle.start.to_int_value()
             other_end = other_handle.end.to_int_value()
             return start <= other_start < end or other_start <= start < other_end
@@ -264,7 +269,12 @@ class SlicedHandleBinding(NestedHandleBinding):
     def _get_collapsed_start(self) -> Expression:
         if TYPE_CHECKING:
             assert isinstance(self.base_handle, SlicedHandleBinding)
-        if self.start.is_evaluated() and self.base_handle.start.is_evaluated():
+        if (
+            self.start.is_evaluated()
+            and self.start.is_constant()
+            and self.base_handle.start.is_evaluated()
+            and self.base_handle.start.is_constant()
+        ):
             return Expression(
                 expr=str(
                     self.base_handle.start.to_int_value() + self.start.to_int_value()
@@ -275,7 +285,11 @@ class SlicedHandleBinding(NestedHandleBinding):
     def _get_collapsed_stop(self) -> Expression:
         if TYPE_CHECKING:
             assert isinstance(self.base_handle, SlicedHandleBinding)
-        if self._is_evaluated() and self.base_handle.start.is_evaluated():
+        if (
+            self.is_constant()
+            and self.base_handle.start.is_evaluated()
+            and self.base_handle.start.is_constant()
+        ):
             return Expression(
                 expr=str(
                     self.end.to_int_value()
@@ -295,8 +309,8 @@ class SlicedHandleBinding(NestedHandleBinding):
         if (
             isinstance(prefix, SlicedHandleBinding)
             and self.base_handle == prefix.base_handle
-            and self._is_evaluated()
-            and prefix._is_evaluated()
+            and self.is_constant()
+            and prefix.is_constant()
         ):
             prefix_start = prefix.start.to_int_value()
             prefix_end = prefix.end.to_int_value()
@@ -313,14 +327,12 @@ class SlicedHandleBinding(NestedHandleBinding):
                 )
         return super().replace_prefix(prefix, replacement)
 
-    def _is_evaluated(self) -> bool:
-        return self.start.is_evaluated() and self.end.is_evaluated()
-
     def is_constant(self) -> bool:
         return (
             super().is_constant()
-            and self._is_evaluated()
+            and self.start.is_evaluated()
             and self.start.is_constant()
+            and self.end.is_evaluated()
             and self.end.is_constant()
         )