Clifford Simulator

doc/source/api-reference/qibo.rst

@@ -1368,6 +1368,71 @@ Pauli basis to computational basis
 .. autofunction:: qibo.quantum_info.pauli_to_comp_basis
 
 
+Phase-space Representation of Stabilizer States
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A *stabilizer state* :math:`\ketbra{\psi}{\psi}` can be uniquely defined by
+the set of its *stabilizers*, i.e. those unitary operators :math:`U` that have
+:math:`\psi` as an eigenstate with eigenvalue :math:`1`.
+In general, :math:`n`-qubit stabilizer states are stabilized by :math:`d = 2^n`
+Pauli operators on said :math:`n` qubits.
+However, it is known that the set of :math:`d` Paulis can be generated by only
+:math:`n` unique members of the set.
+In that case, indeed, the number of operators needed to represent a
+stabilizer state reduces to :math:`n`.
+Each one of these :math:`n` Pauli *generators* takes :math:`2n + 1` bits to specify,
+yielding a :math:`n(2n+1)` total number of bits needed.
+In particular, `Aaronson and Gottesman (2004) <aaronson_>`_ demonstrated that the application
+of Clifford gates on stabilizer states can be efficiently simulated in this representation
+at the cost of storing the generators of the *destabilizers*, in addition to the stabilizers.
+
+A :math:`n`-qubit stabilizer state is uniquely defined by a symplectic matrix of the form
+
+.. image:: ../_static/symplectic_matrix.png
+   :width: 2329px
+   :height: 1213px
+   :scale: 30 %
+   :align: center
+
+where :math:`(x_{kl},z_{kl})` are the bits encoding the :math:`n`-qubits Pauli generator as
+
+.. math::
+
+   P_{k} = \bigotimes_{l=1}^{n} \, i^{x_{kl} \, \oplus \, z_{kl}} \, X_{l}^{x_{kl}} \, Z_{l}^{z_{kl}}.
+
+The :class:`qibo.quantum_info.clifford.Clifford` object is in charge of storing the
+phase-space representation of a stabilizer state.
+This object is automatically created after the execution of a Clifford circuit through the
+:class:`qibo.backends.clifford.CliffordBackend`, but it can also be created by directly
+passing a symplectic matrix to the constructor.
+
+.. testsetup::
+
+   from qibo.quantum_info import Clifford
+   from qibo.backends import CliffordBackend, NumpyBackend
+
+   # construct the |00...0> state
+   backend = CliffordBackend(NumpyBackend())
+   symplectic_matrix = backend.zero_state(nqubits=3)
+   clifford = Clifford(symplectic_matrix, engine=NumpyBackend())
+
+The generators of the stabilizers can be extracted with the
+:meth:`qibo.quantum_info.clifford.Clifford.generators` method,
+or the complete set of :math:`d = 2^{n}` stabilizers operators can be extracted through the
+:meth:`qibo.quantum_info.clifford.Clifford.stabilizers` method.
+
+.. testcode::
+
+   generators, phases = clifford.generators()
+   stabilizers = clifford.stabilizers()
+
+The destabilizers can be extracted analogously with :meth:`qibo.quantum_info.clifford.Clifford.destabilizers`.
+
+.. autoclass:: qibo.quantum_info.clifford.Clifford
+    :members:
+    :member-order: bysource
+
+
 Metrics
 ^^^^^^^
 
@@ -1895,6 +1960,7 @@ Kraus operators as probabilistic sum of unitaries
     for a limited set of operators. We leave to the user to decide how to
     best use this function.
 
+
 Utility Functions
 ^^^^^^^^^^^^^^^^^
 
@@ -2021,3 +2087,58 @@ variable.
 .. autoclass:: qibo.backends.abstract.Backend
     :members:
     :member-order: bysource
+
+Clifford Simulation
+^^^^^^^^^^^^^^^^^^^
+
+A special backend in qibo supports the simulation of Clifford circuits.
+This :class:`qibo.backends.clifford.CliffordBackend` backend implements the phase-space formalism
+introduced in `https://arxiv.org/abs/quant-ph/0406196 <aaronson_>`_ to efficiently simulate gate
+application and measurements sampling in the stabilizers state representation.
+The execution of a circuit through this backend creates a
+:class:`qibo.quantum_info.clifford.Clifford` object that gives access to the final measured
+samples through the :meth:`qibo.quantum_info.clifford.Clifford.samples` method,
+similarly to :class:`qibo.result.CircuitResult`.
+The probabilities and frequencies are computed starting from the samples by the
+:meth:`qibo.quantum_info.clifford.Clifford.frequencies` and
+:meth:`qibo.quantum_info.clifford.Clifford.probabilities` methods.
+
+.. _aaronson: https://arxiv.org/abs/quant-ph/0406196
+
+It is also possible to recover the standard state representation with the
+:meth:`qibo.quantum_info.clifford.Clifford.state` method.
+Note, however, that this process is inefficient as it involves the construction of all the
+stabilizers starting from the generators encoded inside the symplectic matrix.
+
+As for the other backends, the Clifford backend can be set with
+
+.. testcode::  python
+
+    import qibo
+    qibo.set_backend("clifford", platform="numpy")
+
+by specifying the engine used for calculation, if not provided the current :class:`qibo.backends.GlobalBackend` is used
+
+.. testcode::  python
+    from qibo import set_backend
+    from qibo.backends import CliffordBackend
+
+    # setting numpy as the global backend
+    set_backend("numpy")
+    # the clifford backend will use the numpy backend as engine
+    backend = CliffordBackend()
+
+Alternatively, a Clifford circuit can also be executed starting from the :class:`qibo.quantum_info.clifford.Clifford` object
+
+.. code-block::  python
+
+    from qibo.quantum_info import Clifford, random_clifford
+
+    nqubits = 2
+    circuit = random_clifford(nqubits)
+    result = Clifford.from_circuit(circuit)
+
+
+.. autoclass:: qibo.backends.clifford.CliffordBackend
+    :members:
+    :member-order: bysource

doc/source/code-examples/examples.rst

@@ -26,6 +26,7 @@ Here is an example of a circuit with 2 qubits:
     # should print `tf.Tensor([1, 0, 0, 0])`
     print(result.state())
     # should print `np.array([1, 0, 0, 0])`
+
 .. testoutput::
     :hide:
 

src/qibo/backends/__init__.py

@@ -1,6 +1,7 @@
 import os
 
 from qibo.backends.abstract import Backend
+from qibo.backends.clifford import CliffordBackend
 from qibo.backends.npmatrices import NumpyMatrices
 from qibo.backends.numpy import NumpyBackend
 from qibo.backends.tensorflow import TensorflowBackend
@@ -33,6 +34,13 @@ def construct_backend(backend, platform=None, runcard=None):
         from qibolab.backends import QibolabBackend  # pylint: disable=E0401
 
         return QibolabBackend(platform, runcard)
+    elif backend == "clifford":
+        if platform is not None:  # pragma: no cover
+            if platform in ("cupy", "numba", "cuquantum"):
+                platform = construct_backend("qibojit", platform=platform)
+            else:
+                platform = construct_backend(platform)
+        return CliffordBackend(platform)
 
     else:  # pragma: no cover
         raise_error(ValueError, f"Backend {backend} is not available.")
@@ -141,7 +149,7 @@ def set_device(device):
     if device[0] != "/" or len(parts) < 2 or len(parts) > 3:
         raise_error(
             ValueError,
-            "Device name should follow the pattern: " "/{device type}:{device number}.",
+            "Device name should follow the pattern: /{device type}:{device number}.",
         )
     backend = GlobalBackend()
     backend.set_device(device)