classiq 0.54.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

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

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -3,6 +3,14 @@ CONTROL_OPERATOR_NAME = "control"
 INVERT_OPERATOR_NAME = "invert"
 REPEAT_OPERATOR_NAME = "iteration"
 POWER_OPERATOR_NAME = "power"
-COMPUTE_OPERATOR_NAME = "compute"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
+
+All_BUILTINS_OPERATORS = {
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
+    POWER_OPERATOR_NAME,
+    UNCOMPUTE_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+}

classiq/interface/generator/generated_circuit_data.py

@@ -59,7 +59,6 @@ class GeneratedFunction(pydantic.BaseModel):
     registers: list[GeneratedRegister] = list()
     depth: Optional[int] = pydantic.Field(default=None)
     width: Optional[int] = pydantic.Field(default=None)
-    released_auxiliary_qubits: list[int] = list()
     dangling_inputs: dict[str, GeneratedRegister] = dict()
     dangling_outputs: dict[str, GeneratedRegister] = dict()
 

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

@@ -154,6 +154,10 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         "Setting this option to False can potentially speed up the synthesis, and is "
         "recommended for executing iterative algorithms.",
     )
+    synthesize_all_separately: bool = pydantic.Field(
+        default=False,
+        description="If true, all functions will be synthesized separately",
+    )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
         default=[QuantumFormat.QASM],
         description="The quantum circuit output format(s). ",

classiq/interface/generator/types/compilation_metadata.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel, Field
+
+
+class CompilationMetadata(BaseModel):
+    should_synthesize_separately: bool = Field(default=False)

classiq/interface/ide/visual_model.py

@@ -1,3 +1,4 @@
+from collections import Counter
 from typing import Any, Optional
 
 import pydantic
@@ -23,7 +24,7 @@ class OperationType(StrEnum):
 class OperationData(pydantic.BaseModel):
     approximated_depth: Optional[int] = None
     width: int
-    gate_count: dict[str, int] = pydantic.Field(default_factory=dict)
+    gate_count: Counter[str] = pydantic.Field(default_factory=dict)
 
 
 class CircuitMetrics(pydantic.BaseModel):
@@ -104,6 +105,7 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
+    details: str = pydantic.Field(default="")
     children: list["Operation"]
     operation_data: Optional[OperationData] = None
     operation_links: OperationLinks

classiq/interface/model/control.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
+from classiq.interface.model.quantum_type import QuantumType
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
@@ -13,8 +15,12 @@ if TYPE_CHECKING:
 class Control(QuantumExpressionOperation):
     kind: Literal["Control"]
     body: "StatementBlock"
+    else_block: Optional["StatementBlock"] = None
 
     _ctrl_size: int = pydantic.PrivateAttr(default=0)
+    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+        default=None,
+    )
 
     @property
     def ctrl_size(self) -> int:
@@ -22,3 +28,18 @@ class Control(QuantumExpressionOperation):
 
     def set_ctrl_size(self, ctrl_size: int) -> None:
         self._ctrl_size = ctrl_size
+
+    @property
+    def result_type(self) -> QuantumType:
+        assert self._result_type is not None
+        return self._result_type
+
+    def initialize_var_types(
+        self,
+        var_types: dict[str, QuantumType],
+        machine_precision: int,
+    ) -> None:
+        super().initialize_var_types(var_types, machine_precision)
+        self._result_type = compute_arithmetic_result_type(
+            self.expression.expr, var_types, machine_precision
+        )

classiq/interface/model/model.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -98,6 +99,9 @@ class Model(VersionedModel, ASTNode):
     debug_info: DebugInfoCollection = pydantic.Field(
         default_factory=DebugInfoCollection
     )
+    functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
+        default_factory=dict
+    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/native_function_definition.py

@@ -29,5 +29,5 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
         default_factory=list, description="List of function calls to perform."
     )
     synthesis_data: FunctionSynthesisData = pydantic.Field(
-        default_factory=FunctionSynthesisData,
+        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
     )

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,8 +1,5 @@
 from collections.abc import Mapping, Sequence
-from typing import Literal, Optional
-
-import pydantic
-from pydantic_core.core_schema import ValidationInfo
+from typing import Literal
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
@@ -29,28 +26,7 @@ class ArithmeticOperationKind(StrEnum):
 class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
-    inplace_result: Optional[bool] = pydantic.Field(
-        description="Determines whether the result variable is initialized",
-        default=None,
-        exclude=True,
-    )
-
-    operation_kind: ArithmeticOperationKind = pydantic.Field(
-        default=None, validate_default=True
-    )
-
-    @pydantic.field_validator("operation_kind", mode="before")
-    @classmethod
-    def _propagate_inplace_result(
-        cls, operation_kind: Optional[ArithmeticOperationKind], info: ValidationInfo
-    ) -> ArithmeticOperationKind:
-        if operation_kind is None:
-            operation_kind = (
-                ArithmeticOperationKind.InplaceXor
-                if info.data["inplace_result"]
-                else ArithmeticOperationKind.Assignment
-            )
-        return operation_kind
+    operation_kind: ArithmeticOperationKind
 
     @property
     def is_inplace(self) -> bool:

classiq/interface/model/quantum_statement.py

@@ -75,6 +75,9 @@ class QuantumOperation(QuantumStatement):
     def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
         self._generative_blocks[block_name] = py_callable
 
+    def remove_generative_block(self, block_name: str) -> None:
+        self._generative_blocks.pop(block_name)
+
     def get_generative_block(self, block_name: str) -> Callable:
         return self._generative_blocks[block_name]
 

classiq/model_expansions/closure.py

@@ -1,14 +1,21 @@
+import json
+import uuid
 from collections import defaultdict
-from collections.abc import Sequence
+from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field
-from functools import cached_property
+from functools import cached_property, singledispatch
+from symtable import Symbol
 from typing import Any, Optional, Union
 
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    All_BUILTINS_OPERATORS,
+)
 from classiq.interface.generator.visitor import Visitor
-from classiq.interface.model.native_function_definition import FunctionSynthesisData
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -20,8 +27,14 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq import ClassicalParameterDeclaration
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
-from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    Scope,
+    evaluated_to_str as evaluated_classical_param_to_str,
+)
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 
@@ -52,7 +65,21 @@ class FunctionClosure(Closure):
     is_lambda: bool = False
     is_atomic: bool = False
     signature_scope: Scope = field(default_factory=Scope)
-    synthesis_data: FunctionSynthesisData = field(default_factory=FunctionSynthesisData)
+
+    # creates a unique id for the function closure based on the arguments values.
+    # The closure is changing across the interpreter flow so it's closure_id may change
+    @property
+    def closure_id(self) -> str:
+        # builtins operators have side effects, so  generate a unique id for than
+        # may create a bugs. Therefore, with each call to closure_id a new id is
+        # created
+        if self.is_lambda or self.name in All_BUILTINS_OPERATORS:
+            signature = str(uuid.uuid4())
+        else:
+            signature = _generate_closure_id(
+                self.positional_arg_declarations, self.scope.data.values()
+            )
+        return f"{self.name}__{signature}"
 
     @property
     def body(self) -> Sequence[QuantumStatement]:
@@ -77,7 +104,6 @@ class FunctionClosure(Closure):
         expr_renamer: Optional[ExpressionRenamer] = None,
         is_lambda: bool = False,
         is_atomic: bool = False,
-        synthesis_data: Optional[FunctionSynthesisData] = None,
         **kwargs: Any,
     ) -> Self:
         if expr_renamer:
@@ -90,9 +116,6 @@ class FunctionClosure(Closure):
                 body = expr_renamer.visit(body)
 
         blocks = {"body": body} if body is not None else {}
-        synthesis_data = (
-            synthesis_data if synthesis_data is not None else FunctionSynthesisData()
-        )
         return cls(
             name,
             blocks,
@@ -100,7 +123,6 @@ class FunctionClosure(Closure):
             positional_arg_declarations,
             is_lambda,
             is_atomic,
-            synthesis_data=synthesis_data,
             **kwargs,
         )
 
@@ -171,3 +193,44 @@ class VariableCollector(Visitor):
             defining_function = lambda_environment[var].defining_function
             if defining_function is not None:
                 self._variables[var].add(defining_function.name)
+
+
+def _generate_closure_id(
+    args_declaration: Sequence[PositionalArg], evaluated_args: Collection[Evaluated]
+) -> str:
+    args_signature: dict = {}
+    for arg_declara, eval_arg in zip(args_declaration, evaluated_args):
+        args_signature |= _generate_arg_id(arg_declara, eval_arg)
+    return json.dumps(args_signature)
+
+
+def _generate_arg_id(
+    arg_declaration: PositionalArg, evaluated_arg: Evaluated
+) -> dict[str, str]:
+    arg_value = evaluated_arg.value
+    arg_name = arg_declaration.name
+    if isinstance(arg_declaration, ClassicalParameterDeclaration):
+        return {arg_name: evaluated_classical_param_to_str(arg_value)}
+    return {arg_name: _evaluated_arg_to_str(arg_value)}
+
+
+@singledispatch
+def _evaluated_arg_to_str(arg: Any) -> str:
+    if isinstance(arg, str):
+        return arg
+    return str(uuid.uuid4())
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
+    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_symbol_to_str(port: Symbol) -> str:
+    return repr(port)
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_operand_to_str(operand: FunctionClosure) -> str:
+    return operand.closure_id

classiq/model_expansions/function_builder.py

@@ -19,7 +19,6 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
-    FunctionSynthesisData,
     NativeFunctionDefinition,
 )
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -76,10 +75,6 @@ class FunctionContext(OperationContext[FunctionClosure]):
     def is_lambda(self) -> bool:
         return self.closure.is_lambda
 
-    @property
-    def synthesis_data(self) -> FunctionSynthesisData:
-        return self.closure.synthesis_data
-
 
 class OperationBuilder:
     def __init__(self) -> None:
@@ -176,7 +171,6 @@ class OperationBuilder:
             name=name,
             body=function_context.body,
             positional_arg_declarations=new_parameters,
-            synthesis_data=function_context.synthesis_data,
         )
 
 

classiq/model_expansions/generative_functions.py

@@ -186,7 +186,7 @@ def _expand_operand_as_declarative(
 
 
 def _register_declarative_function(interpreter: "Interpreter", func_name: str) -> None:
-    if func_name in nameables_to_dict(interpreter._expanded_functions):
+    if func_name in nameables_to_dict(list(interpreter._expanded_functions.values())):
         return
 
     for user_gen_func in interpreter._generative_functions:
@@ -199,7 +199,7 @@ def _register_declarative_function(interpreter: "Interpreter", func_name: str) -
         dec_func = QFunc(user_gen_func._py_callable)
         dec_func.expand()
         dec_func_def = QMODULE.native_defs[func_name]
-        interpreter._expanded_functions.append(dec_func_def)
+        interpreter._expanded_functions[func_name] = dec_func_def
         _DecFuncVisitor(interpreter).visit(dec_func_def)
 
 

classiq/model_expansions/interpreter.py

@@ -12,6 +12,7 @@ from classiq.interface.exceptions import (
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -46,7 +47,6 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.model_expansions.call_to_model_converter import BlockFunctionInfo
 from classiq.model_expansions.capturing.propagated_var_stack import PropagatedVarStack
 from classiq.model_expansions.closure import (
     Closure,
@@ -108,7 +108,7 @@ class Interpreter:
         self._model = model
         self._current_scope = Scope()
         self._builder = OperationBuilder()
-        self._expanded_functions: list[NativeFunctionDefinition] = []
+        self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
         self._propagated_var_stack = PropagatedVarStack(
             self._current_scope, self._builder
         )
@@ -119,10 +119,11 @@ class Interpreter:
             generative_functions = []
         self._generative_functions = generative_functions
         init_top_level_scope(model, generative_functions, self._current_scope)
-
+        self._expanded_functions_compilation_metadata: dict[
+            str, CompilationMetadata
+        ] = dict()
         self._counted_name_allocator = CountedNameAllocator()
         self._error_manager: ErrorManager = ErrorManager()
-        self._synthesized_separately_blocks: dict[str, BlockFunctionInfo] = {}
 
     @contextmanager
     def _scope_guard(self, scope: Scope) -> Iterator[None]:
@@ -153,14 +154,13 @@ class Interpreter:
             main_closure.positional_arg_declarations, main_closure
         )
         context = self._expand_operation(main_closure)
-        self._expanded_functions.append(
+        self._expanded_functions[main_closure.closure_id] = (
             self._builder.create_definition(cast(FunctionContext, context))
         )
 
-    def expand(self) -> tuple[Model, dict[str, BlockFunctionInfo]]:
+    def expand(self) -> Model:
         try:
             with self._error_manager.call("main"):
-                self._synthesized_separately_blocks = {}
                 self._expand_main_func()
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
@@ -172,20 +172,18 @@ class Interpreter:
         finally:
             self._error_manager.report_errors(ClassiqExpansionError)
 
-        return (
-            Model(
-                constraints=self._model.constraints,
-                preferences=self._model.preferences,
-                classical_execution_code=self._model.classical_execution_code,
-                execution_preferences=self._model.execution_preferences,
-                functions=self._expanded_functions,
-                constants=self._model.constants,
-                enums=self._model.enums,
-                types=self._model.types,
-                qstructs=self._model.qstructs,
-                debug_info=self._model.debug_info,
-            ),
-            self._synthesized_separately_blocks,
+        return Model(
+            constraints=self._model.constraints,
+            preferences=self._model.preferences,
+            classical_execution_code=self._model.classical_execution_code,
+            execution_preferences=self._model.execution_preferences,
+            functions=list(self._expanded_functions.values()),
+            constants=self._model.constants,
+            enums=self._model.enums,
+            types=self._model.types,
+            qstructs=self._model.qstructs,
+            debug_info=self._model.debug_info,
+            functions_compilation_metadata=self._expanded_functions_compilation_metadata,
         )
 
     @singledispatchmethod
@@ -346,9 +344,8 @@ class Interpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if (
-                isinstance(operation, FunctionClosure)
-                and operation.synthesis_data.should_synthesize_separately
+            if isinstance(operation, FunctionClosure) and (
+                self._expanded_functions.get(operation.closure_id) is not None
             ):
                 pass
             elif isinstance(operation, FunctionClosure) and operation.name == "permute":
@@ -385,5 +382,5 @@ class Interpreter:
         return (
             self._model.functions
             + [gen_func.func_decl for gen_func in self._generative_functions]
-            + self._expanded_functions  # type:ignore[operator]
+            + list(self._expanded_functions.values())
         )

classiq/model_expansions/quantum_operations/control.py

@@ -9,6 +9,7 @@ from classiq.interface.exceptions import (
 from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import QmodQNumProxy
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.generator.functions.builtins.internal_operators import (
@@ -21,6 +22,7 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -40,6 +42,7 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
     ExpressionOperationEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.qmod.builtins.functions.standard_gates import X
 
 ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
@@ -47,22 +50,42 @@ ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
         condition = self._evaluate_op_expression(control)
-        control = control.model_copy(update=dict(expression=condition))
 
         arrays_with_subscript = self._get_symbols_to_split(condition)
         if len(arrays_with_subscript) > 0:
             self._emit_with_split(control, condition, arrays_with_subscript)
             return
 
+        control = self._evaluate_types_in_expression(control, condition)
         condition_val = condition.value.value
         if isinstance(condition_val, QmodSizedProxy):
-            self._validate_canonical_condition(condition_val)
-            self._emit_canonical_control(control)
-            return
+            if control.else_block is None:
+                self._validate_canonical_condition(condition_val)
+                self._emit_canonical_control(control)
+                return
+            else:
+                self._interpreter.emit_statement(
+                    control.model_copy(
+                        update=dict(
+                            expression=self._uncanonize_condition(condition_val)
+                        )
+                    )
+                )
+                return
 
-        self._validate_condition(condition_val)
+        self._validate_condition(control)
         self._emit_with_boolean(control)
 
+    def _uncanonize_condition(self, condition_val: QmodSizedProxy) -> Expression:
+        lhs = (
+            " & ".join(
+                f"{condition_val.handle}[{idx}]" for idx in range(condition_val.size)
+            )
+            if isinstance(condition_val, QmodQArrayProxy)
+            else condition_val.handle
+        )
+        return Expression(expr=f"{lhs} == 1")
+
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
         control = self._evaluate_types_in_expression(control, control.expression)
@@ -129,9 +152,10 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         condition_val = control.expression.value.value
         if self._is_simple_equality(condition_val):
             ctrl, ctrl_state = resolve_num_condition(condition_val)
-            self._emit_with_x_gates(control, ctrl, ctrl_state)
-        else:
-            self._emit_with_arithmetic(control)
+            if control.else_block is None or ctrl.size == 1:
+                self._emit_with_x_gates(control, ctrl, ctrl_state)
+                return
+        self._emit_with_arithmetic(control)
 
     @staticmethod
     def _is_simple_equality(condition_val: ExpressionValue) -> TypeGuard[Equality]:
@@ -151,13 +175,37 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
     def _create_canonical_control_op(
         self, control: Control, handle_name: str
-    ) -> Control:
+    ) -> list[ConcreteQuantumStatement]:
         handle_expr = self._interpreter.evaluate(Expression(expr=handle_name)).emit()
-        return control.model_copy(update=dict(expression=handle_expr))
+        control_then = control.model_copy(
+            update=dict(expression=handle_expr, else_block=None)
+        )
+        if control.else_block is None:
+            return [control_then]
+        else_compute_call = QuantumFunctionCall(
+            function="X", positional_args=[HandleBinding(name=handle_name)]
+        )
+        else_compute_call.set_func_decl(X.func_decl)
+        control_else_inner = control.model_copy(
+            update=dict(
+                expression=handle_expr, body=control.else_block, else_block=None
+            ),
+            deep=True,
+        )
+        control_else = WithinApply(
+            compute=[else_compute_call],
+            action=[control_else_inner],
+        )
+        if control_else_inner.is_generative():
+            control_else_inner.set_generative_block(
+                "body", control_else_inner.get_generative_block("else_block")
+            )
+            control_else_inner.remove_generative_block("else_block")
+        return [control_then, control_else]
 
-    def _emit_with_x_gates(
+    def _control_with_x_gates(
         self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
-    ) -> None:
+    ) -> ConcreteQuantumStatement:
         compute_op: list[ConcreteQuantumStatement] = []
 
         x_gate_value = self._get_x_gate_value(ctrl_state)
@@ -175,12 +223,19 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             cast_decl, bind_op = self._get_array_cast_ops(ctrl)
             self._interpreter.emit_statement(cast_decl)
             compute_op.append(bind_op)
-            control_op = self._create_canonical_control_op(control, str(cast_decl.name))
+            control_ops = self._create_canonical_control_op(
+                control, str(cast_decl.name)
+            )
         else:
-            control_op = self._create_canonical_control_op(control, str(ctrl.handle))
+            control_ops = self._create_canonical_control_op(control, str(ctrl.handle))
+
+        return WithinApply(compute=compute_op, action=control_ops)
 
+    def _emit_with_x_gates(
+        self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
+    ) -> None:
         self._interpreter.emit_statement(
-            WithinApply(compute=compute_op, action=[control_op])
+            self._control_with_x_gates(control, ctrl, ctrl_state)
         )
 
     @staticmethod
@@ -217,14 +272,18 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         self._interpreter.emit_statement(
             WithinApply(
                 compute=[arith_expression],
-                action=[self._create_canonical_control_op(control, aux_var)],
+                action=self._create_canonical_control_op(control, aux_var),
             )
         )
 
-    @staticmethod
-    def _validate_condition(condition_val: ExpressionValue) -> None:
-        if not isinstance(condition_val, Boolean):
-            raise ClassiqExpansionError(_condition_err_msg(condition_val))
+    def _validate_condition(self, control: Control) -> None:
+        condition_value = control.expression.value.value
+        if not (
+            isinstance(condition_value, Boolean)
+            or self._all_vars_boolean(control)
+            and self._is_res_boolean(control)
+        ):
+            raise ClassiqExpansionError(_condition_err_msg(condition_value))
 
     @staticmethod
     def _validate_canonical_condition(condition_val: ExpressionValue) -> None: