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

classiq/interface/generator/functions/core_lib_declarations/quantum_operators.py

@@ -1,169 +0,0 @@
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import Bool, Integer
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-    QuantumOperandDeclaration,
-)
-
-REPEAT_OPERATOR = QuantumFunctionDeclaration(
-    name="repeat",
-    param_decls={"count": Integer()},
-    operand_declarations={
-        "iteration": QuantumOperandDeclaration(
-            name="iteration", param_decls={"index": Integer()}
-        )
-    },
-)
-
-OPERAND_FIELD_NAME = "operand"
-CTRL_FIELD_NAME = "ctrl"
-
-
-INVERT_OPERATOR = QuantumFunctionDeclaration(
-    name="invert",
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
-    },
-)
-
-
-CONTROL_OPERATOR = QuantumFunctionDeclaration(
-    name="control",
-    port_declarations={
-        CTRL_FIELD_NAME: PortDeclaration(
-            name=CTRL_FIELD_NAME,
-            direction=PortDeclarationDirection.Inout,
-        )
-    },
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
-    },
-)
-
-IF_OPERATOR = QuantumFunctionDeclaration(
-    name="if",
-    param_decls={"condition": Bool()},
-    operand_declarations={
-        "then": QuantumOperandDeclaration(name="then"),
-        "else": QuantumOperandDeclaration(name="else"),
-    },
-)
-
-SWITCH_OPERATOR = QuantumFunctionDeclaration(
-    name="switch",
-    param_decls={"selector": Integer()},
-    operand_declarations={
-        "cases": QuantumOperandDeclaration(
-            name="cases",
-            is_list=True,
-        )
-    },
-)
-
-
-JOIN_OPERATOR = QuantumFunctionDeclaration(
-    name="join",
-    port_declarations={
-        "in1": PortDeclaration(name="in1", direction="input"),
-        "in2": PortDeclaration(name="in2", direction="input"),
-        "out": PortDeclaration(
-            name="out",
-            direction="output",
-            size=Expression(expr="len(in1)+len(in2)"),
-        ),
-    },
-)
-
-
-SPLIT_OPERATOR = QuantumFunctionDeclaration(
-    name="split",
-    param_decls={"out1_size": Integer(), "out2_size": Integer()},
-    port_declarations={
-        "in": PortDeclaration(
-            name="in",
-            direction="input",
-            size=Expression(expr="out1_size+out2_size"),
-        ),
-        "out1": PortDeclaration(
-            name="out1", direction="output", size=Expression(expr="out1_size")
-        ),
-        "out2": PortDeclaration(
-            name="out2", direction="output", size=Expression(expr="out2_size")
-        ),
-    },
-)
-
-
-PERMUTE_OPERATOR = QuantumFunctionDeclaration(
-    name="permute",
-    operand_declarations={
-        "functions": QuantumOperandDeclaration(
-            name="functions",
-            is_list=True,
-        )
-    },
-)
-
-
-POWER_OPERATOR = QuantumFunctionDeclaration(
-    name="power",
-    param_decls={"power": Integer()},
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(name=OPERAND_FIELD_NAME)
-    },
-)
-
-APPLY = QuantumFunctionDeclaration(
-    name="apply",
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(
-            name=OPERAND_FIELD_NAME,
-        )
-    },
-)
-
-
-COMPUTE = QuantumFunctionDeclaration(
-    name="compute",
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(
-            name=OPERAND_FIELD_NAME,
-        )
-    },
-)
-
-
-UNCOMPUTE = QuantumFunctionDeclaration(
-    name="uncompute",
-    operand_declarations={
-        OPERAND_FIELD_NAME: QuantumOperandDeclaration(
-            name=OPERAND_FIELD_NAME,
-        )
-    },
-)
-
-
-BUILTIN_QUANTUM_OPERATOR_LIST = [
-    REPEAT_OPERATOR,
-    INVERT_OPERATOR,
-    CONTROL_OPERATOR,
-    IF_OPERATOR,
-    SWITCH_OPERATOR,
-    JOIN_OPERATOR,
-    SPLIT_OPERATOR,
-    PERMUTE_OPERATOR,
-    POWER_OPERATOR,
-    APPLY,
-    COMPUTE,
-    UNCOMPUTE,
-]
-
-
-QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.update(
-    nameables_to_dict(BUILTIN_QUANTUM_OPERATOR_LIST)
-)

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/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/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())