Sequence and Image Transformations with Monarq: Quantum Implementations for NISQ Devices

This paper introduces the Monarq framework, which integrates QCrank encoding with EHands polynomial transformations to demonstrate reliable implementations of fundamental signal and image processing tasks, such as convolution and edge detection, on current noisy intermediate-scale quantum hardware.

The Gist

Here is an explanation of the paper, translated into everyday language with analogies.

The Big Picture: Driving a Shaky Sports Car

Imagine you have a brand-new, incredibly fast sports car. It’s capable of speeds no other car can match. However, right now, the road it drives on is full of potholes and gravel (this represents the current "noisy" state of quantum computers).

The authors of this paper asked a simple question: "Can we use this shaky, fast car to do everyday tasks, like editing a photo or mixing music, without crashing?"

They built a toolkit called Monarq. Think of Monarq as a special set of adapters and instructions that lets you drive this quantum car on the gravel road and still get a smooth ride. They proved that yes, you can do useful work on these current machines, even if they aren't perfect yet.

---

The Two Main Ingredients

To make this work, the team combined two existing technologies that speak the same "language."

1. QCrank (The Loading Dock)

• What it is: A way to get data into the quantum computer.
• The Analogy: Imagine a library. Usually, to find a book, you have to walk down every aisle. QCrank is like a magical conveyor belt that instantly places every book on the correct shelf at the exact same time. It takes a list of numbers (like a photo or a sound wave) and loads them into the quantum computer efficiently.
• Why it matters: It saves time and energy, which is crucial because quantum computers lose their "memory" very quickly.

2. EHands (The Workshop)

• What it is: A way to do math inside the quantum computer.
• The Analogy: Imagine you need to build a complex shape out of clay. Instead of sculpting the whole thing at once (which is hard and messy), EHands gives you simple, pre-made blocks (like LEGO bricks). You snap them together to do multiplication or addition.
• Why it matters: These "blocks" are simple enough that the quantum computer doesn't break under the pressure of the math.

The Magic Connection:
The best part is that the Loading Dock (QCrank) and the Workshop (EHands) use the exact same language. You don't need a translator. You can load the data and immediately start building with it.

---

What Did They Actually Do? (The Tests)

The team tested this toolkit on four different tasks, ranging from simple math to complex image processing.

1. Mixing Signals (Convolution)

• Task: Blending two lists of numbers together.
• Analogy: Like blending a strawberry smoothie and a banana smoothie together to make a new flavor.
• Result: They did this on a real IBM quantum computer. It worked, but the "flavor" was a little weak, so they had to turn up the volume (calibration) to match the real taste.

2. Breaking Down Sound (Discrete-Time Fourier Transform)

• Task: Taking a complex signal and finding the specific frequencies inside it.
• Analogy: Listening to a chord on a piano and identifying exactly which notes (C, E, G) are being played.
• Result: They did this on a perfect computer simulation. It worked perfectly, proving the math is correct.

3. Finding Slopes (Squared Gradient)

• Task: Looking at an image and calculating how steep the "hills" are in the picture.
• Analogy: Imagine a topographic map. This tool tells you where the ground is flat and where it is a steep cliff.
• Result: They tested this on a real quantum chip. The results were a bit "fuzzy" (due to the noise), but they could clearly see the cliffs and the flat ground.

4. Tracing Outlines (Edge Detection)

• Task: Finding the edges of objects in a photo.
• Analogy: Taking a black-and-white photo of a cat and using a highlighter to trace only the outline of the cat, ignoring the fur inside.
• Result: They simulated this on a larger scale. The computer successfully identified the edges of bacteria in a photo.

---

The Results: Good News, But Be Realistic

The Good News:
They proved that you can run these image and signal processing tasks on current quantum hardware. The "Monarq" framework acts like a bridge, connecting the messy real world to the quantum world.

The Reality Check:

• Not Faster Yet: Right now, a normal classical computer (like your laptop) is still faster at doing these tasks. This experiment isn't about beating the speed of light; it's about proving the quantum car can drive.
• The "Noise" Problem: Because the quantum computers are "noisy," the results sometimes came out too quiet. The team had to apply a "calibration factor" (like turning up the gain on a microphone) to make the results match reality.
• Size Limits: They could only process small images (like a 32x32 pixel grid). To do a full HD photo, they would need to chop the image into tiny pieces and process them one by one.

The Conclusion

Think of this paper as the Wright Brothers' first flight. The plane didn't carry passengers, and it didn't go very far. But it proved that flight is possible.

The Monarq framework shows us that quantum computers can eventually handle complex tasks like medical imaging, autonomous driving sensors, and scientific data analysis. We aren't there yet, but this toolkit gives us the blueprint for how to get there when the hardware gets better.

Technical Summary

Here is a detailed technical summary of the paper "Sequence and Image Transformations with Monarq: Quantum Implementations for NISQ Devices."

1. Problem Statement

Quantum computing holds theoretical promise for signal and image processing tasks (e.g., convolution, Fourier transforms, edge detection). However, translating these algorithms into practical applications on Noisy Intermediate-Scale Quantum (NISQ) devices faces significant hurdles:

• Hardware Constraints: Inherent noise, limited coherence times, and restricted qubit connectivity prevent the execution of deep circuits.
• Encoding and Processing Gaps: Many existing proposals require deep circuits or lack efficient methods to encode real-valued data and perform calculations before decoherence occurs.
• Experimental Validation: There is a scarcity of end-to-end experimental demonstrations on real quantum hardware that validate the reliability of quantum data processing operations compared to classical ground truths.

The core research question is: Can quantum implementations of classical data processing operations yield reliable results on current NISQ hardware?

2. Methodology

The authors introduce Monarq, a unified quantum data processing framework designed specifically for NISQ constraints. The methodology relies on the seamless integration of two existing protocols:

• QCrank Encoding:
  • Function: Efficiently inputs real-valued sequences into quantum processors.
  • Mechanism: Uses parallel Uniformly Controlled Rotation (UCR) gates to encode $n_d \cdot 2^{n_a}$ real values ($x \in [-1, 1]$) using $n_a$ address qubits and $n_d$ data qubits.
  • Encoding Scheme: Utilizes Expectation Value Encoding (EVEN), where a value $x$ is encoded via a rotation $R_y(\theta)$ with $\theta = \arccos(x)$.
• EHands Protocol:
  • Function: Performs polynomial transformations on quantum hardware.
  • Mechanism: Defines elementary arithmetic operations (Multiplication $\Pi$, Weighted Sum $\Sigma$, Negation) that compose into shallow circuits.
  • Compatibility: Uses the same EVEN encoding as QCrank, allowing data encoded by QCrank to be processed directly by EHands operators without intermediate conversion.
• Integration (Monarq Pipeline):
  1. Encode: Classical data is loaded into a quantum state using QCrank.
  2. Compute: EHands operators apply polynomial transformations (e.g., $x^2$, $xy$) to the data qubits.
  3. Decode: Results are retrieved via Pauli-Z measurement expectation values, conditioned on the address register.
• Error Mitigation:
  • Calibration: A post-processing attenuation factor is applied to measured expectation values to correct for systematic signal attenuation caused by gate infidelity.
  • Tiling: For large images (e.g., edge detection), the input is subdivided into tiles processed by multiple smaller circuits to fit within hardware qubit and gate limits.
  • Error Analysis: Total error is modeled as the quadrature sum of shot noise ($\sigma_{shot}$) and cumulative gate infidelity ($\sigma_{hw}$).

3. Key Contributions

1. Monarq Framework: A novel integration of QCrank data encoding and EHands polynomial computation via a shared EVEN encoding scheme, creating a streamlined quantum data processing pipeline.
2. Algorithm Validation: Implementation and benchmarking of four diverse algorithms:
   • Convolution: Element-wise multiplication of two sequences.
   • Discrete-Time Fourier Transform (DFT): Computed via in-situ summation (by not measuring address qubits).
   • Squared Gradient: Computation of image gradients using central differences.
   • Edge Detection: Combining 2D gradients with thresholding.
3. Experimental Methodology: A standardized procedure for assessing processing accuracy using Root Mean Square Error (RMSE) against classical ground truth, including specific calibration for hardware attenuation.
4. NISQ Optimization: Demonstration of shallow, non-variational circuits tailored to current hardware constraints (e.g., IBM Quantum Processors), avoiding the "barren plateau" issues common in variational approaches.

4. Experimental Results

The authors validated the framework on IBM Quantum hardware (Pittsburgh, Kingston, Aachen) and ideal simulators.

• Convolution (Hardware):
  • Setup: 7-qubit circuit on IBM Pittsburgh.
  • Performance: Achieved an RMSE of 0.065 after post-processing calibration.
  • Limit: Feasible for circuits requiring up to ~200 transpiled CNOT gates; precision degraded significantly beyond this threshold.
• Squared Gradient (Hardware):
  • Setup: 8-qubit circuits on IBM Aachen (64 circuits tiled for a $32 \times 32$ image).
  • Performance: Strong visual correspondence with classical gradient maps. Required a calibration factor of 2.9.
  • Insight: Confirmed that quantum circuits can reliably detect significant image features ($G^2_x > 0.1$).
• DFT (Simulator):
  • Setup: 20-qubit circuit on ideal simulator (Gravitational wave signal analysis).
  • Performance: High fidelity across selected frequency ranges. Deviations were purely due to shot noise, reducible by increasing shot count.
• Edge Detection (Simulator):
  • Setup: 20-qubit circuit on ideal simulator (192 $\times$ 128 pixel image tiled into 24 circuits).
  • Performance: Successfully identified boundaries and internal structures while suppressing noise, producing a clean binary edge map.
• Error Scaling: Accuracy is inversely proportional to the number of CNOT gates. Hardware runs showed attenuation factors (e.g., 1.96 for convolution, 2.9 for gradient) that were predictable and correctable.

5. Significance

• Feasibility Benchmark: This work establishes that meaningful computational results for classical data processing tasks are achievable on current NISQ hardware, even without claiming "quantum advantage" over classical methods.
• Foundation for Future Algorithms: The framework provides fundamental building blocks (convolution, transforms, gradients) necessary for developing advanced quantum algorithms in machine learning and computer vision.
• Practical Roadmap: By identifying error scaling (gate count vs. accuracy) and demonstrating tiling strategies, the paper offers a practical roadmap for scaling quantum data processing as hardware improves.
• Educational Value: It highlights the practical challenges of NISQ algorithm development, such as calibration, shot noise management, and circuit depth constraints, serving as a reference for future research in quantum signal processing.