---
title: PiecewisePolynomialPauliRotations (latest version)
description: API reference for qiskit.circuit.library.PiecewisePolynomialPauliRotations in the latest version of qiskit
source: https://eu-de.quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.circuit.library.PiecewisePolynomialPauliRotations
---

# PiecewisePolynomialPauliRotations

*class* `qiskit.circuit.library.PiecewisePolynomialPauliRotations(num_state_qubits=None, breakpoints=None, coeffs=None, basis='Y', name='pw_poly')`

[GitHub](https://github.com/Qiskit/qiskit/tree/stable/2.5/qiskit/circuit/library/arithmetic/piecewise_polynomial_pauli_rotations.py#L28-L325)

Bases: [`FunctionalPauliRotations`](/docs/api/qiskit/qiskit.circuit.library.FunctionalPauliRotations "qiskit.circuit.library.arithmetic.functional_pauli_rotations.FunctionalPauliRotations")

Piecewise-polynomially-controlled Pauli rotations.

This class implements a piecewise polynomial (not necessarily continuous) function, $f(x)$, on qubit amplitudes, which is defined through breakpoints and coefficients as follows. Suppose the breakpoints $(x_0, ..., x_J)$ are a subset of $[0, 2^n-1]$, where $n$ is the number of state qubits. Further on, denote the corresponding coefficients by $[a_{j,1},...,a_{j,d}]$, where $d$ is the highest degree among all polynomials.

Then $f(x)$ is defined as:

$$
f(x) = \begin{cases}
0, x < x_0 \\
\sum_{i=0}^{i=d}a_{j,i}/2 x^i, x_j \leq x < x_{j+1}
\end{cases}
$$

where if given the same number of breakpoints as polynomials, we implicitly assume $x_{J+1} = 2^n$.

> **Note**
>
> Note the $1/2$ factor in the coefficients of $f(x)$, this is consistent with Qiskit’s Pauli rotations.

**Examples**

```python
>>> from qiskit import QuantumCircuit
>>> from qiskit.circuit.library.arithmetic.piecewise_polynomial_pauli_rotations import\
... PiecewisePolynomialPauliRotations
>>> qubits, breakpoints, coeffs = (2, [0, 2], [[0, -1.2],[-1, 1, 3]])
>>> poly_r = PiecewisePolynomialPauliRotations(num_state_qubits=qubits,
...breakpoints=breakpoints, coeffs=coeffs)
>>>
>>> qc = QuantumCircuit(poly_r.num_qubits)
>>> qc.h(list(range(qubits)));
>>> qc.append(poly_r.to_instruction(), list(range(qc.num_qubits)));
>>> qc.draw()
     ┌───┐┌──────────┐
q_0: ┤ H ├┤0         ├
     ├───┤│          │
q_1: ┤ H ├┤1         ├
     └───┘│          │
q_2: ─────┤2         ├
          │  pw_poly │
q_3: ─────┤3         ├
          │          │
q_4: ─────┤4         ├
          │          │
q_5: ─────┤5         ├
          └──────────┘
```

References:

\[1] Haener, T., Roetteler, M., & Svore, K. M. (2018). Optimizing Quantum Circuits for Arithmetic. [arXiv:1805.12445](https://arxiv.org/abs/1805.12445)

\[2] Carrera Vazquez, A., Hiptmair, R., & Woerner, S. (2022). Enhancing the Quantum Linear Systems Algorithm using Richardson Extrapolation. [ACM Transactions on Quantum Computing 3, 1, Article 2](https://doi.org/10.1145/3490631)

> **Deprecated since version 2.2**
>
> The class `qiskit.circuit.library.arithmetic.piecewise_polynomial_pauli_rotations.PiecewisePolynomialPauliRotations` is deprecated as of Qiskit 2.2. It will be removed in Qiskit 3.0. Use the class PiecewisePolynomialPauliRotationsGate instead.

**Parameters**

- **num\_state\_qubits** ([*int*](https://docs.python.org/3/library/functions.html#int) *| None*) – The number of qubits representing the state.
- **breakpoints** ([*list*](https://docs.python.org/3/library/stdtypes.html#list)*\[*[*int*](https://docs.python.org/3/library/functions.html#int)*] | None*) – The breakpoints to define the piecewise-linear function. Defaults to `[0]`.
- **coeffs** ([*list*](https://docs.python.org/3/library/stdtypes.html#list)*\[*[*list*](https://docs.python.org/3/library/stdtypes.html#list)*\[*[*float*](https://docs.python.org/3/library/functions.html#float)*]] | None*) – The coefficients of the polynomials for different segments of the piecewise-linear function. `coeffs[j][i]` is the coefficient of the i-th power of x for the j-th polynomial. Defaults to linear: `[[1]]`.
- **basis** ([*str*](https://docs.python.org/3/library/stdtypes.html#str)) – The type of Pauli rotation (`'X'`, `'Y'`, `'Z'`).
- **name** ([*str*](https://docs.python.org/3/library/stdtypes.html#str)) – The name of the circuit.

## Attributes

### breakpoints

The breakpoints of the piecewise polynomial function.

The function is polynomial in the intervals `[point_i, point_{i+1}]` where the last point implicitly is `2**(num_state_qubits + 1)`.

**Returns**

The list of breakpoints.

### coeffs

The coefficients of the polynomials.

**Returns**

The polynomial coefficients per interval as nested lists.

### contains\_zero\_breakpoint

Whether 0 is the first breakpoint.

**Returns**

True, if 0 is the first breakpoint, otherwise False.

### mapped\_coeffs

The coefficients mapped to the internal representation, since we only compare x>=breakpoint.

**Returns**

The mapped coefficients.

### name

Type: `str`

A human-readable name for the circuit.

**Example**

```python
from qiskit import QuantumCircuit

qc = QuantumCircuit(2, 2, name="my_circuit")
print(qc.name)
```

```text
my_circuit
```

## Methods

### evaluate

`evaluate(x)`

[GitHub](https://github.com/Qiskit/qiskit/tree/stable/2.5/qiskit/circuit/library/arithmetic/piecewise_polynomial_pauli_rotations.py#L210-L224)

Classically evaluate the piecewise polynomial rotation.

**Parameters**

**x** ([*float*](https://docs.python.org/3/library/functions.html#float)) – Value to be evaluated at.

**Returns**

Value of piecewise polynomial function at x.

**Return type**

[float](https://docs.python.org/3/library/functions.html#float)