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

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -7,8 +7,10 @@ from numpy.random import permutation
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.allocate import Allocate
@@ -52,9 +54,7 @@ from classiq.model_expansions.generative_functions import emit_generative_statem
 from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 from classiq.model_expansions.quantum_operations import (
     BindEmitter,
-    ClassicalIfEmitter,
     QuantumFunctionCallEmitter,
-    RepeatEmitter,
     VariableDeclarationStatementEmitter,
 )
 from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
@@ -69,6 +69,9 @@ from classiq.model_expansions.quantum_operations.expression_evaluator import (
     ExpressionEvaluator,
 )
 from classiq.model_expansions.quantum_operations.handle_evaluator import HandleEvaluator
+from classiq.model_expansions.quantum_operations.repeat_block_evaluator import (
+    RepeatBlockEvaluator,
+)
 from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -87,7 +90,9 @@ class GenerativeInterpreter(BaseInterpreter):
         generative_functions: list[GenerativeQFunc],
     ) -> None:
         super().__init__(model)
-        add_generative_functions_to_scope(generative_functions, self._top_level_scope)
+        add_generative_functions_to_scope(
+            generative_functions, self._top_level_scope, override_atomic=True
+        )
 
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         renamed_params = [
@@ -189,8 +194,22 @@ class GenerativeInterpreter(BaseInterpreter):
         VariableDeclarationStatementEmitter(self).emit(variable_declaration)
 
     @emit.register
+    def _emit_classical_if(self, classical_if: ClassicalIf) -> None:
+        self.emit_classical_if(classical_if)
+
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:
-        ClassicalIfEmitter(self).emit(classical_if)
+        CompositeEmitter[ClassicalIf](
+            self,
+            [
+                ExpressionEvaluator(self, "condition"),
+                BlockEvaluator(
+                    self,
+                    CLASSICAL_IF_OPERATOR_NAME,
+                    "then",
+                    "else_",
+                ),
+            ],
+        ).emit(classical_if)
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
@@ -208,8 +227,17 @@ class GenerativeInterpreter(BaseInterpreter):
         BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
 
     @emit.register
+    def _emit_repeat(self, repeat: Repeat) -> None:
+        self.emit_repeat(repeat)
+
     def emit_repeat(self, repeat: Repeat) -> None:
-        RepeatEmitter(self).emit(repeat)
+        CompositeEmitter[Repeat](
+            self,
+            [
+                ExpressionEvaluator(self, "count"),
+                RepeatBlockEvaluator(self, REPEAT_OPERATOR_NAME, "body"),
+            ],
+        ).emit(repeat)
 
     @emit.register
     def _emit_control(self, control: Control) -> None:

classiq/model_expansions/quantum_operations/__init__.py

@@ -1,9 +1,7 @@
 from classiq.model_expansions.quantum_operations.bind import BindEmitter
-from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     QuantumFunctionCallEmitter,
 )
-from classiq.model_expansions.quantum_operations.repeat import RepeatEmitter
 from classiq.model_expansions.quantum_operations.variable_decleration import (
     VariableDeclarationStatementEmitter,
 )

classiq/model_expansions/quantum_operations/block_evaluator.py

@@ -1,6 +1,7 @@
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
 from classiq.model_expansions.closure import Closure
@@ -54,7 +55,8 @@ class BlockEvaluator(Emitter[QuantumOperation]):
         }
         block_closure = Closure(
             name=self._operation_name,
-            scope=Scope(parent=self._current_scope),
+            scope=self.get_scope(op),
+            positional_arg_declarations=self.get_params(op),
             blocks=blocks,
         )
         context = self._expand_operation(block_closure)
@@ -69,8 +71,20 @@ class BlockEvaluator(Emitter[QuantumOperation]):
         blocks = [
             block for block in self._block_names if op.has_generative_block(block)
         ]
-        context = self._expand_generative_context(op, self._operation_name, blocks)
+        context = self._expand_generative_context(
+            op,
+            self._operation_name,
+            blocks,
+            self.get_params(op),
+            self.get_scope(op),
+        )
         return {
             _REVERSE_BLOCK_RENAMES.get(block, block): context.statements(block)
             for block in blocks
         }
+
+    def get_params(self, op: QuantumOperation) -> Sequence[PositionalArg]:
+        return []
+
+    def get_scope(self, op: QuantumOperation) -> Scope:
+        return Scope(parent=self._current_scope)

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -2,17 +2,32 @@ from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
     TYPE_CHECKING,
+    Any,
     Generic,
     cast,
 )
 from uuid import UUID
 
+import sympy
+
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.generated_circuit_data import OperationLevel
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -75,6 +90,16 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
             )
 
 
+def _is_symbolic(arg: Any) -> bool:
+    if isinstance(arg, list):
+        return any(_is_symbolic(item) for item in arg)
+    if isinstance(arg, QmodStructInstance):
+        return any(_is_symbolic(item) for item in arg.fields.values())
+    if isinstance(arg, sympy.Basic):
+        return len(arg.free_symbols) > 0
+    return isinstance(arg, (ClassicalProxy, AnyClassicalValue))
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
@@ -197,7 +222,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             ].occurrences_number += 1
             return function_def
 
-        function_def = self._create_function_definition(function_context)
+        function_def = self._create_function_definition(function_context, args)
         self._expanded_functions[closure_id] = function_def
         self._top_level_scope[function_def.name] = Evaluated(
             value=function_context.closure.with_new_declaration(function_def)
@@ -210,14 +235,23 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         return function_def
 
     def _create_function_definition(
-        self, function_context: FunctionContext
+        self, function_context: FunctionContext, args: list[Evaluated]
     ) -> NativeFunctionDefinition:
-        func_def = self._builder.create_definition(function_context)
+        params = [
+            param
+            for arg, param in zip(args, function_context.positional_arg_declarations)
+            if isinstance(param, PortDeclaration)
+            or (
+                isinstance(param, ClassicalParameterDeclaration)
+                and _is_symbolic(arg.value)
+            )
+        ]
+        func_def = self._builder.create_definition(function_context, params)
 
         captured_vars = function_context.closure.captured_vars.filter_vars(
             function_context.closure
         )
-        captured_ports = captured_vars.get_captured_ports()
+        captured_ports = captured_vars.get_captured_parameters()
         if len(captured_ports) == 0:
             return func_def
         func_def.positional_arg_declarations = list(
@@ -239,15 +273,22 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         closure: FunctionClosure,
     ) -> None:
         for parameter, argument in zip(parameters, arguments):
+            param_handle = HandleBinding(name=parameter.name)
             if isinstance(argument.value, QuantumSymbol):
                 assert isinstance(parameter, PortDeclaration)
                 closure.scope[parameter.name] = Evaluated(
                     QuantumSymbol(
-                        handle=HandleBinding(name=parameter.name),
+                        handle=param_handle,
                         quantum_type=parameter.quantum_type,
                     ),
                     defining_function=closure,
                 )
+            elif _is_symbolic(argument.value):
+                assert isinstance(parameter, ClassicalParameterDeclaration)
+                closure.scope[parameter.name] = Evaluated(
+                    value=parameter.classical_type.get_classical_proxy(param_handle),
+                    defining_function=closure,
+                )
             else:
                 closure.scope[parameter.name] = argument
 
@@ -264,7 +305,9 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             return [arg.emit() for arg in evaluated_args]
 
         positional_args = [
-            arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
+            arg.emit()
+            for arg in evaluated_args
+            if isinstance(arg.value, QuantumSymbol) or _is_symbolic(arg.value)
         ]
 
         return positional_args

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,5 +1,6 @@
 import ast
 from abc import ABC, abstractmethod
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -19,14 +20,22 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.handle_binding import HandleBinding, NestedHandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
@@ -103,17 +112,20 @@ class Emitter(Generic[QuantumStatementT], ABC):
         op: QuantumOperation,
         context_name: str,
         block_names: Union[None, str, list[str]] = None,
-        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+        params: Optional[Sequence[PositionalArg]] = None,
+        scope: Optional[Scope] = None,
     ) -> OperationContext:
         if isinstance(block_names, str):
             block_names = [block_names]
         block_names = block_names or ["body"]
-        func_decl = func_decl or NamedParamsQuantumFunctionDeclaration(
-            name=context_name
+        func_decl = NamedParamsQuantumFunctionDeclaration(
+            name=context_name,
+            positional_arg_declarations=[] if params is None else params,
         )
+        _scope = Scope(parent=self._current_scope) if scope is None else scope
         gen_closure = GenerativeClosure(
             name=func_decl.name,
-            scope=Scope(parent=self._interpreter._builder.current_scope),
+            scope=_scope,
             blocks={},
             generative_blocks={
                 block_name: GenerativeQFunc(
@@ -121,6 +133,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
                 )
                 for block_name in block_names
             },
+            positional_arg_declarations=func_decl.positional_arg_declarations,
         )
         context = self._interpreter._expand_operation(gen_closure)
         op.clear_generative_blocks()
@@ -145,6 +158,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         return new_expression
 
     def emit_statement(self, statement: QuantumStatement) -> None:
+        self._update_captured_classical_vars(statement)
         if isinstance(statement, QuantumOperation):
             self._update_captured_vars(statement)
         if statement.uuid not in self._interpreter._model.debug_info:
@@ -153,6 +167,14 @@ class Emitter(Generic[QuantumStatementT], ABC):
             )
         self._builder.emit_statement(statement)
 
+    def _update_captured_classical_vars(self, stmt: QuantumStatement) -> None:
+        for expr in stmt.expressions:
+            self._update_captured_classical_vars_in_expression(expr)
+
+    def _update_captured_classical_vars_in_expression(self, expr: Expression) -> None:
+        for var_name, var_type in self._get_classical_vars_in_expression(expr):
+            self._capture_classical_var(var_name, var_type)
+
     def _update_captured_vars(self, op: QuantumOperation) -> None:
         handles = (
             [(handle, PortDeclarationDirection.Input) for handle in op.inputs]
@@ -167,6 +189,12 @@ class Emitter(Generic[QuantumStatementT], ABC):
     ) -> None:
         if handle.name not in self._current_scope:
             return
+        if not handle.is_constant():
+            self._update_captured_classical_vars_in_expression(
+                Expression(expr=str(handle))
+            )
+        while isinstance(handle, NestedHandleBinding) and not handle.is_constant():
+            handle = handle.base_handle
         defining_function = self._current_scope[handle.name].defining_function
         if defining_function is None:
             raise ClassiqInternalExpansionError
@@ -178,8 +206,20 @@ class Emitter(Generic[QuantumStatementT], ABC):
             direction=direction,
         )
 
+    def _capture_classical_var(self, var_name: str, var_type: ClassicalType) -> None:
+        if var_name not in self._current_scope:
+            return
+        defining_function = self._current_scope[var_name].defining_function
+        if defining_function is None:
+            raise ClassiqInternalExpansionError
+        self._builder.current_block.captured_vars.capture_classical_var(
+            var_name=var_name,
+            var_type=var_type,
+            defining_function=defining_function,
+        )
+
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expr.expr))
         handles = dict.fromkeys(
             handle
@@ -187,3 +227,21 @@ class Emitter(Generic[QuantumStatementT], ABC):
             if isinstance(self._current_scope[handle.name].value, QuantumSymbol)
         )
         return [self._interpreter.evaluate(handle).value for handle in handles]
+
+    def _get_classical_vars_in_expression(
+        self, expr: Expression
+    ) -> list[tuple[str, ClassicalType]]:
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
+        vrc.visit(ast.parse(expr.expr))
+        return list(
+            {
+                handle.name: get_proxy_type(proxy)
+                for handle in vrc.var_handles
+                if handle.name in self._current_scope
+                and isinstance(
+                    proxy := self._current_scope[handle.name].value, ClassicalProxy
+                )
+            }.items()
+        )

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -26,6 +26,10 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
+        for var_name, var_type in self._get_classical_vars_in_expression(
+            evaluated_expression
+        ):
+            self._capture_classical_var(var_name, var_type)
         op = op.model_copy(
             update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
         )

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -18,7 +18,7 @@ class HandleEvaluator(Emitter[QuantumOperation]):
         handle = getattr(op, self._handle_name)
         if not isinstance(handle, HandleBinding):
             return False
-        evaluated_handle = self._interpreter.evaluate(handle).value.handle
+        evaluated_handle = self._interpreter.evaluate(handle).value.handle.collapse()
         if handle == evaluated_handle:
             return False
         op = op.model_copy(

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,6 +1,14 @@
 from typing import TYPE_CHECKING
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import OperandIdentifier
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
@@ -19,6 +27,10 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         self._model = self._interpreter._model
 
     def emit(self, call: QuantumFunctionCall, /) -> bool:
+        if isinstance(call.function, OperandIdentifier):
+            index_val = self._interpreter.evaluate(call.function.index).value
+            if isinstance(index_val, ClassicalScalarProxy):
+                return self._emit_symbolic_lambda_list(call, index_val)
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
@@ -27,6 +39,43 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             )
         return True
 
+    def _emit_symbolic_lambda_list(
+        self, call: QuantumFunctionCall, index: ClassicalScalarProxy
+    ) -> bool:
+        if TYPE_CHECKING:
+            assert isinstance(call.function, OperandIdentifier)
+        funcs = self._interpreter.evaluate(call.function.name).value
+        if not isinstance(funcs, list):
+            raise ClassiqInternalExpansionError(
+                f"Unexpected lambda list type {type(funcs).__name__!r}"
+            )
+        self._interpreter.emit(self._create_recursive_if(call, index, len(funcs)))
+        return True
+
+    @staticmethod
+    def _create_recursive_if(
+        call: QuantumFunctionCall, index: ClassicalScalarProxy, num_funcs: int
+    ) -> QuantumStatement:
+        if TYPE_CHECKING:
+            assert isinstance(call.function, OperandIdentifier)
+        stmt: list[QuantumStatement] = []
+        for idx in reversed(range(num_funcs)):
+            stmt = [
+                ClassicalIf(
+                    condition=Expression(expr=f"{index} == {idx}"),
+                    then=[
+                        QuantumFunctionCall(
+                            function=OperandIdentifier(
+                                name=call.function.name, index=Expression(expr=str(idx))
+                            ),
+                            positional_args=call.positional_args,
+                        )
+                    ],
+                    else_=stmt,
+                )
+            ]
+        return stmt[0]
+
 
 class DeclarativeQuantumFunctionCallEmitter(
     QuantumFunctionCallEmitter, DeclarativeCallEmitter

classiq/model_expansions/quantum_operations/repeat_block_evaluator.py

@@ -0,0 +1,34 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.repeat import Repeat
+
+from classiq import ClassicalParameterDeclaration
+from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.scope import Evaluated, Scope
+
+
+class RepeatBlockEvaluator(BlockEvaluator):
+    def get_params(self, op: QuantumOperation) -> Sequence[PositionalArg]:
+        if TYPE_CHECKING:
+            assert isinstance(op, Repeat)
+        return [
+            ClassicalParameterDeclaration(name=op.iter_var, classical_type=Integer())
+        ]
+
+    def get_scope(self, op: QuantumOperation) -> Scope:
+        if TYPE_CHECKING:
+            assert isinstance(op, Repeat)
+        scope = super().get_scope(op)
+        scope[op.iter_var] = Evaluated(
+            value=ClassicalScalarProxy(HandleBinding(name=op.iter_var), Integer()),
+            defining_function=self._builder.current_function,
+        )
+        return scope

classiq/model_expansions/scope.py

@@ -1,13 +1,10 @@
 import itertools
-import re
 from collections import UserDict
 from collections.abc import Iterator
 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,
@@ -16,8 +13,8 @@ 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.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
 )
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
@@ -53,28 +50,38 @@ class QuantumSymbol:
     def emit(self) -> HandleBinding:
         return self.handle
 
-    def __getitem__(self, item: Union[slice, int]) -> "QuantumSymbol":
-        if isinstance(item, int):
-            return self._subscript(item)
-
-        return self._slice(item.start, item.stop)
+    def __getitem__(
+        self, item: Union[slice, int, ClassicalScalarProxy]
+    ) -> "QuantumSymbol":
+        if isinstance(item, slice):
+            return self._slice(item.start, item.stop)
+        return self._subscript(item)
 
-    def _slice(self, start: int, end: int) -> "QuantumSymbol":
+    def _slice(
+        self,
+        start: Union[int, ClassicalScalarProxy],
+        end: Union[int, ClassicalScalarProxy],
+    ) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if start >= end:
+        if TYPE_CHECKING:
+            assert self.quantum_type.length is not None
+        if isinstance(start, int) and isinstance(end, int) and start >= end:
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} slice '{self.handle}[{start}:{end}]' "
                 f"has non-positive length"
             )
-        array_length = self.quantum_type.length_value
-        if start < 0 or end > array_length:
+        if (isinstance(start, int) and start < 0) or (
+            isinstance(end, int)
+            and self.quantum_type.length.is_constant()
+            and end > self.quantum_type.length_value
+        ):
             raise ClassiqExpansionError(
                 f"Slice [{start}:{end}] is out of bounds for "
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {array_length})"
+                f"length {self.quantum_type.length_value})"
             )
         return QuantumSymbol(
             handle=SlicedHandleBinding(
@@ -88,17 +95,24 @@ class QuantumSymbol:
             ),
         )
 
-    def _subscript(self, index: int) -> "QuantumSymbol":
+    def _subscript(self, index: Union[int, ClassicalScalarProxy]) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        array_length = self.quantum_type.length_value
-        if index < 0 or index >= array_length:
+        if TYPE_CHECKING:
+            assert self.quantum_type.length is not None
+        if isinstance(index, int) and (
+            index < 0
+            or (
+                self.quantum_type.length.is_constant()
+                and index >= self.quantum_type.length_value
+            )
+        ):
             raise ClassiqExpansionError(
                 f"Index {index} is out of bounds for "
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {array_length})"
+                f"length {self.quantum_type.length})"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(
@@ -204,8 +218,6 @@ 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: