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

classiq/interface/model/quantum_if_operation.py

@@ -1,95 +0,0 @@
-from typing import TYPE_CHECKING, Optional
-
-import pydantic
-from sympy import Equality
-from sympy.core.numbers import Integer
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.qmod_qnum_proxy import QmodQNumProxy
-from classiq.interface.model.quantum_expressions.control_state import (
-    min_bit_length,
-    to_twos_complement,
-)
-from classiq.interface.model.quantum_expressions.quantum_expression import (
-    QuantumExpressionOperation,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-if TYPE_CHECKING:
-    from classiq.interface.model.quantum_function_call import QuantumOperand
-
-
-QUANTUM_IF_INOUT_NAME = "ctrl"
-QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT = (
-    "quantum_if condition must be of the form '<quantum-variable> == "
-    "<classical-integer-expression>', but condition's {}-hand side was {!r}"
-)
-
-
-class QuantumIfOperation(QuantumExpressionOperation):
-    then: "QuantumOperand"
-    _ctrl: Optional[QmodQNumProxy] = pydantic.PrivateAttr(
-        default=None,
-    )
-    _ctrl_val: Optional[int] = pydantic.PrivateAttr(
-        default=None,
-    )
-
-    @property
-    def condition(self) -> Expression:
-        return self.expression
-
-    @property
-    def ctrl(self) -> QmodQNumProxy:
-        assert self._ctrl is not None
-        return self._ctrl
-
-    @property
-    def ctrl_val(self) -> int:
-        assert self._ctrl_val is not None
-        return self._ctrl_val
-
-    def resolve_condition(self) -> None:
-        condition = self.condition.value.value
-        if not isinstance(condition, Equality):
-            raise ClassiqValueError(
-                f"quantum_if condition must be an equality, was {str(condition)!r}"
-            )
-        ctrl, ctrl_val = condition.args
-        if isinstance(ctrl, Integer) and isinstance(ctrl_val, QmodQNumProxy):
-            ctrl, ctrl_val = ctrl_val, ctrl
-        if not isinstance(ctrl, QmodQNumProxy):
-            raise ClassiqValueError(
-                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format("left", str(ctrl))
-            )
-        if not isinstance(ctrl_val, Integer):
-            raise ClassiqValueError(
-                QUANTUM_IF_CONDITION_ARG_ERROR_MESSAGE_FORMAT.format(
-                    "right", str(ctrl_val)
-                )
-            )
-        self._ctrl, self._ctrl_val = ctrl, int(ctrl_val)
-
-    @property
-    def ctrl_state(self) -> str:
-        is_signed = self.ctrl.is_signed
-        fraction_places = self.ctrl.fraction_digits
-        ctrl_size = len(self.ctrl)
-        if not is_signed and self.ctrl_val < 0:
-            raise ClassiqValueError(
-                f"Variable {str(self.ctrl)!r} is not signed but control value "
-                f"{self.ctrl_val} is negative"
-            )
-        required_qubits = min_bit_length(self.ctrl_val, is_signed)
-        if ctrl_size < required_qubits:
-            raise ClassiqValueError(
-                f"Variable {str(self.ctrl)!r} has {ctrl_size} qubits but control value "
-                f"{str(self.ctrl_val)!r} requires at least {required_qubits} qubits"
-            )
-        if fraction_places != 0:
-            raise ClassiqValueError(
-                f"quantum-if on a non-integer quantum variable {str(self.ctrl)!r} is "
-                f"not supported at the moment"
-            )
-        return to_twos_complement(self.ctrl_val, ctrl_size, is_signed)

classiq/interface/model/resolvers/function_call_resolver.py

@@ -1,43 +0,0 @@
-from typing import Any, Mapping
-
-from classiq.interface.generator.visitor import Visitor
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-
-
-class FunctionCallResolver(Visitor):
-    def __init__(
-        self,
-        quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
-    ) -> None:
-        self._quantum_function_dict = quantum_function_dict
-
-    def visit_QuantumFunctionCall(self, fc: QuantumFunctionCall) -> None:
-        fc.resolve_function_decl(self._quantum_function_dict, check_operands=True)
-        self.visit_BaseModel(fc)
-
-    def visit_NativeFunctionDefinition(
-        self, func_def: NativeFunctionDefinition
-    ) -> None:
-        curr_dict = self._quantum_function_dict
-        self._quantum_function_dict = {
-            **self._quantum_function_dict,
-            **func_def.operand_declarations,
-        }
-        self.visit_BaseModel(func_def)
-        self._quantum_function_dict = curr_dict
-
-
-def resolve_function_calls(
-    root: Any,
-    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
-) -> None:
-    FunctionCallResolver(
-        {
-            **QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS,
-            **quantum_function_dict,
-        },
-    ).visit(root)

classiq/interface/model/validations/handle_validation_base.py

@@ -1,55 +0,0 @@
-import abc
-from typing import Dict, Mapping, Type
-
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.validation_handle import HandleState, ValidationHandle
-
-EXPECTED_TERMINAL_STATES: Dict[PortDeclarationDirection, HandleState] = {
-    PortDeclarationDirection.Output: HandleState.INITIALIZED,
-    PortDeclarationDirection.Inout: HandleState.INITIALIZED,
-}
-
-
-class HandleValidationBase(abc.ABC):
-    def __init__(
-        self,
-        port_declarations: Mapping[str, PortDeclaration],
-    ) -> None:
-        self._port_declarations = port_declarations.values()
-
-    def report_errored_handles(self, exception_type: Type[Exception]) -> None:
-        self._validate_terminal_handle_state()
-
-        errored_handles = {
-            name: state.errors
-            for name, state in self._validation_handles_state.items()
-            if state.state is HandleState.ERRORED
-        }
-        if errored_handles:
-            raise exception_type(
-                "\n".join(
-                    f"Handle {handle_name!r} was errored with {'. '.join(errors)!r}"
-                    for handle_name, errors in errored_handles.items()
-                )
-            )
-
-    def _validate_terminal_handle_state(self) -> None:
-        for port_decl in self._port_declarations:
-            handle_state = self._validation_handles_state[port_decl.name]
-            expected_terminal_state = EXPECTED_TERMINAL_STATES.get(port_decl.direction)
-            if (
-                expected_terminal_state is not None
-                and handle_state.state is not expected_terminal_state
-                and handle_state.state is not HandleState.ERRORED
-            ):
-                handle_state.append_error(
-                    f"At the end of the function, in port {port_decl.name} is expected to be {expected_terminal_state} but it isn't"
-                )
-
-    @property
-    @abc.abstractmethod
-    def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
-        raise NotImplementedError

classiq/interface/model/validations/handles_validator.py

@@ -1,154 +0,0 @@
-from typing import Dict, Mapping, Set, Union
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
-    APPLY,
-    OPERAND_FIELD_NAME,
-)
-from classiq.interface.model.handle_binding import (
-    HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-)
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
-from classiq.interface.model.quantum_statement import QuantumOperation
-from classiq.interface.model.validation_handle import HandleState, ValidationHandle
-from classiq.interface.model.validations.handle_validation_base import (
-    HandleValidationBase,
-)
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-
-def _initialize_handles_to_state(
-    port_declarations: Mapping[str, PortDeclaration],
-) -> Dict[str, ValidationHandle]:
-    handles_to_state: Dict[str, ValidationHandle] = dict()
-
-    for port_decl in port_declarations.values():
-        handles_to_state[port_decl.name] = ValidationHandle(
-            initial_state=(
-                HandleState.INITIALIZED
-                if port_decl.direction.includes_port_direction(PortDirection.Input)
-                else HandleState.UNINITIALIZED
-            )
-        )
-
-    return handles_to_state
-
-
-class HandleValidator(HandleValidationBase):
-    def __init__(
-        self,
-        port_declarations: Mapping[str, PortDeclaration],
-    ) -> None:
-        super().__init__(port_declarations)
-        self._port_declarations = port_declarations.values()
-        self._handles_to_state = _initialize_handles_to_state(port_declarations)
-
-    @property
-    def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
-        return self._handles_to_state
-
-    def handle_call(self, call: QuantumOperation) -> None:
-        if isinstance(call, QuantumFunctionCall) and call.function == APPLY.name:
-            self._handle_apply(call)
-        self._handle_inputs(call.wiring_inputs)
-        self._handle_outputs(call.wiring_outputs)
-        self._handle_inouts(call.wiring_inouts)
-
-    def handle_variable_declaration(
-        self, declaration: VariableDeclarationStatement
-    ) -> None:
-        handle_wiring_state = self._handles_to_state.get(declaration.name)
-        if handle_wiring_state is not None:
-            handle_wiring_state.append_error(
-                f"Trying to declare a variable of the same name as previously declared variable {declaration.name}"
-            )
-            return
-
-        self._handles_to_state[declaration.name] = ValidationHandle(
-            HandleState.UNINITIALIZED
-        )
-
-    def _handle_inputs(self, inputs: Mapping[str, HandleBinding]) -> None:
-        for handle_binding in inputs.values():
-            handle_wiring_state = self._handles_to_state[handle_binding.name]
-            if handle_wiring_state.state is not HandleState.INITIALIZED:
-                handle_wiring_state.append_error(
-                    f"Trying to access handle {handle_binding.name!r} as input but it is in incorrect state"
-                )
-                continue
-
-            handle_wiring_state.uninitialize()
-
-    def _handle_outputs(self, outputs: Mapping[str, HandleBinding]) -> None:
-        for handle_binding in outputs.values():
-            handle_wiring_state = self._handles_to_state[handle_binding.name]
-
-            if handle_wiring_state.state is not HandleState.UNINITIALIZED:
-                handle_wiring_state.append_error(
-                    f"Trying to access handle {handle_binding.name!r} as output but it is in incorrect state"
-                )
-                continue
-
-            handle_wiring_state.initialize()
-
-    def _handle_inouts(
-        self,
-        inouts: Mapping[
-            str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-        ],
-    ) -> None:
-        sliced_handles = set()
-        whole_handles = set()
-
-        for handle_binding in inouts.values():
-            handle_wiring_state = self._handles_to_state[handle_binding.name]
-
-            if handle_wiring_state.state is not HandleState.INITIALIZED:
-                handle_wiring_state.append_error(
-                    f"Trying to access handle {handle_binding.name!r} as inout but it is in incorrect state"
-                )
-
-            if isinstance(
-                handle_binding, (SlicedHandleBinding, SubscriptHandleBinding)
-            ):
-                sliced_handles.add(handle_binding.name)
-            else:
-                whole_handles.add(handle_binding.name)
-
-        for handle in sliced_handles & whole_handles:
-            self._handles_to_state[handle].append_error(
-                f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
-            )
-
-    def _handle_apply(self, call: QuantumFunctionCall) -> None:
-        operand = call.operands[OPERAND_FIELD_NAME]
-        if not isinstance(operand, QuantumLambdaFunction):
-            return
-        local_variables: Set[str] = set()
-        output_capturing_variables: Set[str] = set()
-        for statement in operand.body:
-            if isinstance(statement, VariableDeclarationStatement):
-                local_variables.add(statement.name)
-            elif isinstance(statement, QuantumOperation):
-                for handle in statement.wiring_outputs.values():
-                    if (
-                        handle.name in local_variables
-                        or handle.name in output_capturing_variables
-                    ):
-                        continue
-                    output_capturing_variables.add(handle.name)
-                    self._handles_to_state[handle.name].initialize()
-            else:
-                raise ClassiqValueError(
-                    f"Unknown statement type {type(statement).__name__}"
-                )

classiq/interface/model/validations/port_to_wire_name_generator.py

@@ -1,12 +0,0 @@
-import typing
-from collections import Counter
-
-
-class PortToWireNameGenerator:
-    def __init__(self) -> None:
-        self._name_counter: typing.Counter[str] = Counter()
-
-    def get(self, port_name: str) -> str:
-        counter = self._name_counter[port_name]
-        self._name_counter[port_name] += 1
-        return f"{port_name}_{counter}"

classiq/model/__init__.py

@@ -1,14 +0,0 @@
-from typing import List
-
-from classiq.interface.generator.model import *  # noqa: F403
-from classiq.interface.generator.model import __all__ as _model_all
-
-from classiq.model.composite_function_generator import FunctionGenerator
-from classiq.model.model import Model
-
-__all__ = ["FunctionGenerator", "Model"]
-__all__.extend(_model_all)
-
-
-def __dir__() -> List[str]:
-    return __all__

classiq/model/composite_function_generator.py

@@ -1,33 +0,0 @@
-from typing import List
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.functions import SynthesisNativeFunctionDefinition
-from classiq.interface.generator.quantum_function_call import (
-    SynthesisQuantumFunctionCall,
-)
-
-from classiq.model import function_handler
-from classiq.quantum_functions.function_library import FunctionLibrary
-
-
-class FunctionGenerator(function_handler.FunctionHandler):
-    def __init__(self, function_name: str) -> None:
-        super().__init__()
-        self._name = function_name
-        self._logic_flow_list: List[SynthesisQuantumFunctionCall] = list()
-
-    @property
-    def _body(self) -> List[SynthesisQuantumFunctionCall]:
-        return self._logic_flow_list
-
-    def to_function_definition(self) -> SynthesisNativeFunctionDefinition:
-        return SynthesisNativeFunctionDefinition(
-            name=self._name,
-            body=self._body,
-            port_declarations=self._port_declarations,
-            input_ports_wiring=self._external_port_wiring[PortDirection.Input],
-            output_ports_wiring=self._external_port_wiring[PortDirection.Output],
-        )
-
-    def create_library(self) -> None:
-        self.include_library(FunctionLibrary())