classiq 0.87.0__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/applications/__init__.py

@@ -1,9 +1,8 @@
-from classiq.applications import chemistry, combinatorial_optimization, finance, qsvm
+from classiq.applications import chemistry, combinatorial_optimization, qsvm
 
 __all__ = [
     "chemistry",
     "combinatorial_optimization",
-    "finance",
     "qsvm",
 ]
 

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -43,7 +43,7 @@ def compute_qaoa_initial_point(
 
     beta_params: np.ndarray = np.linspace(1, 0, repetitions) * time_step
     gamma_params: np.ndarray = np.linspace(0, 1, repetitions) * time_step
-    return list(itertools.chain(*zip(gamma_params, beta_params)))
+    return [float(x) for x in itertools.chain(*zip(gamma_params, beta_params))]
 
 
 def pyo_model_to_hamiltonian(

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -137,7 +137,7 @@ def hamiltonian_to_matrix(
         hamiltonian = _sparse_pauli_to_list(hamiltonian)
     matrix = np.zeros(
         [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
-        dtype=np.complex_,
+        dtype=np.complex128,
     )
     for p in hamiltonian:
         matrix += p.coefficient * pauli_string_to_mat(p.pauli)

classiq/evaluators/qmod_annotated_expression.py

@@ -1,5 +1,5 @@
 import ast
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Union, cast
@@ -45,7 +45,7 @@ def qmod_val_to_str(val: Any) -> str:
             f"{field_name}={qmod_val_to_str(field_val)}"
             for field_name, field_val in val.fields.items()
         )
-        return f"{val.struct_declaration.name}({fields})"
+        return f"struct_literal({val.struct_declaration.name}, {fields})"
     if isinstance(val, list):
         return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
     if isinstance(val, Enum):
@@ -82,6 +82,7 @@ class QmodAnnotatedExpression:
             QmodExprNodeId, QuantumTypeAttributeAnnotation
         ] = {}
         self._concatenations: dict[QmodExprNodeId, ConcatenationAnnotation] = {}
+        self._locked = False
 
     def __str__(self) -> str:
         return ast.unparse(_ExprInliner(self).visit(self.root))
@@ -93,6 +94,8 @@ class QmodAnnotatedExpression:
         return self._node_mapping[node_id]
 
     def set_value(self, node: Union[ast.AST, QmodExprNodeId], value: Any) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         self._values[node] = value
@@ -110,6 +113,8 @@ class QmodAnnotatedExpression:
     def set_type(
         self, node: Union[ast.AST, QmodExprNodeId], qmod_type: QmodType
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node_id = id(node)
             self._node_mapping[node_id] = node
@@ -138,6 +143,8 @@ class QmodAnnotatedExpression:
         return cast(ClassicalType, qmod_type)
 
     def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         var = var.collapse()
         if isinstance(node, ast.AST):
             node = id(node)
@@ -165,6 +172,8 @@ class QmodAnnotatedExpression:
         return node in self._quantum_vars
 
     def remove_var(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if node in self._classical_vars:
@@ -178,6 +187,8 @@ class QmodAnnotatedExpression:
         value: Union[ast.AST, QmodExprNodeId],
         index: Union[ast.AST, QmodExprNodeId],
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if isinstance(value, ast.AST):
@@ -195,7 +206,7 @@ class QmodAnnotatedExpression:
 
     def get_quantum_subscripts(
         self,
-    ) -> dict[QmodExprNodeId, QuantumSubscriptAnnotation]:
+    ) -> Mapping[QmodExprNodeId, QuantumSubscriptAnnotation]:
         return self._quantum_subscripts
 
     def set_quantum_type_attr(
@@ -204,6 +215,8 @@ class QmodAnnotatedExpression:
         value: Union[ast.AST, QmodExprNodeId],
         attr: str,
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if isinstance(value, ast.AST):
@@ -219,7 +232,7 @@ class QmodAnnotatedExpression:
 
     def get_quantum_type_attributes(
         self,
-    ) -> dict[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
+    ) -> Mapping[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
         return self._quantum_type_attrs
 
     def set_concatenation(
@@ -227,6 +240,8 @@ class QmodAnnotatedExpression:
         node: Union[ast.AST, QmodExprNodeId],
         elements: Sequence[Union[ast.AST, QmodExprNodeId]],
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         inlined_elements: list[QmodExprNodeId] = []
@@ -244,13 +259,13 @@ class QmodAnnotatedExpression:
             node = id(node)
         return node in self._concatenations
 
-    def get_concatenations(self) -> dict[QmodExprNodeId, ConcatenationAnnotation]:
+    def get_concatenations(self) -> Mapping[QmodExprNodeId, ConcatenationAnnotation]:
         return self._concatenations
 
-    def get_classical_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+    def get_classical_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._classical_vars
 
-    def get_quantum_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+    def get_quantum_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._quantum_vars
 
     def clear_node_data(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
@@ -282,3 +297,11 @@ class QmodAnnotatedExpression:
         self._quantum_subscripts |= other._quantum_subscripts
         self._quantum_type_attrs |= other._quantum_type_attrs
         self._concatenations |= other._concatenations
+
+    def clone(self) -> "QmodAnnotatedExpression":
+        expr_val = QmodAnnotatedExpression(self.root)
+        expr_val._add_data_from(self)
+        return expr_val
+
+    def lock(self) -> None:
+        self._locked = True

classiq/evaluators/qmod_expression_visitors/qmod_expression_bwc.py

@@ -73,11 +73,6 @@ class QmodExpressionBwc(ast.NodeTransformer):
                 return node
             return ast.Compare(left=args[0], ops=[ast.GtE()], comparators=[args[1]])
 
-        if func == "struct_literal":
-            if num_args != 1:
-                return node
-            return ast.Call(func=node.args[0], args=[], keywords=node.keywords)
-
         if func == "do_subscript":
             if num_args != 2 or num_kwargs != 0:
                 return node

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -103,8 +103,8 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit(self, node: ast.AST) -> None:
         if not isinstance(node, _SUPPORTED_NODES):
-            raise ClassiqInternalExpansionError(
-                f"Syntax error: {type(node).__name__!r} is not supported"
+            raise ClassiqExpansionError(
+                f"Syntax error: {type(node).__name__!r} is not a valid Qmod expression"
             )
         super().visit(node)
 
@@ -138,11 +138,23 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             self._eval_piecewise(node)
             return
 
-        for arg in node.args:
-            self.visit(arg)
         for kwarg in node.keywords:
             self.visit(kwarg)
 
+        if (
+            func_name == "struct_literal"
+            and len(node.args) == 1
+            and isinstance(node.args[0], ast.Name)
+            and (struct_name := node.args[0].id) in self._classical_struct_decls
+        ):
+            eval_struct_instantiation(
+                self._expr_val, node, self._classical_struct_decls[struct_name]
+            )
+            return
+
+        for arg in node.args:
+            self.visit(arg)
+
         if func_name == "measure":
             eval_measurement(self._expr_val, node)
             return
@@ -157,13 +169,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
             return
 
-        # FIXME: Remove (CLS-3241)
-        if func_name in self._classical_struct_decls:
-            eval_struct_instantiation(
-                self._expr_val, node, self._classical_struct_decls[func_name]
-            )
-            return
-
         # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_callables:
             if func_name not in self._classical_function_declarations:
@@ -176,6 +181,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
             return
 
+        # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_declarations:
             eval_symbolic_function(
                 self._expr_val, node, self._classical_function_declarations[func_name]
@@ -272,4 +278,5 @@ def evaluate_qmod_expression(
         classical_function_callables=classical_function_callables,
         scope=scope,
     ).visit(expr_value.root)
+    expr_value.lock()
     return expr_value

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -9,10 +9,12 @@ from classiq.evaluators.qmod_annotated_expression import (
 def replace_expression_vars(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[HandleBinding, HandleBinding],
-) -> None:
+) -> QmodAnnotatedExpression:
+    expr_val = expr_val.clone()
     if len(renaming) == 0:
-        return
-    all_vars = expr_val.get_classical_vars() | expr_val.get_quantum_vars()
+        expr_val.lock()
+        return expr_val
+    all_vars = dict(expr_val.get_classical_vars()) | dict(expr_val.get_quantum_vars())
     for node_id, var in all_vars.items():
         renamed_var = var
         for source, target in renaming.items():
@@ -24,15 +26,18 @@ def replace_expression_vars(
         expr_val.clear_node_data(node_id)
         expr_val.set_type(node_id, node_type)
         expr_val.set_var(node_id, renamed_var)
-    return
+    expr_val.lock()
+    return expr_val
 
 
 def replace_expression_type_attrs(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[tuple[HandleBinding, str], HandleBinding],
-) -> None:
+) -> QmodAnnotatedExpression:
+    expr_val = expr_val.clone()
     if len(renaming) == 0:
-        return
+        expr_val.lock()
+        return expr_val
     type_attrs = dict(expr_val.get_quantum_type_attributes())
     for node_id, ta in type_attrs.items():
         var = expr_val.get_var(ta.value)
@@ -47,13 +52,15 @@ def replace_expression_type_attrs(
         expr_val.clear_node_data(node_id)
         expr_val.set_type(node_id, node_type)
         expr_val.set_var(node_id, renamed_var)
-    return
+    expr_val.lock()
+    return expr_val
 
 
 def replace_expression_nodes(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[QmodExprNodeId, str],
 ) -> str:
+    expr_val = expr_val.clone()
     for node_id, renamed_var in renaming.items():
         expr_val.set_var(node_id, HandleBinding(name=f"{renamed_var}"))
     return str(expr_val)

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -1,10 +1,12 @@
 import ast
-from typing import Any, cast
+from typing import Any, Callable, TypeVar, cast
 
 import sympy
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 
 from classiq.evaluators.qmod_annotated_expression import (
     QmodAnnotatedExpression,
@@ -37,13 +39,15 @@ _SYMPY_WRAPPERS = {
     do_div.__name__: do_div,
 }
 
+_PY_NODE = TypeVar("_PY_NODE", bound=ast.AST)
+
 
 class _VarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(self, expr_val: QmodAnnotatedExpression) -> None:
         self._expr_val = expr_val
         self._mask_id = 0
         self.masks: dict[str, QmodExprNodeId] = {}
-        self._assigned_masks: dict[HandleBinding, str] = {}
+        self._assigned_masks: dict[Any, str] = {}
 
     def _create_mask(self) -> str:
         mask = f"x{self._mask_id}"
@@ -52,27 +56,44 @@ class _VarMaskTransformer(OutOfPlaceNodeTransformer):
 
     def visit(self, node: ast.AST) -> ast.AST:
         if self._expr_val.has_value(node):
-            return ast.parse(str(self._expr_val.get_value(node)))
+            val = self._expr_val.get_value(node)
+            if not isinstance(val, (list, QmodStructInstance)):
+                return ast.Constant(value=val)
+            mask = self._create_mask()
+            self.masks[mask] = id(node)
+            return ast.Name(id=mask)
         if self._expr_val.has_var(node):
             var = self._expr_val.get_var(node)
-            if var in self._assigned_masks:
-                mask = self._assigned_masks[var]
-            else:
-                mask = self._create_mask()
-                self._assigned_masks[var] = mask
-                self.masks[mask] = id(node)
-            return ast.Name(id=mask)
-        if self._expr_val.has_quantum_subscript(node):
+            var_str = str(var.collapse())
+            if var_str in self._assigned_masks:
+                return ast.Name(id=self._assigned_masks[var_str])
             mask = self._create_mask()
+            self._assigned_masks[var_str] = mask
             self.masks[mask] = id(node)
             return ast.Name(id=mask)
         return super().visit(node)
 
-    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
-        mask = self._create_mask()
+    def _reduce_node(
+        self, node: _PY_NODE, inner_node: ast.AST, key: Callable[[_PY_NODE], str]
+    ) -> ast.AST:
+        new_value = self.visit(inner_node)
+        if isinstance(new_value, ast.Name):
+            mask_key = (new_value.id, key(node))
+            if mask_key in self._assigned_masks:
+                return ast.Name(self._assigned_masks[mask_key])
+            mask = self._create_mask()
+            self._assigned_masks[mask_key] = mask
+        else:
+            mask = self._create_mask()
         self.masks[mask] = id(node)
         return ast.Name(id=mask)
 
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        return self._reduce_node(node, node.value, lambda n: n.attr)
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        return self._reduce_node(node, node.value, lambda n: ast.unparse(node.slice))
+
 
 class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(
@@ -230,12 +251,14 @@ class _InverseSympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
         if func == BitwiseAnd.__name__:
             return ast.BinOp(left=node.args[0], op=ast.BitAnd(), right=node.args[1])
 
-        if func == "Mod":
-            return ast.BinOp(left=node.args[0], op=ast.Mod(), right=node.args[1])
+        if func == "Abs":
+            node.func.id = "abs"
         if func == "Max":
             node.func.id = "max"
         elif func == "Min":
             node.func.id = "min"
+        if func == "Mod":
+            return ast.BinOp(left=node.args[0], op=ast.Mod(), right=node.args[1])
 
         return node
 

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -42,7 +42,7 @@ def _eval_type_attribute(
         return
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)) and attr == "len":
         expr_val.set_type(node, Integer())
-        if subject_type.has_length:
+        if subject_type.has_constant_length:
             expr_val.set_value(node, subject_type.length_value)
         elif isinstance(subject_type, QuantumType):
             expr_val.set_quantum_type_attr(node, subject, attr)

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -30,6 +30,9 @@ from classiq.evaluators.qmod_node_evaluators.utils import (
     element_types,
     is_classical_integer,
 )
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
+)
 
 # These sympy functions are not declared as int funcs for some reason...
 INTEGER_FUNCTION_OVERRIDE = {"floor", "ceiling"}
@@ -169,7 +172,9 @@ def eval_function(
         cast(str, kwarg_name): expr_val.get_value(kwarg_value)
         for kwarg_name, kwarg_value in kwargs.items()
     }
-    expr_val.set_value(node, func(*arg_values, **kwarg_values))
+    ret_val = func(*arg_values, **kwarg_values)
+    expr_val.set_type(node, infer_classical_type(ret_val))
+    expr_val.set_value(node, ret_val)
 
 
 def try_eval_sympy_function(
@@ -261,10 +266,10 @@ def try_eval_builtin_function(
                 *[expr_val.get_value(arg) for arg in node.args]
             )
             ret_val: Any
-            if args_are_int:
-                ret_val = int(sympy_val)
-            elif isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
+            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
                 ret_val = complex(sympy_val)
+            elif args_are_int:
+                ret_val = int(sympy_val)
             else:
                 ret_val = float(sympy_val)
             expr_val.set_value(node, ret_val)
@@ -287,9 +292,14 @@ def try_eval_builtin_function(
         _validate_no_kwargs(node)
         expr_val.set_type(node, Real())
         if args_have_values:
-            expr_val.set_value(
-                node, sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
-            )
+            sympy_val = sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
+            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
+                ret_val = complex(sympy_val)
+            elif float(sympy_val) == int(sympy_val):
+                ret_val = int(sympy_val)
+            else:
+                ret_val = float(sympy_val)
+            expr_val.set_value(node, ret_val)
         return True
 
     if func_name == "abs":
@@ -301,7 +311,7 @@ def try_eval_builtin_function(
         expr_val.set_type(node, ret_type)
         if args_have_values:
             expr_val.set_value(
-                node, sympy.Abs(*[expr_val.get_value(arg) for arg in node.args])
+                node, abs(*[expr_val.get_value(arg) for arg in node.args])
             )
         return True
 

classiq/evaluators/qmod_node_evaluators/compare_evaluation.py

@@ -100,12 +100,20 @@ def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
     elif isinstance(op, ast.NotEq):
         expr_val.set_value(node, left_value != right_value)
     elif isinstance(op, ast.Lt):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value < right_value)
     elif isinstance(op, ast.Gt):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value > right_value)
     elif isinstance(op, ast.LtE):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value <= right_value)
     elif isinstance(op, ast.GtE):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value >= right_value)
     else:
         raise ClassiqExpansionError(f"Unsupported comparison {type(op).__name__!r}")

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -33,7 +33,10 @@ def eval_enum_member(
     }
     attr = node.attr
     if attr not in enum_members:
-        raise ClassiqExpansionError(f"Enum {enum_name} has no member named {attr!r}")
+        raise ClassiqExpansionError(
+            f"Enum {enum_name} has no member {attr!r}. Available members: "
+            f"{', '.join(enum_members.keys())}"
+        )
 
     expr_val.set_type(node, Enum(name=enum_name))
     expr_val.set_value(node, enum_members[attr])

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -29,7 +29,7 @@ def get_numeric_attrs(
 
     if TYPE_CHECKING:
         assert isinstance(qmod_type, QuantumScalar)
-    if not qmod_type.is_evaluated:
+    if not qmod_type.is_constant:
         return None
     return NumericAttributes.from_quantum_scalar(qmod_type, machine_precision)
 

classiq/evaluators/qmod_node_evaluators/struct_instantiation_evaluation.py

@@ -20,7 +20,7 @@ from classiq.evaluators.qmod_node_evaluators.compare_evaluation import (
 def eval_struct_instantiation(
     expr_val: QmodAnnotatedExpression, node: ast.Call, decl: StructDeclaration
 ) -> None:
-    if len(node.args) > 0 or any(kwarg.arg is None for kwarg in node.keywords):
+    if len(node.args) != 1 or any(kwarg.arg is None for kwarg in node.keywords):
         raise ClassiqExpansionError(
             "Classical structs must be instantiated using keyword arguments"
         )

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -69,7 +69,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
     subject_type = expr_val.get_type(subject)
     slice_type: QmodType
     if isinstance(subject_type, ClassicalArray):
-        if subject_type.has_length and (
+        if subject_type.has_constant_length and (
             (start_val is not None and start_val >= subject_type.length_value)
             or (stop_val is not None and stop_val > subject_type.length_value)
         ):
@@ -93,7 +93,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
             slice_type = subject_type.get_raw_type()
     elif isinstance(subject_type, QuantumBitvector):
         if start_val is not None and stop_val is not None:
-            if subject_type.has_length and (
+            if subject_type.has_constant_length and (
                 start_val >= subject_type.length_value
                 or stop_val > subject_type.length_value
             ):
@@ -150,7 +150,7 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)):
         if (
             sub_val is not None
-            and subject_type.has_length
+            and subject_type.has_constant_length
             and sub_val >= subject_type.length_value
         ):
             raise ClassiqExpansionError("Array index out of range")

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -85,7 +85,7 @@ def array_len(
 ) -> Optional[int]:
     if isinstance(classical_type, ClassicalTuple):
         return len(classical_type.element_types)
-    if classical_type.has_length:
+    if classical_type.has_constant_length:
         return classical_type.length_value
     return None
 

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -73,9 +73,9 @@ def _inject_classical_array_attributes(
     if isinstance(to_type, ClassicalArray):
         if isinstance(from_type, ClassicalArray):
             length: Optional[Expression]
-            if from_type.has_length:
+            if from_type.has_constant_length:
                 if (
-                    to_type.has_length
+                    to_type.has_constant_length
                     and from_type.length_value != to_type.length_value
                 ):
                     return None
@@ -90,7 +90,7 @@ def _inject_classical_array_attributes(
             return ClassicalArray(element_type=element_type, length=length)
         if isinstance(from_type, ClassicalTuple):
             if (
-                to_type.has_length
+                to_type.has_constant_length
                 and len(from_type.element_types) != to_type.length_value
             ):
                 return None
@@ -103,7 +103,7 @@ def _inject_classical_array_attributes(
             return ClassicalTuple(element_types=element_types)
         return None
     if isinstance(from_type, ClassicalArray):
-        if from_type.has_length and from_type.length_value != len(
+        if from_type.has_constant_length and from_type.length_value != len(
             to_type.element_types
         ):
             return None

classiq/evaluators/qmod_type_inference/quantum_type_inference.py

@@ -290,3 +290,41 @@ def inject_quantum_type_attributes_inplace(
         to_type.set_fields(updated_type.fields)
         return True
     raise ClassiqInternalExpansionError
+
+
+def validate_quantum_type_attributes(quantum_type: QuantumType) -> None:
+    if isinstance(quantum_type, TypeName):
+        if len(quantum_type.fields) == 0:
+            raise ClassiqExpansionError(
+                f"QStruct {quantum_type.name} must have at least one field"
+            )
+        for field_type in quantum_type.fields.values():
+            validate_quantum_type_attributes(field_type)
+        return
+    if isinstance(quantum_type, QuantumBitvector):
+        validate_quantum_type_attributes(quantum_type.element_type)
+        if quantum_type.has_constant_length and quantum_type.length_value < 1:
+            raise ClassiqExpansionError(
+                f"QArray length must be positive, got {quantum_type.length_value}"
+            )
+        return
+    if isinstance(quantum_type, QuantumNumeric):
+        if quantum_type.has_size_in_bits and quantum_type.size_in_bits < 1:
+            raise ClassiqExpansionError(
+                f"QNum size must be positive, got {quantum_type.size_in_bits}"
+            )
+        if quantum_type.has_fraction_digits:
+            if quantum_type.fraction_digits_value < 0:
+                raise ClassiqExpansionError(
+                    f"QNum fraction digits must be positive, got "
+                    f"{quantum_type.fraction_digits_value}"
+                )
+            if (
+                quantum_type.has_size_in_bits
+                and quantum_type.fraction_digits_value > quantum_type.size_in_bits
+            ):
+                raise ClassiqExpansionError(
+                    f"QNum size ({quantum_type.size_in_bits}) must be greater or "
+                    f"equals than the fraction digits "
+                    f"({quantum_type.fraction_digits_value})"
+                )

classiq/evaluators/type_type_match.py

@@ -21,7 +21,7 @@ def check_signature_match(
 ) -> None:
     if len(decl_params) != len(op_params):
         raise ClassiqExpansionError(
-            f"{location_str} should have {len(decl_params)} parameters, "
+            f"{location_str.capitalize()} should have {len(decl_params)} parameters, "
             f"not {len(op_params)}"
         )
     for idx, (decl_param, op_param) in enumerate(zip(decl_params, op_params)):