classiq 0.74.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/qmod/builtins/functions/standard_gates.py

@@ -2,7 +2,7 @@ from typing import Literal
 
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CReal
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import Const, QArray, QBit, QFree
 
 
 @qfunc(external=True)
@@ -25,7 +25,7 @@ def H(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def X(target: QBit) -> None:
+def X(target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -44,7 +44,7 @@ def X(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def Y(target: QBit) -> None:
+def Y(target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -63,7 +63,7 @@ def Y(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def Z(target: QBit) -> None:
+def Z(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -82,7 +82,7 @@ def Z(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def I(target: QBit) -> None:
+def I(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -101,7 +101,7 @@ def I(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def S(target: QBit) -> None:
+def S(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -120,7 +120,7 @@ def S(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def T(target: QBit) -> None:
+def T(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -139,7 +139,7 @@ def T(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def SDG(target: QBit) -> None:
+def SDG(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -158,7 +158,7 @@ def SDG(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def TDG(target: QBit) -> None:
+def TDG(target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -177,7 +177,7 @@ def TDG(target: QBit) -> None:
 
 
 @qfunc(external=True)
-def PHASE(theta: CReal, target: QBit) -> None:
+def PHASE(theta: CReal, target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -239,7 +239,7 @@ def RY(theta: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def RZ(theta: CReal, target: QBit) -> None:
+def RZ(theta: CReal, target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -324,7 +324,7 @@ def RYY(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
 
 
 @qfunc(external=True)
-def RZZ(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
+def RZZ(theta: CReal, target: Const[QArray[QBit, Literal[2]]]) -> None:
     """
     [Qmod core-library function]
 
@@ -345,7 +345,7 @@ def RZZ(theta: CReal, target: QArray[QBit, Literal[2]]) -> None:
 
 
 @qfunc(external=True)
-def CH(ctrl: QBit, target: QBit) -> None:
+def CH(ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -370,7 +370,7 @@ def CH(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CX(ctrl: QBit, target: QBit) -> None:
+def CX(ctrl: Const[QBit], target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -395,7 +395,7 @@ def CX(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CY(ctrl: QBit, target: QBit) -> None:
+def CY(ctrl: Const[QBit], target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -420,7 +420,7 @@ def CY(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CZ(ctrl: QBit, target: QBit) -> None:
+def CZ(ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -445,7 +445,7 @@ def CZ(ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRX(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CRX(theta: CReal, ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -471,7 +471,7 @@ def CRX(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CRY(theta: CReal, ctrl: Const[QBit], target: QBit) -> None:
     """
     [Qmod core-library function]
 
@@ -497,7 +497,7 @@ def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CRZ(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -523,7 +523,7 @@ def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
+def CPHASE(theta: CReal, ctrl: Const[QBit], target: Const[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -549,7 +549,7 @@ def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def SWAP(qbit0: QBit, qbit1: QBit) -> None:
+def SWAP(qbit0: QFree[QBit], qbit1: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 
@@ -574,7 +574,7 @@ def SWAP(qbit0: QBit, qbit1: QBit) -> None:
 
 
 @qfunc(external=True)
-def IDENTITY(target: QArray[QBit]) -> None:
+def IDENTITY(target: Const[QArray[QBit]]) -> None:
     """
     [Qmod core-library function]
 
@@ -623,7 +623,7 @@ def U(theta: CReal, phi: CReal, lam: CReal, gam: CReal, target: QBit) -> None:
 
 
 @qfunc(external=True)
-def CCX(ctrl: QArray[QBit, Literal[2]], target: QBit) -> None:
+def CCX(ctrl: Const[QArray[QBit, Literal[2]]], target: QFree[QBit]) -> None:
     """
     [Qmod core-library function]
 

classiq/qmod/declaration_inferrer.py

@@ -19,6 +19,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.enum_declaration import declaration_from_enum
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -40,6 +41,10 @@ from classiq.qmod.python_classical_type import PythonClassicalType
 from classiq.qmod.qmod_variable import QVar, get_port_from_type_hint
 from classiq.qmod.quantum_callable import QCallableList
 from classiq.qmod.semantics.validation.type_hints import validate_annotation
+from classiq.qmod.semantics.validation.types_validation import (
+    check_duplicate_types,
+    validate_cstruct,
+)
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 if sys.version_info[0:2] >= (3, 9):
@@ -61,14 +66,16 @@ class _PythonClassicalType(PythonClassicalType):
 
         enum_decl = declaration_from_enum(py_type)
         self.qmodule.enum_decls[py_type.__name__] = enum_decl
+        check_duplicate_types([enum_decl])
 
-    def register_struct(self, py_type: type) -> None:
-        if (
-            self.qmodule is None
-            or py_type.__name__ in BUILTIN_STRUCT_DECLARATIONS
-            or py_type.__name__ in self.qmodule.type_decls
-        ):
-            return
+    def register_struct(self, py_type: type) -> TypeName:
+        classical_type = super().register_struct(py_type)
+        if self.qmodule is None:
+            return classical_type
+        all_decls = BUILTIN_STRUCT_DECLARATIONS | self.qmodule.type_decls
+        if py_type.__name__ in all_decls:
+            classical_type.set_classical_struct_decl(all_decls[py_type.__name__])
+            return classical_type
 
         struct_decl = StructDeclaration(
             name=py_type.__name__,
@@ -77,6 +84,11 @@ class _PythonClassicalType(PythonClassicalType):
             },
         )
         self.qmodule.type_decls[py_type.__name__] = struct_decl
+        check_duplicate_types([struct_decl])
+        validate_cstruct(struct_decl)
+
+        classical_type.set_classical_struct_decl(struct_decl)
+        return classical_type
 
 
 def python_type_to_qmod(

classiq/qmod/generative.py

@@ -4,6 +4,11 @@ from typing import TYPE_CHECKING, Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
+
+from classiq.qmod.cparam import CParamScalar
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -41,4 +46,7 @@ def get_frontend_interpreter() -> "GenerativeInterpreter":
 
 
 def interpret_expression(expr: str) -> Any:
-    return get_frontend_interpreter().evaluate(Expression(expr=expr)).value
+    val = get_frontend_interpreter().evaluate(Expression(expr=expr)).value
+    if isinstance(val, AnyClassicalValue):
+        return CParamScalar(str(val))
+    return val

classiq/qmod/native/expression_to_qmod.py

@@ -131,6 +131,10 @@ class ASTToQMODCode:
                     ]
                 )
                 return f"{self.ast_to_code(node.args[0])} {{{initializer_list}}}"
+            elif func == "do_subscript":
+                if len(node.args) != 2:
+                    raise AssertionError("Error parsing array access.")
+                return f"{self.ast_to_code(node.args[0])}[{self.ast_to_code(node.args[1])}]"
             else:
                 return "{}({})".format(
                     func, ", ".join(self._cleaned_ast_to_code(arg) for arg in node.args)

classiq/qmod/native/pretty_printer.py

@@ -26,6 +26,7 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.generator.visitor import NodeType
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
@@ -192,7 +193,7 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         qualifier_str = (
             f"{port_decl.type_qualifier} "
-            if port_decl.type_qualifier is not TypeQualifier.Quantum
+            if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]
             else ""
         )
         dir_str = (
@@ -308,8 +309,6 @@ class DSLPrettyPrinter(ModelVisitor):
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         classical_if = f"{self._indent}if ({self.visit(op.condition)}) {{\n"
-        if not op.then:
-            raise AssertionError('Expected non empty "then" block')
         classical_if += self._visit_body(op.then)
 
         if op.else_:
@@ -345,6 +344,12 @@ class DSLPrettyPrinter(ModelVisitor):
         invert_code += f"{self._indent}}}\n"
         return invert_code
 
+    def visit_Block(self, block: Block) -> str:
+        invert_code = f"{self._indent}block {{\n"
+        invert_code += self._visit_body(block.statements)
+        invert_code += f"{self._indent}}}\n"
+        return invert_code
+
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
         self._level += 1

classiq/qmod/pretty_print/pretty_printer.py

@@ -264,7 +264,7 @@ class PythonPrettyPrinter(ModelVisitor):
         if port_decl.direction is not PortDeclarationDirection.Inout:
             self._imports[port_decl.direction.name] = 1
             var_type = f"{port_decl.direction.name}[{var_type}]"
-        if port_decl.type_qualifier is not TypeQualifier.Quantum:
+        if port_decl.type_qualifier in [TypeQualifier.Const, TypeQualifier.QFree]:
             self._imports[port_decl.type_qualifier.name] = 1
             var_type = f"{port_decl.type_qualifier.name}[{var_type}]"
         return var_type

classiq/qmod/python_classical_type.py

@@ -19,7 +19,7 @@ from classiq.interface.generator.functions.classical_type import (
     Real,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-from classiq.interface.generator.functions.type_name import Enum, Struct
+from classiq.interface.generator.functions.type_name import Enum, Struct, TypeName
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
 from classiq.qmod.utilities import version_portable_get_args
@@ -59,8 +59,7 @@ class PythonClassicalType:
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
-            self.register_struct(py_type)
-            return Struct(name=py_type.__name__)
+            return self.register_struct(py_type)
         elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
             self.register_enum(py_type)
             return Enum(name=py_type.__name__)
@@ -68,8 +67,8 @@ class PythonClassicalType:
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None
 
-    def register_struct(self, py_type: type) -> None:
-        pass
+    def register_struct(self, py_type: type) -> TypeName:
+        return Struct(name=py_type.__name__)
 
     def register_enum(self, py_type: EnumMeta) -> None:
         pass

classiq/qmod/qmod_constant.py

@@ -1,6 +1,6 @@
 import inspect
 from dataclasses import is_dataclass
-from typing import Any, Optional, cast, get_origin
+from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
 
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
@@ -17,7 +17,7 @@ from classiq.qmod.generative import (
     interpret_expression,
     is_generative_mode,
 )
-from classiq.qmod.model_state_container import ModelStateContainer
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.qmod_parameter import CParam, CParamList, CParamStruct
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.utilities import qmod_val_to_expr_str
@@ -42,11 +42,12 @@ class QConstant(SymbolicExpr):
 
     def add_to_model(self) -> None:
         from classiq.qmod.builtins.constants import __all__ as builtin_constants
+        from classiq.qmod.semantics.validation.constants_validation import (
+            check_duplicate_constants,
+        )
 
-        if self.name in builtin_constants:
+        if self.name in builtin_constants or QConstant.CURRENT_QMODULE is None:
             return
-        if QConstant.CURRENT_QMODULE is None:
-            raise ClassiqError(QMODULE_ERROR_MESSAGE)
 
         expr = qmod_val_to_expr_str(self._value)
         if (
@@ -57,6 +58,7 @@ class QConstant(SymbolicExpr):
 
         constant = self._get_constant_node()
         QConstant.CURRENT_QMODULE.constants[self.name] = constant
+        check_duplicate_constants([constant])
         if is_generative_mode():
             get_frontend_interpreter().add_constant(constant)
 
@@ -106,8 +108,10 @@ class QConstant(SymbolicExpr):
     def __getitem__(self, item: Any) -> CParam:
         self.add_to_model()
 
-        assert QConstant.CURRENT_QMODULE is not None
-
+        if QConstant.CURRENT_QMODULE is None:
+            QConstant.set_current_model(QMODULE)
+        if TYPE_CHECKING:
+            assert QConstant.CURRENT_QMODULE is not None
         qmod_type = python_type_to_qmod(
             self._py_type, qmodule=QConstant.CURRENT_QMODULE
         )
@@ -141,3 +145,7 @@ class QConstant(SymbolicExpr):
         if is_generative_mode():
             return interpret_expression(len_expr)
         return cast(int, CParamScalar(len_expr))
+
+    def __str__(self) -> str:
+        self.add_to_model()
+        return super().__str__()

classiq/qmod/qmod_variable.py

@@ -22,7 +22,12 @@ from typing import (  # type: ignore[attr-defined]
 
 from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
-from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqInternalError,
+    ClassiqNotImplementedError,
+    ClassiqValueError,
+)
+from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy import (
@@ -65,6 +70,8 @@ from classiq.qmod.generative import (
 )
 from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.validation.types_validation import validate_qstruct
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
 from classiq.qmod.utilities import (
@@ -340,6 +347,23 @@ class QNum(Generic[_P], QScalar):
                 return interpret_expression(str(self.is_signed))
         return CParamScalar(f"get_field({self}, 'is_signed')")
 
+    def get_maximal_bounds(self) -> tuple[float, float]:
+        if not is_generative_mode():
+            raise ClassiqNotImplementedError(
+                "get_maximal_bounds() is supported in generative mode only"
+            )
+
+        if TYPE_CHECKING:
+            assert isinstance(self.size, int)
+            assert isinstance(self.is_signed, bool)
+            assert isinstance(self.fraction_digits, int)
+
+        return RegisterArithmeticInfo.get_maximal_bounds(
+            size=self.size,
+            is_signed=self.is_signed,
+            fraction_places=self.fraction_digits,
+        )
+
     # Support comma-separated generic args in older Python versions
     if sys.version_info[0:2] < (3, 10):
 
@@ -674,6 +698,8 @@ def _register_qstruct(
     if type_hint is QStruct or struct_name in qmodule.qstruct_decls:
         return
 
+    # temp assignment for recursive qstruct definitions
+    qmodule.qstruct_decls[struct_name] = QStructDeclaration(name=struct_name)
     _validate_fields(type_hint)
     struct_decl = QStructDeclaration(
         name=struct_name,
@@ -683,6 +709,8 @@ def _register_qstruct(
         },
     )
     qmodule.qstruct_decls[struct_name] = struct_decl
+    QStructAnnotator().visit(struct_decl)
+    validate_qstruct(struct_decl)
 
 
 def _validate_fields(type_hint: type[QStruct]) -> None:
@@ -727,5 +755,5 @@ def _get_root_type(py_type: Any) -> type[QVar]:
     )
     root_type = get_origin(non_annotated_type) or non_annotated_type
     if not issubclass(root_type, QVar):
-        raise ClassiqInternalError(f"Invalid quantum type {root_type}")
+        raise ClassiqValueError(f"Invalid quantum type {root_type.__name__!r}")
     return root_type

classiq/qmod/quantum_function.py

@@ -14,7 +14,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
-from classiq.interface.model.model import Model
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
@@ -31,6 +31,7 @@ from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+from classiq.qmod.semantics.validation.main_validation import validate_main_function
 from classiq.qmod.utilities import mangle_keyword
 
 
@@ -104,7 +105,7 @@ class QFunc(BaseQFunc):
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
         name = self._py_callable.__name__
-        if hasattr(self._qmodule, "native_defs") and name in self._qmodule.native_defs:
+        if name in self._qmodule.native_defs:
             return self._qmodule.native_defs[name]
         return infer_func_decl(self._py_callable, qmodule=self._qmodule)
 
@@ -250,15 +251,23 @@ class GenerativeQFunc(BaseQFunc):
     ) -> None:
         super().__init__(py_callable, compilation_metadata)
         self._func_decl = func_decl
+        self._inferred_func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None
 
     @property
     def func_decl(self) -> NamedParamsQuantumFunctionDeclaration:
-        if self._func_decl is None:
-            self._func_decl = infer_func_decl(self._py_callable, self._qmodule)
-        return self._func_decl
+        if self._func_decl is not None:
+            return self._func_decl
+        if self._inferred_func_decl is None:
+            self._inferred_func_decl = infer_func_decl(self._py_callable, self._qmodule)
+        return self._inferred_func_decl
 
     def __call__(self, *args: Any, **kwargs: Any) -> None:
-        self._qmodule.generative_functions[self.func_decl.name] = self
+        if self.func_decl.name not in self._qmodule.generative_functions:
+            self._qmodule.generative_functions[self.func_decl.name] = self
+            if self._func_decl is None:
+                self._inferred_func_decl = infer_func_decl(
+                    self._py_callable, self._qmodule
+                )
         super().__call__(*args, **kwargs)
 
     def create_model(
@@ -268,6 +277,10 @@ class GenerativeQFunc(BaseQFunc):
         preferences: Optional[Preferences] = None,
         classical_execution_function: Optional[CFunc] = None,
     ) -> Model:
+        self._qmodule.reset()
+        if self.func_decl.name == MAIN_FUNCTION_NAME:
+            validate_main_function(self.func_decl)
+
         def _dec_main(*args: Any, **kwargs: Any) -> None:
             self(*args, **kwargs)
 

classiq/qmod/semantics/lambdas.py

@@ -1,3 +1,4 @@
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
@@ -14,8 +15,11 @@ def get_renamed_parameters(
     renamed_parameters: list[str] = []
     renamed_operands: dict[str, QuantumOperandDeclaration] = {}
     renamed_ports: list[PortDeclaration] = []
-    for idx, param in enumerate(lambda_func.func_decl.positional_arg_declarations):
-        param_name = lambda_func.pos_rename_params[idx]
+    for param, param_name in zip_strict(
+        lambda_func.func_decl.positional_arg_declarations,
+        lambda_func.pos_rename_params,
+        strict=False,
+    ):
         if isinstance(param, AnonClassicalParameterDeclaration):
             renamed_parameters.append(param_name)
         elif isinstance(param, AnonQuantumOperandDeclaration):

classiq/qmod/semantics/validation/main_validation.py

@@ -1,16 +1,22 @@
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
 
 from classiq import ClassicalParameterDeclaration
 
 
-def validate_main_function(func: NativeFunctionDefinition) -> None:
+def validate_main_function(func: NamedParamsQuantumFunctionDeclaration) -> None:
     for param in func.positional_arg_declarations:
         _validate_main_param(param)
 
@@ -18,6 +24,8 @@ def validate_main_function(func: NativeFunctionDefinition) -> None:
 def _validate_main_param(param: PositionalArg) -> None:
     if isinstance(param, ClassicalParameterDeclaration):
         _validate_main_classical_param_type(param.classical_type, param.name)
+    if isinstance(param, PortDeclaration):
+        _validate_main_quantum_param_type(param)
 
 
 def _validate_main_classical_param_type(
@@ -30,3 +38,8 @@ def _validate_main_classical_param_type(
         )
     if isinstance(param, ClassicalArray):
         _validate_main_classical_param_type(param.element_type, param_name)
+
+
+def _validate_main_quantum_param_type(param: PortDeclaration) -> None:
+    if param.direction != PortDeclarationDirection.Output:
+        raise ClassiqValueError("Function 'main' cannot declare quantum inputs")

classiq/qmod/symbolic.py

@@ -1,5 +1,4 @@
 import sys
-from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -12,6 +11,9 @@ from typing import (
 import numpy as np
 
 from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    subscript_to_str,
+)
 
 from classiq.qmod import model_state_container
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -24,6 +26,7 @@ from classiq.qmod.qmod_parameter import (
 )
 from classiq.qmod.symbolic_expr import SymbolicExpr
 from classiq.qmod.symbolic_type import SymbolicTypes
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 pi = SymbolicExpr("pi", False)
 E = SymbolicExpr("E", False)
@@ -306,27 +309,13 @@ def sum(arr: SymbolicTypes) -> CParamScalar:
     return symbolic_function(arr)
 
 
-def _subscript_to_str(index: Any) -> str:
-    if not isinstance(index, slice):
-        return str(index)
-    expr = ""
-    if index.start is not None:
-        expr += str(index.start)
-    expr += ":"
-    if index.stop is not None:
-        expr += str(index.stop)
-    if index.step is not None:
-        expr += f":{index.step}"
-    return expr
-
-
 def subscript(
-    array: Union[
-        Sequence[Union[float, CReal, CParamScalar]], CArray[CReal], np.ndarray
-    ],
+    array: Union[list, CArray[CReal], np.ndarray],
     index: Any,
 ) -> CParamScalar:
-    return CParamScalar(expr=f"{_unwrap_numpy(array)}[{_subscript_to_str(index)}]")
+    return CParamScalar(
+        expr=f"{qmod_val_to_expr_str(_unwrap_numpy(array))}[{subscript_to_str(index)}]"
+    )
 
 
 __all__ = [