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

classiq/interface/generator/credit_risk_example/linear_gci.py

@@ -1,122 +0,0 @@
-from statistics import NormalDist
-from typing import Any, Dict, List, Tuple
-
-import numpy as np
-import pydantic
-
-from classiq.interface.generator import function_params, linear_pauli_rotations
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.helpers.custom_pydantic_types import (
-    PydanticNonOneProbabilityFloat,
-    PydanticProbabilityFloat,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-RHOS_PZEROS_LENGTH_ERROR_MSG = "rhos and p_zeros must have the same length"
-
-
-class LinearGCI(function_params.FunctionParams):
-    """
-    A circuit composed of a series of Y rotations to perform a linear approximation to the Gaussian Conditional
-    Independence model.
-    The model consists of a Bernoulli probability, which itself is a function of a latent random variable x:
-    p(x) = F( (F_inv(p_zero) + x*sqrt(rho))/sqrt(1-rho) )
-    with F being the Gaussian CDF, p_zero is p(x=0) when rho=0, and rho reflects the sensitivity.
-
-    The circuit takes a state register |x> and zero-input target qubits.
-    Each target qubit undergoes the following transformation:
-    |x>|0> -> cos((slope*x + offset)/2)|x>|0> + sin((slope*x + offset)/2)|x>|1>
-    Where the slope and the offset are determined by the linear approximation of the inverse sine of p(x).
-    """
-
-    num_state_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="The number of input qubits"
-    )
-    truncation_value: float = pydantic.Field(
-        description="The truncation value of the latent normal distribution"
-    )
-    p_zeros: List[PydanticProbabilityFloat] = pydantic.Field(
-        description="The probability when the latent normal variable equals zero"
-    )
-    rhos: List[PydanticNonOneProbabilityFloat] = pydantic.Field(
-        description="The sensitivity of the probability to changes in the latent normal variable values"
-    )
-
-    @pydantic.validator("rhos")
-    def validate_rhos(
-        cls, rhos: List[PydanticNonOneProbabilityFloat], values: Dict[str, Any]
-    ) -> List[PydanticNonOneProbabilityFloat]:
-        p_zeros = values.get("p_zeros")
-        if p_zeros is None:
-            raise ClassiqValueError("Cannot validate rhos, p_zeros is missing")
-
-        if len(p_zeros) != len(rhos):
-            raise ClassiqValueError(RHOS_PZEROS_LENGTH_ERROR_MSG)
-        return rhos
-
-    @property
-    def linear_pauli_rotations(self) -> linear_pauli_rotations.LinearPauliRotations:
-        offsets, slopes = get_gci_values(
-            qubit_count_state=self.num_state_qubits,
-            truncation_value=self.truncation_value,
-            rhos=self.rhos,
-            p_zeros=self.p_zeros,
-        )
-        return linear_pauli_rotations.LinearPauliRotations(
-            num_state_qubits=self.num_state_qubits,
-            bases=["Y"] * len(self.rhos),
-            offsets=offsets,
-            slopes=slopes,
-        )
-
-    def _create_ios(self) -> None:
-        state_name = linear_pauli_rotations.STATE
-        target_name = linear_pauli_rotations.TARGET
-        self._inputs = {
-            state_name: RegisterUserInput(name=state_name, size=self.num_state_qubits),
-            target_name: RegisterUserInput(name=target_name, size=len(self.rhos)),
-        }
-        self._outputs = {**self.inputs}
-
-
-def get_gci_values(
-    *,
-    qubit_count_state: int,
-    truncation_value: float,
-    rhos: List[float],
-    p_zeros: List[float],
-) -> Tuple[List[float], List[float]]:
-    qubit_count_target = len(rhos)
-
-    # Qiskit's code below
-
-    # get normal (inverse) CDF and pdf
-    def cdf(x: float) -> float:
-        return NormalDist().cdf(x)
-
-    def inv_cdf(p: float) -> float:
-        return NormalDist().inv_cdf(p)
-
-    def pdf(x: float) -> float:
-        return NormalDist().pdf(x)
-
-    # create linear rotations for conditional defaults
-    slopes = []
-    offsets = []
-    for k in range(qubit_count_target):
-        psi = inv_cdf(p_zeros[k]) / np.sqrt(1 - rhos[k])
-
-        # compute slope / offset
-        slope = -np.sqrt(rhos[k]) / np.sqrt(1 - rhos[k])
-        slope *= pdf(psi) / np.sqrt(1 - cdf(psi)) / np.sqrt(cdf(psi))
-        offset = 2 * np.arcsin(np.sqrt(cdf(psi)))
-
-        # adjust for integer to normal range mapping
-        offset += slope * (-truncation_value)
-        slope *= 2 * truncation_value / (2**qubit_count_state - 1)
-
-        offsets.append(offset)
-        slopes.append(slope)
-
-    return offsets, slopes

classiq/interface/generator/credit_risk_example/weighted_adder.py

@@ -1,69 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-import numpy as np
-import pydantic
-
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import get_zero_input_name
-
-from classiq.exceptions import ClassiqValueError
-
-LENGTH_ERROR_MESSAGE = "Input length error: Length of weights vector has to be identical to the number of input qubits"
-STATE = "state"
-SUM = "sum"
-
-
-class PydanticStrictNonNegativeInteger(pydantic.ConstrainedInt):
-    strict = True
-    ge = 0
-
-
-class WeightedAdder(function_params.FunctionParams):
-    """
-    Creates a circuit implementing a scalar product between an n-qubit state |q1,q2,...,qn> and an n-length non-negative
-    integer vector (w1,w2,...wn), such that the result of the output register is |q1*w1+q2*w2+...qn*wn>.
-    If no weights are provided, they are default to 1 for every qubit.
-    """
-
-    num_state_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="The number of input qubits"
-    )
-    weights: List[PydanticStrictNonNegativeInteger] = pydantic.Field(
-        default=None,
-        description="List of non-negative integers corresponding to the weight of each qubit",
-    )
-
-    @pydantic.validator("weights", always=True, pre=True)
-    def validate_weights(
-        cls,
-        weights: Optional[List[PydanticStrictNonNegativeInteger]],
-        values: Dict[str, Any],
-    ) -> List[PydanticStrictNonNegativeInteger]:
-        num_state_qubits = values.get("num_state_qubits")
-        if num_state_qubits is None:
-            raise ClassiqValueError(
-                "Missing num_state_qubits and weights, either must be provided"
-            )
-        if weights is None:
-            return [PydanticStrictNonNegativeInteger(1)] * num_state_qubits
-        if len(weights) != num_state_qubits:
-            raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
-        return weights
-
-    def num_sum_qubits(self) -> int:
-        sum_weights = np.sum(self.weights)
-        if sum_weights > 0:
-            return 1 + int(np.floor(np.log2(sum_weights)))
-        return 1
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            STATE: RegisterUserInput(name=STATE, size=self.num_state_qubits)
-        }
-        zero_input_name = get_zero_input_name(SUM)
-        self._create_zero_input_registers({zero_input_name: self.num_sum_qubits()})
-        self._outputs = {
-            **self._inputs,
-            SUM: RegisterUserInput(name=SUM, size=self.num_sum_qubits()),
-        }

classiq/interface/generator/expressions/enums/chemistry.py

@@ -1,28 +0,0 @@
-import enum
-from typing import Dict
-
-from sympy import Basic, Integer
-
-from classiq.interface.chemistry.elements import ELEMENTS
-from classiq.interface.chemistry.ground_state_problem import (
-    FermionMapping as LibraryFermionMapping,
-)
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-Element = ClassicalEnum("Element", ELEMENTS)  # type: ignore[call-overload]
-
-
-class MolecularBasis(enum.Enum):
-    sto3g = 0
-
-    def to_sympy(self) -> Basic:
-        return Integer(self.value)
-
-    @staticmethod
-    def sympy_locals() -> Dict[str, Basic]:
-        return {f"Basis_{basis.name}": basis.to_sympy() for basis in MolecularBasis}
-
-
-FermionMapping = ClassicalEnum(  # type: ignore[call-overload]
-    "FermionMapping", [mapping.name for mapping in LibraryFermionMapping]
-)

classiq/interface/generator/expressions/enums/classical_enum.py

@@ -1,20 +0,0 @@
-import enum
-from typing import Any, Mapping
-
-from classiq.interface.helpers.classproperty import classproperty
-
-
-class ClassicalEnum(int, enum.Enum):
-    def __str__(self) -> str:
-        return f"{type(self).__name__}.{self.name}"
-
-    def __repr__(self) -> str:
-        return str(self)
-
-    @classproperty
-    def type_name(cls) -> str:  # noqa: N805
-        return "Enum"
-
-    @classproperty
-    def fields(cls) -> Mapping[str, Any]:  # noqa: N805
-        return {i.name: i for i in cls}  # type:ignore[attr-defined]

classiq/interface/generator/expressions/enums/ladder_operator.py

@@ -1,6 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class LadderOperator(ClassicalEnum):
-    PLUS = 0
-    MINUS = 1

classiq/interface/generator/expressions/enums/optimizers.py

@@ -1,9 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class Optimizer(ClassicalEnum):
-    COBYLA = 1
-    SPSA = 2
-    L_BFGS_B = 3
-    NELDER_MEAD = 4
-    ADAM = 5

classiq/interface/generator/expressions/enums/pauli.py

@@ -1,8 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class Pauli(ClassicalEnum):
-    I = 0  # noqa: E741
-    X = 1
-    Y = 2
-    Z = 3

classiq/interface/generator/expressions/enums/qsvm_feature_map_entanglement.py

@@ -1,9 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class QSVMFeatureMapEntanglement(ClassicalEnum):
-    FULL = 0
-    LINEAR = 1
-    CIRCULAR = 2
-    SCA = 3
-    PAIRWISE = 4

classiq/interface/generator/functions/foreign_function_definition.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, List, NoReturn, Optional, Tuple, Union
-
-import pydantic
-
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import ArithmeticIODict, IOName
-from classiq.interface.generator.functions.function_implementation import (
-    FunctionImplementation,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    SynthesisPortDeclaration,
-)
-from classiq.interface.generator.functions.quantum_function_declaration import (
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.interface.generator.functions.register import Register
-from classiq.interface.generator.functions.register_mapping_data import (
-    RegisterMappingData,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-ImplementationsType = Tuple[FunctionImplementation, ...]
-
-
-class SynthesisForeignFunctionDefinition(SynthesisQuantumFunctionDeclaration):
-    """
-    Facilitates the creation of a user-defined elementary function
-
-    This class sets extra to forbid so that it can be used in a Union and not "steal"
-    objects from other classes.
-    """
-
-    register_mapping: RegisterMappingData = pydantic.Field(
-        default_factory=RegisterMappingData,
-        description="The PortDirection data that is common to all implementations of the function",
-    )
-    implementations: Optional[ImplementationsType] = pydantic.Field(
-        description="The implementations of the custom function",
-    )
-
-    @pydantic.validator("register_mapping")
-    def _validate_register_mapping(
-        cls, register_mapping: RegisterMappingData
-    ) -> RegisterMappingData:
-        if not register_mapping.output_registers:
-            raise ClassiqValueError(
-                "The outputs of a custom function must be non-empty"
-            )
-        return register_mapping
-
-    @pydantic.validator("implementations", pre=True)
-    def _parse_implementations(
-        cls,
-        implementations: Optional[Union[ImplementationsType, FunctionImplementation]],
-    ) -> Optional[ImplementationsType]:
-        if isinstance(implementations, FunctionImplementation):
-            return (implementations,)
-
-        return implementations
-
-    @pydantic.validator("implementations")
-    def _validate_implementations(
-        cls,
-        implementations: Optional[ImplementationsType],
-        values: Dict[str, Any],
-    ) -> Optional[ImplementationsType]:
-        if not implementations:
-            raise ClassiqValueError(
-                "The implementations of a custom function must be non-empty."
-            )
-
-        register_mapping = values.get("register_mapping")
-        assert isinstance(register_mapping, RegisterMappingData)
-        for impl in implementations:
-            impl.validate_ranges_of_all_registers(register_mapping=register_mapping)
-
-        return implementations
-
-    @property
-    def inputs(self) -> ArithmeticIODict:
-        return _map_reg_user_input(self.register_mapping.input_registers)
-
-    @property
-    def outputs(self) -> ArithmeticIODict:
-        return _map_reg_user_input(self.register_mapping.output_registers)
-
-    def renamed(self, new_name: str) -> SynthesisForeignFunctionDefinition:
-        return SynthesisForeignFunctionDefinition(
-            name=new_name,
-            implementations=self.implementations,
-            register_mapping=self.register_mapping,
-        )
-
-    @property
-    def port_declarations(self) -> Dict[IOName, SynthesisPortDeclaration]:
-        raise ClassiqValueError(
-            "Bad usage of foreign function definition: port_declarations"
-        )
-
-    @port_declarations.setter
-    def port_declarations(self, value: Any) -> NoReturn:
-        raise ClassiqValueError(
-            "Bad usage of foreign function definition: port_declarations"
-        )
-
-
-def _map_reg_user_input(registers: List[Register]) -> ArithmeticIODict:
-    return {
-        reg.name: RegisterUserInput(size=len(reg.qubits), name=reg.name)
-        for reg in registers
-    }

classiq/interface/generator/functions/function_implementation.py

@@ -1,107 +0,0 @@
-from itertools import chain
-from typing import Optional, Tuple, Union
-
-import pydantic
-from pydantic import BaseModel
-
-from classiq.interface.generator.functions.register import Register
-from classiq.interface.generator.functions.register_mapping_data import (
-    RegisterMappingData,
-)
-from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-
-from classiq.exceptions import ClassiqValueError
-
-RegistersStrictType = Tuple[Register, ...]
-RegistersType = Union[Register, RegistersStrictType]
-
-
-def to_tuple(reg_type: RegistersType) -> RegistersStrictType:
-    if isinstance(reg_type, Register):
-        return (reg_type,)
-    else:
-        return reg_type
-
-
-class FunctionImplementation(BaseModel):
-    """
-    Facilitates the creation of a user-defined custom function implementation
-    """
-
-    class Config:
-        validate_all = True
-        extra = "forbid"
-
-    name: Optional[PydanticNonEmptyString] = pydantic.Field(
-        default=None,
-        description="The name of the custom implementation",
-    )
-
-    serialized_circuit: PydanticNonEmptyString = pydantic.Field(
-        description="The QASM code of the custom function implementation",
-    )
-
-    auxiliary_registers: RegistersStrictType = pydantic.Field(
-        default_factory=tuple,
-        description="A tuple of auxiliary registers to the custom implementation",
-    )
-
-    def num_qubits_in_all_registers(self, register_mapping: RegisterMappingData) -> int:
-        all_input_registers = (
-            register_mapping.input_registers
-            + register_mapping.zero_input_registers
-            + list(self.auxiliary_registers)
-        )
-        input_qubits = set(
-            chain.from_iterable(register.qubits for register in all_input_registers)
-        )
-        return len(input_qubits)
-
-    @pydantic.validator(
-        "auxiliary_registers",
-        pre=True,
-        always=True,
-    )
-    def validate_all_registers_are_tuples(
-        cls,
-        registers: RegistersType,
-    ) -> RegistersStrictType:
-        if isinstance(registers, Register):
-            return (registers,)
-        return registers
-
-    def validate_ranges_of_all_registers(
-        self, register_mapping: RegisterMappingData
-    ) -> None:
-        input_registers = register_mapping.input_registers
-        output_registers = register_mapping.output_registers
-        zero_input_registers = register_mapping.zero_input_registers
-        auxiliary_registers = list(self.auxiliary_registers)
-
-        all_input_registers = (
-            input_registers + zero_input_registers + auxiliary_registers
-        )
-        input_qubits = set(
-            chain.from_iterable(register.qubits for register in all_input_registers)
-        )
-        num_qubits = len(input_qubits)
-        all_qubits = set(range(num_qubits))
-        if num_qubits != sum(register.width for register in all_input_registers):
-            raise ClassiqValueError("The input registers must not overlap.")
-        if input_qubits != all_qubits:
-            raise ClassiqValueError(
-                "The set of qubits contained in all registers must be consecutive."
-            )
-
-        all_output_registers = output_registers + auxiliary_registers
-        output_qubits = set(
-            chain.from_iterable(register.qubits for register in all_output_registers)
-        )
-        if len(output_qubits) != sum(
-            register.width for register in all_output_registers
-        ):
-            raise ClassiqValueError("The output registers must not overlap.")
-        if not output_qubits == all_qubits:
-            raise ClassiqValueError(
-                "The input and output qubits must be mutually consistent."
-            )

classiq/interface/generator/functions/native_function_definition.py

@@ -1,155 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-import pydantic
-
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import IOName, PortDirection
-from classiq.interface.generator.functions.port_declaration import (
-    SynthesisPortDeclaration,
-)
-from classiq.interface.generator.functions.quantum_function_declaration import (
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.interface.generator.quantum_function_call import (
-    SynthesisQuantumFunctionCall,
-    WireDict,
-    WireName,
-)
-from classiq.interface.generator.validations import flow_graph
-
-from classiq.exceptions import ClassiqValueError
-
-LOGIC_FLOW_DUPLICATE_NAME_ERROR_MSG = (
-    "Cannot have multiple function calls with the same name"
-)
-
-
-class IOData(pydantic.BaseModel):
-    wire: WireName = pydantic.Field(
-        description="The name of the wire of the PortDirection data."
-    )
-    reg: RegisterUserInput = pydantic.Field(
-        description="The register information about the PortDirection data."
-    )
-
-    class Config:
-        frozen = True
-
-
-class SynthesisNativeFunctionDefinition(SynthesisQuantumFunctionDeclaration):
-    """
-    Facilitates the creation of a user-defined composite function
-
-    This class sets extra to forbid so that it can be used in a Union and not "steal"
-    objects from other classes.
-    """
-
-    input_ports_wiring: Dict[IOName, WireName] = pydantic.Field(
-        description="The mapping between the functions input ports, to inner wires",
-        default_factory=dict,
-    )
-
-    output_ports_wiring: Dict[IOName, WireName] = pydantic.Field(
-        description="The mapping between the functions output ports, to inner wires",
-        default_factory=dict,
-    )
-
-    body: List[SynthesisQuantumFunctionCall] = pydantic.Field(
-        default_factory=list, description="List of function calls to perform."
-    )
-
-    def validate_body(self) -> None:
-        function_call_names = {call.name for call in self.body}
-        if len(function_call_names) != len(self.body):
-            raise ClassiqValueError(LOGIC_FLOW_DUPLICATE_NAME_ERROR_MSG)
-        flow_graph.validate_legal_wiring(
-            self.body,
-            flow_input_names=list(self.input_ports_wiring.values()),
-            flow_output_names=list(self.output_ports_wiring.values()),
-        )
-        flow_graph.validate_acyclic_logic_flow(
-            self.body,
-            flow_input_names=list(self.input_ports_wiring.values()),
-            flow_output_names=list(self.output_ports_wiring.values()),
-        )
-
-    @classmethod
-    def _validate_direction_ports(
-        cls,
-        port_declarations: Dict[IOName, SynthesisPortDeclaration],
-        directions_external_port_wiring: WireDict,
-        direction: PortDirection,
-    ) -> None:
-        for io_name in directions_external_port_wiring:
-            if (
-                io_name not in port_declarations
-                or not port_declarations[io_name].direction == direction
-            ):
-                raise ClassiqValueError(
-                    f"The wired {direction} port {io_name!r} is not declared."
-                )
-
-    @pydantic.root_validator
-    def validate_ports(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        port_declarations: Optional[Dict[IOName, SynthesisPortDeclaration]] = (
-            values.get("port_declarations")
-        )
-        if port_declarations is None:
-            return values
-        cls._validate_direction_ports(
-            port_declarations,
-            values.get("input_ports_wiring", dict()),
-            PortDirection.Input,
-        )
-        cls._validate_direction_ports(
-            port_declarations,
-            values.get("output_ports_wiring", dict()),
-            PortDirection.Output,
-        )
-        return values
-
-    @pydantic.validator("input_ports_wiring", always=True)
-    def _populate_input_ports_wiring(
-        cls, input_ports_wiring: Dict[IOName, WireName], values: Dict[str, Any]
-    ) -> Dict[IOName, WireName]:
-        return _validate_ports_wiring_for_direction(
-            input_ports_wiring, values, PortDirection.Input
-        )
-
-    @pydantic.validator("output_ports_wiring", always=True)
-    def _populate_output_ports_wiring(
-        cls, output_ports_wiring: Dict[IOName, WireName], values: Dict[str, Any]
-    ) -> Dict[IOName, WireName]:
-        return _validate_ports_wiring_for_direction(
-            output_ports_wiring, values, PortDirection.Output
-        )
-
-
-def _get_single_port_wiring(
-    ports_wiring: Dict[IOName, WireName], name: str, direction: PortDirection
-) -> WireName:
-    direction_id = "out" if direction == PortDirection.Output else "in"
-    return ports_wiring.get(name) or f"{name}_{direction_id}"
-
-
-def _port_declarations_to_wiring(
-    ports_wiring: Dict[IOName, WireName],
-    port_decls: Dict[IOName, SynthesisPortDeclaration],
-    direction: PortDirection,
-) -> Dict[IOName, WireName]:
-    return {
-        name: _get_single_port_wiring(ports_wiring, name, direction)
-        for name, port in port_decls.items()
-        if port.direction.includes_port_direction(direction)
-    }
-
-
-def _validate_ports_wiring_for_direction(
-    ports_wiring: Dict[IOName, WireName],
-    values: Dict[str, Any],
-    direction: PortDirection,
-) -> Dict[IOName, WireName]:
-    port_decls = values.get("port_declarations")
-    if port_decls is None:
-        return ports_wiring
-    return _port_declarations_to_wiring(ports_wiring, port_decls, direction)