Forem: David Graves

When Quantum Helps the Cops: How D-Wave’s Hybrid Computer Optimized Police Response Times

David Graves — Mon, 13 Oct 2025 18:11:10 +0000

“Hybrid-quantum application reduced time to solution from four months to four minutes and cut average incident response times by nearly 50%.”
— D-Wave & North Wales Police, September 2025

A Real-World Quantum Success Story

For years, “quantum advantage” has felt like something perpetually just out of reach. But this fall, North Wales Police quietly showed the world that the future might already be here.

In a partnership with D-Wave, they built a hybrid quantum application that helped optimize where police vehicles should be placed across their region, balancing coverage and minimizing response times.

And it worked: what once took months of planning was reduced to minutes, and average response times fell by nearly half. That’s not just theory…that’s quantum physics helping people on the ground.

The Optimization Problem in Plain English

Think of the challenge like this:

You’ve got a limited number of patrol cars and a map divided into different zones. You can park each vehicle somewhere, but you don’t know exactly where incidents will happen next.

The challenge? Put the vehicles where they’ll be most useful, so that no matter where the next call comes from, someone can get there fast.

The tricky part is that there’s no single “right” answer…just an insane number of possible combinations. If you have 10 cars and 20 zones, that’s billions of potential arrangements. Even the best classical algorithms can bog down trying to find the ideal balance between distance, demand, and coverage.

That’s where quantum annealing comes in. Instead of checking every possible configuration one by one, it uses quantum effects to explore many possibilities at once. Think of it like watching marbles roll across a bumpy landscape. Each valley is a potential solution. The goal is to find the deepest one, the global best.

A Toy Example: Placing Patrol Cars with Python

Here’s a simplified demo that shows what this kind of optimization feels like in code. We’ll use D-Wave’s open-source dimod library and a simulated annealer (which you can later replace with a real D-Wave solver).

from dimod import BinaryQuadraticModel
from dwave.samplers import SimulatedAnnealingSampler

vehicles = ['A', 'B']
zones = [1, 2, 3]
demand = {1: 2.0, 2: 1.0, 3: 3.0}
distance = {
    (1,1): 0, (1,2): 5, (1,3): 9,
    (2,1): 5, (2,2): 0, (2,3): 4,
    (3,1): 9, (3,2): 4, (3,3): 0
}

Q = {}
penalty = 50.0

# Objective: minimize expected response time to incidents
demand_weight = 0.5
for v in vehicles:
    for i in zones:
        response_cost = sum(demand[j] * distance[(i, j)] for j in zones)
        Q[((v, i), (v, i))] = response_cost - demand_weight * demand[i]

# Constraint 1: each vehicle assigned to exactly one zone
for v in vehicles:
    for i in zones:
        Q[((v, i), (v, i))] = Q.get(((v, i), (v, i)), 0) - 2 * penalty
    for i in zones:
        for j in zones:
            if i < j:
                Q[((v, i), (v, j))] = Q.get(((v, i), (v, j)), 0) + 2 * penalty

# Constraint 2: no two vehicles assigned to the same zone
for i in zones:
    for v1_idx, v1 in enumerate(vehicles):
        for v2 in vehicles[v1_idx + 1:]:
            # Penalize both vehicles being in the same zone
            Q[((v1, i), (v2, i))] = Q.get(((v1, i), (v2, i)), 0) + 2 * penalty

# Solve
bqm = BinaryQuadraticModel.from_qubo(Q)
sampler = SimulatedAnnealingSampler()
result = sampler.sample(bqm, num_reads=100).first

print(f"Energy: {result.energy}")
print("\nBest configuration:")
assigned_zones = {}
for var, val in result.sample.items():
    if val:
        v, i = var
        assigned_zones[v] = i
        print(f"  Vehicle {v} -> Zone {i}")
        avg_response = sum(demand[j] * distance[(i, j)] for j in zones) / sum(demand.values())
        print(f"    Expected response time: {avg_response:.2f}")

This little model tries to “place” each patrol car in the zone that best balances travel cost and incident likelihood. In real-world versions, dozens (or hundreds) of such constraints are modeled at once: travel time, shift overlap, coverage radius, even historical crime data.

The real D-Wave solver does the same thing on a much larger scale, using quantum annealing to explore solutions faster than classical methods can.

From Demo to Deployment

The North Wales Police project took this concept out of simulation and into daily operations. They fed real geographic data, historical incident logs, and shift schedules into a hybrid quantum-classical solver hosted by D-Wave.

The hybrid model used quantum annealing to explore thousands of deployment configurations, while classical algorithms refined and verified the best candidates.

The results were dramatic:

4 months to 4 minutes: time to generate new deployment strategies
~50% improvement in average response times
90% of incidents responded to within the target window

That’s not just faster computing, that’s faster help arriving where it’s needed most. The same logic can optimize ambulance routes, delivery fleets, or even power grids.

The Quiet Revolution

The North Wales Police project shows something profound: quantum computing doesn’t need to replace classical systems to be valuable. It just needs to amplify them. By combining quantum exploration with classical logic, we’re beginning to see a new kind of intelligence, one that finds better answers not by thinking harder, but by thinking differently.

Quantum computing isn’t a future headline anymore. It’s quietly making cities safer, one optimized decision at a time.

Playing Quantum Tic-Tac-Toe with Python and Qiskit

David Graves — Sun, 28 Sep 2025 06:15:11 +0000

My daughter loves playing Tic-Tac-Toe, it's simple, quick, and endlessly fun. Watching her strategize made me wonder: what if we could add a quantum twist to the game? Could we take this classic game and make it probabilistic, unpredictable, and, in a way, "truly quantum"? That curiosity led to Quantum Tic-Tac-Toe, a CLI game where cells can exist in a superposition, and your moves can collapse into deterministic ownership. You can find the source code here.

Why Quantum Tic-Tac-Toe?

Quantum computing is fundamentally about probabilities and superpositions. A qubit can be 0, 1, or both at the same time…until it's measured. I wanted a simple, interactive way to demonstrate this idea, and a well-known, yet simple game like Tic-Tac-Toe seemed perfect.

Empty cell: available.
Deterministic cell: a player owns it.
Superposed cell: a quantum "maybe," indicated with a ?.

Every move has a chance to push a cell into superposition, and certain actions collapse the board, assigning ownership based on quantum measurements.

Building the Game

I implemented the game in Python using Qiskit. This was really overkill for what I was building, but I wanted to incorporate some concepts specific to the qiskit library here. Each superposed cell is represented by a qubit. We tried a few different approaches before finally settling on the logic presented below. Our original approach was to maintain superpositions indefinitely. This made it unbelievably difficult for anyone to win, as all superposed cells had to collapse in just the right way. We could have made some adjustments to make this more likely, but ultimately, we decided on a simpler gameplay.

The core logic is simple:

First move on empty cell: deterministic ownership.
Move on already owned cell: push it into superposition.
Collapse: simulate a quantum measurement for each superposed cell to determine ownership.

For the first version, I used a single-shot collapse. This means that each cell in superposition is measured once, and the result immediately determines the owner.

    def collapse_superposition(self):
        superposed_indices = self.get_superposition_cells()

        if not superposed_indices:
            return

        print(f"\nCollapsing {len(superposed_indices)} superposed cells using independent quantum measurement...")

        simulator = AerSimulator()

        for cell_idx in superposed_indices:
            # Build a separate circuit for each cell
            qc = QuantumCircuit(1, 1)
            qc.h(0)  # put qubit in superposition
            qc.measure(0, 0)

            # Execute with 100 shots
            compiled_circuit = transpile(qc, simulator)
            job = simulator.run(compiled_circuit, shots=100)
            result = job.result()
            counts = result.get_counts(compiled_circuit)

            measurement = list(counts.keys())[0]
            clean_measurement = measurement.replace(' ', '')

            bit_value = int(clean_measurement)
            owner = 'X' if not bit_value else 'O'
            self.board[cell_idx] = {'state': 'deterministic', 'owner': owner}
            print(f"Cell {cell_idx} collapsed to: {owner}")

After the measurement, X or O is assigned deterministically based on the outcome.

Findings from the Single-Shot Approach

Playing the game with the single-shot collapse revealed some interesting behaviors:

Highly unpredictable outcomes: because each collapse only measures once, the board can swing dramatically from turn to turn.
Harder to plan strategy: you might try to push a cell into superposition to gain a probabilistic advantage, only for it to collapse against you immediately.
Fun emergent patterns: watching how a cell "flips" from superposition to deterministic ownership captures the spirit of quantum uncertainty beautifully.

In short: single-shot collapses are exciting, chaotic, and very "quantum-like."

Multi-Shot Collapse: A More Scientific Approach

For those wanting a more statistical quantum simulation, I also implemented a multi-shot collapse. Here, each cell is measured 100 times, and the majority vote determines ownership.

    def collapse_superposition(self):  # multi-shot collapse
        """Collapse all superposed cells using independent quantum measurements per cell"""
        superposed_indices = self.get_superposition_cells()

        if not superposed_indices:
            return

        print(f"\nCollapsing {len(superposed_indices)} superposed cells using independent quantum measurement...")

        simulator = AerSimulator()

        for cell_idx in superposed_indices:
            # Build a separate circuit for each cell
            qc = QuantumCircuit(1, 1)
            qc.h(0)  # put qubit in superposition
            qc.measure(0, 0)

            # Execute with 100 shots
            compiled_circuit = transpile(qc, simulator)
            job = simulator.run(compiled_circuit, shots=100)
            result = job.result()
            counts = result.get_counts(compiled_circuit)

            # Majority vote for this cell
            ones = counts.get('1', 0)
            zeros = counts.get('0', 0)
            owner = 'O' if ones >= zeros else 'X'

            self.board[cell_idx] = {'state': 'deterministic', 'owner': owner}
            print(f"Cell {cell_idx} collapsed to: {owner}")

This approach leans closer to 50/50 outcomes and reduces the randomness compared to the single-shot version. It's more predictable, and players can start to develop strategies around probability, rather than pure chaos.

Lessons Learned

Quantum mechanics can be fun and interactive. Using a simple game, you can demonstrate superposition, measurement, and probability without any heavy math.
Randomness vs. strategy: single-shot collapses feel wildly quantum, while multi-shot collapses introduce a kind of probabilistic predictability.
Python + Qiskit is accessible: you don't need a real quantum computer to experiment, and simulators like Aer make it easy to explore concepts locally.

Try It Yourself

I've open-sourced the Quantum Tic-Tac-Toe CLI game, so you can try it out and see how quantum unpredictability affects your strategy.

Highlights for experimentation:

Play using single-shot collapse…expect chaos.
Try the multi-shot approach, and see how probabilities smooth the outcomes.
Push deterministic cells into superposition, and watch the quantum dice roll!

Quantum Tic-Tac-Toe isn't just a fun Python project…it's a hands-on introduction to quantum behavior. Whether you're a developer curious about quantum computing, or just someone who wants a quirky new take on Tic-Tac-Toe, this project gives a small taste of how quantum mechanics works in practice.

There's one scenario in the game that I didn't cover, see if you can find the bug!

What Quantum Computing Teaches Us About Software Design Today

David Graves — Thu, 31 Jul 2025 02:19:47 +0000

"Nature isn't classical, dammit, and if you want to make a simulation of nature, you'd better make it quantum mechanical." — Richard Feynman

Quantum computing might seem distant—something for researchers in lab coats and dilution refrigerators—but its core ideas can actually inform how we design classical systems today.

In fact, thinking "quantum-ish" may help us build better, more resilient systems in a world filled with distributed services, unpredictable inputs, and constant change.

1. Embrace Uncertainty

In classical computing, we do everything we can to eliminate uncertainty. We debounce inputs, retry failed requests, sanitize every form field. Predictability is king.

But quantum systems don't fear uncertainty. They work with it—representing multiple possibilities at once until measurement collapses them into a result.

That mindset maps surprisingly well to modern systems:

Feature flags let us run multiple realities in production.
Eventual consistency accepts short-term ambiguity for long-term stability.
Probabilistic data structures (like HyperLogLog) sacrifice precision for speed and scale.

2. Model Entanglement

In quantum physics, entangled particles affect each other instantly, even when separated. Their states are linked.

We see entanglement-like behavior all the time in software:

A cached value depends on a DB row.
An API call depends on the state of an OAuth token.
A user experience depends on latency across the globe.

Recognizing these links lets us build more thoughtful systems:

Use distributed tracing to map dependencies.
Implement circuit breakers to contain blast radius.
Log why a service fails, not just that it failed.

3. Think in Superposition

A qubit isn't just on or off—it's both, until observed.

In software, sometimes we try to collapse state too early:

# premature optimization:
if user.paid:
    enable_feature_x()

But maybe we need to wait:

if user.session_looks_like_paid_user():
    show_trial_features()

Delayed decisions can create better experiences. Good defaults, progressive disclosure, and adaptive UX all benefit from keeping options open until the last responsible moment.

TL;DR

You don’t need a quantum computer to learn from quantum thinking.

Embrace uncertainty where it improves flexibility.
Model entanglements to uncover hidden dependencies.
Use superposition as inspiration for deferred decisions.

These aren’t metaphors. They’re real strategies that help us survive complexity in distributed systems, user behavior, and product growth.

What do you think?
Have you ever designed a system that felt more quantum than classical?
I'd love to hear how you embraced uncertainty or modeled complex dependencies.

Drop a comment or share your story.