classiq 0.83.0__py3-none-any.whl → 0.84.0__py3-none-any.whl

classiq/open_library/functions/modular_exponentiation.py

@@ -1,5 +1,6 @@
 from classiq.open_library.functions.qft_functions import qft, qft_no_swap
 from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
+from classiq.qmod.builtins.functions.allocation import free
 from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
 from classiq.qmod.builtins.operations import (
     allocate,
@@ -11,7 +12,7 @@ from classiq.qmod.builtins.operations import (
 )
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
@@ -50,8 +51,10 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     )
 
 
-@qfunc
-def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) -> None:
+@qfunc(unchecked=["phi_b"])
+def cc_modular_add(
+    n: CInt, a: CInt, phi_b: Permutable[QArray[QBit]], c1: Const[QBit], c2: Const[QBit]
+) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -69,11 +72,9 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
     ctrl: QArray[QBit] = QArray()
     aux = QBit()
 
+    allocate(aux)
     within_apply(
-        lambda: (
-            allocate(aux),
-            bind([c1, c2], ctrl),
-        ),
+        lambda: bind([c1, c2], ctrl),
         lambda: (
             control(ctrl, lambda: qft_space_add_const(a, phi_b)),
             invert(lambda: qft_space_add_const(n, phi_b)),
@@ -87,11 +88,16 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
             ),
         ),
     )
+    free(aux)
 
 
-@qfunc
+@qfunc(unchecked=["b"])
 def c_modular_multiply(
-    n: CInt, a: CInt, b: QArray[QBit], x: QArray[QBit], ctrl: QBit
+    n: CInt,
+    a: CInt,
+    b: Permutable[QArray[QBit]],
+    x: Const[QArray[QBit]],
+    ctrl: Const[QBit],
 ) -> None:
     """
     [Qmod Classiq-library function]
@@ -118,7 +124,7 @@ def c_modular_multiply(
 
 
 @qfunc
-def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
+def multiswap(x: Permutable[QArray[QBit]], y: Permutable[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -150,16 +156,12 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
         x: The quantum factor.
         ctrl: The control bit.
     """
-    b: QArray[QBit] = QArray()
-
-    within_apply(
-        lambda: allocate(x.len + 1, b),
-        lambda: (
-            c_modular_multiply(n, a, b, x, ctrl),
-            control(ctrl, lambda: multiswap(x, b)),
-            invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)),
-        ),
-    )
+    b: QArray[QBit] = QArray(length=x.len + 1)
+    allocate(b)
+    c_modular_multiply(n, a, b, x, ctrl)
+    control(ctrl, lambda: multiswap(x, b))
+    invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl))
+    free(b)
 
 
 @qfunc

classiq/open_library/functions/state_preparation.py

@@ -483,3 +483,20 @@ def prepare_dicke_state(k: int, qvar: QArray[QBit]) -> None:
     if k > 0:
         apply_to_all(X, qvar[0:k])
         prepare_dicke_state_unary_input(k, qvar)
+
+
+@qfunc
+def prepare_basis_state(state: list[bool], arr: Output[QArray]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Initializes a quantum array in the specified basis state.
+
+    Args:
+        values: The desired basis state, given as a list of boolean values for each qubit.
+        arr: The quantum array to prepare.
+    """
+    allocate(len(state), arr)
+    for idx, value in enumerate(state):
+        if value:
+            X(arr[idx])

classiq/qmod/builtins/enums.py

@@ -1,7 +1,11 @@
 from enum import IntEnum
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.structs import SparsePauliOp
+
 
 class Element(IntEnum):
     H = 0
@@ -176,6 +180,25 @@ class Pauli(IntEnum):
     """Z (int): Pauli-Z matrix, represented by the integer 3. \n
     $Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$"""
 
+    def __call__(self, index: int) -> "SparsePauliOp":
+        from classiq.qmod.builtins.structs import (
+            IndexedPauli,
+            SparsePauliOp,
+            SparsePauliTerm,
+        )
+
+        return SparsePauliOp(
+            terms=[  # type:ignore[arg-type]
+                SparsePauliTerm(
+                    paulis=[  # type:ignore[arg-type]
+                        IndexedPauli(pauli=self, index=index)  # type:ignore[arg-type]
+                    ],
+                    coefficient=1.0,  # type:ignore[arg-type]
+                )
+            ],
+            num_qubits=index + 1,  # type:ignore[arg-type]
+        )
+
 
 class QSVMFeatureMapEntanglement(IntEnum):
     FULL = 0

classiq/qmod/builtins/functions/__init__.py

@@ -71,6 +71,7 @@ CORE_LIB_DECLS = [
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
+        multi_suzuki_trotter,
         parametric_suzuki_trotter,
         sparse_suzuki_trotter,
         qdrift,
@@ -132,6 +133,7 @@ __all__ = [  # noqa: RUF022
     "molecule_hartree_fock",
     "molecule_hva",
     "molecule_ucc",
+    "multi_suzuki_trotter",
     "parametric_suzuki_trotter",
     "pauli_feature_map",
     "permute",

classiq/qmod/builtins/functions/exponentiation.py

@@ -55,13 +55,11 @@ def commuting_paulis_exponent(
 
 @qfunc(external=True)
 def suzuki_trotter(
-    pauli_operator: CArray[PauliTerm],
+    pauli_operator: SparsePauliOp,  # FIXME: Rename to hamiltonian (CLS-2912)
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit],  # FIXME: Add length expr (CLS-2912)
 ) -> None:
     """
     [Qmod core-library function]
@@ -82,6 +80,36 @@ def suzuki_trotter(
     pass
 
 
+@qfunc(external=True)
+def multi_suzuki_trotter(
+    hamiltonians: CArray[SparsePauliOp],
+    evolution_coefficients: CArray[CReal],
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition jointly to a sum of Hamiltonians
+    (represented as Pauli operators), each with its separate evolution coefficient,
+    approximating $\\exp{-iH_1t_1+H_2t_2+\\dots}$  with a specified order and number of
+    repetitions.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
+
+    Args:
+        hamiltonians: The hamitonians to be exponentiated, in sparse representation.
+        evolution_coefficients: The hamiltonian coefficients (can be link-time).
+        order: The order of the Suzuki-Trotter decomposition.
+        repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def parametric_suzuki_trotter(
     paulis: CArray[CArray[Pauli]],

classiq/qmod/builtins/structs.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass, fields, is_dataclass
+from typing import Union
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.text_utils import are, readable_list, s
 
 from classiq.qmod.builtins.enums import LadderOperator, Pauli
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
@@ -56,13 +59,62 @@ class SparsePauliOp:
     Represents a collection of sparse Pauli operators.
 
     Attributes:
-        paulis (CArray[SparsePauliTerm]): The list of chosen sparse Pauli operators in the term, corresponds to a product of them. (See: SparsePauliTerm)
+        terms (CArray[SparsePauliTerm]): The list of chosen sparse Pauli terms, corresponds to a product of them. (See: SparsePauliTerm)
         num_qubits (CInt): The number of qubits in the Hamiltonian.
     """
 
-    paulis: CArray[SparsePauliTerm]
+    terms: CArray[SparsePauliTerm]
     num_qubits: CInt
 
+    def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
+        if isinstance(obj, (int, float, complex)):
+            return SparsePauliOp(
+                terms=[  # type:ignore[arg-type]
+                    SparsePauliTerm(
+                        paulis=term.paulis,
+                        coefficient=obj * term.coefficient,
+                    )
+                    for term in self.terms  # type:ignore[attr-defined]
+                ],
+                num_qubits=self.num_qubits,
+            )
+        if len(self.terms) != 1 or len(obj.terms) != 1:  # type:ignore[arg-type]
+            raise ClassiqValueError("Cannot attach a pauli to multiple pauli terms")
+        existing_indices = {
+            indexed_pauli.index for indexed_pauli in self.terms[0].paulis
+        }
+        added_indices = {indexed_pauli.index for indexed_pauli in obj.terms[0].paulis}
+        overlapping_indices = sorted(existing_indices.intersection(added_indices))
+        if len(overlapping_indices):
+            raise ClassiqValueError(
+                f"Pauli{s(overlapping_indices)} at "
+                f"{'indices' if len(overlapping_indices) > 1 else 'index'} "
+                f"{readable_list(overlapping_indices)} {are(overlapping_indices)} "
+                f"already assigned"
+            )
+        return SparsePauliOp(
+            terms=[  # type:ignore[arg-type]
+                SparsePauliTerm(
+                    paulis=self.terms[0].paulis + obj.terms[0].paulis,
+                    coefficient=self.terms[0].coefficient * obj.terms[0].coefficient,
+                )
+            ],
+            num_qubits=max(
+                self.num_qubits, obj.num_qubits  # type:ignore[call-overload]
+            ),
+        )
+
+    def __rmul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
+        return self.__mul__(obj)
+
+    def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+        return SparsePauliOp(
+            terms=self.terms + other.terms,  # type:ignore[arg-type]
+            num_qubits=max(
+                self.num_qubits, other.num_qubits  # type:ignore[call-overload]
+            ),
+        )
+
 
 @dataclass
 class Position:
@@ -167,7 +219,7 @@ BUILTIN_STRUCT_DECLARATIONS = {
     struct_decl.__name__: StructDeclaration(
         name=struct_decl.__name__,
         variables={
-            field.name: PythonClassicalType().convert(field.type)
+            field.name: PythonClassicalType().convert(field.type, nested=True)
             for field in fields(struct_decl)
         },
     )

classiq/qmod/declaration_inferrer.py

@@ -75,14 +75,15 @@ class _PythonClassicalType(PythonClassicalType):
         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__].model_copy()
+                all_decls[py_type.__name__].model_copy(deep=True)
             )
             return classical_type
 
         struct_decl = StructDeclaration(
             name=py_type.__name__,
             variables={
-                f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
+                f.name: self.convert(f.type, nested=True)
+                for f in dataclasses.fields(py_type)
             },
         )
         check_duplicate_types([struct_decl, *self.qmodule.user_types()])

classiq/qmod/native/pretty_printer.py

@@ -1,13 +1,13 @@
 from collections.abc import Mapping
 from typing import Optional, Union
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Integer,
     Real,
@@ -85,11 +85,10 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.pretty_print.expression_to_qmod import transform_expression
 
 from classiq.open_library.functions import OPEN_LIBRARY_FUNCTIONS
-from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class DSLPrettyPrinter(ModelVisitor):
@@ -248,9 +247,6 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_Bool(self, ctbool: Bool) -> str:
         return "bool"
 
-    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
-        return f"{self.visit(ctlist.element_type)}[]"
-
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         element_type = self.visit(ctarray.element_type)
         if ctarray.length is not None:

classiq/qmod/pretty_print/expression_to_python.py

@@ -6,8 +6,9 @@ from typing import Callable
 
 import numpy as np
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
+
 import classiq
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
 BINARY_OPS: Mapping[type[ast.operator], str] = {

classiq/qmod/pretty_print/pretty_printer.py

@@ -3,13 +3,13 @@ from typing import Optional, Union, cast
 
 import black
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Integer,
     Real,
@@ -88,7 +88,6 @@ from classiq.interface.model.within_apply_operation import WithinApply
 import classiq
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class VariableDeclarationAssignment(Visitor):
@@ -338,10 +337,6 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["CBool"] = 1
         return "CBool"
 
-    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
-        self._imports["CArray"] = 1
-        return f"CArray[{self.visit(ctlist.element_type)}]"
-
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         self._imports["CArray"] = 1
         element_type = self.visit(ctarray.element_type)

classiq/qmod/python_classical_type.py

@@ -31,7 +31,9 @@ CARRAY_ERROR_MESSAGE = (
 
 
 class PythonClassicalType:
-    def convert(self, py_type: type) -> Optional[ConcreteClassicalType]:
+    def convert(
+        self, py_type: type, nested: bool = False
+    ) -> Optional[ConcreteClassicalType]:
         if py_type is int:
             return Integer().set_generative()
         elif py_type is CInt:
@@ -45,16 +47,18 @@ class PythonClassicalType:
         elif py_type is CBool:
             return Bool()
         elif get_origin(py_type) is list:
-            element_type = self.convert(get_args(py_type)[0])
+            element_type = self.convert(get_args(py_type)[0], nested=True)
             if element_type is not None:
                 return ClassicalArray(element_type=element_type).set_generative()
         elif get_origin(py_type) is CArray:
             array_args = version_portable_get_args(py_type)
             if len(array_args) == 1:
-                return ClassicalArray(element_type=self.convert(array_args[0]))
+                return ClassicalArray(
+                    element_type=self.convert(array_args[0], nested=True)
+                )
             elif len(array_args) == 2:
                 return ClassicalArray(
-                    element_type=self.convert(array_args[0]),
+                    element_type=self.convert(array_args[0], nested=True),
                     length=Expression(expr=get_type_hint_expr(array_args[1])),
                 )
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
@@ -62,7 +66,10 @@ class PythonClassicalType:
             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__).set_generative()
+            enum_type = Enum(name=py_type.__name__)
+            if not nested:
+                enum_type.set_generative()
+            return enum_type
         elif py_type in (CArray, list):
             raise ClassiqValueError(CARRAY_ERROR_MESSAGE)
         return None

classiq/qmod/qmod_constant.py

@@ -5,10 +5,7 @@ from typing import TYPE_CHECKING, Any, Optional, cast, get_origin
 from classiq.interface.exceptions import ClassiqError, ClassiqValueError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    ClassicalList,
-)
+from classiq.interface.generator.functions.classical_type import ClassicalArray
 
 from classiq.qmod.cparam import CArray, CParamScalar
 from classiq.qmod.declaration_inferrer import python_type_to_qmod
@@ -118,7 +115,7 @@ class QConstant(SymbolicExpr):
         if qmod_type is None:
             raise ClassiqError("Invalid QMOD type")
 
-        if not isinstance(qmod_type, (ClassicalList, ClassicalArray)):
+        if not isinstance(qmod_type, ClassicalArray):
             raise ClassiqError("Invalid subscript to non-list constant")
 
         return CParamList(

classiq/qmod/qmod_parameter.py

@@ -4,7 +4,6 @@ from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     ClassicalType,
     Integer,
@@ -42,7 +41,7 @@ class CParamList(CParam):
     def __init__(
         self,
         expr: str,
-        list_type: Union[ClassicalList, ClassicalArray, ClassicalTuple],
+        list_type: Union[ClassicalArray, ClassicalTuple],
         qmodule: ModelStateContainer,
     ) -> None:
         super().__init__(expr)
@@ -149,7 +148,7 @@ def create_param(
         decl = ctype.classical_struct_decl
         ctype = Struct(name=ctype.name)
         ctype.set_classical_struct_decl(decl)
-    if isinstance(ctype, (ClassicalList, ClassicalArray, ClassicalTuple)):
+    if isinstance(ctype, (ClassicalArray, ClassicalTuple)):
         return CParamList(expr_str, ctype, qmodule=qmodule)
     elif isinstance(ctype, Struct):
         return CParamStruct(expr_str, ctype, qmodule=qmodule)
@@ -164,8 +163,6 @@ def get_qmod_type(ctype: ClassicalType) -> type:
         return CReal
     elif isinstance(ctype, Bool):
         return CBool
-    elif isinstance(ctype, ClassicalList):
-        return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]
     elif isinstance(ctype, ClassicalArray):
         if ctype.length is None:
             return CArray[get_qmod_type(ctype.element_type)]  # type: ignore[misc]

classiq/qmod/qmod_variable.py

@@ -34,19 +34,20 @@ from classiq.interface.generator.expressions.proxies.quantum.qmod_qarray_proxy i
     ILLEGAL_SLICE_MSG,
     ILLEGAL_SLICING_STEP_MSG,
 )
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_modifier import TypeModifier
-from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.helpers.classproperty import classproperty
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
     AmplitudeLoadingOperation,
 )
@@ -136,7 +137,7 @@ class QVar(Symbolic):
         return self._base_handle
 
     @abc.abstractmethod
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         raise NotImplementedError()
 
     @classmethod
@@ -164,6 +165,14 @@ class QVar(Symbolic):
         return self.get_qmod_type().type_name
 
 
+class QmodExpressionCreator(Protocol):
+    """
+    A callable that creates a Qmod expression from the provided QVars.
+    """
+
+    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
+
+
 _Q = TypeVar("_Q", bound=QVar)
 Output = Annotated[_Q, PortDeclarationDirection.Output]
 Input = Annotated[_Q, PortDeclarationDirection.Input]
@@ -273,7 +282,7 @@ class QBit(QScalar):
     ) -> "QBit":
         return QBit(origin, _expr_str=expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         return QuantumBit()
 
 
@@ -329,7 +338,7 @@ class QNum(Generic[_P], QScalar):
     ) -> "QNum":
         return QNum(origin, *_get_qnum_attributes(type_hint), _expr_str=expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
+    def get_qmod_type(self) -> ConcreteQuantumType:
         return QuantumNumeric(
             size=self._size,
             is_signed=self._is_signed,
@@ -498,8 +507,15 @@ class QStruct(QVar):
             setattr(self, field_name, var)
         super().__init__(name, expr_str=_expr_str)
 
-    def get_qmod_type(self) -> QuantumType:
-        return TypeName(name=self._struct_name)
+    def get_qmod_type(self) -> ConcreteQuantumType:
+        classical_type = Struct(name=self._struct_name)
+        classical_type.set_fields(
+            {
+                field_name: field_var.get_qmod_type()
+                for field_name, field_var in self._fields.items()
+            }
+        )
+        return classical_type
 
     @classmethod
     def to_qvar(
@@ -529,9 +545,23 @@ class QStruct(QVar):
             _expr_str=expr_str,
         )
 
+    @classproperty
+    def num_qubits(cls) -> int:  # noqa: N805
+        """
+        The total number of qubits in this quantum struct.
+        Raises an error if the struct doesn't have a fixed size.
+        """
+        qvar = cls.to_qvar(HandleBinding(name="dummy"), type_hint=cls, expr_str=None)
+        quantum_type = qvar.get_qmod_type()
+        if not quantum_type.has_size_in_bits:
+            raise ClassiqValueError(
+                f"Could not infer the size of struct {qvar._struct_name!r}"
+            )
+        return quantum_type.size_in_bits
+
 
-def create_qvar_for_port_decl(port: AnonPortDeclaration, name: str) -> QVar:
-    return _create_qvar_for_qtype(port.quantum_type, HandleBinding(name=name))
+def create_qvar_from_quantum_type(quantum_type: ConcreteQuantumType, name: str) -> QVar:
+    return _create_qvar_for_qtype(quantum_type, HandleBinding(name=name))
 
 
 def _create_qvar_for_qtype(
@@ -689,17 +719,27 @@ def _get_quantum_bit_vector(type_hint: type[QArray]) -> QuantumBitvector:
     return QuantumBitvector(element_type=element_type, length=length_expr)
 
 
-def _get_quantum_struct(type_hint: type[QStruct]) -> TypeName:
-    _register_qstruct(type_hint, qmodule=QMODULE)
-    return TypeName(name=type_hint.__name__)
+def _get_quantum_struct(type_hint: type[QStruct]) -> Struct:
+    decl = _register_qstruct(type_hint, qmodule=QMODULE)
+    classical_type = Struct(name=type_hint.__name__)
+    if decl is not None:
+        classical_type.set_fields(
+            {
+                field_name: field_type.model_copy(deep=True)
+                for field_name, field_type in decl.fields.items()
+            }
+        )
+    return classical_type
 
 
 def _register_qstruct(
     type_hint: type[QStruct], *, qmodule: ModelStateContainer
-) -> None:
+) -> Optional[QStructDeclaration]:
     struct_name = type_hint.__name__
-    if type_hint is QStruct or struct_name in qmodule.qstruct_decls:
-        return
+    if type_hint is QStruct:
+        return None
+    if struct_name in qmodule.qstruct_decls:
+        return qmodule.qstruct_decls[struct_name]
 
     # temp assignment for recursive qstruct definitions
     qmodule.qstruct_decls[struct_name] = QStructDeclaration(name=struct_name)
@@ -714,6 +754,7 @@ def _register_qstruct(
     qmodule.qstruct_decls[struct_name] = struct_decl
     QStructAnnotator().visit(struct_decl)
     validate_qstruct(struct_decl)
+    return struct_decl
 
 
 def _validate_fields(type_hint: type[QStruct]) -> None:

classiq/qmod/quantum_expandable.py

@@ -68,7 +68,7 @@ from classiq.qmod.qmod_parameter import (
 )
 from classiq.qmod.qmod_variable import (
     QVar,
-    create_qvar_for_port_decl,
+    create_qvar_from_quantum_type,
 )
 from classiq.qmod.quantum_callable import QCallable, QExpandableInterface
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -163,7 +163,9 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
                     create_param(actual_name, arg.classical_type, self._qmodule)
                 )
             elif isinstance(arg, AnonPortDeclaration):
-                result.append(create_qvar_for_port_decl(arg, actual_name))
+                result.append(
+                    create_qvar_from_quantum_type(arg.quantum_type, actual_name)
+                )
             else:
                 assert isinstance(arg, AnonQuantumOperandDeclaration)
                 result.append(QTerminalCallable(arg, idx))