classiq 0.42.2__py3-none-any.whl → 0.43.1__py3-none-any.whl

classiq/interface/generator/functions/quantum_function_declaration.py

@@ -1,69 +0,0 @@
-from typing import Dict, Set
-
-import pydantic
-from pydantic import BaseModel
-
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import (
-    ArithmeticIODict,
-    IOName,
-    PortDirection,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    SynthesisPortDeclaration,
-)
-from classiq.interface.helpers.validation_helpers import validate_nameables_mapping
-
-
-class SynthesisQuantumFunctionDeclaration(BaseModel):
-    """
-    Facilitates the creation of a common quantum function interface object.
-    """
-
-    name: str = pydantic.Field(description="The name of the function")
-
-    port_declarations: Dict[IOName, SynthesisPortDeclaration] = pydantic.Field(
-        description="The input and output ports of the function.",
-        default_factory=dict,
-    )
-
-    @property
-    def input_set(self) -> Set[IOName]:
-        return set(self.inputs.keys())
-
-    @property
-    def output_set(self) -> Set[IOName]:
-        return set(self.outputs.keys())
-
-    @property
-    def inputs(self) -> ArithmeticIODict:
-        return _ports_to_registers(self.port_declarations, PortDirection.Input)
-
-    @property
-    def outputs(self) -> ArithmeticIODict:
-        return _ports_to_registers(self.port_declarations, PortDirection.Output)
-
-    @pydantic.validator("port_declarations")
-    def _validate_port_declarations_names(
-        cls, port_declarations: Dict[IOName, SynthesisPortDeclaration]
-    ) -> Dict[IOName, SynthesisPortDeclaration]:
-        validate_nameables_mapping(port_declarations, "Port")
-        return port_declarations
-
-    class Config:
-        extra = pydantic.Extra.forbid
-
-
-def _ports_to_registers(
-    port_declarations: Dict[IOName, SynthesisPortDeclaration], direction: PortDirection
-) -> ArithmeticIODict:
-    return {
-        name: RegisterUserInput(
-            name=name,
-            size=port_decl.size,
-            is_signed=port_decl.is_signed,
-            fraction_places=port_decl.fraction_places,
-        )
-        for name, port_decl in port_declarations.items()
-        if port_decl.direction.includes_port_direction(direction)
-    }

classiq/interface/generator/functions/register.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from operator import attrgetter
-from typing import Iterable, Tuple
-
-import pydantic
-from pydantic import BaseModel
-
-from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-
-from classiq.exceptions import ClassiqValueError
-
-QubitsType = Tuple[pydantic.NonNegativeInt, ...]
-
-
-class Register(BaseModel):
-    """
-    A user-defined custom register.
-    """
-
-    name: PydanticNonEmptyString = pydantic.Field(
-        description="The name of the custom register",
-    )
-
-    qubits: QubitsType = pydantic.Field(
-        description="A tuple of qubits as integers as indexed within a custom function code",
-    )
-
-    @property
-    def width(self) -> pydantic.PositiveInt:
-        """The number of qubits of the custom register"""
-        return len(self.qubits)
-
-    @pydantic.validator("qubits")
-    def validate_qubits(cls, qubits: QubitsType) -> QubitsType:
-        if len(qubits) == 0:
-            raise ClassiqValueError("qubits field must be non-empty.")
-        if len(set(qubits)) != len(qubits):
-            raise ClassiqValueError("All qubits of a register must be distinct.")
-        return qubits
-
-
-def get_register_names(reg_list: Iterable[Register]) -> Iterable[str]:
-    return map(attrgetter("name"), reg_list)

classiq/interface/generator/functions/register_mapping_data.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-import itertools
-from typing import Any, Dict, Iterable, List, Tuple
-
-import pydantic
-
-from classiq.interface.generator.functions.register import Register, get_register_names
-from classiq.interface.generator.register_role import RegisterRole as Role
-from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-
-from classiq.exceptions import ClassiqValueError
-
-REGISTER_NOT_FOUND_ERROR = "Register name not found"
-
-
-class RegisterMappingData(pydantic.BaseModel):
-    input_registers: List[Register] = pydantic.Field(default_factory=list)
-    output_registers: List[Register] = pydantic.Field(default_factory=list)
-    zero_input_registers: List[Register] = pydantic.Field(default_factory=list)
-
-    @pydantic.root_validator()
-    def validate_mapping(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        input_registers = values.get("input_registers", list())
-        output_registers = values.get("output_registers", list())
-        zero_input_registers = values.get("zero_input_registers", list())
-
-        input_qubits = cls._get_qubit_range(input_registers)
-        output_qubits = cls._get_qubit_range(output_registers)
-        zero_input_qubits = cls._get_qubit_range(zero_input_registers)
-
-        all_input_qubits = sorted(input_qubits + zero_input_qubits)
-        if not cls._validate_no_overlap(all_input_qubits):
-            raise ClassiqValueError("overlapping input qubits are not allowed")
-        if not cls._validate_no_overlap(output_qubits):
-            raise ClassiqValueError("overlapping output qubits are not allowed")
-
-        if not output_qubits == all_input_qubits:
-            raise ClassiqValueError(
-                "output registers should be included within the input / zero input registers"
-            )
-
-        return values
-
-    @pydantic.validator("input_registers", "output_registers")
-    def validate_input_registers_are_distinct(
-        cls, field_value: List[Register]
-    ) -> List[Register]:
-        if len(field_value) != len({io_register.name for io_register in field_value}):
-            raise ClassiqValueError(
-                "The names of PortDirection registers must be distinct."
-            )
-        return field_value
-
-    @staticmethod
-    def _validate_no_overlap(reg_list: List[int]) -> bool:
-        return len(reg_list) == len(set(reg_list))
-
-    @staticmethod
-    def _get_qubit_range(registers: Iterable[Register]) -> List[int]:
-        return sorted(itertools.chain.from_iterable(reg.qubits for reg in registers))
-
-    @property
-    def input_names(self) -> Iterable[str]:
-        return get_register_names(self.input_registers)
-
-    @property
-    def output_names(self) -> Iterable[str]:
-        return get_register_names(self.output_registers)
-
-    def validate_equal_mappings(self, other: RegisterMappingData) -> None:
-        if any(
-            [
-                self.input_registers != other.input_registers,
-                self.output_registers != other.output_registers,
-                self.zero_input_registers != other.zero_input_registers,
-            ]
-        ):
-            raise ClassiqValueError(
-                "Interface should be identical in all implementations"
-            )
-
-    def get_input_register(self, name: PydanticNonEmptyString) -> Register:
-        for reg in self.input_registers:
-            if reg.name == name:
-                return reg
-        raise ClassiqValueError(REGISTER_NOT_FOUND_ERROR)
-
-    def get_output_register(self, name: PydanticNonEmptyString) -> Register:
-        for reg in self.output_registers:
-            if reg.name == name:
-                return reg
-        raise ClassiqValueError(REGISTER_NOT_FOUND_ERROR)
-
-    @staticmethod
-    def from_registers_dict(
-        regs_dict: Dict[Role, Tuple[Register, ...]]
-    ) -> RegisterMappingData:
-        return RegisterMappingData(
-            input_registers=list(regs_dict[Role.INPUT]),
-            output_registers=list(regs_dict[Role.OUTPUT]),
-            zero_input_registers=list(regs_dict[Role.ZERO_INPUT]),
-        )
-
-    class Config:
-        extra = "forbid"

classiq/interface/generator/inequality_mixer.py

@@ -1,51 +0,0 @@
-import pydantic
-
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.argument_utils import RegisterOrConst
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.parameters import ParameterFloatType
-
-DATA_REG_INPUT_NAME: str = "data_reg_input"
-BOUND_REG_INPUT_NAME: str = "bound_reg_input"
-
-DATA_REG_OUTPUT_NAME: str = "data_reg_output"
-BOUND_REG_OUTPUT_NAME: str = "bound_reg_output"
-
-
-class InequalityMixer(function_params.FunctionParams):
-    """
-    Mixing a fixed point number variable below a given upper bound or above a given
-    lower bound. i.e. after applying this function the variable will hold a
-    superposition position of all the valid values.
-    """
-
-    data_reg_input: RegisterArithmeticInfo = pydantic.Field(
-        description="The input variable to mix."
-    )
-
-    bound_reg_input: RegisterOrConst = pydantic.Field(
-        description="Fixed number or variable that define the upper or lower bound for"
-        " the mixing operation. In case of a fixed number bound, the value"
-        " must be positive."
-    )
-
-    mixer_parameter: ParameterFloatType = pydantic.Field(
-        description="The parameter used for rotation gates in the mixer.",
-        is_exec_param=True,
-    )
-
-    is_less_inequality: bool = pydantic.Field(
-        default=True,
-        description="Whether to mix below or above a certain bound."
-        "Less inequality mixes between 0 and the given bound."
-        "Greater inequality mixes between the bound and the maximal number allowed by"
-        " the number of qubits (i.e 2^n - 1).",
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {DATA_REG_INPUT_NAME: self.data_reg_input}
-        self._outputs = {DATA_REG_OUTPUT_NAME: self.data_reg_input}
-
-        if isinstance(self.bound_reg_input, RegisterArithmeticInfo):
-            self._inputs[BOUND_REG_INPUT_NAME] = self.bound_reg_input
-            self._outputs[BOUND_REG_OUTPUT_NAME] = self.bound_reg_input

classiq/interface/generator/model/classical_main_validator.py

@@ -1,106 +0,0 @@
-import ast
-from typing import Dict, List
-
-from classiq.executor import DEFAULT_RESULT_NAME
-
-STANDARD_CMAIN_BODY_LENGTH = 2  # assignment of sample call, save statement
-
-
-class NonStandardClassicalCodeError(Exception):
-    pass
-
-
-# `is_standard_cmain` and `extract_sample_params` could easily be merged to one function, as they
-# are doing similar tasks, but we decided to separate them for the sake of a better interface
-def is_standard_cmain(model_classical_execution_code: str) -> bool:
-    try:
-        classical_body = _get_classical_body(model_classical_execution_code)
-        if len(classical_body) != STANDARD_CMAIN_BODY_LENGTH:
-            return False
-
-        _assert_sample_call(classical_body)
-        _assert_save_statement(classical_body)
-
-        return True
-    except NonStandardClassicalCodeError:
-        return False
-
-
-def extract_sample_params(model_classical_execution_code: str) -> Dict[str, float]:
-    classical_main = _get_classical_body(model_classical_execution_code)
-
-    qmain_params: Dict[str, float] = {}
-    sample_call = _get_sample_call(classical_main)
-    if len(sample_call.args) == 1 and isinstance(sample_call.args[0], ast.Dict):
-        ast_dict = sample_call.args[0]
-        qmain_params = dict(
-            zip(
-                [k.value for k in ast_dict.keys if isinstance(k, ast.Constant)],
-                [v.value for v in ast_dict.values if isinstance(v, ast.Constant)],
-            )
-        )
-
-    return qmain_params
-
-
-def has_classical_exec(model_classical_execution_code: str) -> bool:
-    return model_classical_execution_code != ""
-
-
-def _get_classical_body(model_classical_execution_code: str) -> List[ast.stmt]:
-    if not has_classical_exec(model_classical_execution_code):
-        raise NonStandardClassicalCodeError
-    return ast.parse(model_classical_execution_code).body
-
-
-def _assert_sample_call(classical_body: List[ast.stmt]) -> None:
-    _get_sample_call(classical_body)
-
-
-def _get_sample_call(
-    classical_body: List[ast.stmt],
-) -> ast.Call:
-    classical_call = classical_body[0]
-    if not isinstance(classical_call, ast.Assign):
-        raise NonStandardClassicalCodeError
-
-    if len(classical_call.targets) != 1:
-        raise NonStandardClassicalCodeError
-    target = classical_call.targets[0]
-    if not isinstance(target, ast.Name) or target.id != DEFAULT_RESULT_NAME:
-        raise NonStandardClassicalCodeError
-
-    invoked_expression = classical_call.value
-    if not isinstance(invoked_expression, ast.Call):
-        raise NonStandardClassicalCodeError
-    if (
-        not isinstance(invoked_expression.func, ast.Name)
-        or invoked_expression.func.id != "sample"
-    ):
-        raise NonStandardClassicalCodeError
-
-    return invoked_expression
-
-
-def _assert_save_statement(classical_body: List[ast.stmt]) -> None:
-    save_statement = classical_body[1]
-    if not isinstance(save_statement, ast.Expr) or not isinstance(
-        save_statement.value, ast.Call
-    ):
-        raise NonStandardClassicalCodeError
-
-    call = save_statement.value
-    if not isinstance(call.func, ast.Name) or call.func.id != "save":
-        raise NonStandardClassicalCodeError
-
-    if not len(call.args) == 1:
-        raise NonStandardClassicalCodeError
-
-    if (
-        not isinstance(call.args[0], ast.Dict)
-        or not isinstance(call.args[0].keys[0], ast.Constant)
-        or call.args[0].keys[0].value != DEFAULT_RESULT_NAME
-        or not isinstance(call.args[0].values[0], ast.Name)
-        or call.args[0].values[0].id != DEFAULT_RESULT_NAME
-    ):
-        raise NonStandardClassicalCodeError

classiq/interface/generator/range_mixer.py

@@ -1,56 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.arith.argument_utils import RegisterOrConst
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.generator.parameters import ParameterFloatType
-
-DATA_REG_INPUT_NAME: str = "data_reg_input"
-LOWER_BOUND_REG_INPUT_NAME: str = "lower_bound_reg_input"
-UPPER_BOUND_REG_INPUT_NAME: str = "upper_bound_reg_input"
-
-
-DATA_REG_OUTPUT_NAME: str = "data_reg_output"
-LOWER_BOUND_REG_OUTPUT_NAME: str = "lower_bound_reg_output"
-UPPER_BOUND_REG_OUTPUT_NAME: str = "upper_bound_reg_output"
-
-
-class RangeMixer(FunctionParams):
-    """
-    Mixing a fixed point number variable between a given lower and upper bounds.
-    I.e. after applying this function the variable will hold a
-    superposition of all the valid values.
-    """
-
-    data_reg_input: RegisterArithmeticInfo = pydantic.Field(
-        description="The input variable to mix."
-    )
-
-    lower_bound_reg_input: RegisterOrConst = pydantic.Field(
-        description="Fixed number or variable that define the lower bound for"
-        " the mixing operation. In case of a fixed number bound, the value"
-        " must be positive."
-    )
-
-    upper_bound_reg_input: RegisterOrConst = pydantic.Field(
-        description="Fixed number or variable that define the upper bound for"
-        " the mixing operation. In case of a fixed number bound, the value"
-        " must be positive."
-    )
-
-    mixer_parameter: ParameterFloatType = pydantic.Field(
-        description="The parameter used for rotation gates in the mixer.",
-        is_exec_param=True,
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {DATA_REG_INPUT_NAME: self.data_reg_input}
-        self._outputs = {DATA_REG_OUTPUT_NAME: self.data_reg_input}
-
-        if isinstance(self.lower_bound_reg_input, RegisterArithmeticInfo):
-            self._inputs[LOWER_BOUND_REG_INPUT_NAME] = self.lower_bound_reg_input
-            self._outputs[LOWER_BOUND_REG_OUTPUT_NAME] = self.lower_bound_reg_input
-
-        if isinstance(self.upper_bound_reg_input, RegisterArithmeticInfo):
-            self._inputs[UPPER_BOUND_REG_INPUT_NAME] = self.upper_bound_reg_input
-            self._outputs[UPPER_BOUND_REG_OUTPUT_NAME] = self.upper_bound_reg_input

classiq/interface/generator/state_propagator.py

@@ -1,74 +0,0 @@
-from typing import Any, Dict, List
-
-import numpy as np
-import pydantic
-
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.complex_type import Complex
-from classiq.interface.generator.function_params import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-
-class StatePropagator(function_params.FunctionParams):
-    """
-    Creates a quantum circuit that propagates the start state vector to the end state vector,
-    both are assumed to be pure states.
-    The default start state vector is |000...0>.
-    """
-
-    end_state_vector: List[Complex] = pydantic.Field(
-        description="The desired state vector at the end of the operator."
-        " Must be of size 2**num_qubits. Does not have to be "
-        "normalized"
-    )
-
-    start_state_vector: List[Complex] = pydantic.Field(
-        default_factory=list,
-        description="The  state vector at the input of the operator."
-        " Must be of size 2**num_qubits. Does not have to be"
-        " normalized",
-    )
-
-    @pydantic.validator("start_state_vector", always=True)
-    def validate_start_state(
-        cls, start_state_vector: List[Complex], values: Dict[str, Any]
-    ) -> List[Complex]:
-        end_state_vector = values.get("end_state_vector")
-        if end_state_vector is None:
-            raise ClassiqValueError(
-                "Cannot validate start_start_vector without end_state_vector"
-            )
-
-        num_qubits = cls._num_qubits(end_state_vector)
-        if len(start_state_vector) == 0:
-            default_start_state_vector = [Complex(0.0) for _ in range(2**num_qubits)]
-            default_start_state_vector[0] = Complex(1.0)
-            start_state_vector = default_start_state_vector
-
-        if len(start_state_vector) != len(end_state_vector):
-            raise ClassiqValueError(
-                "Start and end state vectors are of non-equal length"
-            )
-
-        return start_state_vector
-
-    @staticmethod
-    def _num_qubits(vector: List[Complex]) -> int:
-        return int(np.log2(len(vector)))
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            DEFAULT_INPUT_NAME: RegisterArithmeticInfo(
-                size=self._num_qubits(self.start_state_vector)
-            )
-        }
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterArithmeticInfo(
-                size=self._num_qubits(self.end_state_vector)
-            )
-        }

classiq/interface/model/resolvers/function_call_resolver.py

@@ -1,64 +0,0 @@
-import itertools
-from typing import Any, Mapping
-
-from classiq.interface.generator.visitor import Visitor
-from classiq.interface.model.control import Control
-from classiq.interface.model.invert import Invert
-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,
-)
-from classiq.interface.model.repeat import Repeat
-from classiq.interface.model.within_apply_operation import WithinApply
-
-
-class FunctionCallResolver(Visitor):
-    def __init__(
-        self,
-        quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
-    ) -> None:
-        self._quantum_function_dict = quantum_function_dict
-
-    def visit_Invert(self, invert: Invert) -> None:
-        for fc in invert.body:
-            self.visit(fc)
-
-    def visit_Repeat(self, repeat: Repeat) -> None:
-        for fc in repeat.body:
-            self.visit(fc)
-
-    def visit_Control(self, control: Control) -> None:
-        for fc in control.body:
-            self.visit(fc)
-
-    def visit_WithinApply(self, within_apply: WithinApply) -> None:
-        for fc in itertools.chain(within_apply.compute, within_apply.action):
-            self.visit(fc)
-
-    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