classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/model_expansions/capturing/mangling_utils.py

@@ -0,0 +1,56 @@
+import re
+from typing import Optional
+
+from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+
+IDENTIFIER_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
+CAPTURE_PATTERN = re.compile(
+    rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__\d*"
+)
+ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
+
+
+def mangle_captured_var_name(
+    var_name: str, function_name: str, function_depth: int
+) -> str:
+    return f"{var_name}{CAPTURE_SUFFIX}{function_name}__{function_depth}"
+
+
+def _match_capture_pattern(name: str) -> Optional[re.Match[str]]:
+    return re.match(CAPTURE_PATTERN, name)
+
+
+def is_captured_var_name(name: str) -> bool:
+    return _match_capture_pattern(name) is not None
+
+
+def demangle_capture_name(name: str) -> str:
+    match = _match_capture_pattern(name)
+    return match.group(1) if match else name
+
+
+def demangle_handle(handle: HandleBinding) -> HandleBinding:
+    demangled_name = demangle_name(handle.name)
+    return handle.rename(demangled_name)
+
+
+def demangle_name(name: str) -> str:
+    if HANDLE_ID_SEPARATOR not in name:
+        return name
+    if ARRAY_CAST_SUFFIX in name:
+        return name.split(ARRAY_CAST_SUFFIX)[0]
+    name = re.sub(r"([^_])_\d+$", r"\1", name)
+    name_parts = name.split(HANDLE_ID_SEPARATOR)
+    new_name_parts = [name_parts[0]]
+    for part in name_parts[1:]:
+        if re.fullmatch(r"\d+", part):
+            new_name_parts.append(f"[{part}]")
+        elif re.fullmatch(r"\d+_\d+", part):
+            part_left, part_right = part.split("_")
+            new_name_parts.append(f"[{part_left}:{part_right}]")
+        else:
+            new_name_parts.append(f".{part}")
+    new_name_parts = list(map(demangle_capture_name, new_name_parts))
+    new_name = "".join(new_name_parts)
+    return new_name

classiq/model_expansions/closure.py

@@ -0,0 +1,171 @@
+import dataclasses
+import json
+from collections.abc import Collection, Sequence
+from dataclasses import dataclass, field
+from functools import singledispatch
+from typing import Any, Optional
+
+from typing_extensions import Self
+
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
+)
+from classiq.interface.model.quantum_lambda_function import QuantumCallable
+from classiq.interface.model.quantum_statement import QuantumStatement
+
+from classiq.model_expansions.capturing.captured_vars import CapturedVars
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    Scope,
+    evaluated_to_str as evaluated_classical_param_to_str,
+)
+from classiq.qmod.builtins.functions import permute
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+@dataclass(frozen=True)
+class Closure:
+    name: str
+    blocks: dict[str, Sequence[QuantumStatement]]
+    scope: Scope
+    positional_arg_declarations: Sequence[PositionalArg] = tuple()
+    captured_vars: CapturedVars = field(default_factory=CapturedVars)
+
+    @property
+    def port_declarations(self) -> dict[str, PortDeclaration]:
+        return {
+            param.name: param
+            for param in self.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+        }
+
+
+@dataclass(frozen=True)
+class GenerativeClosure(Closure):
+    generative_blocks: dict[str, GenerativeQFunc] = None  # type:ignore[assignment]
+
+
+@dataclass(frozen=True)
+class FunctionClosure(Closure):
+    is_lambda: bool = False
+    is_atomic: bool = False
+    signature_scope: Scope = field(default_factory=Scope)
+    _depth: Optional[int] = None
+
+    @property
+    def depth(self) -> int:
+        if self._depth is None:
+            raise ClassiqInternalExpansionError
+        return self._depth
+
+    # creates a unique id for the function closure based on the arguments values.
+    # The closure is changing across the interpreter flow so it's closure_id may change
+    @property
+    def closure_id(self) -> str:
+        signature = _generate_closure_id(self.scope.data.values())
+        return f"{self.name}__{signature}"
+
+    @property
+    def body(self) -> Sequence[QuantumStatement]:
+        if self.name == permute.func_decl.name:
+            # permute is an old Qmod "generative" function that doesn't have a body
+            return []
+        return self.blocks["body"]
+
+    @classmethod
+    def create(
+        cls,
+        name: str,
+        scope: Scope,
+        body: Optional[Sequence[QuantumStatement]] = None,
+        positional_arg_declarations: Sequence[PositionalArg] = tuple(),
+        expr_renamer: Optional[ExpressionRenamer] = None,
+        is_lambda: bool = False,
+        is_atomic: bool = False,
+        **kwargs: Any,
+    ) -> Self:
+        if expr_renamer:
+            positional_arg_declarations = (
+                expr_renamer.rename_positional_arg_declarations(
+                    positional_arg_declarations
+                )
+            )
+            if body is not None:
+                body = expr_renamer.visit(body)
+
+        blocks = {"body": body} if body is not None else {}
+        return cls(
+            name,
+            blocks,
+            scope,
+            positional_arg_declarations,
+            CapturedVars(),
+            is_lambda,
+            is_atomic,
+            **kwargs,
+        )
+
+    def with_new_declaration(
+        self, declaration: NamedParamsQuantumFunctionDeclaration
+    ) -> Self:
+        fields: dict = self.__dict__ | {
+            "name": declaration.name,
+            "positional_arg_declarations": declaration.positional_arg_declarations,
+        }
+        return type(self)(**fields)
+
+    def set_depth(self, depth: int) -> Self:
+        return dataclasses.replace(self, _depth=depth)
+
+    def clone(self) -> Self:
+        return dataclasses.replace(
+            self,
+            scope=self.scope.clone(),
+            signature_scope=self.signature_scope.clone(),
+            captured_vars=self.captured_vars.clone(),
+        )
+
+    def emit(self) -> QuantumCallable:
+        return self.name
+
+
+@dataclass(frozen=True)
+class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
+    pass
+
+
+def _generate_closure_id(evaluated_args: Collection[Evaluated]) -> str:
+    args_signature = [
+        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
+    ]
+    return json.dumps(args_signature)
+
+
+@singledispatch
+def _evaluated_arg_to_str(arg: Any) -> str:
+    if isinstance(arg, str):
+        return arg
+    if isinstance(arg, QuantumSymbol):
+        return _evaluated_quantum_symbol_to_str(arg)
+    if isinstance(arg, FunctionClosure):
+        return _evaluated_one_operand_to_str(arg)
+    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
+        return _evaluated_operands_list_to_str(arg)
+    return evaluated_classical_param_to_str(arg)
+
+
+def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
+    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+
+
+def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
+    return operand.closure_id
+
+
+def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
+    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/debug_flag.py

@@ -0,0 +1,3 @@
+from contextvars import ContextVar
+
+debug_mode: ContextVar[bool] = ContextVar("debug_mode", default=False)

classiq/model_expansions/evaluators/arg_type_match.py

@@ -0,0 +1,158 @@
+from collections.abc import Sequence
+from enum import Enum
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.classical_type import (
+    StructMetaType,
+)
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.generator.functions.type_name import (
+    TypeName,
+)
+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,
+)
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.type_type_match import check_signature_match
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.qmod_parameter import CInt, get_qmod_type
+
+
+def check_type_match(
+    parameters: Sequence[AnonPositionalArg],
+    arguments: list[Evaluated],
+    function_name: str,
+) -> None:
+    if len(parameters) != len(arguments):
+        raise ClassiqExpansionError(
+            f"Function {function_name!r} takes {len(parameters)} arguments but "
+            f"{len(arguments)} were given"
+        )
+    for parameter, evaluated_arg in zip(parameters, arguments):
+        check_arg_type_match(evaluated_arg.value, parameter, function_name)
+
+
+def check_arg_type_match(
+    argument: Any, parameter: AnonPositionalArg, function_name: str
+) -> None:
+    message_prefix = (
+        f"Argument {str(argument)!r} to parameter {parameter.name!r} of function "
+        f"{function_name!r} has incompatible type; "
+    )
+    if isinstance(parameter, AnonPortDeclaration):
+        error_message = message_prefix + "expected quantum variable"
+        _check_qvar_type_match(argument, error_message)
+    elif isinstance(parameter, AnonQuantumOperandDeclaration):
+        if parameter.is_list:
+            error_message = message_prefix + "expected list of operands"
+            _check_operand_list_type_match(
+                argument, parameter, function_name, error_message
+            )
+        else:
+            error_message = message_prefix + "expected operand"
+            _check_operand_type_match(argument, parameter, function_name, error_message)
+    elif isinstance(parameter, AnonClassicalParameterDeclaration):
+        error_message = (
+            message_prefix + f"expected {_resolve_type_name(parameter.classical_type)}"
+        )
+        _check_classical_type_match(argument, parameter, error_message)
+    else:
+        raise ClassiqExpansionError(
+            f"unexpected parameter declaration type: {type(parameter).__name__}"
+        )
+
+
+def _check_qvar_type_match(argument: Any, error_message: str) -> None:
+    if not isinstance(argument, QuantumSymbol):
+        raise ClassiqExpansionError(error_message)
+
+
+def _check_operand_list_type_match(
+    argument: Any,
+    parameter: AnonQuantumOperandDeclaration,
+    function_name: str,
+    error_message: str,
+) -> None:
+    if not isinstance(argument, list) or any(
+        not isinstance(op, FunctionClosure) for op in argument
+    ):
+        raise ClassiqExpansionError(error_message)
+    for idx, operand in enumerate(argument):
+        if operand.positional_arg_declarations is not None:
+            check_signature_match(
+                parameter.positional_arg_declarations,
+                operand.positional_arg_declarations,
+                f"operand #{idx + 1} in parameter {parameter.name!r} "
+                f"in function {function_name!r}",
+            )
+
+
+def _check_operand_type_match(
+    argument: Any,
+    parameter: AnonQuantumOperandDeclaration,
+    function_name: str,
+    error_message: str,
+) -> None:
+    if not isinstance(argument, FunctionClosure):
+        raise ClassiqExpansionError(error_message)
+    if argument.positional_arg_declarations is not None:
+        check_signature_match(
+            parameter.positional_arg_declarations,
+            argument.positional_arg_declarations,
+            f"operand {parameter.name!r} in function {function_name!r}",
+        )
+
+
+def _check_classical_type_match(
+    argument: Any, parameter: AnonClassicalParameterDeclaration, error_message: str
+) -> None:
+    classical_type = parameter.classical_type
+    type_name = _resolve_type_name(classical_type)
+    type_is_struct = (
+        isinstance(classical_type, TypeName)
+        and classical_type.name in QMODULE.type_decls
+    )
+    type_is_enum = (
+        isinstance(classical_type, TypeName)
+        and classical_type.name in QMODULE.enum_decls
+    )
+    arg_is_qvar = isinstance(argument, QmodSizedProxy)
+    arg_is_builtin = argument.__class__.__module__ == "builtins"
+    arg_is_enum = isinstance(argument, Enum)
+    arg_is_struct = isinstance(argument, QmodStructInstance)
+    arg_struct_name = None if not arg_is_struct else argument.struct_declaration.name
+    if (
+        arg_is_qvar
+        or (arg_is_builtin and (type_is_struct or type_is_enum))
+        or (arg_is_struct and (not type_is_struct or arg_struct_name != type_name))
+        or (
+            arg_is_enum
+            and get_qmod_type(classical_type) != CInt
+            and (not type_is_enum or type(argument).__name__ != type_name)
+        )
+    ):
+        raise ClassiqExpansionError(error_message)
+
+
+def _resolve_type_name(classical_type: ConcreteClassicalType) -> str:
+    if isinstance(classical_type, StructMetaType):
+        type_name = "Struct"
+    else:
+        type_name = get_qmod_type(classical_type).__name__
+    if not isinstance(classical_type, TypeName):
+        return type_name
+    if type_name not in QMODULE.type_decls and type_name not in QMODULE.enum_decls:
+        raise ClassiqExpansionError(f"Undefined type {type_name}")
+    return type_name

classiq/model_expansions/evaluators/argument_types.py

@@ -0,0 +1,42 @@
+from collections.abc import Sequence
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
+
+from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+
+
+def add_information_from_output_arguments(
+    parameters: Sequence[AnonPositionalArg],
+    args: list[Evaluated],
+) -> list[Evaluated]:
+    """
+    This function propagates the quantum type information from the output arguments
+    to the arguments that were passed to it.
+    Example:
+        ...
+        p = QArray("p", QBit)
+        allocate(4, p)
+        other statements with p...
+
+    In the other statements with p, the size of 4 will be part of p's type info.
+    """
+    for parameter, argument in zip(parameters, args):
+        if not isinstance(parameter, AnonPortDeclaration):
+            continue
+
+        argument_as_quantum_symbol = argument.as_type(QuantumSymbol)
+
+        if parameter.direction != PortDeclarationDirection.Output:
+            continue
+
+        copy_type_information(
+            parameter.quantum_type,
+            argument_as_quantum_symbol.quantum_type,
+            str(argument_as_quantum_symbol.handle),
+        )
+    return args

classiq/model_expansions/evaluators/classical_expression.py

@@ -0,0 +1,36 @@
+from typing import get_args
+
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.model.handle_binding import HandleBinding
+
+from classiq.model_expansions.expression_evaluator import evaluate
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+
+
+def evaluate_classical_expression(expr: Expression, scope: Scope) -> Evaluated:
+    all_symbols = scope.items()
+    locals_dict = {
+        name: EvaluatedExpression(value=evaluated.value)
+        for name, evaluated in all_symbols
+        if isinstance(evaluated.value, get_args(ExpressionValue))
+    } | {
+        name: EvaluatedExpression(
+            value=evaluated.value.quantum_type.get_proxy(HandleBinding(name=name))
+        )
+        for name, evaluated in all_symbols
+        if isinstance(evaluated.value, QuantumSymbol)
+        and evaluated.value.quantum_type.has_size_in_bits
+    }
+    uninitialized_locals = {
+        name
+        for name, evaluated in all_symbols
+        if isinstance(evaluated.value, QuantumSymbol)
+        and not evaluated.value.quantum_type.has_size_in_bits
+    }
+
+    ret = evaluate(expr, locals_dict, uninitialized_locals)
+    return Evaluated(value=ret.value)

classiq/model_expansions/evaluators/control.py

@@ -0,0 +1,144 @@
+from typing import Any
+
+from sympy import Equality
+from sympy.core.numbers import Number
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQNumProxy,
+    QmodQScalarProxy,
+    QmodSizedProxy,
+)
+
+CONTROL_INOUT_NAME = "ctrl"
+
+
+def type_name(obj: Any) -> str:
+    if isinstance(obj, QmodSizedProxy):
+        return obj.type_name
+    return type(obj).__name__
+
+
+def resolve_num_condition(condition: Equality) -> tuple[QmodSizedProxy, str]:
+    ctrl, ctrl_val = condition.args
+    if isinstance(ctrl, Number) and isinstance(ctrl_val, QmodQScalarProxy):
+        ctrl, ctrl_val = ctrl_val, ctrl
+    if not isinstance(ctrl, QmodSizedProxy) or not (isinstance(ctrl_val, Number)):
+        _raise_numeric_condition_error(ctrl, ctrl_val)
+    return ctrl, _calculate_ctrl_state(ctrl, float(ctrl_val))
+
+
+def _calculate_ctrl_state(ctrl: QmodSizedProxy, ctrl_val: float) -> str:
+    is_signed, fraction_places = _get_numeric_attributes(ctrl)
+
+    integer_ctrl_val = _get_integer_ctrl_val(ctrl, ctrl_val, fraction_places)
+
+    _validate_control_value_sign(ctrl, integer_ctrl_val, is_signed)
+    _validate_control_var_qubits(
+        ctrl, integer_ctrl_val, is_signed, fraction_places, ctrl_val
+    )
+
+    return _to_twos_complement(integer_ctrl_val, ctrl.size)
+
+
+def _get_numeric_attributes(ctrl: QmodSizedProxy) -> tuple[bool, int]:
+    return (
+        (ctrl.is_signed, ctrl.fraction_digits)
+        if isinstance(ctrl, QmodQNumProxy)
+        else (False, 0)
+    )
+
+
+def _get_integer_ctrl_val(
+    ctrl: QmodSizedProxy, ctrl_val: float, fraction_places: int
+) -> int:
+    unfractioned_ctrl_val = ctrl_val * 2**fraction_places
+    if unfractioned_ctrl_val != int(unfractioned_ctrl_val):
+        raise ClassiqExpansionError(
+            f"Variable {str(ctrl)!r} doesne't have enough fraction digits to "
+            f"represent control value {ctrl_val}"
+        )
+    return int(unfractioned_ctrl_val)
+
+
+def _validate_control_value_sign(
+    ctrl: QmodSizedProxy, ctrl_val: int, is_signed: bool
+) -> None:
+    if not is_signed and ctrl_val < 0:
+        raise ClassiqExpansionError(
+            f"Variable {str(ctrl)!r} is not signed but control value "
+            f"{ctrl_val} is negative"
+        )
+
+
+def _validate_control_var_qubits(
+    ctrl: QmodSizedProxy,
+    ctrl_val: int,
+    is_signed: bool,
+    fraction_places: int,
+    orig_ctrl_val: float,
+) -> None:
+    required_qubits = _min_bit_length(ctrl_val, is_signed)
+    fraction_places_message = (
+        f" with {fraction_places} fraction digits" if fraction_places else ""
+    )
+    if ctrl.size < required_qubits:
+        raise ClassiqExpansionError(
+            f"Variable {str(ctrl)!r} has {ctrl.size} qubits{fraction_places_message} but control value "
+            f"{str(orig_ctrl_val if fraction_places else ctrl_val)!r} requires at least {required_qubits} qubits{fraction_places_message}"
+        )
+
+
+def _raise_numeric_condition_error(ctrl: Any, ctrl_val: Any) -> None:
+    message = (
+        "Control condition must be of the form '<quantum-variable> == "
+        "<classical-number-expression>' or vice versa. "
+    )
+    prefix = f"Neither {ctrl!r} (type {type_name(ctrl)}) or {ctrl_val!r} (type {type_name(ctrl_val)}) is a "
+    if not isinstance(ctrl, QmodSizedProxy) and not isinstance(
+        ctrl_val, QmodSizedProxy
+    ):
+        message += prefix + "quantum variable."
+    elif not isinstance(ctrl, Number) and not isinstance(ctrl_val, Number):
+        message += prefix + "classical number."
+    raise ClassiqExpansionError(message)
+
+
+def _min_unsigned_bit_length(number: int) -> int:
+    if number < 0:
+        raise ClassiqExpansionError(
+            f"Quantum register is not signed but control value "
+            f"'{number}' is negative"
+        )
+    try:
+        return 1 if number == 0 else number.bit_length()
+    except AttributeError as e:
+        raise e
+
+
+def _min_signed_bit_length(number: int) -> int:
+    pos_val = abs(number)
+    is_whole = pos_val & (pos_val - 1) == 0
+    if number <= 0 and is_whole:
+        return _min_unsigned_bit_length(pos_val)
+    return _min_unsigned_bit_length(pos_val) + 1
+
+
+def _min_bit_length(number: int, is_signed: bool) -> int:
+    return (
+        _min_signed_bit_length(number)
+        if is_signed
+        else _min_unsigned_bit_length(number)
+    )
+
+
+def _to_twos_complement(value: int, bits: int) -> str:
+    if value >= 0:
+        return bin(value)[2:].zfill(bits)[::-1]
+    return _to_negative_twos_complement(value, bits)
+
+
+def _to_negative_twos_complement(value: int, bits: int) -> str:
+    mask = (1 << bits) - 1
+    value = (abs(value) ^ mask) + 1
+    return bin(value)[:1:-1].rjust(bits, "1")