Quantum robotics: computing, sensing and cognition, each against its classical baseline.

Author's view

Yeshwanth Guru, author and maintainer.

I started Quantum Mind from one belief: a robot that works with people needs a different kind of probability than the one inside most of its filters. People are not neutral sensors. A look changes what a hand movement means, a question changes the answer to the next question, and asking someone whether they trust a robot changes their trust. Classical filters assume the evidence arrives in independent pieces; quantum probability was built for the case where the order and the context of a measurement matter.

Quantum robotics is a young field with at least three threads, and I think it helps to keep them apart: (1) quantum computing for robot algorithms (planning, optimisation, learning), promising on paper but with no practical advantage shown on real robot problems with today's noisy devices; (2) quantum sensing for robots (atomic and solid-state sensors for navigation, magnetometry, gravimetry), which is physical hardware; and (3) quantum-probability models of the beliefs a robot holds about people (context, order and trust), which run on ordinary computers and can be tested today.

Quantum Mind covers all three, because I want to work on the whole umbrella, and it holds each thread to the same standard: a classical baseline, an ablation, and results that are allowed to say no. Thread 1 poses robot problems as binary optimisation, supplies the classical baselines and a thin adapter to Qiskit's QAOA, and does not re-implement what Qiskit and PennyLane do better. Thread 2 models quantum-limited sensors and fuses a slow, stable quantum accelerometer with a fast, drifting classical one in simulation, and does not claim to build a sensor. Thread 3 is the quantum-probability model of the beliefs a robot holds about people, the part I have developed furthest. The circuits of the thread-3 models also run on quantum hardware, which is the bridge between the threads. I claim no speed-up anywhere.

In every thread I ask the same question: does the quantum version beat the classical one, and does the robot decide or move better with it? For beliefs about people that becomes: does quantum probability describe human context better than the classical alternative? Every model sits next to the classical model it has to beat.

I did not re-implement general-purpose quantum algorithms or optimisers, because Qiskit, PennyLane and optimisation libraries do them better, and I limited the scope to AI, machine learning, vision, robotics and embodied AI. Models from the literature are implemented from their papers and cited in the model atlas, which labels each as published, extended or unique; the unique ones are my own designs.

I do not claim a quantum computational advantage (QAOA does no better than random sampling on the problems I tested), quantum sensing hardware, or results with real people and robots, and COBRA's gain is modest and shown only on synthetic data. Next: a pilot study with a real robot, more reliable training, runs on hardware and measured sensor data for threads 1 and 2, and independent replication. If a claim does not hold, please open an issue.

New in 3.0

Version 3.0 covers all three threads of quantum robotics. General-purpose quantum algorithms (VQE, Grover, quantum kernels) and quantum-inspired optimisers are left to Qiskit, PennyLane and dedicated optimisation libraries; thread 1 connects to Qiskit's QAOA instead of re-implementing it. New: quantum_mind.computing, quantum_mind.sensing and COBRA.

COBRA: context-rotated belief

The same hand cue means hand over after a look at the robot and retrieve after a look away. A Bayes filter adds the same evidence either way. COBRA keeps the belief as a density matrix and lets the previous frame rotate the basis in which the next reading is measured.

from quantum_mind.belief import COBRA, min_cost_action

model = COBRA(n_hyp=3, n_features=3).fit(frames, intent)
belief = model.start()                 # online, one frame at a time
for frame in sensor_stream:
    p = belief.update(frame)           # P(handover, retrieve, withdraw)
action = min_cost_action(p, cost)      # hand over, wait or ask

Two-qubit playground

An exact two-qubit simulation running in this page. Apply gates and watch both Bloch vectors move. After a CNOT on a superposition the qubits become entangled: each vector shrinks into the ball and the concurrence rises. Drag a sphere to rotate it.

The same views in Python, for any Qiskit circuit: circuit_trajectory(qc), animate_bloch, LiveBloch, plot_entanglement. Checked against Qiskit in the test suite.

Three threads, each tested against its classical limit

Every thread reports a classical baseline and says where the classical method wins. Read the concepts page.

Interactive animations

Generated by the package itself (animate_bloch). Press play, drag the slider, rotate with the mouse.

For robots that ask people questions

A robot's questions can change people's answers, and asking about trust can change trust. The robotics layer gives a robot a predicted answer, its uncertainty, and a rule for when to ask instead of act.

from quantum_mind.applications.robotics import HumanModelService

svc = HumanModelService()
svc.add_answer({'order': 'AB', 'answers': [1, 0]})
svc.query({'order': 'AB', 'ask_cost': 1.0, 'error_cost': 3.0})
# prediction, uncertainty (bits), model weights,
# {'action': 'ask' | 'act', 'reason': ...}

Results, reported as measured

Simulated data, small problems; they illustrate the methods and are not a benchmark. Where a classical model wins, the table says so.

What is and is not claimed

• No quantum advantage is claimed. COBRA is a classical simulation of the quantum-probability formalism; its gain over classical filters is shown only on synthetic data built to contain a context effect.
• No hardware results are included yet. IBM and Braket submission code is tested against local stand-ins (a fake IBM device, the Braket local simulator).
• All data in the examples are simulated or published aggregates, and labelled as such. No study with real people and a robot has been run yet; the validation page lists what is checked and gives a protocol for a pilot.
• In several robotics comparisons the simulated people follow the same model the robot uses, which favours the order-aware method by construction; the tutorials say where.

Get started

pip install "quantum-mind[all]"

# quantum-like: is there an order effect?
from quantum_mind.core import compare
from quantum_mind.families.order_effects import (
    QuantumOrderModel4D, BayesOrderModel, AnchoringOrderModel, qq_test)
print(qq_test(counts))
compare([QuantumOrderModel4D, BayesOrderModel,
         AnchoringOrderModel], counts)

# a robot's belief about what a person wants
import numpy as np
from quantum_mind.belief import COBRA, GaussianBayesFilter

model = COBRA(3, 3).fit(frames, intent)          # frames: (N, T, 3)
classical = GaussianBayesFilter(3).fit(frames, intent)
model.predict_proba(new)    # context-aware belief
classical.predict_proba(new)

# watch a circuit on Bloch spheres
from quantum_mind.viz import circuit_trajectory, animate_bloch
animate_bloch(circuit_trajectory(qc))