classiq 0.69.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

classiq/interface/generator/functions/type_name.py

@@ -4,7 +4,15 @@ from typing import TYPE_CHECKING, Any, Literal, Optional
 import pydantic
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
+    QmodQStructProxy,
+)
 from classiq.interface.generator.functions.classical_type import (
     ClassicalType,
 )
@@ -16,6 +24,7 @@ from classiq.interface.model.quantum_type import (
 
 if TYPE_CHECKING:
     from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+    from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
 class TypeName(ClassicalType, QuantumType):
@@ -24,6 +33,9 @@ class TypeName(ClassicalType, QuantumType):
     _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
         pydantic.PrivateAttr(default=None)
     )
+    _classical_struct_decl: Optional["StructDeclaration"] = pydantic.PrivateAttr(
+        default=None
+    )
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -40,7 +52,7 @@ class TypeName(ClassicalType, QuantumType):
             )
 
     def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
-        from classiq.interface.generator.expressions.qmod_qstruct_proxy import (
+        from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
             QmodQStructProxy,
         )
 
@@ -81,6 +93,18 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_evaluated for field_type in self.fields.values()
         )
 
+    @property
+    def has_classical_struct_decl(self) -> bool:
+        return self._classical_struct_decl is not None
+
+    def set_classical_struct_decl(self, decl: "StructDeclaration") -> None:
+        self._classical_struct_decl = decl
+
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        if self._classical_struct_decl is None:
+            raise ClassiqExpansionError(f"Type {self.name!r} is undefined")
+        return ClassicalStructProxy(handle, self._classical_struct_decl)
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -1,4 +1,5 @@
 import logging
+import re
 from typing import Literal, Optional, Union
 
 import pydantic
@@ -7,6 +8,9 @@ from typing_extensions import TypeAlias
 
 from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.compiler_keywords import (
+    generate_original_function_name,
+)
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
@@ -32,6 +36,11 @@ ParameterName = str
 IOQubitMapping: TypeAlias = dict[str, tuple[int, ...]]
 
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["__"] = "__"
+QASM_SEPARATOR = "_"
+SPLIT_MARKER: str = "part"
+PART_SUFFIX_REGEX = re.compile(
+    rf".+{QASM_SEPARATOR}{SPLIT_MARKER}{QASM_SEPARATOR}(\d+)$"
+)
 
 VISUALIZATION_HIDE_LIST = [
     "apply_to_all",
@@ -168,9 +177,18 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
 
     @property
     def name(self) -> str:
-        if self.generated_function is None:
-            return ""
-        return self.generated_function.name
+        generated_name = self.generated_function.name if self.generated_function else ""
+        # Temp fix for currently "supported" statements (same as for level_ property)
+        if generated_name in {StatementType.CONTROL, StatementType.POWER}:
+            return generated_name
+        if self.first_back_ref and isinstance(self.first_back_ref, QuantumFunctionCall):
+            name = generate_original_function_name(self.first_back_ref.func_name)
+            if part_match := PART_SUFFIX_REGEX.match(generated_name):
+                suffix = f" [{part_match.group(1)}]"
+            else:
+                suffix = ""
+            return f"{name}{suffix}"
+        return generated_name
 
     @property
     def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:

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

@@ -47,6 +47,7 @@ class QuantumFormat(StrEnum):
     IONQ = "ionq"
     CIRQ_JSON = "cirq_json"
     QASM_CIRQ_COMPATIBLE = "qasm_cirq_compatible"
+    EXECUTION_SERIALIZATION = "_execution_serialization"
 
 
 _SERVICE_PROVIDER_TO_FORMAT: dict[Provider, QuantumFormat] = {

classiq/interface/generator/quantum_program.py

@@ -117,7 +117,6 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         instruction_set: Optional[QuantumInstructionSet] = None,
     ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
-
         if instruction_set is not None:
             code, syntax = (
                 self.program_circuit.get_code(instruction_set),

classiq/interface/model/native_function_definition.py

@@ -10,13 +10,6 @@ if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
 
 
-class FunctionSynthesisData(pydantic.BaseModel):
-    should_synthesize_separately: bool = pydantic.Field(
-        default=False,
-        description="Whether the function should be synthesized separately.",
-    )
-
-
 class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     """
     Facilitates the creation of a user-defined composite function
@@ -28,6 +21,3 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
     body: "StatementBlock" = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
-    synthesis_data: FunctionSynthesisData = pydantic.Field(
-        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
-    )

classiq/interface/model/quantum_type.py

@@ -11,13 +11,17 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
+    QmodQArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQBitProxy,
     QmodQNumProxy,
     QmodQScalarProxy,
 )
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import HandleBinding
 
@@ -213,6 +217,14 @@ class QuantumNumeric(QuantumScalar):
             0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
         )
 
+    @property
+    def is_qbit(self) -> bool:
+        return (
+            self.size_in_bits == 1
+            and self.fraction_digits_value == 0
+            and not self.sign_value
+        )
+
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -12,9 +12,15 @@ from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
 )
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
-from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qstruct_proxy import (
+    QmodQStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.type_proxy import TypeProxy
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,

classiq/model_expansions/evaluators/arg_type_match.py

@@ -3,10 +3,12 @@ from enum import Enum
 from typing import Any
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.functions.classical_type import (
     StructMetaType,
 )

classiq/model_expansions/evaluators/classical_expression.py

@@ -23,13 +23,13 @@ def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
         )
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and evaluated.value.quantum_type.has_size_in_bits
+        and evaluated.value.quantum_type.is_evaluated
     }
     uninitialized_locals = {
         name
         for name, evaluated in all_symbols
         if isinstance(evaluated.value, QuantumSymbol)
-        and not evaluated.value.quantum_type.has_size_in_bits
+        and not evaluated.value.quantum_type.is_evaluated
     }
 
     ret = evaluate(expr, locals_dict, uninitialized_locals)

classiq/model_expansions/evaluators/control.py

@@ -8,7 +8,7 @@ from classiq.interface.generator.arith.argument_utils import (
     unsigned_integer_interpretation,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQNumProxy,
     QmodQScalarProxy,
     QmodSizedProxy,

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,9 +1,10 @@
-from typing import Union
+from typing import TypeVar, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -31,8 +32,6 @@ from classiq.model_expansions.evaluators.classical_expression import (
 from classiq.model_expansions.evaluators.quantum_type_utils import (
     copy_type_information,
     set_element_type,
-    set_fraction_digits,
-    set_is_signed,
     set_length,
     set_size,
 )
@@ -162,9 +161,14 @@ def _evaluate_qarray_in_quantum_symbol(
     )
     set_element_type(type_to_update, new_element_type)
     if type_to_update.length is not None:
-        new_length = evaluate_classical_expression(
-            type_to_update.length, scope
-        ).as_type(int)
+        new_length = _eval_expr(
+            type_to_update.length,
+            scope,
+            int,
+            type_to_update.type_name,
+            "length",
+            param_name,
+        )
         set_length(type_to_update, new_length)
     return type_to_update
 
@@ -173,23 +177,61 @@ def _evaluate_qnum_in_quantum_symbol(
     type_to_update: QuantumNumeric, scope: Scope, param_name: str
 ) -> QuantumNumeric:
     if type_to_update.is_signed is not None:
-        new_is_sign = evaluate_classical_expression(
-            type_to_update.is_signed, scope
-        ).as_type(bool)
-        set_is_signed(type_to_update, new_is_sign, param_name)
+        new_is_sign = _eval_expr(
+            type_to_update.is_signed,
+            scope,
+            bool,
+            type_to_update.type_name,
+            "sign",
+            param_name,
+        )
+        type_to_update.is_signed = Expression(expr=str(new_is_sign))
     if type_to_update.fraction_digits is not None:
-        new_fraction_digits = evaluate_classical_expression(
-            type_to_update.fraction_digits, scope
-        ).as_type(int)
-        set_fraction_digits(type_to_update, new_fraction_digits, param_name)
+        new_fraction_digits = _eval_expr(
+            type_to_update.fraction_digits,
+            scope,
+            int,
+            type_to_update.type_name,
+            "fraction digits",
+            param_name,
+        )
+        type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     if type_to_update.size is not None:
-        new_size = evaluate_classical_expression(type_to_update.size, scope).as_type(
-            int
+        new_size = _eval_expr(
+            type_to_update.size,
+            scope,
+            int,
+            type_to_update.type_name,
+            "size",
+            param_name,
         )
         set_size(type_to_update, new_size, param_name)
     return type_to_update
 
 
+_EXPR_TYPE = TypeVar("_EXPR_TYPE")
+
+
+def _eval_expr(
+    expression: Expression,
+    scope: Scope,
+    expected_type: type[_EXPR_TYPE],
+    type_name: str,
+    attr_name: str,
+    param_name: str,
+) -> _EXPR_TYPE:
+    val = evaluate_classical_expression(expression, scope).value
+    if expected_type is int and isinstance(val, float):
+        val = int(val)
+    if not isinstance(val, expected_type):
+        raise ClassiqExpansionError(
+            f"When inferring the type of parameter {param_name!r}: "
+            f"{type_name} {attr_name} must be {expected_type.__name__}, got "
+            f"{str(val)!r}"
+        )
+    return val
+
+
 def _evaluate_qstruct_in_quantum_symbol(
     type_to_update: TypeName, scope: Scope, param_name: str
 ) -> TypeName:

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -1,5 +1,4 @@
 from collections.abc import Sequence
-from typing import Optional
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -33,12 +32,11 @@ def copy_type_information(
     if isinstance(to_type, QuantumBit):
         set_size(to_type, from_type.size_in_bits, to_param_name)
     elif isinstance(to_type, QuantumNumeric):
-        set_is_signed(to_type, getattr(from_type, "sign_value", None), to_param_name)
-        set_fraction_digits(
-            to_type,
-            getattr(from_type, "fraction_digits_value", None),
-            to_param_name,
-        )
+        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)
     elif isinstance(to_type, QuantumBitvector):
         if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
@@ -73,8 +71,8 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
     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:
-            set_is_signed(quantum_type, False, param_name)
-            set_fraction_digits(quantum_type, 0, param_name)
+            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:
@@ -107,54 +105,6 @@ def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
             set_size(fields_without_size[0], size - predetermined_size_part, param_name)
 
 
-def set_fraction_digits(
-    quantum_numeric: QuantumNumeric, fraction_digits: Optional[int], param_name: str
-) -> None:
-    if fraction_digits is not None and fraction_digits < 0:
-        raise ClassiqExpansionError(
-            f"Number of fraction digits for {param_name!r} was deduced to be negative: "
-            f"{fraction_digits!r}"
-        )
-
-    if (
-        fraction_digits is not None
-        and quantum_numeric.fraction_digits is not None
-        and quantum_numeric.fraction_digits.is_evaluated()
-        and quantum_numeric.fraction_digits_value != fraction_digits
-    ):
-        raise ClassiqExpansionError(
-            f"Fraction digits mismatch for variable {param_name!r} between declared "
-            f"fraction digits {quantum_numeric.fraction_digits_value!r} and assigned fraction "
-            f"digits {fraction_digits!r}"
-        )
-
-    if not (
-        quantum_numeric.fraction_digits is not None
-        and quantum_numeric.fraction_digits.is_evaluated()
-    ):
-        quantum_numeric.fraction_digits = Expression(expr=str(fraction_digits or 0))
-
-
-def set_is_signed(
-    quantum_numeric: QuantumNumeric, is_signed: Optional[bool], param_name: str
-) -> None:
-    if (
-        is_signed is not None
-        and quantum_numeric.is_signed is not None
-        and quantum_numeric.is_signed.is_evaluated()
-        and quantum_numeric.sign_value != is_signed
-    ):
-        raise ClassiqExpansionError(
-            f"Sign mismatch for variable {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
-        )
-
-    if not (
-        quantum_numeric.is_signed is not None
-        and quantum_numeric.is_signed.is_evaluated()
-    ):
-        quantum_numeric.is_signed = Expression(expr=str(is_signed or False))
-
-
 def set_element_type(
     quantum_array: QuantumBitvector, element_type: ConcreteQuantumType
 ) -> None:

classiq/model_expansions/expression_evaluator.py

@@ -17,7 +17,9 @@ from classiq.interface.generator.expressions.expression_constants import (
 )
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
+    QmodSizedProxy,
+)
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )

classiq/model_expansions/generative_functions.py

@@ -1,10 +1,29 @@
 from collections.abc import Mapping
+from sys import exc_info
+from types import TracebackType
 from typing import TYPE_CHECKING, Any
 
-from classiq.interface.generator.expressions.qmod_struct_instance import (
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
-from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.functions.classical_type import ClassicalArray
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -20,9 +39,10 @@ from classiq.model_expansions.closure import (
     GenerativeClosure,
 )
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.cparam import CParam
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
-from classiq.qmod.qmod_parameter import CParamStruct
+from classiq.qmod.qmod_parameter import CParamStruct, create_param
 from classiq.qmod.qmod_variable import QNum, _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
@@ -37,6 +57,23 @@ if TYPE_CHECKING:
     )
 
 
+def _unwrap_traceback_frame(e: Exception) -> Exception:
+    fallback_error = ClassiqExpansionError(str(e))
+    traceback = exc_info()[2]
+    if traceback is None:
+        return fallback_error
+    back_frame = traceback.tb_frame.f_back
+    if back_frame is None:
+        return fallback_error
+    back_tb = TracebackType(
+        tb_next=None,
+        tb_frame=back_frame,
+        tb_lasti=back_frame.f_lasti,
+        tb_lineno=back_frame.f_lineno,
+    )
+    return e.with_traceback(back_tb)
+
+
 class LenList(list):
     @property
     def len(self) -> int:
@@ -45,7 +82,10 @@ class LenList(list):
     def __getitem__(self, item: Any) -> Any:
         if isinstance(item, QNum):
             return SymbolicExpr(f"{self}[{item}]", True)
-        return super().__getitem__(item)
+        try:
+            return super().__getitem__(item)
+        except (IndexError, TypeError) as e:
+            raise _unwrap_traceback_frame(e) from None
 
     @classmethod
     def wrap(cls, obj: Any) -> Any:
@@ -54,6 +94,22 @@ class LenList(list):
         return LenList([cls.wrap(item) for item in obj])
 
 
+def _create_qmod_classical_var(proxy: ClassicalProxy) -> CParam:
+    if isinstance(proxy, ClassicalScalarProxy):
+        classical_type = proxy._classical_type
+    elif isinstance(proxy, ClassicalArrayProxy):
+        classical_type = ClassicalArray(
+            element_type=proxy._element_type, size=proxy._length
+        )
+    elif isinstance(proxy, ClassicalStructProxy):
+        classical_type = TypeName(name=proxy._decl.name)
+    else:
+        raise ClassiqInternalExpansionError(
+            f"Unrecognized classical proxy {type(proxy).__name__}"
+        )
+    return create_param(str(proxy.handle), classical_type, QMODULE)
+
+
 def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
     if isinstance(param, PortDeclaration):
         quantum_symbol = evaluated.as_type(QuantumSymbol)
@@ -90,6 +146,9 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
             struct_type=Struct(name=classical_value.struct_declaration.name),
             qmodule=QMODULE,
         )
+    if isinstance(classical_value, ClassicalProxy):
+        return _create_qmod_classical_var(classical_value)
+
     return LenList.wrap(classical_value)
 
 

classiq/model_expansions/quantum_operations/arithmetic/explicit_boolean_expressions.py

@@ -0,0 +1,60 @@
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.arith.arithmetic import is_bool
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
+
+from classiq.model_expansions.scope import QuantumSymbol
+
+
+def validate_assignment_bool_expression(
+    result_symbol: QuantumSymbol, expr: str, op_kind: ArithmeticOperationKind
+) -> None:
+    if not is_bool(expr):
+        return
+    _validate_target_type(result_symbol, expr, op_kind)
+
+
+def _validate_target_type(
+    target_symbol: QuantumSymbol, expr: str, op_kind: ArithmeticOperationKind
+) -> None:
+    supported_types = _supported_types()
+    if target_symbol.quantum_type.qmod_type_name not in supported_types:
+        raise ClassiqValueError(
+            f'The expression has been evaluated to "{expr}" which is a Boolean value. '
+            f"Cannot perform {op_kind.value} operation of Boolean expression to result variable '{target_symbol.handle}' of type {target_symbol.quantum_type.qmod_type_name}. "
+            f"Boolean expressions can only be applied on {' or '.join(supported_types)}."
+        )
+
+
+def convert_assignment_bool_expression(op: ArithmeticOperation) -> None:
+    if not is_bool(op.expression.expr):
+        return
+    op.expression = op.expression.model_copy(
+        update=dict(expr="1" if op.expression.expr == "True" else "0")
+    )
+
+
+def convert_inplace_op_bool_expression(
+    op: ArithmeticOperation, target: QuantumSymbol
+) -> None:
+    if not is_bool(op.expression.expr):
+        return
+    _validate_target_type(target, op.expression.expr, op.operation_kind)
+    op.expression = op.expression.model_copy(
+        update=dict(expr="1" if op.expression.expr == "True" else "0")
+    )
+
+
+def _supported_types() -> tuple[str, ...]:
+    return (
+        QuantumBit().qmod_type_name,
+        QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ).qmod_type_name,
+    )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -11,6 +11,10 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
+    convert_assignment_bool_expression,
+    validate_assignment_bool_expression,
+)
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
@@ -24,6 +28,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         ):
             direction = PortDeclarationDirection.Output
             self._update_result_type(op)
+            convert_assignment_bool_expression(op)
         else:
             direction = PortDeclarationDirection.Inout
         self._capture_handle(op.result_var, direction)
@@ -47,6 +52,10 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             self._machine_precision,
         )
         result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+
+        validate_assignment_bool_expression(
+            result_symbol, op.expression.expr, op.operation_kind
+        )  # must be here, otherwise copy_type_information will throw a non-indicative error
         copy_type_information(
             result_type, result_symbol.quantum_type, str(op.result_var)
         )