Can Quantum Computing Detect Credit Card Fraud Better Than AI? I Ran the Experiment.

Spoiler: Not yet. But what I found along the way might change how we think about quantum machine learning entirely.

Every second, thousands of credit card transactions flash through global payment networks. Hidden among them — fraud. Invisible to the naked eye, detectable only through pattern recognition at machine speed.

Classical AI handles this well. Random Forest, XGBoost, gradient-boosted trees — these models have become the workhorses of fraud detection, achieving impressive accuracy on datasets with hundreds of features and millions of transactions.

But there’s a question nobody in the financial AI space seems to be asking seriously:

What happens when you replace the kernel in a Support Vector Machine with a quantum circuit?

I spent weeks running that experiment. Here’s what I found.

Why Quantum Kernels? A Quick Primer

If you’ve used an SVM before, you know the kernel trick — it’s the magic that lets a linear classifier draw non-linear decision boundaries by implicitly mapping data into a higher-dimensional space.

Classical kernels — RBF, polynomial — do this mathematically. They’re fast, well-understood, and battle-tested.

Quantum kernels do something different. They use a quantum circuit to encode classical data into a quantum state. The inner product between two quantum states becomes the kernel value. The key idea: a quantum computer can access a Hilbert space of exponentially large dimension — spaces so vast that no classical computer can even represent them explicitly.

The theoretical promise: for the right datasets, quantum kernels might find class separation that classical kernels simply cannot.

The critical question: is financial fraud data “the right dataset”?

The Experiment

I built a complete benchmarking pipeline using the IEEE-CIS Fraud Detection dataset — 590,540 real transactions, 433 features, with a fraud rate of 3.5%. One of the most realistic fraud datasets publicly available.

What I tested:

Classical baselines:

• XGBoost
• Random Forest
• RBF-SVM
• Polynomial-SVM

Quantum configurations:

• ZZFeatureMap quantum kernel SVM
• Three dimensionality reduction methods: PCA, LDA, t-SNE
• Three qubit scales: 4, 6, 8 qubits
• Three noise levels: p=0 (ideal), p=0.001 (low), p=0.01 (medium NISQ)

That’s 9 quantum configurations × 3 noise levels = 27 noise experiments, plus all classical baselines.

Everything ran on AWS EC2 with 96 vCPUs. The quantum simulations alone took days.

The Results — Honest Numbers

Classical baselines first:

Model AUC-ROC F1 Random Forest 0.925 0.673 XGBoost 0.921 0.637 RBF-SVM 0.790 0.294 Poly-SVM 0.766 0.362

Random Forest wins. Clean. Expected.

Quantum kernel results:

Config AUC-ROC KAS LDA 8q 0.530 0.371 PCA 6q 0.497 0.333 LDA 4q 0.462 0.169 PCA 8q 0.375 0.368

Best quantum AUC: 0.530. Best classical AUC: 0.925.

The gap is 0.40 AUC points. That’s a significant gap by any measure.

And every single quantum configuration achieved F1 = 0.000 — meaning the quantum classifier consistently predicted only the majority class, failing to identify a single fraud transaction.

So Quantum Lost. Why Is This Paper Worth Reading?

Because the headline result isn’t the interesting part.

Here’s what is.

Finding 1: I Invented a New Metric — The Kernel Alignment Score

The biggest problem in quantum kernel research right now is this: how do you know if your quantum kernel is actually doing something quantum?

A quantum kernel might produce decent AUC values while just approximating what a classical RBF kernel would do. That’s not interesting. That’s expensive classical computation disguised as quantum.

I introduced the Kernel Alignment Score (KAS) — a diagnostic metric that measures how structurally different a quantum kernel matrix is from a classical RBF kernel matrix.

The math is centered kernel alignment:

KAS(K_Q, K_C) = <K̃_Q, K̃_C>_F / (||K̃_Q||_F · ||K̃_C||_F)

KAS approaching 1 → quantum kernel mimics classical structure. KAS approaching 0 → quantum kernel exploring genuinely different feature space.

What I found: KAS values ranged from 0.169 to 0.371 across all configurations. The quantum circuits are genuinely exploring different regions of feature space — not approximating classical kernels. The quantum feature maps are doing real quantum things.

The problem isn’t that the quantum kernel isn’t quantum enough. The problem is that being different isn’t the same as being discriminatively better.

This insight is actionable. Before deploying a quantum kernel in production, run KAS. If KAS is high, don’t bother — your quantum hardware is just an expensive classical approximation. If KAS is low but performance is poor, the quantum feature space is structurally distinct but not discriminatively useful for your specific task.

KAS is a go/no-go signal. That’s a practically useful tool regardless of whether quantum wins or loses.

Finding 2: LDA Beats PCA for Quantum Kernels — By a Lot

This is the finding that surprised me most.

Most QML papers don’t think carefully about how they reduce dimensionality before feeding data into quantum circuits. They just use PCA because it’s the default.

I tested three methods: PCA, LDA, and t-SNE.

LDA won decisively.

LDA at 8 qubits: AUC = 0.530 PCA at 6 qubits: AUC = 0.497 t-SNE at 6 qubits: AUC = 0.497

But more interesting than the numbers is why.

PCA maximizes variance. It finds the directions of maximum spread in the data. For fraud detection, the most “spread out” directions aren’t necessarily the most discriminative directions. Fraudulent transactions might differ subtly from legitimate ones in ways that aren’t variance-maximizing.

LDA maximizes class separability — the Fisher criterion. It explicitly finds the projection that separates fraud from non-fraud as cleanly as possible.

When you feed LDA-projected features into a ZZFeatureMap quantum circuit, you’re giving the circuit features that already encode inter-class discrimination. The quantum encoding then amplifies that structure.

Practical takeaway: If you’re building quantum kernel models, your dimensionality reduction method matters as much as your circuit design. Don’t default to PCA.

Finding 3: Noise Made the Quantum Classifier Better

This one genuinely confused me when I first saw it.

For t-SNE configurations, AUC improved as I added more depolarizing noise:

t-SNE 8q AUC p=0 (ideal) 0.375 p=0.001 (low noise) 0.462 p=0.01 (medium noise) 0.501

More noise → better performance. How?

This is the noise-enhancement effect, and it turns out it’s a known phenomenon in quantum computing research (Huang et al., 2026 identified it independently on analog hardware).

The intuition: depolarizing noise acts as implicit regularization on the quantum kernel matrix. It smooths out overfitting to the specific 400-sample training subset. In a high-dimensional quantum feature space with limited data, noise prevents the kernel from fitting noise in the data itself.

This has a practical implication that sounds counterintuitive: for small-sample quantum kernel experiments on tabular data, you might not want to minimize hardware noise.

The Honest Interpretation

Let me be direct about what these results mean.

Quantum kernel SVMs cannot currently compete with classical tree-based methods on financial fraud detection. The AUC gap of 0.40 points is real and significant.

But this isn’t a story about quantum computing failing. It’s a story about where we are in the NISQ era and what the real constraints are.

The experiment used 400 samples for quantum evaluation — necessary because quantum kernel matrix computation scales as O(n²) on classical simulators. With 400 samples, a classifier learning to detect fraud in a 3.5% fraud-rate dataset has limited statistical power.

The constraint isn’t the quantum algorithm. The constraint is classical simulation of quantum circuits. When fault-tolerant quantum hardware arrives — when we can run 50-qubit circuits on real hardware with low noise and evaluate quantum kernels on 10,000+ samples — this comparison needs to be rerun.

The KAS metric I introduced will help researchers understand, when that day comes, whether the quantum kernel is genuinely exploiting quantum structure or just approximating classical methods expensively.

What’s Next

This paper opened three research directions I’m actively thinking about:

1. Cost-sensitive quantum learning The F1=0 failure mode suggests quantum SVMs need explicit class-weighting mechanisms adapted for quantum kernels. Classical cost-sensitive SVMs handle imbalance through misclassification penalties — quantum variants of this don’t exist yet.

2. Fraud-specific quantum feature maps ZZFeatureMap is a general-purpose feature map. A feature map designed specifically for transaction data — encoding temporal patterns, merchant categories, and velocity features directly into circuit structure — might change the picture entirely.

3. Real hardware validation IBM Quantum’s Heron processors and IonQ’s trapped-ion systems are reaching fidelities where small-scale experiments become meaningful. Running this on real hardware with real noise profiles (not simulated) is the next step.

The Paper

If you want the full technical details — equations, all 27 noise experiments, the KAS formulation — the paper is published on Zenodo:

DOI: 10.5281/zenodo.20094653

The complete code is on GitHub: quantum-kernel-fraud-detection

Final Thought

We’re at an interesting moment in quantum machine learning. The hardware is getting better every year. The algorithms are maturing. The theoretical foundations are solid.

But the honest empirical work — running real experiments on real datasets and reporting what actually happens, not just what theory predicts — is still relatively rare.

Quantum doesn’t win yet on fraud detection. But the why of that loss contains signals about where quantum kernels might eventually win. LDA outperforming PCA, noise acting as regularization, KAS measuring genuine quantum structure — these are data points toward a theory of when and why quantum kernels will matter.

That theory is still being written.

Charan Panthangi is a Lead AI Engineer at a Fortune 500 media conglomerate, IIM Indore alumni, and IIT Madras Quantum Computing certification holder. He has published five peer-reviewed papers in applied AI and quantum machine learning.

LinkedIn: linkedin.com/in/charan-panthangi Paper DOI: 10.5281/zenodo.20094653