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

classiq/model/logic_flow.py

@@ -1,149 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Optional, Tuple
-
-import networkx as nx
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.quantum_function_call import (
-    ZERO_INDICATOR,
-    SynthesisQuantumFunctionCall,
-)
-
-from classiq.exceptions import ClassiqWiringError
-from classiq.model import logic_flow_change_handler
-from classiq.quantum_register import QReg, Qubit
-
-
-# We need the dataclass to be hashable for inserting it into the graph,
-# hence the dataclass is frozen.
-@dataclass(frozen=True)
-class _Pin:
-    pin_name: str
-    index: int
-    func_call: Optional[SynthesisQuantumFunctionCall]
-    io: PortDirection  # We need to store PortDirection because a function may have an input and an output pin with the same name
-
-    def __str__(self) -> str:
-        return f"{self.pin_name}[{self.index}]"
-
-
-@dataclass(frozen=True)
-class _ZeroPin(_Pin):
-    def __init__(self, io: PortDirection) -> None:
-        super().__init__(pin_name=ZERO_INDICATOR, index=0, func_call=None, io=io)
-
-    def __str__(self) -> str:
-        return ZERO_INDICATOR
-
-
-class _StrictDiGraph(nx.DiGraph):
-    def add_edge(self, u_of_edge: Any, v_of_edge: Any, **attr: Any) -> None:
-        if u_of_edge in self and v_of_edge in self[u_of_edge]:
-            raise ClassiqWiringError(
-                f"Cannot reconnect an already connected edge: {u_of_edge}, {v_of_edge}"
-            )
-        super().add_edge(u_of_edge, v_of_edge, **attr)
-
-
-INVALID_QUBITS_ERROR_MESSAGE = (
-    "Cannot use a QReg with consumed or uninitialized qubits:"
-)
-
-
-class LogicFlowBuilder:
-    def __init__(self) -> None:
-        self._logic_flow_graph = _StrictDiGraph()
-        self._connect_qubit_func = {
-            PortDirection.Input: self._connect_qubit_to_func_call,
-            PortDirection.Output: self._connect_func_call_to_qubit,
-        }
-
-    def _is_qubit_available(self, qubit: Qubit) -> bool:
-        return qubit in self._logic_flow_graph.nodes
-
-    def _validate_qreg(self, qreg: QReg) -> None:
-        invalid_qubit_indices = [
-            i
-            for i, qubit in enumerate(qreg.qubits)
-            if not self._is_qubit_available(qubit)
-        ]
-        if invalid_qubit_indices:
-            raise ClassiqWiringError(
-                f"{INVALID_QUBITS_ERROR_MESSAGE} {invalid_qubit_indices}"
-            )
-
-    def _verify_no_loops(self, dest_node: SynthesisQuantumFunctionCall) -> None:
-        if not nx.is_directed_acyclic_graph(self._logic_flow_graph):
-            raise ClassiqWiringError(f"Cannot wire function {dest_node} to itself")
-
-    def _connect_qubit_to_func_call(
-        self,
-        qubit: Qubit,
-        dest_pin: _Pin,
-        dest_node: Optional[SynthesisQuantumFunctionCall],
-    ) -> None:
-        if dest_node is not None:
-            self._logic_flow_graph.add_edge(dest_pin, dest_node)
-        source_node, source_pin = self._get_source_node_and_pin(qubit)
-        # relabel_nodes replaces a node with another (inplace and keeping the edges)
-        nx.relabel_nodes(self._logic_flow_graph, {qubit: dest_pin}, copy=False)
-        logic_flow_change_handler.handle_inner_connection(
-            source_node,
-            str(source_pin),
-            str(dest_pin),
-            dest_node,
-        )
-
-    def _get_source_node_and_pin(
-        self, qubit: Qubit
-    ) -> Tuple[SynthesisQuantumFunctionCall, _Pin]:
-        source_pin = next(self._logic_flow_graph.predecessors(qubit))
-        source_node = next(self._logic_flow_graph.predecessors(source_pin))
-        return source_node, source_pin
-
-    def _connect_func_call_to_qubit(
-        self, qubit: Qubit, source_pin: _Pin, source_node: SynthesisQuantumFunctionCall
-    ) -> None:
-        self._logic_flow_graph.add_edge(source_node, source_pin)
-        self._logic_flow_graph.add_edge(source_pin, qubit)
-
-    def _connect_io(
-        self,
-        io: PortDirection,
-        func_node: SynthesisQuantumFunctionCall,
-        pin_name: str,
-        qreg: QReg,
-        pin_indices: Optional[range] = None,
-    ) -> None:
-        if pin_indices is None:
-            pin_indices = range(len(qreg))
-        pins = [_Pin(pin_name, i, func_node, io) for i in pin_indices]
-        for pin, qubit in zip(pins, qreg.qubits):
-            self._connect_qubit_func[io](qubit, pin, func_node)
-
-    def connect_qreg_to_func_call(
-        self,
-        source: QReg,
-        dest_pin_name: str,
-        dest_func_call: SynthesisQuantumFunctionCall,
-        pin_indices: Optional[range] = None,
-    ) -> None:
-        self._validate_qreg(source)
-        self._connect_io(
-            PortDirection.Input, dest_func_call, dest_pin_name, source, pin_indices
-        )
-        self._verify_no_loops(dest_func_call)
-
-    def connect_func_call_to_qreg(
-        self,
-        source_func_call: SynthesisQuantumFunctionCall,
-        source_pin_name: str,
-        dest: QReg,
-    ) -> None:
-        self._connect_io(PortDirection.Output, source_func_call, source_pin_name, dest)
-
-    def connect_qreg_to_zero(self, source: QReg) -> None:
-        for qubit in source.qubits:
-            self._connect_qubit_to_func_call(
-                qubit, _ZeroPin(PortDirection.Output), None
-            )

classiq/model/logic_flow_change_handler.py

@@ -1,71 +0,0 @@
-from typing import Optional
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.quantum_function_call import (
-    ZERO_INDICATOR,
-    SynthesisQuantumFunctionCall,
-)
-
-
-def _get_io_wire_name(
-    name: str, call: SynthesisQuantumFunctionCall, io: PortDirection
-) -> str:
-    if io == PortDirection.Input:
-        return f"{io.name}:{name}->{call.name}:{name}"
-    else:
-        return f"{call.name}:{name}->{io.name}:{name}"
-
-
-def _get_wire_name(
-    source_call: SynthesisQuantumFunctionCall,
-    source_pin_name: str,
-    dest_pin_name: str,
-    dest_call: Optional[SynthesisQuantumFunctionCall],
-) -> str:
-    if dest_call is None:
-        assert dest_pin_name == ZERO_INDICATOR
-        return ZERO_INDICATOR
-    return f"{source_call.name}:{source_pin_name}->{dest_call.name}:{dest_pin_name}"
-
-
-def _set_model_output(
-    call: SynthesisQuantumFunctionCall, pin_name: str, wire_name: str
-) -> None:
-    call_outputs = dict(call.outputs_dict)
-    call_outputs[pin_name] = wire_name
-    call.outputs = call_outputs
-    if wire_name != ZERO_INDICATOR:
-        call.non_zero_output_wires.append(wire_name)
-
-
-def _set_model_input(
-    call: Optional[SynthesisQuantumFunctionCall], pin_name: str, wire_name: str
-) -> None:
-    if call is None:
-        return
-    call_inputs = dict(call.inputs_dict)
-    call_inputs[pin_name] = wire_name
-    call.inputs = call_inputs
-    call.non_zero_input_wires.append(wire_name)
-
-
-def handle_inner_connection(
-    source_call: SynthesisQuantumFunctionCall,
-    source_pin_name: str,
-    dest_pin_name: str,
-    dest_call: Optional[SynthesisQuantumFunctionCall],
-) -> None:
-    wire_name = _get_wire_name(source_call, source_pin_name, dest_pin_name, dest_call)
-    _set_model_output(source_call, source_pin_name, wire_name)
-    _set_model_input(dest_call, dest_pin_name, wire_name)
-
-
-def handle_io_connection(
-    io_dir: PortDirection, call: SynthesisQuantumFunctionCall, io_name: str
-) -> str:
-    wire_name = _get_io_wire_name(io_name, call, io_dir)
-    if io_dir == PortDirection.Input:
-        _set_model_input(call, io_name, wire_name)
-    else:
-        _set_model_output(call, io_name, wire_name)
-    return wire_name

classiq/model/model.py

@@ -1,246 +0,0 @@
-"""Model module, implementing facilities for designing models and generating circuits using Classiq platform."""
-
-from __future__ import annotations
-
-import logging
-import tempfile
-from contextlib import nullcontext
-from typing import IO, Any, ContextManager, Dict, List, Mapping, Optional, Union, cast
-
-from classiq.interface.chemistry.operator import PauliOperator
-from classiq.interface.executor.execution_preferences import (
-    ExecutionPreferences,
-    QaeWithQpeEstimationMethod,
-)
-from classiq.interface.generator.expressions.enums import Optimizer
-from classiq.interface.generator.function_params import IOName
-from classiq.interface.generator.functions import SynthesisNativeFunctionDefinition
-from classiq.interface.generator.model import (
-    Constraints,
-    Preferences,
-    SynthesisModel as APIModel,
-)
-from classiq.interface.generator.model.model import MAIN_FUNCTION_NAME, SerializedModel
-from classiq.interface.generator.quantum_function_call import (
-    SynthesisQuantumFunctionCall,
-)
-
-from classiq._internals.async_utils import AsyncifyABC
-from classiq.exceptions import ClassiqError, ClassiqValueError
-from classiq.model import function_handler
-from classiq.quantum_functions.function_library import FunctionLibrary
-from classiq.quantum_register import QReg, QRegGenericAlias
-
-_logger = logging.getLogger(__name__)
-
-_SupportedIO = Union[IO, str]
-
-# TODO: Add docstrings for auto generated methods.
-
-
-ILLEGAL_SETTING_MSG = "Illegal value type provided"
-
-
-def _pauli_str_to_enums(pauli_str: str) -> str:
-    return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
-
-
-def _pauli_operator_to_qmod(hamiltonian: PauliOperator) -> str:
-    if not all(isinstance(summand[1], complex) for summand in hamiltonian.pauli_list):
-        raise ClassiqValueError(
-            "Supporting only Hamiltonian with numeric coefficients."
-        )
-    return ", ".join(
-        f"struct_literal(PauliTerm, pauli=[{_pauli_str_to_enums(pauli)}], coefficient={cast(complex, coeff).real})"
-        for pauli, coeff in hamiltonian.pauli_list
-    )
-
-
-def _file_handler(fp: Optional[_SupportedIO], mode: str = "r") -> ContextManager[IO]:
-    if fp is None:
-        temp_file = tempfile.NamedTemporaryFile(mode, suffix=".qmod", delete=False)
-        print(f"Using temporary file: {temp_file.name!r}")
-        return temp_file
-
-    if isinstance(fp, str):
-        return open(fp, mode)
-
-    return nullcontext(fp)
-
-
-DEFAULT_RESULT_NAME = "result"
-DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME = "estimation"
-
-
-class Model(function_handler.FunctionHandler, metaclass=AsyncifyABC):
-    """Facility to generate circuits, based on the model."""
-
-    def __init__(self, **kwargs: Any) -> None:
-        """Init self."""
-        super().__init__()
-        self._model = APIModel(**kwargs)
-
-    @classmethod
-    def from_model(cls, model: APIModel) -> Model:
-        return cls(**dict(model))
-
-    @property
-    def _body(
-        self,
-    ) -> List[SynthesisQuantumFunctionCall]:
-        return self._model.body
-
-    @property
-    def constraints(self) -> Constraints:
-        """Get the constraints aggregated in self.
-
-        Returns:
-            The constraints data.
-        """
-        return self._model.constraints
-
-    @constraints.setter
-    def constraints(self, value: Any) -> None:
-        if not isinstance(value, Constraints):
-            raise ClassiqError(ILLEGAL_SETTING_MSG)
-        self._model.constraints = value
-
-    @property
-    def preferences(self) -> Preferences:
-        """Get the preferences aggregated in self.
-
-        Returns:
-            The preferences data.
-        """
-        return self._model.preferences
-
-    @preferences.setter
-    def preferences(self, value: Any) -> None:
-        if not isinstance(value, Preferences):
-            raise ClassiqError(ILLEGAL_SETTING_MSG)
-        self._model.preferences = value
-
-    @property
-    def execution_preferences(self) -> ExecutionPreferences:
-        return self._model.execution_preferences
-
-    @execution_preferences.setter
-    def execution_preferences(self, value: Any) -> None:
-        if not isinstance(value, ExecutionPreferences):
-            raise ClassiqError(ILLEGAL_SETTING_MSG)
-        self._model.execution_preferences = value
-
-    def create_inputs(
-        self, inputs: Mapping[IOName, QRegGenericAlias]
-    ) -> Dict[IOName, QReg]:
-        qregs = super().create_inputs(inputs=inputs)
-        self._model.set_inputs(inputs, self.input_wires)
-        return qregs
-
-    def set_outputs(self, outputs: Mapping[IOName, QReg]) -> None:
-        super().set_outputs(outputs=outputs)
-        self._model.set_outputs(outputs, self.output_wires)
-
-    def include_library(self, library: FunctionLibrary) -> None:
-        """Includes a user-defined custom function library.
-
-        Args:
-            library (FunctionLibrary): The custom function library.
-        """
-        super().include_library(library=library)
-        # It is important that the .functions list is shared between the library and
-        # the model, as it is modified in-place
-        self._model.functions = library._data
-        library.remove_function_definition(MAIN_FUNCTION_NAME)
-        self._model.functions.append(
-            SynthesisNativeFunctionDefinition(name=MAIN_FUNCTION_NAME)
-        )
-
-    def get_model(self) -> SerializedModel:
-        return self._model.get_model()
-
-    def create_library(self) -> None:
-        self._function_library = FunctionLibrary(*self._model.functions)
-        self._model.functions = self._function_library._data
-
-    def sample(
-        self,
-        execution_params: Optional[Dict[str, float]] = None,
-    ) -> None:
-        execution_params = execution_params or dict()
-
-        self._model.classical_execution_code += classical_sample_function(
-            execution_params=execution_params
-        )
-
-    def vqe(
-        self,
-        hamiltonian: PauliOperator,
-        maximize: bool,
-        optimizer: Optimizer,
-        max_iteration: int,
-        initial_point: Optional[List[int]] = None,
-        tolerance: float = 0,
-        step_size: float = 0,
-        skip_compute_variance: bool = False,
-        alpha_cvar: float = 1,
-    ) -> None:
-        initial_point = initial_point or []
-        vqe_classical_code = f"""
-{DEFAULT_RESULT_NAME} = vqe(
-    hamiltonian=[{_pauli_operator_to_qmod(hamiltonian)}],
-    maximize={maximize},
-    initial_point={initial_point},
-    optimizer=Optimizer.{optimizer.name},
-    max_iteration={max_iteration},
-    tolerance={tolerance},
-    step_size={step_size},
-    skip_compute_variance={skip_compute_variance},
-    alpha_cvar={alpha_cvar}
-)
-save({{{DEFAULT_RESULT_NAME!r}: {DEFAULT_RESULT_NAME}}})
-"""
-
-        self._model.classical_execution_code += vqe_classical_code
-
-    def iqae(
-        self,
-        epsilon: float,
-        alpha: float,
-        execution_params: Optional[Dict[str, float]] = None,
-    ) -> None:
-        execution_params = execution_params or {}
-
-        iqae_classical_code = f"""
-{DEFAULT_RESULT_NAME} = iqae(
-    epsilon={epsilon},
-    alpha={alpha},
-    execution_params={execution_params}
-)
-save({{{DEFAULT_RESULT_NAME!r}: {DEFAULT_RESULT_NAME}}})
-"""
-
-        self._model.classical_execution_code += iqae_classical_code
-
-    def post_process_amplitude_estimation(
-        self,
-        estimation_register_size: int,
-        estimation_method: QaeWithQpeEstimationMethod,
-    ) -> None:
-        postprocess_classical_code = f"""
-{DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME} = qae_with_qpe_result_post_processing(
-    {estimation_register_size},
-    {estimation_method},
-    {DEFAULT_RESULT_NAME}
-)
-save({{{DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME!r}: {DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME}}})
-"""
-
-        self._model.classical_execution_code += postprocess_classical_code
-
-
-def classical_sample_function(execution_params: Dict[str, float]) -> str:
-    return f"""
-{DEFAULT_RESULT_NAME} = sample({execution_params})
-save({{{DEFAULT_RESULT_NAME!r}: {DEFAULT_RESULT_NAME}}})
-"""