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

classiq/__init__.py

@@ -34,13 +34,10 @@ from classiq.applications.combinatorial_optimization import (
     execute_qaoa,
     pyo_model_to_hamiltonian,
 )
-from classiq.applications.finance import construct_finance_model
-from classiq.applications.grover import construct_grover_model
 from classiq.applications.hamiltonian.pauli_decomposition import (
     hamiltonian_to_matrix,
     matrix_to_hamiltonian,
 )
-from classiq.applications.qsvm import construct_qsvm_model
 from classiq.executor import (
     execute,
     execute_async,
@@ -65,11 +62,8 @@ from classiq.synthesis import (
 )
 
 _application_constructors_all = [
-    "construct_qsvm_model",
     "construct_combinatorial_optimization_model",
     "construct_chemistry_model",
-    "construct_finance_model",
-    "construct_grover_model",
     "molecule_problem_to_qmod",
 ]
 

classiq/_internals/client.py

@@ -23,6 +23,7 @@ from classiq._internals.authentication import token_manager
 from classiq._internals.host_checker import HostChecker
 
 _FRONTEND_VARIANT: str = "classiq-sdk"
+_SDK_ENV: str = "sdk-env"
 _INTERFACE_VARIANT: str = "classiq-interface-sdk"
 _USERAGENT_SEPARATOR: str = " "
 
@@ -74,12 +75,21 @@ def _get_user_agent_header() -> Headers:
     python_version = (
         f"python({_get_python_execution_environment()})/{platform.python_version()}"
     )
+
+    sdk_env_value = os.getenv("SDK_ENV", "Default")
     os_platform = f"{os.name}/{platform.platform()}"
     frontend_version = f"{_FRONTEND_VARIANT}/{_VERSION}"
     interface_version = f"{_INTERFACE_VARIANT}/{_VERSION}"
+    sdk_env = f"{_SDK_ENV}/{sdk_env_value}"
     return {
         "User-Agent": _USERAGENT_SEPARATOR.join(
-            (python_version, os_platform, frontend_version, interface_version)
+            (
+                python_version,
+                os_platform,
+                frontend_version,
+                interface_version,
+                sdk_env,
+            )
         )
     }
 

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -1,30 +1,17 @@
-# flake8: noqa
-
-from typing import Optional, cast
 from collections.abc import Mapping
+from typing import Optional, cast
 
 from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
 )
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.qmod.builtins.structs import (
-    MoleculeProblem as QmodMoleculeProblem,
-    Molecule as QmodMolecule,
-    ChemistryAtom as QmodChemistryAtom,
-    Position as QmodPosition,
-)
 from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     HamiltonianProblem,
     MoleculeProblem,
 )
 from classiq.interface.chemistry.molecule import Atom
-from classiq.qmod.builtins.enums import (
-    Element,
-    FermionMapping,
-)
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import IOName
 from classiq.interface.generator.functions.classical_type import (
@@ -34,6 +21,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -43,6 +31,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.applications.chemistry.ansatz_parameters import (
     AnsatzParameters,
@@ -53,8 +42,21 @@ from classiq.applications.chemistry.ansatz_parameters import (
 from classiq.applications.chemistry.chemistry_execution_parameters import (
     ChemistryExecutionParameters,
 )
-from classiq.interface.exceptions import ClassiqError
+from classiq.qmod.builtins.enums import (
+    Element,
+    FermionMapping,
+)
+from classiq.qmod.builtins.structs import (
+    ChemistryAtom as QmodChemistryAtom,
+    Molecule as QmodMolecule,
+    MoleculeProblem as QmodMoleculeProblem,
+    Position as QmodPosition,
+)
 from classiq.qmod.utilities import qmod_val_to_expr_str
+
+# isort: split
+
+# This import causes a circular import if done earlier. We use isort: split to avoid it
 from classiq.open_library.functions.hea import full_hea
 
 _LADDER_OPERATOR_TYPE_INDICATOR_TO_QMOD_MAPPING: dict[str, str] = {

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -4,6 +4,7 @@ from itertools import filterfalse
 from typing import Optional, Union
 
 import pyomo.environ as pyo
+import sympy
 from pyomo.core import ConcreteModel
 from pyomo.core.base import _GeneralVarData
 from pyomo.core.base.constraint import _GeneralConstraintData
@@ -179,8 +180,13 @@ class OptimizationModel:
             objective_map.sympy2pyomo |= penalty_map.sympy2pyomo
             for key, value in penalty_map.pyomo2sympy.items():
                 objective_map.pyomo2sympy[key] = value
+        sympy_renaming = {
+            var: sympy.Symbol(str(var).replace(",", "_").replace("'", "_"))
+            for var in objective_expr.free_symbols
+        }
+        objective_expr = objective_expr.subs(sympy_renaming)
         sympy_mapping = {
-            sympy_var: (
+            sympy_renaming[sympy_var]: (
                 get_field_name(pyomo_var)
                 if not is_index_var(pyomo_var)
                 else (
@@ -190,4 +196,5 @@ class OptimizationModel:
             )
             for pyomo_var, sympy_var in objective_map.pyomo2sympy.items()
         }
-        self.objective_not_encoded_sympy = sympy_mapping, objective_expr
+        compiled_expr = compile(str(objective_expr), "<string>", "eval")
+        self.objective_not_encoded_sympy = sympy_mapping, objective_expr, compiled_expr

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -7,6 +7,7 @@ from contextlib import contextmanager
 from enum import Enum
 from functools import reduce
 from operator import mul
+from types import CodeType
 from typing import Any, Optional, TypeVar, Union
 
 import pydantic
@@ -362,6 +363,7 @@ def _get_qmod_field_type(var_name: str, var_data: _GeneralVarData) -> type[QVar]
 def evaluate_objective(
     var_mapping: dict[Any, Union[str, tuple[str, tuple[int, ...]]]],
     sympy_expr: sympy.Expr,
+    code_expr: CodeType,
     struct_obj: Any,
 ) -> Any:
     sympy_assignment = {
@@ -375,7 +377,10 @@ def evaluate_objective(
 
     # classical objective evaluation
     if not isinstance(struct_obj, QStruct):
-        return float(sympy_expr.evalf(subs=sympy_assignment))
+        var_assignment = {
+            str(sympy_var): value for sympy_var, value in sympy_assignment.items()
+        }
+        return eval(code_expr, {}, var_assignment)  # noqa: S307
 
     # quantum objective evaluation
     expr_str = str(sympy_expr).replace("'", "")

classiq/applications/finance/__init__.py

@@ -4,10 +4,7 @@ from classiq.interface.finance import (
     log_normal_model_input,
 )
 
-from .finance_model_constructor import construct_finance_model
-
 __all__ = [
-    "construct_finance_model",
     "function_input",
     "gaussian_model_input",
     "log_normal_model_input",

classiq/applications/qsvm/__init__.py

@@ -2,9 +2,7 @@ from classiq.qmod.builtins.enums import QSVMFeatureMapEntanglement
 
 from ..qsvm import qsvm_data_generation
 from .qsvm import *  # noqa: F403
-from .qsvm_model_constructor import construct_qsvm_model
 
 __all__ = [
     "QSVMFeatureMapEntanglement",
-    "construct_qsvm_model",
 ]

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

classiq/interface/backend/backend_preferences.py

@@ -477,6 +477,27 @@ class IQCCBackendPreferences(BackendPreferences):
     slurm_account: str
 
 
+class CINECABackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to CINECA.
+
+    Attributes:
+        ssh_username: The username to use when connecting to the SSH server on the login node.
+        ssh_private_key_path: The path to the ssh private key on local machine.
+    """
+
+    backend_service_provider: ProviderTypeVendor.CINECA = pydantic.Field(
+        default=ProviderVendor.CINECA
+    )
+
+    ssh_username: str = pydantic.Field(
+        description="Username to use when connecting to the SSH server on the login node."
+    )
+    ssh_private_key_path: str = pydantic.Field(
+        description="Path of private key file on local machine to use when connecting to the SSH server on the login node."
+    )
+
+
 def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
     return backend_preferences.backend_name in EXACT_SIMULATORS
 
@@ -509,6 +530,7 @@ BackendPreferencesTypes = Union[
     IntelBackendPreferences,
     AQTBackendPreferences,
     IQCCBackendPreferences,
+    CINECABackendPreferences,
 ]
 
 __all__ = [

classiq/interface/backend/quantum_backend_providers.py

@@ -21,6 +21,7 @@ class ProviderVendor(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     IQCC = "IQCC"
+    CINECA = "CINECA"
 
 
 class ProviderTypeVendor:
@@ -35,6 +36,7 @@ class ProviderTypeVendor:
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
     IQCC = Literal[ProviderVendor.IQCC]
+    CINECA = Literal[ProviderVendor.CINECA]
 
 
 class ClassiqSimulatorBackendNames(StrEnum):

classiq/interface/generator/expressions/expression_types.py

@@ -4,6 +4,9 @@ from sympy import Expr
 from sympy.logic.boolalg import Boolean
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -28,5 +31,5 @@ Proxies = Union[
     QmodSizedProxy,
     ClassicalProxy,
 ]
-RuntimeExpression = Union[Expr, Boolean]
+RuntimeExpression = Union[AnyClassicalValue, Expr, Boolean]
 ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]

classiq/interface/generator/expressions/proxies/classical/any_classical_value.py

@@ -0,0 +1,135 @@
+from typing import Any
+
+
+class AnyClassicalValue:
+    def __init__(self, expr: str) -> None:
+        self._expr = expr
+
+    def __str__(self) -> str:
+        return self._expr
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __getitem__(self, item: Any) -> "AnyClassicalValue":
+        if isinstance(item, slice):
+            subscript = ""
+            if item.start is not None:
+                subscript += str(item.start)
+            subscript += ":"
+            if item.stop is not None:
+                subscript += str(item.stop)
+            if item.step is not None:
+                subscript += f":{item.stop}"
+            item = subscript
+        return AnyClassicalValue(f"{self}[{item}]")
+
+    @staticmethod
+    def _binary_op(lhs: Any, rhs: Any, op: str) -> "AnyClassicalValue":
+        return AnyClassicalValue(f"{lhs} {op} {rhs}")
+
+    @staticmethod
+    def _unary_op(arg: Any, op: str) -> "AnyClassicalValue":
+        return AnyClassicalValue(f"{op}({arg})")
+
+    def __add__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "+")
+
+    def __sub__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "-")
+
+    def __mul__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "*")
+
+    def __truediv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "/")
+
+    def __floordiv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "//")
+
+    def __mod__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "%")
+
+    def __pow__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "**")
+
+    def __lshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "<<")
+
+    def __rshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, ">>")
+
+    def __and__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "&")
+
+    def __xor__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "^")
+
+    def __or__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "|")
+
+    def __radd__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "+")
+
+    def __rsub__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "-")
+
+    def __rmul__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "*")
+
+    def __rtruediv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "/")
+
+    def __rfloordiv__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "//")
+
+    def __rmod__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "%")
+
+    def __rpow__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "**")
+
+    def __rlshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "<<")
+
+    def __rrshift__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, ">>")
+
+    def __rand__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "&")
+
+    def __rxor__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "^")
+
+    def __ror__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(other, self, "|")
+
+    def __lt__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "<")
+
+    def __le__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, "<=")
+
+    def __eq__(self, other: Any) -> "AnyClassicalValue":  # type:ignore[override]
+        return AnyClassicalValue._binary_op(self, other, "==")
+
+    def __ne__(self, other: Any) -> "AnyClassicalValue":  # type: ignore[override]
+        return AnyClassicalValue._binary_op(self, other, "!=")
+
+    def __gt__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, ">")
+
+    def __ge__(self, other: Any) -> "AnyClassicalValue":
+        return AnyClassicalValue._binary_op(self, other, ">=")
+
+    def __neg__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "-")
+
+    def __pos__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "+")
+
+    def __abs__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "abs")
+
+    def __invert__(self) -> "AnyClassicalValue":
+        return AnyClassicalValue._unary_op(self, "~")

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

@@ -2,6 +2,7 @@ CTRL_VAR_PREFIX = "ctrl__"
 CONTROL_OPERATOR_NAME = "control"
 INVERT_OPERATOR_NAME = "invert"
 REPEAT_OPERATOR_NAME = "iteration"
+CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"

classiq/interface/generator/generated_circuit_data.py

@@ -233,6 +233,19 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return list()
         return self.generated_function.control_states
 
+    @property
+    def control_qubits(self) -> tuple[int, ...]:
+        control_states_names = {
+            control_state.name for control_state in self.control_states
+        }
+        return tuple(
+            qubit
+            for register in self.registers
+            for qubit in register.qubit_indexes_absolute
+            if register.role is RegisterRole.INPUT
+            and register.name in control_states_names
+        )
+
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
         if self.absolute_qubits is None:
             return self

classiq/interface/generator/hardware/hardware_data.py

@@ -110,10 +110,12 @@ class HardwareData(pydantic.BaseModel):
             for gate in specified_basis_gates
             if gate in TWO_QUBIT_GATES and gate not in ROUTING_TWO_QUBIT_BASIS_GATES
         ]
+
         if invalid_gates:
             raise ClassiqValueError(
                 "Connectivity-aware synthesis with non-symmetric coupling map "
-                "is currently supported for the following two-qubit gates only: cx, ecr, rzx."
+                "is currently supported for the following two-qubit gates only: "
+                "cx, ecr, rzx, ryy, rxx, rzz, cy, cp, cz, swap"
             )
 
         return self

classiq/interface/generator/transpiler_basis_gates.py

@@ -63,7 +63,9 @@ THREE_QUBIT_GATES: BasisGates = frozenset(("ccx", "cswap"))
 DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
 ALL_GATES: BasisGates = SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES
 
-ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(("cx", "ecr", "rzx"))
+ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
+    ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")
+)
 DEFAULT_ROUTING_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | frozenset(("cx",))
 # The Enum names are capitalized per recommendation in https://docs.python.org/3/library/enum.html#module-enum
 # The Enum values are lowered to keep consistency

classiq/interface/hardware.py

@@ -33,6 +33,7 @@ class Provider(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     IQCC = "IQCC"
+    CINECA = "CINECA"
 
     @property
     def id(self) -> "ProviderIDEnum":

classiq/interface/model/handle_binding.py

@@ -64,6 +64,9 @@ class HandleBinding(ASTNode):
     def __contains__(self, other_handle: "HandleBinding") -> bool:
         return self.collapse() in other_handle.collapse().prefixes()
 
+    def is_constant(self) -> bool:
+        return True
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -105,6 +108,9 @@ class NestedHandleBinding(HandleBinding):
             )
         return self
 
+    def is_constant(self) -> bool:
+        return self.base_handle.is_constant()
+
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression
@@ -178,6 +184,13 @@ class SubscriptHandleBinding(NestedHandleBinding):
             )
         return super().replace_prefix(prefix, replacement)
 
+    def is_constant(self) -> bool:
+        return (
+            super().is_constant()
+            and self.index.is_evaluated()
+            and self.index.is_constant()
+        )
+
 
 class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
@@ -284,6 +297,14 @@ class SlicedHandleBinding(NestedHandleBinding):
     def _is_evaluated(self) -> bool:
         return self.start.is_evaluated() and self.end.is_evaluated()
 
+    def is_constant(self) -> bool:
+        return (
+            super().is_constant()
+            and self._is_evaluated()
+            and self.start.is_constant()
+            and self.end.is_constant()
+        )
+
 
 class FieldHandleBinding(NestedHandleBinding):
     field: str

classiq/interface/server/routes.py

@@ -43,8 +43,6 @@ TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
 
 CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
-GROVER_QMOD_PATH = "/generate_model/grover/qmod"
-FINANCE_QMOD_PATH = "/generate_model/finance/qmod"
 
 
 TASK_TRAIN_SUFFIX = TASKS_SUFFIX + "/train"

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -1,8 +1,8 @@
 from collections.abc import Mapping
 from enum import Enum
-from typing import Any, Callable, Union
+from typing import Any, Callable, Union, get_args
 
-from sympy import Eq, Expr, Number, Piecewise, Symbol
+from sympy import Eq, Expr, Piecewise, Symbol
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -12,6 +12,9 @@ from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
 )
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy import (
     QmodQNumProxy,
 )
@@ -54,6 +57,10 @@ from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     sympy_to_python,
 )
+from classiq.model_expansions.utils.sympy_utils import (
+    is_constant_subscript,
+    unwrap_sympy_numeric,
+)
 from classiq.qmod.model_state_container import QMODULE
 
 
@@ -151,9 +158,13 @@ def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInsta
 
 
 def get_field(
-    proxy: Union[QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list],
+    proxy: Union[
+        QmodSizedProxy, QmodStructInstance, QmodQStructProxy, list, AnyClassicalValue
+    ],
     field: str,
 ) -> ExpressionValue:
+    if isinstance(proxy, AnyClassicalValue):
+        return AnyClassicalValue(f"({proxy}).{field}")
     if isinstance(proxy, type) and issubclass(proxy, Enum):
         return getattr(proxy, field)
     if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
@@ -189,20 +200,25 @@ def get_type(struct_type: Symbol) -> TypeProxy:
     return TypeProxy(QMODULE.type_decls[struct_type.name])
 
 
-def _unwrap_sympy_numeric(n: Any) -> Any:
-    if not isinstance(n, Number) or not n.is_constant():
-        return n
-    if n.is_Integer:
-        return int(n)
-    return float(n)
-
-
 def do_div(lhs: Any, rhs: Any) -> Any:
-    lhs = _unwrap_sympy_numeric(lhs)
-    rhs = _unwrap_sympy_numeric(rhs)
+    lhs = unwrap_sympy_numeric(lhs)
+    rhs = unwrap_sympy_numeric(rhs)
     return lhs / rhs
 
 
+_EXPRESSION_TYPES = get_args(ExpressionValue)
+
+
+def _is_qmod_value(val: Any) -> bool:
+    if not isinstance(val, slice):
+        return isinstance(val, _EXPRESSION_TYPES)
+    if val.start is not None and not isinstance(val.start, _EXPRESSION_TYPES):
+        return False
+    if val.stop is not None and not isinstance(val.stop, _EXPRESSION_TYPES):
+        return False
+    return val.step is None or isinstance(val.step, _EXPRESSION_TYPES)
+
+
 def do_subscript(value: Any, index: Any) -> Any:
     if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
         if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
@@ -214,6 +230,12 @@ def do_subscript(value: Any, index: Any) -> Any:
                 f"\t2. `l[n]`, where `l` is a list of classical real numbers and `n` "
                 f"is a classical or quantum integer."
             )
+        if (
+            isinstance(value, list)
+            and not is_constant_subscript(index)
+            and _is_qmod_value(index)
+        ):
+            return AnyClassicalValue(str(value))[index]
         return value[index]
     if index.is_signed or index.fraction_digits > 0:
         raise ClassiqExpansionError(

classiq/model_expansions/closure.py

@@ -8,7 +8,6 @@ from typing import Any, Optional
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
@@ -35,14 +34,6 @@ class Closure:
     positional_arg_declarations: Sequence[PositionalArg] = tuple()
     captured_vars: CapturedVars = field(default_factory=CapturedVars)
 
-    @property
-    def port_declarations(self) -> dict[str, PortDeclaration]:
-        return {
-            param.name: param
-            for param in self.positional_arg_declarations
-            if isinstance(param, PortDeclaration)
-        }
-
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):