classiq 0.60.0__py3-none-any.whl → 0.61.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -7,7 +7,7 @@ from classiq.interface.generator.functions.port_declaration import (
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.control import Control
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.handle_binding import HandleBinding, SubscriptHandleBinding
 from classiq.interface.model.inplace_binary_operation import (
     BinaryOperation,
     InplaceBinaryOperation,
@@ -19,6 +19,7 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -33,10 +34,11 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
 )
 from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
 from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
 from classiq.qmod.builtins.functions import (
     CX,
+    X,
     allocate,
-    apply_to_all,
     integer_xor,
     modular_add,
     modular_add_constant,
@@ -97,6 +99,7 @@ class InplaceBinaryOperationEmitter(CallEmitter[InplaceBinaryOperation]):
             body = _build_inplace_xor_operation(
                 value_var=value_var,
                 target_var=target_var,
+                name_allocator=self._interpreter._counted_name_allocator,
             )
         else:
             body = _build_inplace_binary_operation(
@@ -128,11 +131,10 @@ class InplaceBinaryOperationEmitter(CallEmitter[InplaceBinaryOperation]):
     def _emit_constant_operation(self, op: InplaceBinaryOperation) -> None:
         if TYPE_CHECKING:
             assert isinstance(op.value, Expression)
-        value = self._evaluate_expression(op.value)
         self._interpreter.emit(
             _internal_inplace_binary_operation_function_call(
                 _binary_function_declaration(op.operation, constant=True),
-                value,
+                op.value,
                 op.target,
             )
         )
@@ -196,7 +198,9 @@ def _build_inplace_binary_operation(
 
 
 def _build_inplace_xor_operation(
-    value_var: QuantumSymbol, target_var: QuantumSymbol
+    value_var: QuantumSymbol,
+    target_var: QuantumSymbol,
+    name_allocator: CountedNameAllocator,
 ) -> list[QuantumStatement]:
     if TYPE_CHECKING:
         assert isinstance(value_var.quantum_type, QuantumNumeric)
@@ -214,7 +218,7 @@ def _build_inplace_xor_operation(
         _trim_superfluous_fraction_digits("value", value_var, frac_digits_diff)
     )
     target_left_var, value_left_var, sign_var_decls, sign_bind_ops, sign_xor = (
-        _split_and_xor_sign(target_overlap_var, value_overlap_var)
+        _split_and_xor_sign(target_overlap_var, value_overlap_var, name_allocator)
     )
 
     action: list[QuantumStatement] = []
@@ -425,7 +429,11 @@ def _split_var(
     return left_var, right_var, split_bind
 
 
-def _split_and_xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> tuple[
+def _split_and_xor_sign(
+    target_var: QuantumSymbol,
+    value_var: QuantumSymbol,
+    name_allocator: CountedNameAllocator,
+) -> tuple[
     Optional[QuantumSymbol],
     Optional[QuantumSymbol],
     list[VariableDeclarationStatement],
@@ -442,7 +450,7 @@ def _split_and_xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) ->
         return target_var, value_var, [], [], []
 
     if value_var.quantum_type.size_in_bits == 1:
-        return None, None, [], [], [_xor_sign(target_var, value_var)]
+        return None, None, [], [], [_xor_sign(target_var, value_var, name_allocator)]
 
     value_rest_var, value_sign_var, value_split_bind = _split_var("value", value_var, 1)
     target_left_var, target_right_var, target_split_bind = _split_var(
@@ -456,11 +464,15 @@ def _split_and_xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) ->
         for var in (value_rest_var, value_sign_var, target_left_var, target_right_var)
     ]
     bind_ops = [value_split_bind, target_split_bind]
-    sign_xor = _xor_sign(target_right_var, value_sign_var)
+    sign_xor = _xor_sign(target_right_var, value_sign_var, name_allocator)
     return target_left_var, value_rest_var, var_decls, bind_ops, [sign_xor]
 
 
-def _xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> Control:
+def _xor_sign(
+    target_var: QuantumSymbol,
+    value_var: QuantumSymbol,
+    name_allocator: CountedNameAllocator,
+) -> Control:
     quantum_type = value_var.quantum_type
     if TYPE_CHECKING:
         assert isinstance(quantum_type, QuantumNumeric)
@@ -470,11 +482,33 @@ def _xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> Control:
     ):
         raise ClassiqInternalExpansionError
 
-    inner_xor = QuantumFunctionCall(
-        function=apply_to_all.func_decl.name,
-        positional_args=["X", target_var.handle],
+    aux_var = name_allocator.allocate("inplace_xor_aux")
+    iteration_var = name_allocator.allocate("i")
+    inner_x_call = QuantumFunctionCall(
+        function=X.func_decl.name,
+        positional_args=[
+            SubscriptHandleBinding(
+                base_handle=HandleBinding(name=aux_var),
+                index=Expression(expr=iteration_var),
+            )
+        ],
+    )
+    inner_x_call.set_func_decl(X.func_decl)
+    inner_xor = WithinApply(
+        compute=[
+            BindOperation(
+                in_handles=[target_var.handle],
+                out_handles=[HandleBinding(name=aux_var)],
+            ),
+        ],
+        action=[
+            Repeat(
+                iter_var=iteration_var,
+                count=Expression(expr=f"{target_var.quantum_type.size_in_bits}"),
+                body=[inner_x_call],
+            )
+        ],
     )
-    inner_xor.set_func_decl(apply_to_all.func_decl)
 
     if quantum_type.sign_value:
         if quantum_type.fraction_digits_value == 1:
@@ -489,5 +523,13 @@ def _xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> Control:
 
     return Control(
         expression=Expression(expr=f"{value_var.handle} == {ctrl_value}"),
-        body=[inner_xor],
+        body=[
+            VariableDeclarationStatement(
+                name=aux_var,
+                quantum_type=QuantumBitvector(
+                    length=Expression(expr=f"{target_var.quantum_type.size_in_bits}")
+                ),
+            ),
+            inner_xor,
+        ],
     )

classiq/model_expansions/quantum_operations/invert.py

@@ -10,12 +10,7 @@ from classiq.model_expansions.scope import Scope
 
 class InvertEmitter(CallEmitter[Invert]):
     def emit(self, invert: Invert, /) -> None:
-        is_generative = invert.is_generative()
-        if is_generative:
-            context = self._register_generative_context(invert, INVERT_OPERATOR_NAME)
-            invert = invert.model_copy(update={"body": context.statements("body")})
-
-        if not is_generative and self._should_wrap(invert.body):
+        if self._should_wrap(invert.body):
             self._emit_wrapped(invert)
             return
 

classiq/model_expansions/quantum_operations/phase.py

@@ -39,8 +39,6 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
         )
 
     def emit(self, phase_op: PhaseOperation, /) -> None:
-        phase_expression = self._evaluate_op_expression(phase_op)
-        phase_op = phase_op.model_copy(update=dict(expression=phase_expression))
         arrays_with_subscript = self.split_symbols(
             phase_op.expression, self._counted_name_allocator.allocate
         )
@@ -51,7 +49,7 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
         phase_op = phase_op.model_copy(
             update=dict(expression=self._negate_expression(phase_op.expression))
         )
-        phase_op = self._evaluate_types_in_expression(phase_op, phase_op.expression)
+        phase_op = self._evaluate_types_in_expression(phase_op)
         if len(phase_op.var_handles) == 0:
             ErrorManager().add_error(
                 "Cannot perform phase operation on an expression with no quantum variables."
@@ -65,12 +63,11 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
         else:
             split_join = False
             evolution_variable = phase_op.var_handles[0]
-        expression = self._evaluate_op_expression(phase_op)
         expression_evolution_function = QuantumFunctionCall(
             function=suzuki_trotter.func_decl.name,
             positional_args=[
                 _convert_cost_expression_to_hamiltonian(
-                    expression.expr,
+                    phase_op.expression.expr,
                     {
                         var.name: self._current_scope[var.name].value.quantum_type
                         for var in phase_op.var_handles

classiq/model_expansions/quantum_operations/power.py

@@ -22,10 +22,6 @@ class PowerEmitter(CallEmitter[Power]):
     _power_expr: Expression
 
     def emit(self, power: Power, /) -> None:
-        if power.is_generative():
-            context = self._register_generative_context(power, POWER_OPERATOR_NAME)
-            power = power.model_copy(update={"body": context.statements("body")})
-
         self._power = power
         self._power_value = self._get_power_value()
         self._power_expr = Expression(

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -5,6 +5,10 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.arith.arithmetic import is_zero
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    is_constant,
+)
 from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import HandleBinding
@@ -45,18 +49,6 @@ HANDLE_ERROR_MESSAGE = (
 )
 
 
-def _is_constant(expr: str) -> bool:
-    try:
-        float(expr)
-        return True
-    except ValueError:
-        return False
-
-
-def _is_zero(expr: str) -> bool:
-    return _is_constant(expr) and float(expr) == 0
-
-
 def _is_variable(expr: str) -> bool:
     return re.fullmatch("[a-zA-Z_][a-zA-Z0-9_]*", expr) is not None
 
@@ -65,29 +57,26 @@ class QuantumAssignmentOperationEmitter(
     ExpressionOperationEmitter[QuantumAssignmentOperation]
 ):
     def emit(self, op: QuantumAssignmentOperation, /) -> None:
-        new_expression = self._evaluate_op_expression(op)
-        if self._skip_assignment(op, new_expression.expr):
+        if self._skip_assignment(op, op.expression.expr):
             return
         arrays_with_subscript = self.split_symbols(
-            new_expression, self._counted_name_allocator.allocate
+            op.expression, self._counted_name_allocator.allocate
         )
         if len(arrays_with_subscript) > 0:
-            self._emit_with_split(op, new_expression, arrays_with_subscript)
+            self._emit_with_split(op, op.expression, arrays_with_subscript)
             return
 
-        self._emit_op(new_expression, op)
+        self._emit_op(op)
 
-    def _emit_op(self, expression: Expression, op: QuantumAssignmentOperation) -> None:
-        op = self._evaluate_types_in_expression(op, expression)
+    def _emit_op(self, op: QuantumAssignmentOperation) -> None:
+        op = self._evaluate_types_in_expression(op)
         if isinstance(op, ArithmeticOperation):
-            self._emit_arithmetic_op(op, expression)
+            self._emit_arithmetic_op(op)
             return
         self._emit_general_assignment_operation(op)
 
-    def _emit_arithmetic_op(
-        self, op: ArithmeticOperation, expression: Expression
-    ) -> None:
-        op, expression, is_bool_opt = self._optimize_boolean_expression(op, expression)
+    def _emit_arithmetic_op(self, op: ArithmeticOperation) -> None:
+        op, expression, is_bool_opt = self._optimize_boolean_expression(op)
         if op.is_inplace:
             self._emit_inplace_arithmetic_op(op, expression, is_bool_opt)
         else:
@@ -102,7 +91,7 @@ class QuantumAssignmentOperationEmitter(
             or op.result_type.size_in_bits > 1
             or not self._is_res_boolean(op)
             or target.quantum_type.size_in_bits > 1
-            or _is_constant(expression.expr)
+            or is_constant(expression.expr)
         ):
             _validate_naive_inplace_handles(op)
             self._build_naive_inplace(op, expression)
@@ -131,7 +120,7 @@ class QuantumAssignmentOperationEmitter(
         self.emit_statement(op)
 
     def _optimize_boolean_expression(
-        self, op: ArithmeticOperation, expression: Expression
+        self, op: ArithmeticOperation
     ) -> tuple[ArithmeticOperation, Expression, bool]:
         if (
             self._interpreter._is_frontend
@@ -143,10 +132,10 @@ class QuantumAssignmentOperationEmitter(
             or not self._all_vars_boolean(op)
             or not self._is_res_boolean(op)
         ):
-            return op, expression, False
+            return op, op.expression, False
         optimizer = BooleanExpressionOptimizer()
         optimized_expression = Expression(
-            expr=ast.unparse(optimizer.visit(ast.parse(expression.expr)))
+            expr=ast.unparse(optimizer.visit(ast.parse(op.expression.expr)))
         )
         optimized_expression = self._evaluate_expression(optimized_expression)
         optimized_op = op.model_copy(update=dict(expression=optimized_expression))
@@ -174,7 +163,7 @@ class QuantumAssignmentOperationEmitter(
                 f"Unrecognized operation kind {qe.operation_kind!r}"
             )
 
-        if _is_constant(new_expression.expr):
+        if is_constant(new_expression.expr):
             self._interpreter.emit_statement(
                 InplaceBinaryOperation(
                     operation=op,
@@ -215,7 +204,7 @@ class QuantumAssignmentOperationEmitter(
         )
 
     def _skip_assignment(self, op: QuantumAssignmentOperation, expr: str) -> bool:
-        if not isinstance(op, ArithmeticOperation) or not _is_zero(expr):
+        if not isinstance(op, ArithmeticOperation) or not is_zero(expr):
             return False
         if op.operation_kind != ArithmeticOperationKind.Assignment:
             return True

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -19,4 +19,6 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name), function.freeze():
-            self._emit_quantum_function_call(function, args)
+            self._emit_quantum_function_call(
+                function, args, self._debug_info.get(call.uuid)
+            )

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -0,0 +1,155 @@
+import ast
+from typing import TYPE_CHECKING, Any, Optional, TypeVar
+
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+from classiq.model_expansions.transformers.ast_renamer import rename_variables
+from classiq.model_expansions.visitors.variable_references import VarRefCollector
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreter import Interpreter
+
+
+QuantumOperationT = TypeVar("QuantumOperationT", bound=QuantumOperation)
+_BLOCK_RENAMES = {
+    "compute": "within",
+    "action": "apply",
+}
+_REVERSE_BLOCK_RENAMES = {rename: name for name, rename in _BLOCK_RENAMES.items()}
+
+
+class ShallowEmitter(Emitter[QuantumOperation]):
+    def __init__(
+        self,
+        interpreter: "Interpreter",
+        operation_name: str,
+        *,
+        components: Optional[list[str]] = None,
+    ) -> None:
+        super().__init__(interpreter)
+        self._operation_name = operation_name
+        self._components: list[str] = components or []
+
+    def emit(self, op: QuantumOperation, /) -> None:
+        expanded_components: dict[str, Any] = {}
+        blocks, expressions, handles = self._split_components(op)
+
+        if len(blocks) > 0:
+            if op.is_generative():
+                expanded_blocks = self.expand_generative_blocks(op)
+            else:
+                expanded_blocks = self.expand_blocks(op, blocks)
+            expanded_components.update(expanded_blocks)
+
+        for expression_name in expressions:
+            expression = getattr(op, expression_name)
+            expression = self._evaluate_expression(expression, preserve_bool_ops=True)
+            self.capture_handles_in_expression(expression)
+            expanded_components[expression_name] = expression
+
+        for handle_name in handles:
+            handle = getattr(op, handle_name)
+            expanded_components[handle_name] = self._interpreter.evaluate(
+                handle
+            ).value.handle
+
+        op = op.model_copy(update=expanded_components)
+        if isinstance(op, ArithmeticOperation):
+            self._post_process_assignment(op)
+        self._builder.emit_statement(op)
+
+    def _post_process_assignment(self, op: ArithmeticOperation) -> None:
+        if op.operation_kind == ArithmeticOperationKind.Assignment:
+            direction = PortDeclarationDirection.Output
+            self._update_result_type(op)
+        else:
+            direction = PortDeclarationDirection.Inout
+        self._capture_handle(op.result_var, direction)
+
+    def _split_components(
+        self, op: QuantumOperation
+    ) -> tuple[list[str], list[str], list[str]]:
+        blocks = self._filter_components(op, list)
+        expressions = self._filter_components(op, Expression)
+        handles = self._filter_components(op, HandleBinding)
+        return blocks, expressions, handles
+
+    def _filter_components(
+        self, op: QuantumOperation, component_type: type
+    ) -> list[str]:
+        return [
+            component
+            for component in self._components
+            if isinstance(getattr(op, component, None), component_type)
+        ]
+
+    def expand_blocks(
+        self, op: QuantumOperation, block_names: list[str]
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = {
+            _BLOCK_RENAMES.get(block, block): block_statements
+            for block in block_names
+            if (block_statements := getattr(op, block)) is not None
+        }
+        block_closure = Closure(
+            name=self._operation_name,
+            scope=Scope(parent=self._current_scope),
+            blocks=blocks,
+        )
+        context = self._expand_operation(block_closure)
+        return {
+            block: context.statements(_BLOCK_RENAMES.get(block, block))
+            for block in block_names
+        }
+
+    def expand_generative_blocks(
+        self, op: QuantumOperation
+    ) -> dict[str, list[QuantumStatement]]:
+        blocks = [block for block in self._components if op.has_generative_block(block)]
+        context = self._expand_generative_context(op, self._operation_name, blocks)
+        return {
+            _REVERSE_BLOCK_RENAMES.get(block, block): context.statements(block)
+            for block in blocks
+        }
+
+    def _update_result_type(self, op: ArithmeticOperation) -> None:
+        expr = str(self._evaluate_expression(op.expression))
+        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc.visit(ast.parse(expr))
+        symbols: list[QuantumSymbol] = [
+            symbol
+            for handle in vrc.var_handles
+            if isinstance(
+                symbol := self._interpreter.evaluate(handle).value, QuantumSymbol
+            )
+        ]
+        expr = rename_variables(
+            expr,
+            {str(symbol.handle): symbol.handle.identifier for symbol in symbols}
+            | {symbol.handle.qmod_expr: symbol.handle.identifier for symbol in symbols},
+        )
+        for symbol in symbols:
+            expr = expr.replace(symbol.handle.qmod_expr, symbol.handle.identifier)
+        result_type = compute_arithmetic_result_type(
+            expr,
+            {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
+            self._machine_precision,
+        )
+        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        copy_type_information(
+            result_type, result_symbol.quantum_type, str(op.result_var)
+        )

classiq/model_expansions/quantum_operations/within_apply.py

@@ -10,20 +10,6 @@ from classiq.model_expansions.scope import Scope
 
 class WithinApplyEmitter(Emitter[WithinApply]):
     def emit(self, within_apply: WithinApply, /) -> None:
-        if within_apply.is_generative():
-            within_apply_context = self._register_generative_context(
-                within_apply, WITHIN_APPLY_NAME, ["within", "apply"]
-            )
-            within_apply = within_apply.model_copy(
-                update={
-                    "compute": within_apply_context.statements("within"),
-                    "action": within_apply_context.statements("apply"),
-                }
-            )
-
-        self._emit_as_operation(within_apply)
-
-    def _emit_as_operation(self, within_apply: WithinApply) -> None:
         within_apply_operation = Closure(
             name=WITHIN_APPLY_NAME,
             blocks=dict(within=within_apply.compute, apply=within_apply.action),

classiq/model_expansions/scope.py

@@ -1,4 +1,5 @@
 import itertools
+import re
 from collections import UserDict
 from collections.abc import Iterator
 from contextlib import contextmanager
@@ -6,6 +7,8 @@ from dataclasses import dataclass
 from functools import singledispatch
 from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union
 
+from sympy import Symbol
+
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -14,6 +17,9 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    CPARAM_EXECUTION_SUFFIX_PATTERN,
+)
 from classiq.interface.generator.expressions.qmod_qarray_proxy import (
     ILLEGAL_SLICE_BOUNDS_MSG,
 )
@@ -88,10 +94,8 @@ class QuantumSymbol:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable."
             )
-        if (
-            index < 0
-            or self.quantum_type.has_length
-            and index > self.quantum_type.length_value
+        if index < 0 or (
+            self.quantum_type.has_length and index > self.quantum_type.length_value
         ):
             raise ClassiqExpansionError(
                 f"Subscript [{index}] is out of bounds for {self.handle}."
@@ -194,6 +198,8 @@ class Scope(EvaluatedUserDict):
             return self.data[name]
         if self._parent is not None:
             return self._parent[name]
+        if re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, name):
+            return Evaluated(value=Symbol(name))
         raise ClassiqExpansionError(f"Variable {name!r} is undefined")
 
     def __contains__(self, item: Any) -> bool:

classiq/model_expansions/scope_initialization.py

@@ -26,7 +26,6 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.qmod.builtins import BUILTIN_CONSTANTS
 from classiq.qmod.builtins.functions import (
     CORE_LIB_DECLS,
-    OPEN_LIB_DECLS,
     STD_QMOD_OPERATORS,
 )
 from classiq.qmod.quantum_function import GenerativeQFunc
@@ -96,16 +95,6 @@ def _init_builtins_scope(scope: Scope) -> None:
                 scope=Scope(parent=scope),
             )
         )
-    for func_decl in OPEN_LIB_DECLS:
-        if func_decl.name not in scope:
-            scope[func_decl.name] = Evaluated(
-                value=FunctionClosure.create(
-                    name=func_decl.name,
-                    positional_arg_declarations=func_decl.positional_arg_declarations,
-                    scope=Scope(parent=scope),
-                    is_atomic=True,
-                )
-            )
     for constant in BUILTIN_CONSTANTS:
         value = constant.value
         if not value.is_evaluated():

classiq/model_expansions/sympy_conversion/expression_to_sympy.py

@@ -170,3 +170,10 @@ class ExpressionSympyTranslator(ast.NodeTransformer):
             args=[self.visit(node.value), self.visit(node.slice)],
             keywords=[],
         )
+
+    def visit_Attribute(self, node: ast.Attribute) -> ast.Call:
+        return ast.Call(
+            func=ast.Name("get_field"),
+            args=[node.value, ast.Constant(value=node.attr)],
+            keywords=[],
+        )

classiq/model_expansions/sympy_conversion/sympy_to_python.py

@@ -109,5 +109,15 @@ class SympyToQuantumExpressionTranslator(PythonCodePrinter):
         return f"(({self._print(expr.args[0])}) ^ ({self._print(expr.args[1])}))"
 
 
-def translate_sympy_quantum_expression(expr: Basic) -> str:
-    return SympyToQuantumExpressionTranslator().doprint(expr)
+class SympyToBoolExpressionTranslator(SympyToQuantumExpressionTranslator):
+    _operators = {
+        **SympyToQuantumExpressionTranslator._operators,
+        **{"not": "not ", "xor": "xor"},
+    }
+
+
+def translate_sympy_quantum_expression(expr: Basic, preserve_bool_ops: bool) -> str:
+    if preserve_bool_ops:
+        return SympyToBoolExpressionTranslator().doprint(expr)
+    else:
+        return SympyToQuantumExpressionTranslator().doprint(expr)

classiq/model_expansions/transformers/ast_renamer.py

@@ -0,0 +1,26 @@
+import ast
+
+_POSSIBLE_HANDLE_AST_TYPES = (ast.Subscript, ast.Attribute, ast.Name)
+
+
+class _ASTRenamer(ast.NodeTransformer):
+    def __init__(self, sub: dict[str, str]) -> None:
+        self._sub = sub
+
+    def visit(self, node: ast.AST) -> ast.AST:
+        if isinstance(node, _POSSIBLE_HANDLE_AST_TYPES):
+            node_expr = ast.unparse(node)
+            if node_expr in self._sub:
+                return ast.Name(id=self._sub[node_expr])
+        return super().visit(node)
+
+    def visit_Call(self, node: ast.Call) -> ast.Call:
+        return ast.Call(
+            func=node.func,
+            args=[self.visit(arg) for arg in node.args],
+            keywords=[],
+        )
+
+
+def rename_variables(expr: str, sub: dict[str, str]) -> str:
+    return ast.unparse(_ASTRenamer(sub).visit(ast.parse(expr)))