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

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"]
@@ -124,6 +144,14 @@ class ClassicalArray(ClassicalType):
     def has_length(self) -> bool:
         return self.length is not None and self.length.is_evaluated()
 
+    @property
+    def has_constant_length(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.length.is_constant()
+        )
+
     @property
     def length_value(self) -> int:
         if not self.has_length:
@@ -163,6 +191,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 +236,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 +262,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

@@ -101,6 +101,12 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_evaluated for field_type in self.fields.values()
         )
 
+    @property
+    def is_constant(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_constant for field_type in self.fields.values()
+        )
+
     @property
     def has_classical_struct_decl(self) -> bool:
         return self._classical_struct_decl is not None
@@ -177,6 +183,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/generator/transpiler_basis_gates.py

@@ -57,11 +57,15 @@ EXTRA_TWO_QUBIT_GATES: BasisGates = frozenset(
     )
 )
 
+NON_UNITARY_GATES: BasisGates = frozenset(("if_else",))
+
 TWO_QUBIT_GATES = BASIC_TWO_QUBIT_GATES | EXTRA_TWO_QUBIT_GATES
 
 THREE_QUBIT_GATES: BasisGates = frozenset(("ccx", "cswap"))
 DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
-ALL_GATES: BasisGates = SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES
+ALL_GATES: BasisGates = (
+    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
+)
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -132,13 +132,6 @@ class FermionMapping(IntEnum):
     FAST_BRAVYI_KITAEV = 3
 
 
-class FinanceFunctionType(IntEnum):
-    VAR = 0
-    SHORTFALL = 1
-    X_SQUARE = 2
-    EUROPEAN_CALL_OPTION = 3
-
-
 class LadderOperator(IntEnum):
     PLUS = 0
     MINUS = 1
@@ -171,7 +164,6 @@ class QSVMFeatureMapEntanglement(IntEnum):
 __all__ = [
     "Element",
     "FermionMapping",
-    "FinanceFunctionType",
     "LadderOperator",
     "Optimizer",
     "Pauli",

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,13 @@
+import functools
+import operator
+from collections.abc import Mapping
 from typing import TYPE_CHECKING, Literal
 
+import pydantic
+
 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:
@@ -14,6 +20,9 @@ class ClassicalIf(QuantumOperation):
     condition: Expression
     then: "StatementBlock"
     else_: "StatementBlock"
+    _condition_wiring_inouts: dict[str, HandleBinding] = pydantic.PrivateAttr(
+        default_factory=dict
+    )
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["then", "else_"])
@@ -21,3 +30,42 @@ 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(),
+            )
+            | self._condition_wiring_inouts
+        )
+
+    @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/classical_parameter_declaration.py

@@ -33,6 +33,10 @@ class AnonClassicalParameterDeclaration(Parameter):
             }
         )
 
+    @property
+    def qmod_type_name(self) -> str:
+        return self.classical_type.qmod_type_name
+
 
 class ClassicalParameterDeclaration(AnonClassicalParameterDeclaration):
     name: str

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()
         )
 

classiq/interface/model/port_declaration.py

@@ -44,6 +44,18 @@ class AnonPortDeclaration(Parameter):
             raise ClassiqInternalError
         return PortDeclaration(**{**self.__dict__, "name": new_name})
 
+    @property
+    def qmod_type_name(self) -> str:
+        prefix = ""
+        suffix = ""
+        if self.type_modifier in (TypeModifier.Const, TypeModifier.Permutable):
+            prefix += f"{self.type_modifier.name}["
+            suffix += "]"
+        if self.direction != PortDeclarationDirection.Inout:
+            prefix += f"{self.direction.name}["
+            suffix += "]"
+        return f"{prefix}{self.quantum_type.qmod_type_name}{suffix}"
+
 
 class PortDeclaration(AnonPortDeclaration):
     name: str

classiq/interface/model/quantum_function_declaration.py

@@ -190,6 +190,18 @@ class AnonQuantumOperandDeclaration(AnonQuantumFunctionDeclaration):
     def is_generative(self) -> bool:
         return self._is_generative
 
+    @property
+    def qmod_type_name(self) -> str:
+        if self.is_list:
+            type_name = "QCallableList"
+        else:
+            type_name = "QCallable"
+        if len(self.positional_arg_declarations) == 0:
+            params = ""
+        else:
+            params = f"[{', '.join(param.qmod_type_name for param in self.positional_arg_declarations)}]"
+        return f"{type_name}{params}"
+
 
 AnonQuantumFunctionDeclaration.model_rebuild()