qml-essentials 0.1.13__py3-none-any.whl

qml_essentials/ansaetze.py

@@ -0,0 +1,485 @@
+from abc import ABC, abstractmethod
+from typing import Any, Optional
+import pennylane.numpy as np
+import pennylane as qml
+
+from typing import List
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Circuit(ABC):
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def n_params_per_layer(n_qubits: int) -> int:
+        return
+
+    @abstractmethod
+    def get_control_indices(self, n_qubits: int) -> List[int]:
+        """
+        Returns the indices for the controlled rotation gates for one layer.
+        Indices should slice the list of all parameters for one layer as follows:
+        [indices[0]:indices[1]:indices[2]]
+
+        Parameters
+        ----------
+        n_qubits : int
+            Number of qubits in the circuit
+
+        Returns
+        -------
+        Optional[np.ndarray]
+            List of all controlled indices, or None if the circuit does not
+            contain controlled rotation gates.
+        """
+        return
+
+    def get_control_angles(self, w: np.ndarray, n_qubits: int) -> Optional[np.ndarray]:
+        """
+        Returns the angles for the controlled rotation gates from the list of
+        all parameters for one layer.
+
+        Parameters
+        ----------
+        w : np.ndarray
+            List of parameters for one layer
+        n_qubits : int
+            Number of qubits in the circuit
+
+        Returns
+        -------
+        Optional[np.ndarray]
+            List of all controlled parameters, or None if the circuit does not
+            contain controlled rotation gates.
+        """
+        indices = self.get_control_indices(n_qubits)
+        if indices is None:
+            return None
+
+        return w[indices[0] : indices[1] : indices[2]]
+
+    @abstractmethod
+    def build(self, n_qubits: int, n_layers: int):
+        return
+
+    def __call__(self, *args: Any, **kwds: Any) -> Any:
+        self.build(*args, **kwds)
+
+
+class Ansaetze:
+    def get_available():
+        return [
+            Ansaetze.No_Ansatz,
+            Ansaetze.Circuit_1,
+            Ansaetze.Circuit_6,
+            Ansaetze.Circuit_9,
+            Ansaetze.Circuit_15,
+            Ansaetze.Circuit_18,
+            Ansaetze.Circuit_19,
+            Ansaetze.No_Entangling,
+            Ansaetze.Strongly_Entangling,
+            Ansaetze.Hardware_Efficient,
+            Ansaetze.Bansatz,
+        ]
+
+    class No_Ansatz(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return 0
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            pass
+
+    class Hardware_Efficient(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 3
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RY(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RY(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits // 2):
+                    qml.CZ(wires=[(2 * q), (2 * q + 1)])
+                for q in range((n_qubits - 1) // 2):
+                    qml.CZ(wires=[(2 * q + 1), (2 * q + 2)])
+
+    class Bansatz(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 3
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RY(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits // 2):
+                    qml.CRX(w[w_idx], wires=[(2 * q), (2 * q + 1)])
+                    w_idx += 1
+
+                for q in range((n_qubits - 1) // 2):
+                    qml.CRX(w[w_idx], wires=[(2 * q + 1), (2 * q + 2)])
+                    w_idx += 1
+
+    class Circuit_19(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CRX(
+                        w[w_idx],
+                        wires=[n_qubits - q - 1, (n_qubits - q) % n_qubits],
+                    )
+                    w_idx += 1
+
+    class Circuit_18(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit18 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CRZ(
+                        w[w_idx],
+                        wires=[n_qubits - q - 1, (n_qubits - q) % n_qubits],
+                    )
+                    w_idx += 1
+
+    class Circuit_15(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit15 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            raise NotImplementedError  # Did not figured out the entangling sequence yet
+
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CNOT(wires=[n_qubits - q - 1, (n_qubits - q) % n_qubits])
+
+            for q in range(n_qubits):
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Circuit_9(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return n_qubits
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit19 ansatz.
+
+            Length of flattened vector must be n_qubits*3-1
+            because for >1 qubits there are three gates
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3-1)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.Hadamard(wires=q)
+
+            if n_qubits > 1:
+                for q in range(n_qubits - 1):
+                    qml.CZ(wires=[n_qubits - q - 2, n_qubits - q - 1])
+
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Circuit_6(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 3 + n_qubits**2
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 4
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            if n_qubits > 1:
+                return [-n_qubits, None, None]
+            else:
+                return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit1 ansatz.
+
+            Length of flattened vector must be n_qubits*2
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*2)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+            if n_qubits > 1:
+                for ql in range(n_qubits):
+                    for q in range(n_qubits):
+                        if q == ql:
+                            continue
+                        qml.CRX(
+                            w[w_idx],
+                            wires=[n_qubits - ql - 1, (n_qubits - q - 1) % n_qubits],
+                        )
+                        w_idx += 1
+
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Circuit_1(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return n_qubits * 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a Circuit1 ansatz.
+
+            Length of flattened vector must be n_qubits*2
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*2)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.RX(w[w_idx], wires=q)
+                w_idx += 1
+                qml.RZ(w[w_idx], wires=q)
+                w_idx += 1
+
+    class Strongly_Entangling(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            if n_qubits > 1:
+                return n_qubits * 6
+            else:
+                log.warning("Number of Qubits < 2, no entanglement available")
+                return 2
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int) -> None:
+            """
+            Creates a StronglyEntanglingLayers ansatz.
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.Rot(w[w_idx], w[w_idx + 1], w[w_idx + 2], wires=q)
+                w_idx += 3
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CNOT(wires=[q, (q + 1) % n_qubits])
+
+            for q in range(n_qubits):
+                qml.Rot(w[w_idx], w[w_idx + 1], w[w_idx + 2], wires=q)
+                w_idx += 3
+
+            if n_qubits > 1:
+                for q in range(n_qubits):
+                    qml.CNOT(wires=[q, (q + n_qubits // 2) % n_qubits])
+
+    class No_Entangling(Circuit):
+        @staticmethod
+        def n_params_per_layer(n_qubits: int) -> int:
+            return n_qubits * 3
+
+        @staticmethod
+        def get_control_indices(n_qubits: int) -> Optional[np.ndarray]:
+            return None
+
+        @staticmethod
+        def build(w: np.ndarray, n_qubits: int):
+            """
+            Creates a circuit without entangling, but with U3 gates on all qubits
+
+            Length of flattened vector must be n_qubits*3
+
+            Args:
+                w (np.ndarray): weight vector of size n_layers*(n_qubits*3)
+                n_qubits (int): number of qubits
+            """
+            w_idx = 0
+            for q in range(n_qubits):
+                qml.Rot(w[w_idx], w[w_idx + 1], w[w_idx + 2], wires=q)
+                w_idx += 3

qml_essentials/coefficients.py

@@ -0,0 +1,37 @@
+from qml_essentials.model import Model
+from functools import partial
+from pennylane.fourier import coefficients
+import numpy as np
+
+
+class Coefficients:
+
+    @staticmethod
+    def sample_coefficients(model: Model, **kwargs) -> np.ndarray:
+        """
+        Sample the Fourier coefficients of a given model
+        using Pennylane fourier.coefficients function.
+
+        Note that the coefficients are complex numbers, but the imaginary part
+        of the coefficients should be very close to zero, since the expectation
+        values of the Pauli operators are real numbers.
+
+        Args:
+            model (Model): The model to sample.
+
+        Returns:
+            np.ndarray: The sampled Fourier coefficients.
+        """
+        kwargs.setdefault("force_mean", True)
+        kwargs.setdefault("execution_type", "expval")
+
+        partial_circuit = partial(model, model.params, **kwargs)
+        coeffs = coefficients(partial_circuit, 1, model.degree)
+
+        if not np.isclose(np.sum(coeffs).imag, 0.0, rtol=1.0e-5):
+            raise ValueError(
+                f"Spectrum is not real. Imaginary part of coefficients is:\
+                {np.sum(coeffs).imag}"
+            )
+
+        return coeffs

qml_essentials/entanglement.py

@@ -0,0 +1,105 @@
+from typing import Callable, Optional, List, Any
+import pennylane as qml
+import pennylane.numpy as np
+
+import logging
+
+log = logging.getLogger(__name__)
+
+
+class Entanglement:
+
+    @staticmethod
+    def meyer_wallach(
+        model: Callable,  # type: ignore
+        n_samples: int,
+        seed: Optional[int],
+        **kwargs: Any
+    ) -> float:
+        """
+        Calculates the entangling capacity of a given quantum circuit
+        using Meyer-Wallach measure.
+
+        Args:
+            model (Callable): Function that models the quantum circuit. It must
+                have a `n_qubits` attribute representing the number of qubits.
+                It must accept a `params` argument representing the parameters
+                of the circuit.
+            n_samples (int): Number of samples per qubit.
+            seed (Optional[int]): Seed for the random number generator.
+            kwargs (Any): Additional keyword arguments for the model function.
+
+        Returns:
+            float: Entangling capacity of the given circuit. It is guaranteed
+                to be between 0.0 and 1.0.
+        """
+
+        def _meyer_wallach(
+            evaluate: Callable[[np.ndarray], np.ndarray],
+            n_qubits: int,
+            samples: int,
+            params: np.ndarray,
+        ) -> float:
+            """
+            Calculates the Meyer-Wallach sampling of the entangling capacity
+            of a quantum circuit.
+
+            Args:
+                evaluate (Callable[[np.ndarray], np.ndarray]): Callable that
+                    evaluates the quantum circuit It must accept a `params`
+                    argument representing the parameters of the circuit and may
+                    accept additional keyword arguments.
+                n_qubits (int): Number of qubits in the circuit
+                samples (int): Number of samples to be taken
+                params (np.ndarray): Parameters of the instructor. Shape:
+                    (samples, *model.params.shape)
+
+            Returns:
+                float: Entangling capacity of the given circuit. It is
+                    guaranteed to be between 0.0 and 1.0
+            """
+            assert (
+                params.shape[0] == samples
+            ), "Number of samples does not match number of parameters"
+
+            mw_measure = np.zeros(samples, dtype=complex)
+            qb = list(range(n_qubits))
+
+            for i in range(samples):
+                # implicitly set input to none in case it's not needed
+                kwargs.setdefault("inputs", None)
+                # explicitly set execution type because everything else won't work
+                U = evaluate(params=params[i], execution_type="density", **kwargs)
+
+                entropy = 0
+
+                for j in range(n_qubits):
+                    density = qml.math.partial_trace(U, qb[:j] + qb[j + 1 :])
+                    entropy += np.trace((density @ density).real)
+
+                mw_measure[i] = 1 - entropy / n_qubits
+
+            mw = 2 * np.sum(mw_measure.real) / samples
+
+            # catch floating point errors
+            return min(max(mw, 0.0), 1.0)
+
+        if n_samples > 0:
+            assert seed is not None, "Seed must be provided when samples > 0"
+            # TODO: maybe switch to JAX rng
+            rng = np.random.default_rng(seed)
+            params = rng.uniform(0, 2 * np.pi, size=(n_samples, *model.params.shape))
+        else:
+            if seed is not None:
+                log.warning("Seed is ignored when samples is 0")
+            n_samples = 1
+            params = model.params.reshape(1, *model.params.shape)
+
+        entangling_capability = _meyer_wallach(
+            evaluate=model,
+            n_qubits=model.n_qubits,
+            samples=n_samples,
+            params=params,
+        )
+
+        return float(entangling_capability)