Improvements on top of the Clifford Simulator

[BrunoLiegiBastonLiegi]

1076 is introducing in qibo a way for simulating clifford circuits efficiently, several improvements can still be introduced on top of that though:

• [x] Currently the CliffordBackend is backend agnostic, in the sense that any one of the backend available in qibo and qibojit right now (except for the TensorflowBackend) can be used as engines for performing the computation happening under the hood of the CliffordBackend. In practice, though, the only difference is whether numpy or cupy primitives are used. Therefore, there's no difference between using, for example, the NumbaBackend or NumpyBackend as engine right now. Numba parallelization can be implemented using the @njit(parallel=True) decorator with the clifford operations that define how gates act in the phase space. Similarly custom cuda kernels can be implemented in cupy using the @jit.rawkernel() decorator on the clifford operations.
• [x] Add support for clifford noise channels through repeated execution, as it works for collapsing measurements already.
• [ ] Come up with a way for representing ensembles of states in the phase space which is what you get when collapsing measurement or noise channels are present in the circuit. This https://arxiv.org/abs/2002.06181 might provide some ideas.
• [ ] Currently the action of a clifford gate in the phase space is represented by a series of row or column wise operations on the symplectic matrix, like for example swapping rows or summing columns. It would be more flexible to have a matrix multiplication representation for each operation.
• [x] As per suggestion of @AlejandroSopena and @AleCandido, it might be a good idea to integrate stim as a separate alternative clifford backend.
• [ ] The clifford gates + the T gate form a universal basis for computation, several methods exist for simulating circuits decomposed in this basis with a cost that grows exponentially only in the number of T gates present. An additional hybrid clifford backend could be implemented following this idea.
• [ ] Python native ints appear to be faster than numpy arrays of bools with boolean algebra. Namely, the operation 5 ^ 3 is faster than np.array([True, False, True]) ^ np.array([False, True, True]). Therefore, a substantial speed up might be obtained by rethinking the symplectic matrix in terms of the integers encoded by its rows and columns, however, this would require to rewrite also all the clifford gates in the new representation.
• [ ] (@alecandido) It would really be nice to have a syntax for gates composition in order to avoid the repetition of patterns, to make it something like:

  theta_switch(
      theta,
      I,
      X | CY | X | CNOT,
      CZ | X | CZ | X,
      CNOT | X | CY | X,
      symplectic_matrix, control_q, target_q, nqubits
  )

  with theta_switch a function applying the repeated pattern (and I chose | at random, any operator would be fine).

• [ ] (@alecandido) Verify whether it is better to use the prange function for explicit parallelization with numba or let numba take care of the parallelization automatically.
• [x] (@alecandido) Try to use np.packbits to pack the columns of the matrix before execution and unpack them at the end.
• [ ] Parallelize the measurements on different qubits.

EXTRA:

• [x] Clifford.to_circuit method
• [ ] Investigate the possibility of implementing this compilation algorithm integrated with transpiler
• [x] #1173
• [ ] In the StimBackend use stim also for sampling measurements and not only for simulating the tableu. An easy trick would be to convert the tableu to a circuit and then sample from it

  c = tableau.to_circuit(state)
  c.append("M", range(qubits))
  s = c.compiler_sampler()

@renatomello did I forget anything?

### Tasks
- [ ] https://github.com/qiboteam/qibo/pull/1139
- [ ] https://github.com/qiboteam/qibo/pull/1150
- [ ] https://github.com/qiboteam/qibojit/pull/161
- [ ] https://github.com/qiboteam/qibo/pull/1183
- [ ] https://github.com/qiboteam/qibo/pull/1239
- [ ] https://github.com/qiboteam/qibo/pull/1248

[renatomello]

@renatomello did I forget anything?

The Clifford.to_circuit method, but there is already a #TODO annotation in the code for it

[renatomello]

One thing I forgot to mention is that we need a way to enumerate the Cliffords for a given number of qubits. Maybe a conversion from one integer to a symplectic matrix. This is important for quantum_info.random_clifford because it is necessary for randomized benchmarking protocols in qibocal.

[renatomello]

@BrunoLiegiBastonLiegi we should also add a few extra methods to the Clifford class, e.g. a compose that composes two Clifford objects, an unitary method like the one in the Circuit class, etc. And I insist we should still have a similar method to the add method of the Circuit class.

[andrea-pasquale]

@BrunoLiegiBastonLiegi For possible improvements related to the CuQuantum backend you might want to check their documentation to see if there some primitives that you can exploit in your implementation of the clifford backend.

[renatomello]

@scarrazza @BrunoLiegiBastonLiegi @alecandido @AlejandroSopena just to add to the already aforementioned issue(s): PennyLane added a new Clifford simulator with stim as engine https://github.com/PennyLaneAI/pennylane/releases/tag/v0.35.0