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

classiq/interface/generator/functions/register_mapping_data.py

@@ -1,102 +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
-
-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 ValueError("overlapping input qubits are not allowed")
-        if not cls._validate_no_overlap(output_qubits):
-            raise ValueError("overlapping output qubits are not allowed")
-
-        if not output_qubits == all_input_qubits:
-            raise ValueError(
-                "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 ValueError("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(
-            list(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 ValueError("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 ValueError(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 ValueError(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.model.model 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,63 +0,0 @@
-from typing import 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,
-)
-
-
-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, values):
-        end_state_vector = values.get("end_state_vector")
-        num_qubits = cls._num_qubits(end_state_vector)
-        if len(start_state_vector) == 0:
-            default_start_state_vector = [0.0 for _ in range(2**num_qubits)]
-            default_start_state_vector[0] = 1.0
-            start_state_vector = default_start_state_vector
-
-        if len(start_state_vector) != len(end_state_vector):
-            raise ValueError("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/generator/types/builtin_struct_declarations/__init__.py

@@ -1,2 +0,0 @@
-from .pauli_struct_declarations import *  # noqa: F403
-from .qaoa_declarations import *  # noqa: F403

classiq/interface/generator/types/builtin_struct_declarations/pauli_struct_declarations.py

@@ -1,22 +0,0 @@
-import functools
-
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
-    Pauli,
-    Real,
-    Struct,
-)
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-
-PAULI_TERM = StructDeclaration(
-    name="PauliTerm",
-    variables={
-        "pauli": ClassicalList(element_type=Pauli()),
-        "coefficient": Real(),
-    },
-)
-
-Hamiltonian = functools.partial(ClassicalList, element_type=Struct(name="PauliTerm"))
-
-StructDeclaration.BUILTIN_STRUCT_DECLARATIONS.update(nameables_to_dict([PAULI_TERM]))

classiq/interface/generator/types/builtin_struct_declarations/qaoa_declarations.py

@@ -1,23 +0,0 @@
-from classiq.interface.generator.functions.classical_function_declaration import (
-    ClassicalFunctionDeclaration,
-)
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
-    Integer,
-    Real,
-    Struct,
-)
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-
-COMPUTE_QAOA_INITIAL_POINT = ClassicalFunctionDeclaration(
-    name="compute_qaoa_initial_point",
-    param_decls={
-        "hamiltonian": ClassicalList(element_type=Struct(name="PauliTerm")),
-        "repetitions": Integer(),
-    },
-    return_type=ClassicalList(element_type=Real()),
-)
-
-ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS.update(
-    nameables_to_dict([COMPUTE_QAOA_INITIAL_POINT])
-)

classiq/interface/generator/types/combinatorial_problem.py

@@ -1,26 +0,0 @@
-from enum import Enum
-from typing import List
-
-import pydantic
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-
-
-class ObjectiveType(Enum):
-    Min = "Min"
-    Max = "Max"
-
-
-class CombinatorialOptimizationStructDeclaration(StructDeclaration):
-    variable_lower_bound: int = pydantic.Field(default=0)
-    variable_upper_bound: int = pydantic.Field(default=1)
-    constraints: List[Expression] = pydantic.Field(
-        default_factory=list, description="List of constraint expressions"
-    )
-    objective_type: ObjectiveType = pydantic.Field(
-        description="Specify whether the optimization problem is Min or Max"
-    )
-    objective_function: Expression = pydantic.Field(
-        description="The expression to optimize, according to the objective type"
-    )

classiq/interface/ide/show.py

@@ -1,34 +0,0 @@
-import re
-
-import pydantic
-
-from classiq.interface.analyzer.result import QasmCode
-
-from classiq import GeneratedCircuit
-from classiq._internals.api_wrapper import ApiWrapper
-from classiq._internals.async_utils import syncify_function
-from classiq.exceptions import ClassiqValueError
-from classiq.synthesis import SerializedQuantumProgram
-
-QASM_VERSION_REGEX = re.compile("OPENQASM (\\d*.\\d*);")
-
-
-async def qasm_show_interactive_async(qasm_code: str) -> None:
-    circuit = await ApiWrapper.get_generated_circuit_from_qasm(QasmCode(code=qasm_code))
-    circuit.show()  # type: ignore[attr-defined]
-
-
-qasm_show_interactive = syncify_function(qasm_show_interactive_async)
-
-
-CANT_PARSE_QUANTUM_PROGRAM_MSG = (
-    "Can not parse quantum_program into GeneratedCircuit, \n"
-)
-
-
-def show(quantum_program: SerializedQuantumProgram) -> None:
-    try:
-        circuit = GeneratedCircuit.parse_raw(quantum_program)
-    except pydantic.error_wrappers.ValidationError as exc:
-        raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
-    circuit.show()  # type: ignore[attr-defined]

classiq/interface/model/common_model_types.py

@@ -1,23 +0,0 @@
-from typing import TypeVar, Union
-
-from pydantic import BaseModel
-
-from classiq.interface.generator.model.model import (
-    SerializedModel as SerializedSynthesisModel,
-    SynthesisModel,
-)
-from classiq.interface.model.model import (
-    Model as UserModel,
-    SerializedModel as SerializedUserModel,
-)
-
-ModelInput = Union[UserModel, SynthesisModel]
-
-
-class ModelRoot(BaseModel):
-    __root__: ModelInput
-
-
-SerializedModelInput = TypeVar(
-    "SerializedModelInput", SerializedSynthesisModel, SerializedUserModel
-)

classiq/interface/model/numeric_reinterpretation.py

@@ -1,25 +0,0 @@
-from typing import Mapping
-
-import pydantic
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_statement import QuantumOperation
-
-from classiq.exceptions import ClassiqValueError
-
-
-class NumericReinterpretationOperation(QuantumOperation):
-    target: HandleBinding
-    fraction_digits: Expression
-    is_signed: Expression
-
-    @property
-    def wiring_inouts(self) -> Mapping[str, HandleBinding]:
-        return {"target": self.target}
-
-    @pydantic.validator("target")
-    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
-        if not handle.is_bindable():
-            raise ClassiqValueError(f"Cannot bind '{handle}'")  # noqa: B907
-        return handle

classiq/interface/model/operator_synthesis_data.py

@@ -1,48 +0,0 @@
-from typing import Any, Dict, Optional
-
-from classiq.interface.generator.control_state import ControlState
-
-
-class OperatorSynthesisData:
-    @property
-    def call_kwargs(self) -> Dict[str, Any]:
-        return dict()
-
-
-class PowerOperatorSynthesisData(OperatorSynthesisData):
-    def __init__(self, power: int) -> None:
-        self._power = power
-
-    @property
-    def call_kwargs(self) -> Dict[str, Any]:
-        return {"power": self._power}
-
-
-class InvertOperatorSynthesisData(OperatorSynthesisData):
-    @property
-    def call_kwargs(self) -> Dict[str, Any]:
-        return {"is_inverse": True}
-
-
-class ControlOperatorSynthesisData(OperatorSynthesisData):
-    _CTRL_VAR_NAME = "ctrl"
-
-    def __init__(self, ctrl_size: int, ctrl_state: Optional[str] = None) -> None:
-        ctrl_state_kwargs = dict()
-        if ctrl_state is not None:
-            ctrl_state_kwargs["ctrl_state"] = ctrl_state
-        self._ctrl_state = ControlState(
-            name=self._CTRL_VAR_NAME, num_ctrl_qubits=ctrl_size, **ctrl_state_kwargs
-        )
-
-    @property
-    def call_kwargs(self) -> Dict[str, Any]:
-        return {
-            "control_states": [self._ctrl_state],
-        }
-
-
-class ComputeOperatorSynthesisData(OperatorSynthesisData):
-    @property
-    def call_kwargs(self) -> Dict[str, Any]:
-        return {"should_control": False}

classiq/interface/model/quantum_expressions/control_state.py

@@ -1,38 +0,0 @@
-from classiq.exceptions import ClassiqValueError
-
-
-def min_unsigned_bit_length(number: int) -> int:
-    if number < 0:
-        raise ClassiqValueError(
-            f"Quantum register is not signed but control value "  # noqa: B907
-            f"'{number}' is negative"
-        )
-    return 1 if number == 0 else number.bit_length()
-
-
-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, is_signed: bool) -> str:
-    required_bits = min_bit_length(value, is_signed)
-    if bits < required_bits:
-        raise ClassiqValueError(
-            f"Cannot express '{value}' using {bits} bits: "  # noqa: B907
-            f"at least {required_bits} bits are required"
-        )
-    if value >= 0:
-        return bin(value)[2:].zfill(bits)[::-1]
-    mask = (1 << bits) - 1
-    value = (abs(value) ^ mask) + 1
-    return bin(value)[:1:-1].rjust(bits, "1")