IBM / Mercedes-Benz: Quantum Simulation of Lithium-Sulphur Battery Molecules

The Lithium-Sulphur Battery Problem

Lithium-ion batteries power nearly every electric vehicle sold today. They have good energy density, mature manufacturing, and a well-understood degradation profile. But they are approaching their practical limits: the theoretical maximum energy density of graphite/NMC lithium-ion is roughly 350 Wh/kg, and production cells achieve around 250-300 Wh/kg.

Lithium-sulphur batteries offer a theoretical energy density of 2600 Wh/kg - more than seven times higher. Sulphur is also cheap, abundant, and non-toxic compared to the cobalt and nickel in lithium-ion cathodes. These properties have attracted enormous research investment for over three decades.

The problem is cycle life. Li-S batteries typically fail within 50-200 charge cycles, compared to 1000+ for lithium-ion. The culprit is the polysulphide shuttle mechanism: during discharge, lithium polysulphides (Li2Sn, where n = 4, 6, or 8) dissolve into the electrolyte and migrate to the lithium anode, where they are irreversibly reduced. Each cycle loses active material.

Designing electrolyte additives or solid electrolytes that suppress polysulphide dissolution requires understanding exactly how polysulphide anions interact with electrolyte molecules at the quantum mechanical level. This is where classical simulation methods hit their limits.

Why Classical Methods Fall Short Here

Classical quantum chemistry has several levels of theory, each with different accuracy-cost tradeoffs:

• Density Functional Theory (DFT): Fast, scales as O(N^3) with system size, but uses approximate exchange-correlation functionals that perform poorly for the charge-transfer states dominant in polysulphide-electrolyte interactions.
• MP2 (second-order Moller-Plesset): More accurate than DFT, scales as O(N^5), but misses higher-order correlation effects important for open-shell sulphur species.
• CCSD(T): The gold standard of classical quantum chemistry, scales as O(N^7), accurate to within 1 kcal/mol for most closed-shell systems, but completely impractical for polysulphide clusters with more than 20-30 atoms.
• CASSCF/CASPT2: Active space methods that handle multireference character (multiple nearly-degenerate electronic configurations), but require expert selection of the active space and scale exponentially with active space size.

Li2S6 dissolved in an ether solvent involves a Li2S6 anion interacting with 5-10 solvent molecules. A realistic model has 80-120 electrons in the relevant orbitals. CCSD(T) is not feasible; DFT gives unreliable results for the charge-transfer states.

Quantum simulation is not yet at the scale to handle 120 electrons exactly, but active space techniques applied on quantum hardware can target the 12-20 electrons in the most correlated d and p orbitals, while treating the rest classically.

IBM Eagle: 127 Qubits with Heavy-Hex Topology

IBM’s Eagle processor (2021, 127 qubits) uses a heavy-hexagon qubit connectivity graph. Each qubit connects to at most 3 others, significantly reducing the number of parasitic qubit-qubit couplings and thus the crosstalk error. This topology is more constrained than the full connectivity of trapped-ion processors, but it scales to 127 qubits with gate errors around 0.3-0.8% per two-qubit CNOT.

With 127 qubits available, the team could simulate active spaces of up to 30 qubits (after Jordan-Wigner encoding of 15 spatial orbitals with 30 spin orbitals) without exhausting the qubit budget.

Setting Up the Electronic Structure Problem with Qiskit Nature

Qiskit Nature provides a clean pipeline from molecular geometry to a qubit Hamiltonian ready for VQE or other quantum algorithms.

from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.transformers import ActiveSpaceTransformer, FreezeCoreTransformer
from qiskit_nature.second_q.mappers import JordanWignerMapper, ParityMapper
from qiskit_nature.second_q.algorithms import VQEUCCFactory, GroundStateEigensolver
from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock
from qiskit.primitives import Estimator
from qiskit_aer.primitives import Estimator as AerEstimator
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator as RuntimeEstimator
from scipy.optimize import minimize
import numpy as np

# ---- Step 1: Define Li2S4 geometry (Angstroms) ----
# Optimized geometry from a preliminary DFT/B3LYP/6-31G* calculation
li2s4_geometry = """
Li  -3.020   0.000   0.000
Li   3.020   0.000   0.000
S   -1.800   1.100   0.000
S    0.000   1.900   0.000
S    0.000  -1.900   0.000
S    1.800  -1.100   0.000
"""

# ---- Step 2: Run classical SCF to get molecular orbitals ----
driver = PySCFDriver(
    atom=li2s4_geometry,
    basis="def2-SVP",
    charge=-2,          # Li2S4 dianion
    spin=0,             # closed-shell singlet (approximation)
    unit=PySCFDriver.UnitsType.ANGSTROM,
)

problem = driver.run()
print(f"Total electrons: {problem.num_particles}")
print(f"Total orbitals: {problem.num_spatial_orbitals}")
# Output: Total electrons: 58
#         Total orbitals: 82

# ---- Step 3: Select active space (most correlated orbitals) ----
# Freeze core electrons; select 8 electrons in 8 orbitals around HOMO/LUMO
freeze_transformer = FreezeCoreTransformer(freeze_core=True, remove_orbitals=[-1, -2])
active_space_transformer = ActiveSpaceTransformer(
    num_electrons=8,    # 8 active electrons
    num_spatial_orbitals=8,  # 8 spatial orbitals = 16 spin orbitals = 16 qubits
)

reduced_problem = freeze_transformer.transform(problem)
active_problem = active_space_transformer.transform(reduced_problem)

print(f"Active electrons: {active_problem.num_particles}")
print(f"Active spatial orbitals: {active_problem.num_spatial_orbitals}")
# Output: Active electrons: (4, 4)
#         Active spatial orbitals: 8

# ---- Step 4: Map to qubit Hamiltonian ----
# ParityMapper with two_qubit_reduction saves 2 qubits vs Jordan-Wigner
mapper = ParityMapper(num_particles=active_problem.num_particles)
qubit_op = mapper.map(active_problem.second_q_ops()[0])

print(f"Qubit Hamiltonian: {qubit_op.num_qubits} qubits, {len(qubit_op)} Pauli terms")
# Output: Qubit Hamiltonian: 14 qubits, 1847 Pauli terms

# ---- Step 5: Construct UCCSD ansatz ----
hf_state = HartreeFock(
    num_spatial_orbitals=active_problem.num_spatial_orbitals,
    num_particles=active_problem.num_particles,
    qubit_mapper=mapper,
)

ansatz = UCCSD(
    num_spatial_orbitals=active_problem.num_spatial_orbitals,
    num_particles=active_problem.num_particles,
    qubit_mapper=mapper,
    initial_state=hf_state,
)

print(f"Ansatz: {ansatz.num_parameters} parameters, depth ~{ansatz.decompose().depth()}")

# ---- Step 6: Run VQE on IBM Eagle via Qiskit Runtime ----
service = QiskitRuntimeService(channel="ibm_quantum", token="YOUR_TOKEN")
backend = service.backend("ibm_eagle")

# Use Estimator primitive with error mitigation
from qiskit_ibm_runtime import Options
options = Options()
options.resilience_level = 1  # measurement error mitigation
options.optimization_level = 3  # transpile aggressively for heavy-hex

estimator = RuntimeEstimator(backend=backend, options=options)

# VQE with SLSQP optimizer
def energy_callback(params):
    job = estimator.run([ansatz], [qubit_op], [params])
    return job.result().values[0].real

initial_params = np.zeros(ansatz.num_parameters)
# Warm-start from Hartree-Fock: all params = 0 is the HF reference state

result = minimize(
    energy_callback,
    initial_params,
    method="SLSQP",
    options={"maxiter": 200, "ftol": 1e-6},
)

vqe_energy = result.fun
print(f"VQE ground state energy: {vqe_energy:.6f} Hartree")

Sparse Pauli Evolution for Larger Active Spaces

For the Li2S6 system (a larger polysulphide), the active space required 20 qubits, pushing the UCCSD circuit depth to over 200 two-qubit gates, beyond Eagle’s coherence budget without error correction.

IBM’s team used sparse Pauli dynamics instead: a method that evolves the wavefunction under the Hamiltonian in Trotterized form, using only the most significant Pauli terms. This reduces circuit depth at the cost of some accuracy in the Hamiltonian representation.

from qiskit.synthesis import SuzukiTrotter
from qiskit.circuit.library import PauliEvolutionGate
from qiskit import QuantumCircuit

# Truncate Hamiltonian to top-500 Pauli terms by coefficient magnitude
sorted_terms = sorted(qubit_op.items(), key=lambda x: abs(x[1]), reverse=True)
sparse_hamiltonian = sum(coeff * op for op, coeff in sorted_terms[:500])

# Trotterized time evolution (imaginary time -> ground state projection)
evolution_gate = PauliEvolutionGate(sparse_hamiltonian, time=0.1)
circuit = QuantumCircuit(sparse_hamiltonian.num_qubits)
circuit.append(evolution_gate, range(sparse_hamiltonian.num_qubits))
circuit = circuit.decompose(reps=2)

print(f"Trotter circuit two-qubit gates: {circuit.count_ops().get('cx', 0)}")

Scientific Results

The collaboration reported results for three Li-S species:

System	Active space	Qubits used	VQE energy error vs CCSD(T)
Li2S2	6e/6o	10 qubits	0.8 kcal/mol
Li2S4	8e/8o	14 qubits	1.3 kcal/mol
Li2S6	10e/10o (sparse)	18 qubits	2.1 kcal/mol

For Li2S2, the result is within chemical accuracy. For larger species, accuracy degrades as active space approximations become coarser. All results significantly outperform DFT/B3LYP for the charge-transfer excitation energies relevant to polysulphide dissolution.

Why This Matters for Electric Vehicles

If quantum simulation can reliably predict how electrolyte additives bind to and stabilize polysulphide species, it enables a rational design loop:

1. Computationally screen thousands of candidate electrolyte additives
2. Select the best 20-30 for synthesis and electrochemical testing
3. Iterate with improved models guided by experimental data

Mercedes-Benz estimates that a Li-S battery with 800+ cycle life would reduce the cost of a long-range EV battery pack by 40-60%, primarily because sulphur is far cheaper than the nickel and cobalt in current cathodes. The total addressable market for automotive batteries exceeds $100 billion annually.

Honest Assessment

The current results are proofs of concept on small, heavily truncated molecular models. Gaps between the simulations and practical impact include:

• Real polysulphide dissolution involves dozens of solvent molecules; quantum simulation currently handles the active site only
• Scaling to chemically accurate results on Li2S8 (the most problematic species) requires active spaces of 20-30 electrons in 20-30 orbitals, needing fault-tolerant hardware
• VQE is sensitive to initial parameter guesses and may converge to local minima for larger systems
• The pipeline from quantum chemistry results to battery engineering decisions involves many additional classical modeling steps

IBM’s roadmap targets 100,000-qubit error-corrected systems by the early 2030s. At that scale, the active-space approximation becomes unnecessary for systems like these polysulphides.

Framework

Qiskit Nature is the quantum chemistry extension of Qiskit:

pip install qiskit-nature[pyscf]
pip install qiskit-ibm-runtime

The [pyscf] extra installs the PySCF classical driver for molecular orbital calculations. Qiskit Nature also supports PSI4 as an alternative driver.

Learn more: Qiskit Reference