4. Quantum Operators

4.1. cudaq::spin_op

[1] CUDA-Q provides a native spin_op data type in the cudaq namespace for the expression of quantum mechanical spin operators.

[2] The spin_op provides an abstraction for a general tensor product of Pauli spin operators, and sums thereof:

\[H = \sum_{i=0}^M P_i, P_i = \prod_{j=0}^N \sigma_j^a\]

for \(a = {x,y,z}\), \(j\) the qubit index, and \(N\) the number of qubits.

[3] The spin_op exposes common C++ operator overloads for algebraic expressions.

[4] CUDA-Q defines convenience functions in cudaq::spin namespace that produce the primitive X, Y, and Z Pauli operators on specified qubit indices which can subsequently be used in algebraic expressions to build up more complicated Pauli tensor products and their sums.

C++

using namespace cudaq::spin;
auto h = 5.907 - 2.1433 * x(0) * x(1) - 2.1433 * y(0) * y(1) + \
         .21829 * z(0) - 6.125 * z(1);

Python

from cudaq import spin
h = 5.907 - 2.1433 * spin.x(0) * spin.x(1) - 2.1433 * spin.y(0) * spin.y(1) + \
         .21829 * spin.z(0) - 6.125 * spin.z(1)

[5] The spin_op also provides a mechanism for the expression of circuit synthesis tasks within quantum kernel code. Specifically, operations that encode \(N\)^thorder trotterization of exponentiated spin_op rotations, e.g. \(U = \exp(-i H t)\), where \(H\) is the provided spin_op.

[6] The spin_op can be created within classical host code and quantum kernel code, and can also be passed by value to quantum kernel code from host code.

The spin_op should take on the following structure:

  namespace cudaq {
  class spin_op {
    public:
      spin_op();
      spin_op(const spin_op&);
      bool empty() const;
      std::size_t num_qubits() const;
      std::size_t num_terms() const;
      std::complex<double> get_coefficient();
      bool is_identity() const;
      void for_each_term(std::function<void(spin_op &)> &&) const;
      void for_each_pauli(std::function<void(pauli, std::size_t)> &&) const;
      spin_op& operator=(const spin_op&);
      spin_op& operator+=(const spin_op&);
      spin_op& operator-=(const spin_op&);
      spin_op& operator*=(const spin_op&);
      bool operator==(const spin_op&);
      spin_op& operator*=(const double);
      spin_op& operator*=(const std::complex<double>)
  };

  namespace spin {
    spin_op x(const std::size_t);
    spin_op y(const std::size_t);
    spin_op z(const std::size_t);
  }
}