Skip to content

Linear Pauli Rotations

This function performs a rotation on a series of \(m\) target qubits, where the rotation angle is a linear function of an \(n\)-qubit control register, as follows:

\[ \left|x\right\rangle _{n}\left|q\right\rangle _{m}\rightarrow\left|x\right\rangle _{n}\prod_{k=1}^{m}\left(\cos\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)- i\sin\left(\frac{a_{k}}{2}x+\frac{b_{k}}{2}\right)P_{k}\right)\left|q_{k}\right\rangle \]

where \(\left|x\right\rangle\) is the control register, \(\left|q\right\rangle\) is the target register, each \(P_{k}\) is one of the three Pauli matrices \(X\), \(Y\), or \(Z\), and \(a_{k}\), \(b_{k}\) are the user given slopes and offsets, respectively.

For example, the operation of a linear \(Y\) rotation on a zero-input qubit is

\[ \left|x\right\rangle _{n}\left|0\right\rangle \rightarrow\left|x\right\rangle _{n}\left( \cos\left(\frac{a}{2}x+\frac{b}{2}\right)\left|0\right\rangle +\sin\left(\frac{a}{2}x+\frac{b}{2}\right)\left|1\right\rangle \right) \]

Such a rotation can be realized as a series of controlled rotations as follows:

\[ \left[R_{y}\left(2^{n-1}a\right)\right]^{x_{n-1}}\cdots \left[R_{y}\left(2^{1}a\right)\right]^{x_{1}} \left[R_{y}\left(2^{0}a\right)\right]^{x_{0}}R_{y}\left(b\right) \]

Syntax

Function: LinearPauliRotations

Parameters:

  • num_state_qubits: PositiveInt
  • bases: Union[PauliLetters, List[PauliLetters]] with PauliLetters = Union['x', 'y', 'z', 'X', 'Y', 'Z']
  • offsets: Union[float, List[float]]
  • slopes: Union[float, List[float]]
{
  "function": "LinearPauliRotations",
  "function_params": {
    "num_state_qubits": 3,
    "bases": ["Y", "Y", "Y"],
    "offsets": [0.1, 0.3, 0.33],
    "slopes": [2.1, 1, 7.0]
  }
}

Example: Three Y Rotations Controlled by a 6-qubit State

This example generates a quantum program with a \(6\)-qubit control state and \(3\) target qubits, acted upon by Y rotations with different slopes and offsets.

{
  "functions": [
    {
      "name": "main",
      "body":[
         {
            "function":"LinearPauliRotations",
            "function_params":{
               "num_state_qubits":6,
               "bases":[
                  "Y",
                  "Y",
                  "Y"
               ],
               "offsets":[
                  0.1,
                  0.3,
                  0.33
               ],
               "slopes":[
                  2.1,
                  1,
                  7.0
               ]
            }
         }
      ]
    }
  ]
 }
from classiq import Model, synthesize, show
from classiq.builtin_functions import LinearPauliRotations

NUM_STATE_QUBITS = 6
BASES = ["Y", "Y", "Y"]
OFFSETS = [0.1, 0.3, 0.33]
SLOPES = [2.1, 1, 7.0]

model = Model()
linear_pauli_rotations_params = LinearPauliRotations(
    num_state_qubits=NUM_STATE_QUBITS, bases=BASES, offsets=OFFSETS, slopes=SLOPES
)
model.LinearPauliRotations(linear_pauli_rotations_params)

quantum_program = synthesize(model.get_model())
show(quantum_program)

The figure shows the resulting quantum program in interactive mode, with the part acting on the first qubit decomposed to demonstrate the partition into individually controlled Y rotations.

 Linear_Pauli_Rotations_interactive_example