classiq 0.45.1__py3-none-any.whl → 0.46.0__py3-none-any.whl

classiq/model_expansions/evaluators/arg_type_match.py

@@ -0,0 +1,160 @@
+from enum import Enum
+from typing import Any, List, Sequence
+
+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.model_tables import SymbolTable
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+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 SymbolTable.type_table
+    )
+    type_is_enum = (
+        isinstance(classical_type, TypeName)
+        and classical_type.name in SymbolTable.enum_table
+    )
+    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 SymbolTable.type_table
+        and type_name not in SymbolTable.enum_table
+    ):
+        raise ClassiqExpansionError(f"Undefined type {type_name}")
+    return type_name

classiq/model_expansions/evaluators/argument_types.py

@@ -0,0 +1,42 @@
+from typing import List, 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, Tuple
+
+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")

classiq/model_expansions/evaluators/parameter_types.py

@@ -0,0 +1,227 @@
+from typing import List, Set, Union
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.functions.type_name import (
+    TypeName,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.arg_type_match import check_type_match
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    copy_type_information,
+    set_element_type,
+    set_fraction_digits,
+    set_is_signed,
+    set_length,
+    set_size,
+    set_struct_fields,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+
+
+def evaluate_parameter_types_from_args(
+    closure: FunctionClosure, signature_scope: Scope, arguments: List[Evaluated]
+) -> List[PositionalArg]:
+    parameters = closure.positional_arg_declarations
+    function_name = closure.name
+    check_type_match(parameters, arguments, function_name)
+
+    for parameter, argument in zip(parameters, arguments):
+        _update_scope(parameter, argument, closure)
+
+    parameter_names = {parameter.name for parameter in parameters}
+    for parameter in parameters:
+        if isinstance(parameter, QuantumOperandDeclaration):
+            parameter_value = closure.scope[parameter.name].value
+            _update_operand_signature_environment(
+                parameter_value, parameter_names, closure
+            )
+
+    return [
+        _evaluate_type_from_arg(
+            parameter, argument, Scope(parent=closure.scope | signature_scope)
+        )
+        for parameter, argument in zip(parameters, arguments)
+    ]
+
+
+def _update_scope(
+    parameter: PositionalArg, argument: Evaluated, closure: FunctionClosure
+) -> None:
+    if not isinstance(parameter, PortDeclaration):
+        closure.scope[parameter.name] = argument
+        return
+    if parameter.direction is PortDeclarationDirection.Output:
+        return
+    quantum_symbol = argument.as_type(QuantumSymbol)
+    if not quantum_symbol.quantum_type.has_size_in_bits:
+        raise ClassiqExpansionError(
+            f"Argument {str(quantum_symbol.emit())!r} to function {closure.name!r} "
+            f"is not initialized"
+        )
+    casted_argument = _cast(
+        parameter.quantum_type,
+        quantum_symbol,
+        parameter.name,
+    )
+    closure.scope[parameter.name] = Evaluated(
+        value=casted_argument, defining_function=closure
+    )
+
+
+NestedFunctionClosureT = Union[FunctionClosure, List["NestedFunctionClosureT"]]
+
+
+def _update_operand_signature_environment(
+    operand_val: NestedFunctionClosureT,
+    parameter_names: Set[str],
+    closure: FunctionClosure,
+) -> None:
+    # We update the environment (parent) of the operand by adding closure.scope.data,
+    # which includes the parameters that appear in the function's signature only.
+    if isinstance(operand_val, list):
+        for operand in operand_val:
+            _update_operand_signature_environment(operand, parameter_names, closure)
+        return
+    if not isinstance(operand_val, FunctionClosure):
+        raise ClassiqInternalExpansionError
+    operand_val.signature_scope.update(
+        {
+            identifier: value
+            for identifier, value in closure.scope.data.items()
+            if identifier in parameter_names
+        }
+    )
+
+
+def _cast(
+    quantum_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+) -> QuantumSymbol:
+    updated_quantum_type = quantum_type.copy()
+    _inject_quantum_arg_info_to_type(updated_quantum_type, quantum_symbol, param_name)
+    return QuantumSymbol(
+        handle=quantum_symbol.handle, quantum_type=updated_quantum_type
+    )
+
+
+def _evaluate_type_from_arg(
+    parameter: PositionalArg, argument: Evaluated, inner_scope: Scope
+) -> PositionalArg:
+    if not isinstance(parameter, PortDeclaration):
+        return parameter
+
+    updated_quantum_type: QuantumType = evaluate_type_in_quantum_symbol(
+        parameter.quantum_type.copy(), inner_scope, parameter.name
+    )
+    if parameter.direction != PortDeclarationDirection.Output:
+        updated_quantum_type = _inject_quantum_arg_info_to_type(
+            updated_quantum_type, argument.as_type(QuantumSymbol), parameter.name
+        )
+    return parameter.copy(update={"quantum_type": updated_quantum_type})
+
+
+def evaluate_type_in_quantum_symbol(
+    type_to_update: QuantumType, scope: Scope, param_name: str
+) -> ConcreteQuantumType:
+    if isinstance(type_to_update, QuantumBitvector):
+        return _evaluate_qarray_in_quantum_symbol(type_to_update, scope, param_name)
+    elif isinstance(type_to_update, QuantumNumeric):
+        return _evaluate_qnum_in_quantum_symbol(type_to_update, scope, param_name)
+    elif isinstance(type_to_update, TypeName):
+        return _evaluate_qstruct_in_quantum_symbol(type_to_update, scope, param_name)
+    else:
+        assert isinstance(type_to_update, QuantumBit)
+        return type_to_update
+
+
+def _evaluate_qarray_in_quantum_symbol(
+    type_to_update: QuantumBitvector, scope: Scope, param_name: str
+) -> QuantumBitvector:
+    new_element_type = evaluate_type_in_quantum_symbol(
+        type_to_update.element_type, scope, param_name
+    )
+    set_element_type(type_to_update, new_element_type)
+    if type_to_update.length is not None:
+        new_length = evaluate_classical_expression(
+            type_to_update.length, scope
+        ).as_type(int)
+        set_length(type_to_update, new_length)
+    return type_to_update
+
+
+def _evaluate_qnum_in_quantum_symbol(
+    type_to_update: QuantumNumeric, scope: Scope, param_name: str
+) -> QuantumNumeric:
+    if type_to_update.is_signed is not None:
+        new_is_sign = evaluate_classical_expression(
+            type_to_update.is_signed, scope
+        ).as_type(bool)
+        set_is_signed(type_to_update, new_is_sign, param_name)
+    if type_to_update.fraction_digits is not None:
+        new_fraction_digits = evaluate_classical_expression(
+            type_to_update.fraction_digits, scope
+        ).as_type(int)
+        set_fraction_digits(type_to_update, new_fraction_digits, param_name)
+    if type_to_update.size is not None:
+        new_size = evaluate_classical_expression(type_to_update.size, scope).as_type(
+            int
+        )
+        set_size(type_to_update, new_size, param_name)
+    return type_to_update
+
+
+def _evaluate_qstruct_in_quantum_symbol(
+    type_to_update: TypeName, scope: Scope, param_name: str
+) -> TypeName:
+    new_fields = {
+        field_name: evaluate_type_in_quantum_symbol(field_type, scope, param_name)
+        for field_name, field_type in type_to_update.fields.items()
+    }
+    set_struct_fields(type_to_update, new_fields)
+    return type_to_update
+
+
+def evaluate_types_in_quantum_symbols(
+    symbols: List[QuantumSymbol], scope: Scope
+) -> List[QuantumSymbol]:
+    return [
+        QuantumSymbol(
+            handle=symbol.handle,
+            quantum_type=evaluate_type_in_quantum_symbol(
+                symbol.quantum_type, scope, str(symbol.handle)
+            ),
+        )
+        for symbol in symbols
+    ]
+
+
+def _inject_quantum_arg_info_to_type(
+    parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+) -> QuantumType:
+    copy_type_information(
+        quantum_symbol.quantum_type,
+        parameter_type,
+        param_name,
+    )
+    return parameter_type