classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -0,0 +1,239 @@
+from collections.abc import Sequence
+from typing import Optional
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.type_name import (
+    TypeName,
+)
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.inplace_binary_operation import BinaryOperation
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+    QuantumType,
+)
+
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+
+
+def copy_type_information(
+    from_type: QuantumType,
+    to_type: QuantumType,
+    to_param_name: str,
+) -> None:
+    if isinstance(to_type, QuantumBit):
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    elif isinstance(to_type, QuantumNumeric):
+        set_is_signed(to_type, getattr(from_type, "sign_value", None), to_param_name)
+        set_fraction_digits(
+            to_type,
+            getattr(from_type, "fraction_digits_value", None),
+            to_param_name,
+        )
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    elif isinstance(to_type, QuantumBitvector):
+        if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
+            from_type.element_type
+        ) == type(to_type.element_type):
+            copy_type_information(
+                from_type.element_type, to_type.element_type, to_param_name
+            )
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    elif isinstance(to_type, TypeName):
+        if isinstance(from_type, TypeName) and from_type.name == to_type.name:
+            for field in from_type.fields:
+                copy_type_information(
+                    from_type.fields[field], to_type.fields[field], to_param_name
+                )
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    else:
+        raise ClassiqInternalExpansionError
+
+
+def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
+    if size <= 0:
+        raise ClassiqExpansionError(
+            f"Size for {param_name!r} was deduced to be non-positive: {size!r}"
+        )
+
+    if quantum_type.has_size_in_bits and quantum_type.size_in_bits != size:
+        raise ClassiqExpansionError(
+            f"Size mismatch for port {param_name!r} between declared size {quantum_type.size_in_bits} and assigned size {size}"
+        )
+
+    if isinstance(quantum_type, QuantumNumeric):
+        quantum_type.size = Expression(expr=str(size))
+        if not quantum_type.has_sign or not quantum_type.has_fraction_digits:
+            set_is_signed(quantum_type, False, param_name)
+            set_fraction_digits(quantum_type, 0, param_name)
+    elif isinstance(quantum_type, QuantumBitvector):
+        if quantum_type.has_length:
+            if size % quantum_type.length_value != 0:
+                raise ClassiqExpansionError(
+                    f"Size mismatch for port {param_name!r}. Cannot fit {size} "
+                    f"qubits into an array of {quantum_type.length_value} elements."
+                )
+            set_size(
+                quantum_type.element_type,
+                size // quantum_type.length_value,
+                param_name,
+            )
+        set_length_by_size(quantum_type, size, param_name)
+    elif isinstance(quantum_type, TypeName):
+        fields_without_size = [
+            field_type
+            for field_type in quantum_type.fields.values()
+            if not field_type.has_size_in_bits
+        ]
+        if len(fields_without_size) > 1:
+            raise ClassiqInternalExpansionError(
+                f"QuantumStruct should have at most one field without "
+                f"predetermined size. Found {fields_without_size}."
+            )
+        if len(fields_without_size) == 1:
+            predetermined_size_part = sum(
+                field_type.size_in_bits if field_type.has_size_in_bits else 0
+                for field_type in quantum_type.fields.values()
+            )
+            set_size(fields_without_size[0], size - predetermined_size_part, param_name)
+
+
+def set_fraction_digits(
+    quantum_numeric: QuantumNumeric, fraction_digits: Optional[int], param_name: str
+) -> None:
+    if fraction_digits is not None and fraction_digits < 0:
+        raise ClassiqExpansionError(
+            f"Number of fraction digits for {param_name!r} was deduced to be negative: "
+            f"{fraction_digits!r}"
+        )
+
+    if (
+        fraction_digits is not None
+        and quantum_numeric.fraction_digits is not None
+        and quantum_numeric.fraction_digits.is_evaluated()
+        and quantum_numeric.fraction_digits_value != fraction_digits
+    ):
+        raise ClassiqExpansionError(
+            f"Fraction digits mismatch for port {param_name!r} between declared "
+            f"fraction digits {quantum_numeric.fraction_digits_value!r} and assigned fraction "
+            f"digits {fraction_digits!r}"
+        )
+
+    if not (
+        quantum_numeric.fraction_digits is not None
+        and quantum_numeric.fraction_digits.is_evaluated()
+    ):
+        quantum_numeric.fraction_digits = Expression(expr=str(fraction_digits or 0))
+
+
+def set_is_signed(
+    quantum_numeric: QuantumNumeric, is_signed: Optional[bool], param_name: str
+) -> None:
+    if (
+        is_signed is not None
+        and quantum_numeric.is_signed is not None
+        and quantum_numeric.is_signed.is_evaluated()
+        and quantum_numeric.sign_value != is_signed
+    ):
+        raise ClassiqExpansionError(
+            f"Sign mismatch for port {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
+        )
+
+    if not (
+        quantum_numeric.is_signed is not None
+        and quantum_numeric.is_signed.is_evaluated()
+    ):
+        quantum_numeric.is_signed = Expression(expr=str(is_signed or False))
+
+
+def set_element_type(
+    quantum_array: QuantumBitvector, element_type: ConcreteQuantumType
+) -> None:
+    quantum_array.element_type = element_type
+
+
+def set_length(quantum_array: QuantumBitvector, length: int) -> None:
+    quantum_array.length = Expression(expr=str(length))
+
+
+def set_length_by_size(
+    quantum_array: QuantumBitvector, size: int, param_name: str
+) -> None:
+    if size <= 0:
+        raise ClassiqExpansionError(
+            f"Size for {param_name!r} was deduced to be non-positive: {size!r}"
+        )
+
+    if quantum_array.has_size_in_bits and quantum_array.size_in_bits != size:
+        raise ClassiqExpansionError(
+            f"Size mismatch for port {param_name!r} between declared size "
+            f"{quantum_array.size_in_bits} ({quantum_array.length_value} elements of "
+            f"size {quantum_array.element_type.size_in_bits}) and assigned size {size}."
+        )
+
+    if not quantum_array.element_type.has_size_in_bits:
+        raise ClassiqExpansionError(
+            f"Could not infer element size for array {param_name!r}."
+        )
+    element_size = quantum_array.element_type.size_in_bits
+
+    if size % element_size != 0:
+        raise ClassiqExpansionError(
+            f"Size mismatch for port {param_name!r}. Cannot fit elements of type "
+            f"{quantum_array.element_type.qmod_type_name} (size {element_size}) into "
+            f"{size} qubits."
+        )
+
+    quantum_array.length = Expression(expr=str(size // element_size))
+
+
+def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
+    illegal_qnum_bind_targets = []
+    for out_handle in bind.out_handles:
+        out_var = scope[out_handle.name].as_type(QuantumSymbol)
+        out_var_type = out_var.quantum_type
+        if not isinstance(out_var_type, QuantumNumeric):
+            continue
+        if not out_var_type.has_size_in_bits:
+            illegal_qnum_bind_targets.append(str(out_var.handle))
+        elif not out_var_type.has_sign:
+            assert not out_var_type.has_fraction_digits
+            illegal_qnum_bind_targets.append(str(out_var.handle))
+    if len(illegal_qnum_bind_targets) > 0:
+        raise ClassiqExpansionError(
+            f"QNum bind targets {illegal_qnum_bind_targets!r} must be declared or initialized with size, sign, and fraction digits"
+        )
+
+
+def get_inplace_op_scalar_as_numeric(
+    var: QuantumSymbol, operation: BinaryOperation, var_kind: str
+) -> QuantumNumeric:
+    if not isinstance(var.quantum_type, QuantumScalar):
+        raise ClassiqExpansionError(
+            f"Cannot perform inplace {operation.name.lower()} with non-scalar {var_kind} {var.handle}"
+        )
+    if isinstance(var.quantum_type, QuantumNumeric):
+        return var.quantum_type
+    if isinstance(var.quantum_type, QuantumBit):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
+    raise ClassiqInternalExpansionError(f"Unexpected scalar type {var.quantum_type}")
+
+
+def is_signature_monomorphic(params: Sequence[PositionalArg]) -> bool:
+    return all(
+        isinstance(param, PortDeclaration) and param.quantum_type.is_evaluated
+        for param in params
+    )

classiq/model_expansions/evaluators/type_type_match.py

@@ -0,0 +1,90 @@
+from collections.abc import Sequence
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+)
+
+
+def check_signature_match(
+    decl_params: Sequence[AnonPositionalArg],
+    op_params: Sequence[AnonPositionalArg],
+    location_str: str,
+) -> None:
+    if len(decl_params) != len(op_params):
+        raise ClassiqExpansionError(
+            f"{location_str} should have {len(decl_params)} parameters, "
+            f"not {len(op_params)}"
+        )
+    for idx, (decl_param, op_param) in enumerate(zip(decl_params, op_params)):
+        message_prefix = f"Argument {idx} in {location_str} has incompatible type; "
+        _check_type_match(op_param, decl_param, location_str, message_prefix)
+
+
+def _check_type_match(
+    op_param: AnonPositionalArg,
+    decl_param: AnonPositionalArg,
+    location_str: str,
+    message_prefix: str,
+) -> None:
+    if isinstance(decl_param, AnonPortDeclaration):
+        error_message = message_prefix + "expected quantum parameter"
+        _check_qvar_type_match(op_param, error_message)
+    elif isinstance(decl_param, AnonQuantumOperandDeclaration):
+        if decl_param.is_list:
+            error_message = message_prefix + "expected operand list parameter"
+        else:
+            error_message = message_prefix + "expected operand parameter"
+        _check_operand_type_match(op_param, decl_param, location_str, error_message)
+    elif isinstance(decl_param, AnonClassicalParameterDeclaration):
+        error_message = (
+            message_prefix + f"expected classical {decl_param.classical_type} parameter"
+        )
+        _check_classical_type_match(op_param, decl_param, error_message)
+    else:
+        raise ClassiqInternalExpansionError(
+            f"unexpected parameter declaration type: {type(decl_param).__name__}"
+        )
+
+
+def _check_qvar_type_match(op_param: AnonPositionalArg, error_message: str) -> None:
+    if not isinstance(op_param, AnonPortDeclaration):
+        raise ClassiqExpansionError(error_message)
+
+
+def _check_operand_type_match(
+    op_param: AnonPositionalArg,
+    decl_param: AnonQuantumOperandDeclaration,
+    location_str: str,
+    error_message: str,
+) -> None:
+    if (
+        not isinstance(op_param, AnonQuantumOperandDeclaration)
+        or decl_param.is_list ^ op_param.is_list
+    ):
+        raise ClassiqExpansionError(error_message)
+    check_signature_match(
+        decl_param.positional_arg_declarations,
+        op_param.positional_arg_declarations,
+        f"operand {decl_param.name} in {location_str}",
+    )
+
+
+def _check_classical_type_match(
+    op_param: AnonPositionalArg,
+    decl_param: AnonClassicalParameterDeclaration,
+    error_message: str,
+) -> None:
+    if (
+        not isinstance(op_param, AnonClassicalParameterDeclaration)
+        or decl_param.classical_type != op_param.classical_type
+    ):
+        raise ClassiqExpansionError(error_message)

classiq/model_expansions/expression_evaluator.py

@@ -0,0 +1,135 @@
+import ast
+import re
+from collections.abc import Mapping
+from enum import EnumMeta
+from typing import Any, Optional
+
+from sympy import sympify
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    CPARAM_EXECUTION_SUFFIX_PATTERN,
+)
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.sympy_supported_expressions import (
+    SYMPY_SUPPORTED_EXPRESSIONS,
+)
+
+from classiq.model_expansions.atomic_expression_functions_defs import (
+    ATOMIC_EXPRESSION_FUNCTIONS,
+    qmod_val_to_python,
+)
+from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
+    translate_to_sympy,
+)
+from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_python
+from classiq.qmod import symbolic
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
+
+
+def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
+    result: dict[str, EvaluatedExpression] = {}
+    for constant in constants:
+        result[constant.name] = evaluate(constant.value, result)
+    return result
+
+
+def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
+    evaluated = evaluate_constants(constants)
+    return {
+        constant.name: qmod_val_to_python(
+            evaluated[constant.name].value, constant.const_type
+        )
+        for constant in constants
+    }
+
+
+def evaluate(
+    expr: Expression,
+    locals_dict: Mapping[str, EvaluatedExpression],
+    uninitialized_locals: Optional[set[str]] = None,
+) -> EvaluatedExpression:
+    model_locals: dict[str, ExpressionValue] = {}
+    model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
+    model_locals.update(
+        {
+            enum_decl.name: enum_decl.create_enum()
+            for enum_decl in (QMODULE.enum_decls | BUILTIN_ENUM_DECLARATIONS).values()
+        }
+    )
+    # locals override builtin-functions
+    model_locals.update({name: expr.value for name, expr in locals_dict.items()})
+    uninitialized_locals = uninitialized_locals or set()
+
+    _validate_undefined_vars(expr.expr, model_locals, uninitialized_locals)
+
+    sympy_expr = translate_to_sympy(expr.expr)
+    try:
+        sympify_result = sympify(sympy_expr, locals=model_locals)
+    except (TypeError, IndexError) as e:
+        raise ClassiqExpansionError(str(e)) from None
+    except AttributeError as e:
+        if isinstance(e.obj, EnumMeta):
+            raise ClassiqExpansionError(
+                f"Enum {e.obj.__name__} has no member {e.name!r}. Available members: "
+                f"{', '.join(e.obj.__members__)}"
+            ) from e
+        raise
+
+    return EvaluatedExpression(
+        value=sympy_to_python(sympify_result, locals=model_locals)
+    )
+
+
+def _validate_undefined_vars(
+    expr: str,
+    model_locals: dict[str, ExpressionValue],
+    uninitialized_locals: Optional[set[str]],
+) -> None:
+    uninitialized_locals = uninitialized_locals or set()
+    id_visitor = _VarsCollector()
+    id_visitor.visit(ast.parse(expr))
+    identifiers = id_visitor.vars
+    undefined_vars = (
+        identifiers
+        - model_locals.keys()
+        - set(SYMPY_SUPPORTED_EXPRESSIONS)
+        - set(symbolic.__all__)
+        - uninitialized_locals
+    )
+
+    # Ignore expanded execution parameters
+    undefined_vars = {
+        var
+        for var in undefined_vars
+        if not re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, var)
+    }
+
+    if len(undefined_vars) == 1:
+        undefined_var = undefined_vars.__iter__().__next__()
+        raise ClassiqExpansionError(f"Variable {undefined_var!r} is undefined")
+    elif len(undefined_vars) > 1:
+        raise ClassiqExpansionError(f"Variables {list(undefined_vars)} are undefined")
+
+
+class _VarsCollector(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.vars: set[str] = set()
+
+    def visit_Name(self, node: ast.Name) -> None:
+        self.vars.add(node.id)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        func = node.func
+        self.visit(func)
+        if not isinstance(func, ast.Name) or func.id != "struct_literal":
+            for arg in node.args:
+                self.visit(arg)
+        for kw in node.keywords:
+            self.visit(kw)

classiq/model_expansions/expression_renamer.py

@@ -0,0 +1,76 @@
+import ast
+from collections.abc import Sequence
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    RESERVED_EXPRESSIONS,
+)
+from classiq.interface.generator.visitor import Transformer
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    ClassicalParameterDeclaration,
+    PositionalArg,
+)
+
+from classiq.model_expansions.visitors.variable_references import VarRefTransformer
+
+
+class ExpressionRenamer(Transformer):
+
+    def __init__(self, var_mapping: dict[str, str]) -> None:
+        self.var_ref_transformer = VarRefTransformer(var_mapping)
+
+    @property
+    def var_mapping(self) -> dict[str, str]:
+        return self.var_ref_transformer.var_mapping
+
+    def visit_QuantumFunctionCall(
+        self, node: QuantumFunctionCall
+    ) -> QuantumFunctionCall:
+        update_dict = dict(
+            positional_args=[self.visit(arg) for arg in node.positional_args],
+        )
+        return node.model_copy(update=update_dict)
+
+    def visit_Expression(self, expression: Expression) -> Expression:
+        parsed_expr = ast.parse(expression.expr)
+        renamed_expr = self.var_ref_transformer.visit(parsed_expr)
+        return Expression(expr=ast.unparse(renamed_expr))
+
+    def rename_string(self, name: str) -> str:
+        return self.var_mapping.get(name, name)
+
+    def rename_expression_dict(
+        self, expr_dict: dict[str, Expression]
+    ) -> dict[str, Expression]:
+        return {
+            self.rename_string(key): self.visit(val) for key, val in expr_dict.items()
+        }
+
+    @classmethod
+    def from_positional_arg_declarations(
+        cls, positional_arg_declarations: Sequence[PositionalArg], suffix: str
+    ) -> "ExpressionRenamer":
+        var_mapping: dict[str, str] = dict()
+        for arg in positional_arg_declarations:
+            if not isinstance(arg, ClassicalParameterDeclaration):
+                continue
+            if arg.name in RESERVED_EXPRESSIONS:
+                continue
+            new_name = arg.name + suffix
+            var_mapping[arg.name] = new_name
+
+        return cls(var_mapping)
+
+    def rename_positional_arg_declarations(
+        self, positional_arg_declarations: Sequence[PositionalArg]
+    ) -> Sequence[PositionalArg]:
+        return tuple(
+            (
+                arg.rename(self.var_mapping[arg.name])
+                if isinstance(arg, ClassicalParameterDeclaration)
+                and arg.name in self.var_mapping
+                else arg
+            )
+            for arg in positional_arg_declarations
+        )