classiq 0.36.0__py3-none-any.whl → 0.37.0__py3-none-any.whl

classiq/interface/model/{modular_addition_operation.py → inplace_binary_operation.py}

@@ -6,12 +6,26 @@ from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
+from classiq._internals.enum_utils import StrEnum
 from classiq.exceptions import ClassiqValueError
 
 
-class ModularAdditionOperation(QuantumOperation):
+class BinaryOperation(StrEnum):
+    Addition = "addition"
+    Xor = "xor"
+
+    @property
+    def internal_function(self) -> str:
+        return {
+            BinaryOperation.Addition: "modular_add",
+            BinaryOperation.Xor: "integer_xor",
+        }[self]
+
+
+class InplaceBinaryOperation(QuantumOperation):
     target: HandleBinding
     value: HandleBinding
+    operation: BinaryOperation
 
     @property
     def wiring_inouts(self) -> Mapping[str, HandleBinding]:
@@ -20,5 +34,5 @@ class ModularAdditionOperation(QuantumOperation):
     @pydantic.validator("target", "value")
     def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
         if not handle.is_bindable():
-            raise ClassiqValueError(f"Cannot bind '{handle}'")  # noqa: B907
+            raise ClassiqValueError(f"Cannot bind '{handle!r}'")
         return handle

classiq/interface/model/native_function_definition.py

@@ -1,9 +1,7 @@
-from typing import Any, Dict, List, Optional
+from typing import List
 
 import pydantic
 
-from classiq.interface.model.local_variable_declaration import LocalVariableDeclaration
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ConcreteQuantumStatement
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
@@ -28,12 +26,8 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
         default_factory=list, description="List of function calls to perform."
     )
 
-    local_handles: List[LocalVariableDeclaration] = pydantic.Field(
-        default_factory=list, description="List of local handles."
-    )
-
     def validate_body(self) -> None:
-        handle_validator = HandleValidator(self.port_declarations, self.local_handles)
+        handle_validator = HandleValidator(self.port_declarations)
 
         for statement in self.body:
             if isinstance(statement, VariableDeclarationStatement):
@@ -42,19 +36,3 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
                 handle_validator.handle_call(statement)
 
         handle_validator.report_errored_handles(ClassiqValueError)
-
-    @pydantic.validator("local_handles")
-    def validate_local_handles(
-        cls, local_handles: List[LocalVariableDeclaration], values: Dict[str, Any]
-    ) -> List[LocalVariableDeclaration]:
-        ports: Optional[Dict[str, PortDeclaration]] = values.get("port_declarations")
-        if ports is None:
-            return local_handles
-
-        intersection = {handle.name for handle in local_handles} & ports.keys()
-        if intersection:
-            raise ClassiqValueError(
-                f"The names {intersection} are both local handles and ports"
-            )
-
-        return local_handles

classiq/interface/model/operator_synthesis_data.py

@@ -40,3 +40,9 @@ class ControlOperatorSynthesisData(OperatorSynthesisData):
         return {
             "control_states": [self._ctrl_state],
         }
+
+
+class ComputeOperatorSynthesisData(OperatorSynthesisData):
+    @property
+    def call_kwargs(self) -> Dict[str, Any]:
+        return {"should_control": False}

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -12,7 +12,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
+    QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric, QuantumType
 
@@ -27,7 +27,7 @@ VAR_DOMAIN_ILLEGAL = (
 )
 
 
-class AmplitudeLoadingOperation(QuantumExpressionOperation):
+class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     _result_type: QuantumType = pydantic.PrivateAttr(default_factory=QuantumBit)
 
     @property
@@ -40,7 +40,11 @@ class AmplitudeLoadingOperation(QuantumExpressionOperation):
             return dict()
         return {AMPLITUDE_IO_NAME: self.var_handles[0]}
 
-    def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:
+    def initialize_var_types(
+        self,
+        var_types: Dict[str, QuantumType],
+        machine_precision: int,
+    ) -> None:
         if len(var_types) != 1:
             raise ClassiqValueError(MULTI_VARS_UNSUPPORTED_ERROR)
         var_type = var_types[self.var_handles[0].name]
@@ -49,7 +53,7 @@ class AmplitudeLoadingOperation(QuantumExpressionOperation):
             and var_type.fraction_digits == var_type.size_in_bits
         ):
             raise ClassiqValueError(VAR_DOMAIN_ILLEGAL)
-        super().initialize_var_types(var_types)
+        super().initialize_var_types(var_types, machine_precision)
 
     @classmethod
     def result_name(cls) -> str:

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -12,20 +12,24 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
+    QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_type import QuantumType
 
 
-class ArithmeticOperation(QuantumExpressionOperation):
+class ArithmeticOperation(QuantumAssignmentOperation):
     inplace_result: bool = pydantic.Field(
         description="Determines whether the result variable is initialized",
     )
 
-    def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:
-        super().initialize_var_types(var_types)
+    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
+            self.expression.expr, var_types, machine_precision
         )
 
     @property

classiq/interface/model/quantum_expressions/control_state.py

@@ -0,0 +1,38 @@
+from classiq.exceptions import ClassiqValueError
+
+
+def min_unsigned_bit_length(number: int) -> int:
+    if number < 0:
+        raise ClassiqValueError(
+            f"Quantum register is not signed but control value "  # noqa: B907
+            f"'{number}' is negative"
+        )
+    return 1 if number == 0 else number.bit_length()
+
+
+def min_signed_bit_length(number: int) -> int:
+    pos_val = abs(number)
+    is_whole = pos_val & (pos_val - 1) == 0
+    if number <= 0 and is_whole:
+        return min_unsigned_bit_length(pos_val)
+    return min_unsigned_bit_length(pos_val) + 1
+
+
+def min_bit_length(number: int, is_signed: bool) -> int:
+    return (
+        min_signed_bit_length(number) if is_signed else min_unsigned_bit_length(number)
+    )
+
+
+def to_twos_complement(value: int, bits: int, is_signed: bool) -> str:
+    required_bits = min_bit_length(value, is_signed)
+    if bits < required_bits:
+        raise ClassiqValueError(
+            f"Cannot express '{value}' using {bits} bits: "  # noqa: B907
+            f"at least {required_bits} bits are required"
+        )
+    if value >= 0:
+        return bin(value)[2:].zfill(bits)[::-1]
+    mask = (1 << bits) - 1
+    value = (abs(value) ^ mask) + 1
+    return bin(value)[:1:-1].rjust(bits, "1")

classiq/interface/model/quantum_expressions/quantum_expression.py

@@ -4,6 +4,9 @@ from typing import Dict, List, Mapping, Optional, Set, Union
 
 import pydantic
 
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    DEFAULT_SUPPORTED_FUNC_NAMES,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
@@ -25,25 +28,19 @@ class VarRefCollector(ast.NodeVisitor):
     def generic_visit(self, node: ast.AST) -> None:
         if isinstance(node, ast.Name) and node.id not in set(
             SYMPY_SUPPORTED_EXPRESSIONS
-        ):
+        ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):
             self.var_names.add(node.id)
         super().generic_visit(node)
 
 
 class QuantumExpressionOperation(QuantumOperation):
     expression: Expression = pydantic.Field()
-    result_var: HandleBinding = pydantic.Field(
-        description="The variable storing the expression result"
-    )
     _var_handles: List[HandleBinding] = pydantic.PrivateAttr(
         default_factory=list,
     )
     _var_types: Dict[str, QuantumType] = pydantic.PrivateAttr(
         default_factory=dict,
     )
-    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
-        default=None,
-    )
 
     @property
     def var_handles(self) -> List[HandleBinding]:
@@ -56,7 +53,11 @@ class QuantumExpressionOperation(QuantumOperation):
     def var_types(self) -> Dict[str, QuantumType]:
         return self._var_types
 
-    def initialize_var_types(self, var_types: Dict[str, QuantumType]) -> None:
+    def initialize_var_types(
+        self,
+        var_types: Dict[str, QuantumType],
+        machine_precision: int,
+    ) -> None:
         assert len(var_types) == len(self.var_handles)
         self._var_types = var_types
 
@@ -68,15 +69,24 @@ class QuantumExpressionOperation(QuantumOperation):
     ]:
         return nameables_to_dict(self.var_handles)
 
-    @property
-    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        return {self.result_name(): self.result_var}
+
+class QuantumAssignmentOperation(QuantumExpressionOperation):
+    result_var: HandleBinding = pydantic.Field(
+        description="The variable storing the expression result"
+    )
+    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+        default=None,
+    )
 
     @property
     def result_type(self) -> QuantumType:
         assert self._result_type is not None
         return self._result_type
 
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {self.result_name(): self.result_var}
+
     @classmethod
     @abc.abstractmethod
     def result_name(cls) -> str:

classiq/interface/model/quantum_function_call.py

@@ -23,7 +23,7 @@ from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.modular_addition_operation import ModularAdditionOperation
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
 from classiq.interface.model.numeric_reinterpretation import (
     NumericReinterpretationOperation,
 )
@@ -38,6 +38,7 @@ from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_if_operation import QuantumIfOperation
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import get_unique_handle_names
 from classiq.interface.model.variable_declaration_statement import (
@@ -288,7 +289,8 @@ class QuantumFunctionCall(QuantumOperation):
 
     def resolve_function_decl(
         self,
-        function_dict: Mapping[str, FunctionDeclaration],
+        function_dict: Mapping[str, QuantumFunctionDeclaration],
+        check_operands: bool,
     ) -> None:
         if self._func_decl is None:
             func_decl = function_dict.get(self.func_name)
@@ -312,6 +314,8 @@ class QuantumFunctionCall(QuantumOperation):
             set(self.func_decl.operand_declarations.keys()),
             self.func_name,
         )
+        if check_operands:
+            _check_operands_against_declaration(self, self.func_decl, function_dict)
 
         for name, op in self.operands.items():
             op_decl = self.func_decl.operand_declarations[name]
@@ -352,7 +356,8 @@ ConcreteQuantumStatement = Union[
     VariableDeclarationStatement,
     BindOperation,
     NumericReinterpretationOperation,
-    ModularAdditionOperation,
+    InplaceBinaryOperation,
+    QuantumIfOperation,
 ]
 
 
@@ -402,6 +407,7 @@ QuantumCallable = Union[str, QuantumLambdaFunction]
 QuantumOperand = Union[QuantumCallable, List[QuantumCallable], LambdaListComprehension]
 
 QuantumFunctionCall.update_forward_refs()
+QuantumIfOperation.update_forward_refs(QuantumOperand=QuantumOperand)
 
 
 def get_lambda_defs(operand: QuantumOperand) -> List[QuantumCallable]:
@@ -441,16 +447,85 @@ def _check_ports_against_declaration(
     )
 
 
+def _check_operand_against_declaration(
+    call: QuantumFunctionCall,
+    operand_decl: QuantumOperandDeclaration,
+    operand_argument: QuantumOperand,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+    in_list: bool = False,
+) -> None:
+    if isinstance(operand_argument, list):
+        if in_list:
+            raise ClassiqValueError(
+                f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not "
+                f"a valid operand. Nested operand lists are not permitted"
+            )
+        for arg in operand_argument:
+            _check_operand_against_declaration(
+                call, operand_decl, arg, function_dict, in_list=True
+            )
+        return
+    operand_arg_decl: QuantumFunctionDeclaration
+    if isinstance(operand_argument, str):
+        if operand_argument not in function_dict:
+            raise ClassiqValueError(
+                f"{operand_argument!r} argument to {call.func_decl.name!r} is not a "
+                f"registered function"
+            )
+        operand_arg_decl = function_dict[operand_argument]
+    elif isinstance(operand_argument, QuantumLambdaFunction):
+        if operand_argument.func_decl is None:
+            return
+        operand_arg_decl = operand_argument.func_decl
+    elif isinstance(operand_argument, LambdaListComprehension):
+        if operand_argument.func.func_decl is None:
+            return
+        operand_arg_decl = operand_argument.func.func_decl
+    else:
+        raise ClassiqValueError(
+            f"{str(operand_argument)!r} argument to {call.func_decl.name!r} is not a "
+            f"valid operand"
+        )
+    num_arg_parameters = len(operand_arg_decl.get_positional_arg_decls())
+    num_decl_parameters = len(operand_decl.get_positional_arg_decls())
+    if num_arg_parameters != num_decl_parameters:
+        raise ClassiqValueError(
+            f"Signature of argument {operand_argument!r} to {call.func_decl.name!r} "
+            f"does not match the signature of parameter {operand_decl.name!r}. "
+            f"{operand_decl.name!r} accepts {num_decl_parameters} parameters but "
+            f"{operand_argument!r} accepts {num_arg_parameters} parameters"
+        )
+
+
+def _check_operands_against_declaration(
+    call: QuantumFunctionCall,
+    decl: QuantumFunctionDeclaration,
+    function_dict: Mapping[str, QuantumFunctionDeclaration],
+) -> None:
+    for operand_parameter, operand_argument in call.operands.items():
+        _check_operand_against_declaration(
+            call,
+            decl.operand_declarations[operand_parameter],
+            operand_argument,
+            function_dict,
+        )
+
+
 def _check_params_against_declaration(
     call_params: Set[str],
     param_decls: Set[str],
     callee_name: str,
 ) -> None:
     unknown_params = call_params - param_decls
-    if unknown_params:
-        raise ClassiqValueError(
-            f"Unknown parameters {unknown_params} in call to {callee_name!r}."
+    if any(re.match(r"arg\d+", param) for param in unknown_params):
+        error_msg = (
+            f"Unsupported passing of named function {callee_name!r} as an operand."
+            "\nSuggestion: replace the named function with lambda function."
         )
+    else:
+        error_msg = f"Unknown parameters {unknown_params} in call to {callee_name!r}."
+    if unknown_params:
+        raise ClassiqValueError(error_msg)
 
     missing_params = param_decls - call_params
     if missing_params:

classiq/interface/model/quantum_function_declaration.py

@@ -83,9 +83,9 @@ class QuantumFunctionDeclaration(FunctionDeclaration):
         default_factory=list
     )
 
-    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
-        Dict[str, "QuantumFunctionDeclaration"]
-    ] = {}
+    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[Dict[str, "QuantumFunctionDeclaration"]] = (
+        {}
+    )
 
     @property
     def input_set(self) -> Set[str]:

classiq/interface/model/quantum_if_operation.py

@@ -0,0 +1,95 @@
+from typing import TYPE_CHECKING, Optional
+
+import pydantic
+from sympy import Equality
+from sympy.core.numbers import Integer
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qnum_proxy import QmodQNumProxy
+from classiq.interface.model.quantum_expressions.control_state import (
+    min_bit_length,
+    to_twos_complement,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+from classiq.exceptions import ClassiqValueError
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_function_call import QuantumOperand
+
+
+QUANTUM_IF_INOUT_NAME = "ctrl"
+QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
+    "quantum_if condition must be of the form '<quantum-variable> == "
+    "<classical-integer-expression>', but condition's {}-hand side was {!r}"
+)
+
+
+class QuantumIfOperation(QuantumExpressionOperation):
+    then: "QuantumOperand"
+    _ctrl: Optional[QmodQNumProxy] = pydantic.PrivateAttr(
+        default=None,
+    )
+    _ctrl_val: Optional[int] = pydantic.PrivateAttr(
+        default=None,
+    )
+
+    @property
+    def condition(self) -> Expression:
+        return self.expression
+
+    @property
+    def ctrl(self) -> QmodQNumProxy:
+        assert self._ctrl is not None
+        return self._ctrl
+
+    @property
+    def ctrl_val(self) -> int:
+        assert self._ctrl_val is not None
+        return self._ctrl_val
+
+    def resolve_condition(self) -> None:
+        condition = self.condition.value.value
+        if not isinstance(condition, Equality):
+            raise ClassiqValueError(
+                f"quantum_if condition must be an equality, was {str(condition)!r}"
+            )
+        ctrl, ctrl_val = condition.args
+        if isinstance(ctrl, Integer) and isinstance(ctrl_val, QmodQNumProxy):
+            ctrl, ctrl_val = ctrl_val, ctrl
+        if not isinstance(ctrl, QmodQNumProxy):
+            raise ClassiqValueError(
+                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
+            )
+        if not isinstance(ctrl_val, Integer):
+            raise ClassiqValueError(
+                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format(
+                    "right", str(ctrl_val)
+                )
+            )
+        self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
+
+    @property
+    def ctrl_state(self) -> str:
+        is_signed = self.ctrl.is_signed
+        fraction_places = self.ctrl.fraction_digits
+        ctrl_size = len(self.ctrl)
+        if not is_signed and self.ctrl_val < 0:
+            raise ClassiqValueError(
+                f"Variable {str(self.ctrl)!r} is not signed but control value "
+                f"{self.ctrl_val} is negative"
+            )
+        required_qubits = min_bit_length(self.ctrl_val, is_signed)
+        if ctrl_size < required_qubits:
+            raise ClassiqValueError(
+                f"Variable {str(self.ctrl)!r} has {ctrl_size} qubits but control value "
+                f"{str(self.ctrl_val)!r} requires at least {required_qubits} qubits"
+            )
+        if fraction_places != 0:
+            raise ClassiqValueError(
+                f"quantum-if on a non-integer quantum variable {str(self.ctrl)!r} is "
+                f"not supported at the moment"
+            )
+        return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)

classiq/interface/model/resolvers/function_call_resolver.py

@@ -16,7 +16,7 @@ class FunctionCallResolver(Visitor):
         self._quantum_function_dict = quantum_function_dict
 
     def visit_QuantumFunctionCall(self, fc: QuantumFunctionCall) -> None:
-        fc.resolve_function_decl(self._quantum_function_dict)
+        fc.resolve_function_decl(self._quantum_function_dict, check_operands=True)
         self.visit_BaseModel(fc)
 
     def visit_NativeFunctionDefinition(

classiq/interface/model/validations/handles_validator.py

@@ -1,13 +1,20 @@
-from typing import Dict, Iterable, Mapping, Union
+from typing import Dict, Mapping, Set, Union
 
 from classiq.interface.generator.function_params import PortDirection
+from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
+    APPLY,
+    OPERAND_FIELD_NAME,
+)
 from classiq.interface.model.handle_binding import (
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.local_variable_declaration import LocalVariableDeclaration
 from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_call import (
+    QuantumFunctionCall,
+    QuantumLambdaFunction,
+)
 from classiq.interface.model.quantum_statement import QuantumOperation
 from classiq.interface.model.validation_handle import HandleState, ValidationHandle
 from classiq.interface.model.validations.handle_validation_base import (
@@ -17,23 +24,21 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 def _initialize_handles_to_state(
     port_declarations: Mapping[str, PortDeclaration],
-    local_handles: Iterable[LocalVariableDeclaration],
 ) -> Dict[str, ValidationHandle]:
     handles_to_state: Dict[str, ValidationHandle] = dict()
 
     for port_decl in port_declarations.values():
         handles_to_state[port_decl.name] = ValidationHandle(
-            initial_state=HandleState.INITIALIZED
-            if port_decl.direction.includes_port_direction(PortDirection.Input)
-            else HandleState.UNINITIALIZED
-        )
-
-    for local_handle in local_handles:
-        handles_to_state[local_handle.name] = ValidationHandle(
-            initial_state=HandleState.UNINITIALIZED
+            initial_state=(
+                HandleState.INITIALIZED
+                if port_decl.direction.includes_port_direction(PortDirection.Input)
+                else HandleState.UNINITIALIZED
+            )
         )
 
     return handles_to_state
@@ -43,19 +48,18 @@ class HandleValidator(HandleValidationBase):
     def __init__(
         self,
         port_declarations: Mapping[str, PortDeclaration],
-        local_handles: Iterable[LocalVariableDeclaration],
     ) -> None:
         super().__init__(port_declarations)
         self._port_declarations = port_declarations.values()
-        self._handles_to_state = _initialize_handles_to_state(
-            port_declarations, local_handles
-        )
+        self._handles_to_state = _initialize_handles_to_state(port_declarations)
 
     @property
     def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
         return self._handles_to_state
 
     def handle_call(self, call: QuantumOperation) -> None:
+        if isinstance(call, QuantumFunctionCall) and call.function == APPLY.name:
+            self._handle_apply(call)
         self._handle_inputs(call.wiring_inputs)
         self._handle_outputs(call.wiring_outputs)
         self._handle_inouts(call.wiring_inouts)
@@ -125,3 +129,26 @@ class HandleValidator(HandleValidationBase):
             self._handles_to_state[handle].append_error(
                 f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
             )
+
+    def _handle_apply(self, call: QuantumFunctionCall) -> None:
+        operand = call.operands[OPERAND_FIELD_NAME]
+        if not isinstance(operand, QuantumLambdaFunction):
+            return
+        local_variables: Set[str] = set()
+        output_capturing_variables: Set[str] = set()
+        for statement in operand.body:
+            if isinstance(statement, VariableDeclarationStatement):
+                local_variables.add(statement.name)
+            elif isinstance(statement, QuantumOperation):
+                for handle in statement.wiring_outputs.values():
+                    if (
+                        handle.name in local_variables
+                        or handle.name in output_capturing_variables
+                    ):
+                        continue
+                    output_capturing_variables.add(handle.name)
+                    self._handles_to_state[handle.name].initialize()
+            else:
+                raise ClassiqValueError(
+                    f"Unknown statement type {type(statement).__name__}"
+                )

classiq/interface/server/routes.py

@@ -4,9 +4,8 @@ LEGACY_EXECUTE_PREFIX = "/execute"
 EXECUTION_PREFIX = "/execution"
 CONVERSION_PREFIX = "/conversion"
 
-SYNTHESIS_SERVICE_PREFIX = "/synthesis/v1"
-
-EXECUTION_SERVICE_PREFIX = "/execution/v1"
+EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
+SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
 
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
@@ -51,10 +50,11 @@ TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
 TASK_RB_SUFFIX = TASKS_SUFFIX + RB
 TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
 
-
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
-EXECUTION_SERVICE_JOBS_FULL_PATH = EXECUTION_SERVICE_PREFIX + EXECUTION_JOBS_SUFFIX
+EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
+    EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
+)
 EXECUTE_QUANTUM_PROGRAM_FULL_PATH = LEGACY_EXECUTE_PREFIX + QUANTUM_PROGRAM_SUFFIX
 EXECUTE_ESTIMATE_FULL_PATH = LEGACY_EXECUTE_PREFIX + ESTIMATE_SUFFIX
 
@@ -62,8 +62,12 @@ ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX
 GENERATE_RESOURCE_ESTIMATOR_REPORT = "/resource_estimator_report"
 
+TASKS_SOLVE_EXACT_SUFFIX = "/tasks/solve_exact"
+
 GENERATE_HAMILTONIAN_SUFFIX = "/generate_hamiltonian"
-GENERATE_HAMILTONIAN_FULL_PATH = SYNTHESIS_SERVICE_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
+GENERATE_HAMILTONIAN_FULL_PATH = (
+    SYNTHESIS_NON_VERSIONED_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
+)
 
 FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"