Angle-based

Higher-Order Angle Encoding

Extends angle encoding with polynomial feature interactions without entanglement.

Qubits

4

Depth

1

Total Gates

4

Simulability

Simulable

Mathematical Formulation

∣ψ(x)⟩=⨂q=0n−1Ra(∑ScS∏i∈Sxi)∣0⟩|\psi(\mathbf{x})\rangle = \bigotimes_{q=0}^{n-1} R_a\left(\sum_{S} c_S \prod_{i \in S} x_i\right)|0\rangle

Description

Higher-order angle encoding extends the basic angle encoding by computing polynomial combinations of input features before encoding them as rotation angles. Instead of mapping each feature directly to a qubit rotation, the encoding first computes all polynomial terms up to a specified order (e.g., x_0·x_1, x_0·x_2, x_1·x_2 for order 2), then distributes these terms across qubits.

Like basic angle encoding, the result is a product state with no entanglement, making it classically simulable. However, the polynomial feature expansion captures nonlinear feature interactions at the classical preprocessing stage, analogous to classical polynomial kernel methods. This provides richer feature representations while maintaining the simplicity of single-qubit rotations.

The number of polynomial terms grows as Σ_{k=1}^{order} C(n,k). For order 2, this is n + n(n-1)/2 terms; for order n, it's 2^n - 1 terms (exponential). A "sum" combination mode averages terms assigned to each qubit, while "product" mode multiplies them.

Circuit Diagram

Property Radar

Properties

Qubits
4
Circuit Depth
1
Total Gates
4
Single-Qubit Gates
4
Two-Qubit Gates
0
Parameters
0
Entangling
No
Simulability
Simulable
Expressibility
—
Entanglement Capability
—
Trainability
0.93
Noise Resilience
—

Resource Scaling

How resource requirements grow with the number of input features.

FeaturesQubitsDepthGates2Q Gates
22120
44140
88180
16161160

Code Examples

Higher-order angle encoding with PennyLane using order-2 polynomial features.

python
from encoding_atlas import HigherOrderAngleEncoding
import pennylane as qml
import numpy as np

enc = HigherOrderAngleEncoding(n_features=4, order=2, rotation="Y")
dev = qml.device("default.qubit", wires=enc.n_qubits)

@qml.qnode(dev)
def circuit(x):
    enc.get_circuit(x, backend="pennylane")
    return qml.state()

x = np.array([0.1, 0.5, 1.2, 2.3])
state = circuit(x)

When to Use This Encoding

  • Capturing polynomial feature interactions without entanglement
  • Classical polynomial kernel emulation in quantum circuits
  • Low-depth feature maps for NISQ devices needing nonlinear encoding
  • Feature expansion preprocessing combined with variational layers
  • Research into product-state expressibility limits

Pros & Cons

Advantages

  • Captures polynomial feature interactions (x_i·x_j terms)
  • Constant depth (O(1) per rep) — extremely NISQ-friendly
  • High trainability (~0.93) with no barren plateau risk
  • Flexible order and combination modes
  • No entanglement overhead — purely single-qubit operations

Limitations

  • No entanglement — classically simulable, no quantum advantage
  • Term count grows combinatorially with order (2^n - 1 at max order)
  • Limited to ~10 features before polynomial explosion
  • Product state expressibility fundamentally limited
  • Polynomial interactions computed classically — quantum circuit adds no benefit for this computation

References

  1. [1]Schuld, M., Sweke, R., & Meyer, J.K. (2021). Effect of data encoding on the expressive power of variational quantum machine learning models. Physical Review A, 103(3), 032430.
  2. [2]Havlíček, V., et al. (2019). Supervised learning with quantum-enhanced feature spaces. Nature, 567(7747), 209–212.