From QRNGs to Quantum Annealers: Harvesting True Entropy from the D-Wave QPU

I am a solo researcher working from my back office, digging into the world of quantum. I work with a handful of QRNG hardware. A year of work with these devices from several hardware developers, has thought me a lot. I know how they behave their streangth and weaknesses, and how to control them using Python. But Randomness from QRNG is not same as Randomness from a Annealing Box like D-Wave quantum system or an Ion Trap system such as ionQ. So let me explain. I am here to share my findings with anyone doing work with Quantum Random generators needing to do Crypto or run large or small simulations. So, as a researcher in quantum projects, you know that in the world of computational science, randomness is the lifeblood of exploration — from cryptography and Monte Carlo simulations to drug discovery and weather modeling. I use them in my projects regulalrly. Frankly, I would not be building a Quantum-Enhanced Drug discovery system if my only choice is to use PRNGs. Traditionally, we rely on pseudorandom number generators (PRNGs), the deterministic algorithms that the beat way I can put it, "mimic" randomness. They’re fast and practical, no work involved to harvest them but ultimately predictable. Enter Quantum Random Number Generators (QRNGs), which harvest entropy directly from quantum phenomena such as photon polarization or vacuum fluctuations.

Devices like USB or PCIe QRNGs from Crypta Labs or ID Quantique produce hardware-level quantum entropy at impressive rates (0.5–8 Mbps). My favorite hardware is the Cryptalab. These are superb for many use cases , but if you want to go deeper, if you want to extract entropy from quantum interactions themselves, the next step is to harvest it from quantum processors. Let me share.

Why D-Wave Entropy Matters

The D-Wave quantum annealer doesn’t just find solutions to optimization problems, it explores an entire energy landscape as it relaxes toward a minimum. Each anneal produces collapse signature a pattern of qubit states shaped by the physical noise, coupling strengths, and tunneling probabilities inside the device. You can not do that with a QRNG hardware.

That collapse trace can be repurposed as quantum entropy: randomness derived from actual superposition dynamics rather than static quantum events. When you extract this data — even if your problem is trivial, you’re effectively bottling a fragment of the quantum field’s noise landscape. That’s why D-Wave entropy often exhibits richer statistical properties than hardware QRNGs or PRNGs. How do I know this? Well, in my applications in Tornado Forecasting, Quantum Drug Discovery (QuantumCURE), I offer QRNG, PRNG, QRNG and PRNG (to compare outputs), D-wave and soon ionq entropies for molecular docking. Results speaking for themselves. So, here I share with you a Python Script you can expand for D-Wave submission. Is it Expensive? Yeah, but harvesting a few hundred thousand quantum Randomness can be achgieved with minimum expenses. A price I am happy to pay for the best randomness I can get.

Writing a Simple QUBO for Entropy Harvesting

Here’s an example you can run via D-Wave’s Ocean SDK (Python).

D-Wave box needs a QUBO to communicate with your goal. We’ll create a simple QUBO (Quadratic Unconstrained Binary Optimization) problem — normally used for finding minima — but here, our goal isn’t the solution.

It’s the collapse samples themselves.

# quantum_entropy_from_dwave.py

from dwave.system import DWaveSampler, EmbeddingComposite

import numpy as np

# Define a simple QUBO matrix

#a mathematical representation used to encode optimization problems. It is defined as a #binary quadratic model where the objective function is expressed in terms of binary #variables.

#QUBO problems are computationally hard and can represent a wide range of optimization #problems across various scientific fields.

#The QUBO formulation is closely related to the Ising Model, allowing for easy conversion #between the two.

It is commonly used in quantum computing, particularly in quantum annealing and #optimization algorithms.

#The structure of QUBO matrices can be exploited to enhance the scalability and applicability #of quantum algorithms to real-world problems.

# A small Ising-like system — intentionally trivial

Q = {(0,0): -1, (1,1): -1, (0,1): 0.5}

# Initialize sampler (requires valid D-Wave API token)

sampler = EmbeddingComposite(DWaveSampler())

# Submit to D-Wave QPU

sampleset = sampler.sample_qubo(Q, num_reads=100)

# Extract the raw bitstrings — our entropy source

bitstrings = [list(s.values()) for s in sampleset.record.sample]

# Convert bitstrings to integers

entropy_values = [int(''.join(map(str, b)), 2) for b in bitstrings]

print("Quantum Entropy Samples:")

print(entropy_values[:10]) # show first 10 samples

# Optional: save as entropy seeds

np.savetxt("dwave_entropy_seeds.txt", entropy_values, fmt="%d")

**Sample Output**

Quantum Entropy Samples:

[3, 0, 1, 2, 2, 3, 1, 0, 3, 2]

Each number corresponds to a quantum collapse — a bitstring produced by D-Wave’s qubit system as it resolves the QUBO’s energy surface.

When you analyze thousands of such runs, you’ll notice subtle non-uniform distributions, small deviations from classical randomness that encode the hardware’s quantum noise fingerprint. That is what you want. In my drug discovery simulations Entropy from D-Wave exhibits a deeper molecular search space than PRNG.

How to Use D-Wave Entropy

Once harvested, this entropy can be injected anywhere PRNGs are used:

Seeding molecular docking (as in QuantumCURE)

Initializing Monte Carlo physics simulation

Driving stochastic neural networks or diffusion models

Feeding symbolic engines like Zaban-e-Quantum, my quantum linguistic framework, a quantum dictionary of Glyphs.

Example usage inside your simulation stack:

```python

entropy_seed = entropy_values[0] # pick one quantum sample

np.random.seed(entropy_seed) # use as seed for classical RNG

The hybrid loop becomes:

> Quantum → Classical → Symbolic → Result

Comparison with IonQ and QRNG Hardware

| Source | Mechanism | Entropy Origin | Throughput | Notes |

Source	Mechanism	Entropy Origin	Throughput	Notes
USB/PCIe QRNG	Photon polarization or vacuum noise	Single-event collapse	~0.5–8 Mbps	Great for fast entropy; hardware-reliable
D-Wave Annealer	Energy landscape tunneling	Collective qubit collapse	10–1000 samples/s	Deep, correlated entropy (structure-rich)
IonQ Ion Trap	Spin-state interference	Controlled decoherence	Variable	Excellent for entanglement-based seeding

D-Wave and IonQ provide **structured entropy** — the kind that carries *context* from the quantum process itself.

That’s what makes it valuable for *entanglement-aware AI systems* like Zaban and *entropy-driven molecular discovery* pipelines like QuantumCURE.

Every QUBO you run on a D-Wave system doesn’t just give you an answer — it gives you a snapshot of reality at the quantum boundary.

For a citizen scientist or independent researcher, this is a profound opportunity:

to harvest nature’s computation itself, transform it into usable seeds, and feed it into systems that explore chemistry, weather, or even language at a quantum depth.

> “Entropy is nature’s handwriting — the signature of uncertainty that reveals structure.”

Mansour Ansari, QuantumLaso LLC

PS: next post will cover harvesting entropy from ionQ box.

#QuantumComputing #DWAVE #QuantumEntropy #DrugDiscovery #CitizenScience #QuantumCURE #Zaban #QRNG #QuantumAI #QUBO #IonQ #QuantumRandomness #AIResearch #QuantumInnovation