8 — Combining Quantum Sensing with Quantum Computing (Part 2)

Hamiltonians, hybrid circuits, and deployment patterns

Continuing the pipeline from Page 7, the essential move is to convert the sensor-informed industrial question into a quantum-native objective. In Qiskit’s terms, a QUBO is mapped to an Ising Hamiltonian; the lowest-energy state corresponds to the best solution. That is exactly the form we want for many industrial inspection, routing, and defect-selection problems.

---

6. How to build a Hamiltonian from sensor data

The most useful first Hamiltonian in industry is an Ising/QUBO cost Hamiltonian. The generic form is a sum of local bias terms and pairwise couplings, which is the right abstraction for defect adjacency, sensor correlation, inspection tradeoffs, and sparse hypothesis selection.

A practical formulation is:$$H = \sum_i h_i Z_i + \sum_{i<j} J_{ij} Z_i Z_j$$where:

• $h_i$​ represents local defect weight, confidence, or penalty,
• $J_{ij}$​ represents adjacency, correlation, or smoothness,
• The ground state encodes the optimal hypothesis or route.

The IBM QAOA tutorial makes the same point explicitly: once a QUBO is written in Ising form, minimizing the cost Hamiltonian is the path to the solution.

How to refine the Hamiltonian

A naive Hamiltonian is usually too crude for industrial work. The refined version should add:

1. Sparsity penalties so the model does not hallucinate too many defects.
2. Spatial smoothness terms so neighboring voxels or scan cells behave coherently.
3. Calibration correction terms so sensor drift does not become “defect signal.”
4. Confidence weighting so low-SNR regions contribute less strongly.
5. Asset-context priors so material thickness, geometry, and process history influence the objective.

That refinement step is where classical physics and domain knowledge matter the most. Quantum computation is strongest when the problem has already been made mathematically faithful.

Example — defect-selection Hamiltonian

Suppose a scan produces four candidate defect cells. Let $x_i \in \{0,1\}$ indicate whether a defect is active in cell $i$. A simple objective function would be:$$C(x)=\sum_i a_i x_i + \lambda \sum_{i<j} b_{ij} x_i x_j + \mu \left(\sum_i x_i – k\right)^2$$

• $a_i$: local misfit against sensor readings
• $b_{ij}$​: adjacency / smoothness / correlation
• $k$: expected sparsity level
• $\mu$: penalty weight

This is the exact kind of formulation that QUBO solvers and QAOA are designed to handle.

Table 5 — Hamiltonian design patterns

Problem	Hamiltonian pattern	Why it works	Quantum method
Defect selection	Sparse Ising / QUBO	Binary hypothesis selection	QAOA
Inspection routing	Graph cost Hamiltonian	Route and coverage constraints	QAOA
Stress minimization	Pauli Hamiltonian	Energy landscape minimization	VQE
Sensor fusion	Entropy-aware objective	Penalize overconfidence	VQE / hybrid variational
Material microstructure	Electronic Hamiltonian	Physics-consistent simulation	VQE / Hamiltonian simulation

---

7. Qiskit implementation pattern

A practical Qiskit workflow is:

1. ingest sensor-derived features,
2. map them into a QUBO or Pauli operator,
3. run a variational solver,
4. interpret the result as a defect state or inspection plan,
5. update the asset record or digital twin.

Qiskit’s VQE documentation emphasizes that the Hamiltonian expectation value is computed through the Estimator primitive, and that classical optimizers such as COBYLA or SPSA are used to tune the variational parameters. Qiskit Runtime sessions are then used when iterative calls need dedicated QPU access.

Example — sensor-derived Hamiltonian and VQE

import numpy as np
from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit.library import TwoLocal
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import COBYLA

# Example: 4-qubit Hamiltonian from sensor-informed defect correlations
H_ndt = SparsePauliOp.from_list([
    ("ZZII", -0.60),  # local correlation from scan cells 1-2
    ("IIZZ", -0.45),  # local correlation from scan cells 3-4
    ("ZIZI", 0.25),   # cross-coupling
    ("IZIZ", 0.25),   # cross-coupling
    ("XXII", 0.10),   # fluctuation / regularization term
])

# Hardware-efficient ansatz
ansatz = TwoLocal(
    num_qubits=4,
    rotation_blocks=["ry", "rz"],
    entanglement_blocks="cx",
    entanglement="linear",
    reps=2
)

optimizer = COBYLA(maxiter=300)

# Estimator can be local simulator or Runtime Estimator in IBM Quantum workflow
# from qiskit_ibm_runtime import EstimatorV2 as Estimator
# estimator = Estimator(mode=backend)

# Illustrative local setup:
from qiskit.primitives import StatevectorEstimator
estimator = StatevectorEstimator()

vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=optimizer)
result = vqe.compute_minimum_eigenvalue(H_ndt)

print("Ground-state energy:", result.eigenvalue)

This pattern is especially suitable when the NDT task has a strong “find the minimum-cost explanation” structure. The Hamiltonian is not the answer itself; it is the mathematically disciplined encoding of the answer-seeking problem.

Example — Qiskit Runtime session for repeated scans

from qiskit_ibm_runtime import QiskitRuntimeService, Session, EstimatorV2 as Estimator

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

with Session(backend=backend) as session:
    estimator = Estimator(mode=session)
    vqe = VQE(estimator=estimator, ansatz=ansatz, optimizer=optimizer)
    result = vqe.compute_minimum_eigenvalue(H_ndt)

print("Session-based energy:", result.eigenvalue)

Qiskit’s session model is relevant because inspection workflows are iterative: estimate, refine, re-scan, and update. IBM documents sessions as a way to group iterative calls and prioritize them during execution.

---

8. PennyLane implementation pattern

PennyLane is especially convenient when the industrial workflow is centered on hybrid quantum-classical machine learning. Its embedding templates are designed precisely for this purpose: encode data into quantum states, append variational layers, and train the model end to end.

Example — amplitude embedding for a normalized sensor field

import pennylane as qml
import numpy as np

# Example feature vector extracted from an NDT scan or quantum-sensor field map
field = np.array([0.2, 0.5, 0.7, 0.1], dtype=float)
field = field / np.linalg.norm(field)

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def encode_field(data):
    qml.AmplitudeEmbedding(data, wires=[0, 1])
    return qml.state()

state = encode_field(field)
print(state)

PennyLane’s amplitude embedding explicitly encodes $2^n$2n features into the amplitude vector of $n$n qubits, which is why it is elegant for small dense datasets but less convenient for large, noisy, or streaming industrial data.

Example — hybrid variational classifier for defect/no-defect

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=4)

def variational_layer(weights):
    for i in range(4):
        qml.RY(weights[i], wires=i)
    for i in range(3):
        qml.CNOT(wires=[i, i + 1])

@qml.qnode(dev)
def classifier(x, weights):
    qml.AngleEmbedding(x, wires=range(4), rotation="Y")
    variational_layer(weights)
    return qml.expval(qml.PauliZ(0))

x = np.array([0.42, 0.18, 0.77, 0.35])
weights = np.array([0.1, 0.2, 0.3, 0.4])

score = classifier(x, weights)
print("Defect score:", score)

This is a strong practical pattern for industrial readers because it mirrors a real production stack: sensor feature extraction on the left, quantum layer in the middle, and a scalar decision score on the right. Angle embedding is especially useful here because it maps features directly into rotation angles.

---

9. Expected outcomes: what “better” means in practice

A clear target set of outcomes include: improved defect detection accuracy, shorter inspection routes, much higher spatial resolution, better multi-sensor fusion, and tighter lifetime prediction. It also explicitly contrasts current classical limits with quantum-enhanced targets, including approximately 98% to >99.9% accuracy improvement, 60–80% inspection time reduction, and 4–10× error reduction in lifespan prediction. Those figures should be framed as directional and context-dependent, not universal guarantees.

The most realistic near-term gain is often decision quality per unit inspection cost rather than a headline “quantum speedup.” The bigger industrial return comes when quantum sensing makes the signal better and quantum computation makes the decision cheaper or faster. That fits the QCSA concept: less sensing time for the same task accuracy, especially when the task is to infer a property of the signal rather than reconstruct the entire raw signal.

A concrete benchmark example comes from the steel-imaging work: the diamond-magnetometer setup achieved high spatial resolution and contactless detection of structural damage even under a non-magnetic cover layer. That shows the type of measurement improvement that can materially change the downstream decision pipeline.

Table 6 — Expected outcome hierarchy

Tier	Outcome	Industrial meaning	Where quantum sensing helps	Where quantum computing helps
Tier 1	Better detection consistency	Fewer misses and fewer false calls	Higher-quality field maps	Better classifier / selector
Tier 2	Faster decisions	Shorter inspection cycles	Faster sensing / better signal	QAOA / variational optimization
Tier 3	Closed-loop inspection	Re-scan planning, twin updates	More informative measurements	Hybrid optimization and inference
Tier 4	Quantum computational-sensing advantage	Task-specific advantage with lower hardware requirements than full computational advantage	Combined sensing and processing	Co-designed quantum protocol

---

10. Implementation checklist for an industrial pilot

1. Start with one asset class and one measurand.
2. Capture raw sensor output plus metadata, not just the processed report.
3. Build a classical pre-processing layer that standardizes features and uncertainty tags.
4. Choose the smallest useful quantum subproblem: classification, sparse inverse inference, or route optimization.
5. Encode the features with angle or basis embedding first; use amplitude embedding only when the dimensionality makes sense.
6. Translate the business objective into a QUBO or Hamiltonian.
7. Run the first prototype as a hybrid workflow, with classical optimization around the quantum circuit.
8. Validate against POD, false calls, latency, and maintenance outcome—not only against algorithmic loss.

The practical lesson is simple: do not force a quantum formulation onto a problem that has not yet been made mathematically clean. The best industrial quantum systems are usually built on strong classical sensing, strong physics modeling, and then a carefully chosen quantum subroutine. That is the path from “interesting demo” to operational value.

---

References

1. NIST, Quantum Sensing Explained — quantum sensors, atomic clocks, spin magnetometers, superconductivity-based magnetometers, and precision measurement framing.
2. NIST, Quantum Information Science — broad QIS framing and enabling technologies.
3. BINDT, POD — Probability Of Detection — POD definition and industrial usage.
4. IBM Quantum Learning, Utility-scale QAOA — QUBO to Ising mapping and cost Hamiltonian grounding.
5. IBM Quantum Learning, Variational Quantum Eigensolver — Estimator-based VQE workflow and optimizer role.
6. IBM Quantum Documentation, Run jobs in a session — iterative QPU access and session execution.
7. PennyLane Documentation, AmplitudeEmbedding / AngleEmbedding / BasisEmbedding / Templates — data encoding and variational workflow primitives.
8. Zhou et al., Imaging damage in steel using a diamond magnetometer — contactless NDT with NV centers in diamond.
9. Khan et al., Quantum Computational-Sensing Advantage — task-specific advantage from combining sensing and computation.