Workflows for

Quantum-centric
Supercomputing

Antonio Córcoles
Principal Research Scientist
Head of Quantum + HPC
IBM Quantum

adcorcol@us.ibm.com
Qiskit Global Summer School 2024
Why do we use computers? – The determinant
A sub-routine for linear-systems solutions, and used
extensively in vector calculus
NumPy:
Myself:

la.det(np.array([[19, 22, 19, 21, 4],

[24, 15, 5, 10, 14],
[8, 17, 20, 7, 18],
[8, 18, 13 11, 21],
[20, 10, 22, 4, 18]]))

Answer: 597888.0
Solution time ~ 200 us (20 million times faster)

IBM Quantum
Why do we use computers? – The determinant
32768

[[19, 22, 19, 21, 4],

32768
[24, 15, 5, 10, 14],
[8, 17, 20, 7, 18], ~ 1 billion elements
[8, 18, 13 11, 21],
[20, 10, 22, 4, 18]])) (32 Gb)

For common, everyday computing tasks, classical computations can scale without the loss of accuracy

IBM Quantum
What is computing?
We can think of a computer in the following way:
• The computer has an initial state.
• The state evolves following a finite sequence of operations.
• There is a mechanism to extract information on the state.

This is essentially a simplified model for a Turing machine.

Alan Turing is considered the father of theoretical computer science

IBM Quantum
What is High-Performance Computing?
(aka HPC, Supercomputing, Extreme Scale Computing)

Serial Computing:

Task 1 Result Task 2 Result

Program CPU Program CPU

Parallel Computing:
HPC comprises:
Program

1) Massively Parallel Computing

CPU CPU CPU
Task 1 Task 2 Task 3
2) Computer Clusters

Result 3) High-Performance Components

IBM Quantum
The paradigm of computing is branching
Quantum computing

Classical computing

Nanosheets

Integrated circuit
108

104
Performance

Discrete
transistor
Vacuum tube
100 Electro-
Mechanical mechanical

10-4

10-8

1900 1920 1940 1960 1980 2000 2000 and beyond

IBM Quantum
What is quantum computing?
We can use the same model for quantum computers as we used for the Turing
machine , but the rules for these key points will be different:

1. a physical system in a perfectly definite state can still

behave randomly

2. two systems that are too far apart to influence each

other can nevertheless behave in ways that, though
individually random, are somehow strongly correlated.

Richard Feynman proposed the idea of a quantum computer

IBM Quantum
What are Qiskit Patterns?
A guide for writing workflows to take advantage of quantum computation
A quantum programming model

Map classical inputs to Optimize problem Execute using Qiskit Postprocess, return
a quantum problem. for quantum execution. Runtime Primitives. result in classical
format.
H S S Rx
Sampler 000101...,
H S S Rx
110110...
H H
H S S H Rx
H H Rx H H circuit bit-strings
H H Rx HH S SH H Rx
H S
H H Rx S H HH
H

H H Rx S H H Estimator
H S
expectation value
circuit
(abstract circuits, observables) (ISA circuits, observables)
+ observable

Mapping Optimizing Executing Postprocessing

IBM Quantum
All steps are amenable to parallelization
What is Quantum-centric supercomputing?

Delivering impactful quantum computing requires the interplay of quantum and

classical resources at scale; quantum-centric supercomputing is the path toward
IBM Quantum
industrial scale applications
 Quantum Computer
Qiskit Runtime Primitives Runtime Compute Infrastructure
Estimator / Sampler Error Channel Storage
Error mitigation / Suppression Calibration Storage
Result accumulation Result Storage
Input Near time Output
QPU Control Plane
Pauli Twirling
QISA circuits Results
Decoder – Error correction
and (observables
Measurement discrimination
operators Real time or
Room Temperature Electronics Quantum chip / Interconnects samples)
Instruction & Waveform Memory Amplifiers
Data / Result Memory Filters

Quantum-centric Supercomputer 3rd Party Regional Platform IBM Quantum Platform

Qiskit Serverless Qiskit Serverless

HPC Workload Manager Cloud Provider

Direct Access API Channel Access API IQP Access API

Plugin

Scheduler Quantum Computer Quantum Computer Quantum Computer

Classical cluster
Qiskit
Services
The workflow
computer

QComputer QComputer

(a) - WLM
QComputer QComputer
(b) - Application workflow
(c) - Qiskit Pattern
(d) - Direct API endpoint
(e) - Classical system node
(f) - QPU
(g) - Classical node
(h) - Quantum computer
IBM Quantum
Circuit Knitting
A protocol whereby a quantum computational problem (1 circuit & 1 Pauli group) is broken
down into multiple quantum computational problems whose outputs are then post-processed
(knit) asynchronously using classical computing

Examples
• Embedding • Operator Back-propagation

• Circuit cutting • Regev’s version of Shor’s algorithm

• Entanglement forging • Multi-product Formulas

Circuit knitting original definition:

Techniques that break down larger circuits into
smaller circuits to run on a quantum computer,
and then knit the results back together using a
classical computer
IBM Quantum
Circuit Knitting: Embedding
Background: Variational Quantum Eigensolver

VQE Components

Hamiltonian 𝐻, represented as a
weight of Pauli observables, eg.
0.2 ∗ 𝐼𝑋𝑌𝐼𝐼 − 1.6 ∗ 𝑋𝑍𝑋𝐼𝐼 + 0.7 ∗ 𝑌𝑍𝐼𝑌𝑋
Perform one iteration of:
• Calculation of 𝜓 = 𝐶|0⟩. Optimizer
Goal: Find |𝜓⟩ that minimizes • Pauli expectation value ⟨𝜓 𝐻 𝜓⟩
⟨𝜓|𝐻|𝜓⟩

Variational form circuit 𝐶, depends

on parameters 𝜃! , … , 𝜃"
𝜃!, … , 𝜃"
Optimizer

IBM Quantum
Circuit Knitting: Embedding

VQE loop Classical

Embedding schemes compute

only one part of the full system
E1
representation on the quantum
… Classical DFT
computer
EN

IBM Quantum
Circuit Knitting: Embedding

The quantum algorithm is restricted to

a subset of active orbitals defined by
an active space where the correlations
are essential to the problem

Rossmannek et al. J. Chem. Phys. 154, 114105 (2021)

Rossmannek et al. J. Phys. Chem. Lett. 14, 3491 (2023)

IBM Quantum
Battaglia et al. arXiv:2404.18737 (2024)
Circuit Knitting: Circuit cutting
QuasiProbability Decomposition (QPD): ℰ 𝜌 = ∑# 𝑎# ℇ# (𝜌)
Unitary channel
(goal) Coefficients Unitary channels
(can be negative) (available)

Convert to probability by defining 𝛾 = ∑# |𝑎# | and then ℇ 𝜌 = 𝛾 ∑# 𝑝# sign(𝑎# )ℇ# (𝜌) with 𝑝# = 𝑎# /𝛾

This allows us to cut gates with execution overhead: 𝛾 % for one cut and 𝛾 %& for 𝑛 cuts

Example:
(*)
q0

q2

q3

q1

IBM Quantum
(*)Figure from Carrera Vázquez et al. arXiv:2402.17833 (2024)
Circuit Knitting: Circuit cutting
Application: periodic boundary conditions in a system with limited physical connectivity

physical connection
virtual connection
Node stabilizer Edge stabilizer

Eagle device (ibm_kyiv)

Three experiments:

SWAP LO LOCC
q0 Z q2 Z
q0
qb,0
Cut Bell pair

q2 qb,1
factory

⌘ qb,2
q3
qb,3 H H
q1
q1 X q3 X

IBM Quantum
Carrera Vázquez et al. arXiv:2402.17833 (2024)
Circuit Knitting: Entanglement forging
!
Schmidt decomposition of a pure 𝑁 + 𝑁 qubit bipartite state: |Ψ⟩ = 𝑈⨂𝑉 ∑%&'! 𝜆& |𝑏& ⟩⨂|𝑏& ⟩

Schmidt coefficients

Density matrix formalism:

%! &)!
* *
Ψ⟩⟨Ψ = (𝑈⨂𝑉) D 𝜆%& |𝑏& ⟩E𝑏& |⨂% + D 𝜆& 𝜆" D (−1)* | 𝜙-#-$ H J𝜙-#-$ |⨂% (𝑈 . ⨂𝑉 . )
&'! "'! *∈ℤ"

# !⟩%& ! "⟩
(with |𝜙!" $= and 𝑝 ∈ ℤ( )
'

Operator expectation value:

! * 𝜙* * * *
𝑂 = ∑%&'! 𝜆%& 𝑏& 𝑂L! 𝑏& 𝑏& 𝑂L% 𝑏& + ∑&)! 𝜆 𝜆 ∑
"'! & " *∈ℤ" (−1) 𝑂L 𝜙
-# -$ ! -# -$ 𝜙 𝑂L 𝜙
-# -$ % -# -$

IBM Quantum
 Circuit Knitting: Entanglement forging

Original circuit to measure O: Example: H20 molecule

With entanglement forging:

Sampling overhead price:

/

𝛾 % ~ D 𝜆#
#

IBM Quantum
Eddins et al. PRX Quantum 3, 010309 (2022)
Circuit Knitting: OBP
Operator Backpropagation (OBP) is a technique that uses HPC resources to trade quantum depth for an increased # of
circuits and more difficult observables
𝑈

We want to estimate ⟨𝜓|𝑈 * 𝒪𝑈|𝜓⟩

𝒪

We can express that value as 𝜓 𝑈!* 𝑈+* 𝒪𝑈+𝑈! 𝜓 and approximate instead ⟨𝜓|𝑈!* 𝒪 , 𝑈!|𝜓⟩ with 𝑈+* 𝒪𝑈+ ≈ 𝒪 , = ∑𝑐- 𝑃-
-

𝑈" 𝑈#
𝑈"

𝒪 𝒪0

𝑈' is evaluated classically

IBM Quantum
Circuit Knitting: OBP
Operator Backpropagation (OBP) is a technique that uses HPC resources to trade quantum depth for an increased # of
circuits and more difficult observables

OBP in practice

Clifford Perturbation Theory: 75 Paulis 10 Paulis

230 Paulis Ba
Ba Ba ck
ck ck pr
• Hardness scales with non-Cliffordness Truncate pr
op
a ga
Truncate pr
op
a ga
Truncate op
a ga
te te
te

• Accuracy-efficiency trade-off through truncation 𝒪 ! = 105 Paulis 38 Paulis 6 Paulis

𝒪

⊗𝑘
Can split error budget across slices

• Equal distribution for each slide (𝜖/4𝑘)

/ 2/
• Clifford gates use no budget, so we could do: (01 , 01 , 0, 0)’
/ /
4 slices • Evenly distributing the error would look like: ( , , 0, 0)’
+1 +1

IBM Quantum
Circuit Knitting: Shor’s algorithm
Problem: Given a composite integer 𝑁 ≤ 23 find one of its non-trivial divisors

Intuition:
Consider 𝑁 = 𝑝𝑞 and its multiplicative group modulo 𝑁, 𝐺

How many elements does 𝐺 have?

Useful property: 𝑥 |4| = 1 mod 𝑁 Then, from 𝑥 56! = 1 mod 𝑝

and its generalization 𝑥 (56!)(96!) = 1 mod 𝑝𝑞, we get 𝐺 = (𝑝 − 1)(𝑞 − 1)

Example: 𝑁 = 15 Then 𝐺 = {1,2,4,7,8,11,13,14}

And we get 𝐺 = 8 = 𝑝 − 1 𝑞 − 1 from which, with 𝑁 = 𝑝𝑞, we obtain 𝑝 = 5 and 𝑞 = 3

IBM Quantum
Circuit Knitting: Shor’s algorithm
Problem: Given a composite integer 𝑁 ≤ 23 find one of its non-trivial divisors

Solution:

Shor’s algorithm does not produce |𝐺| but the period 𝑠 of the function

𝑓 𝑟 = 𝑥 < mod 𝑁

This period is not |𝐺| but it divides |𝐺|

Shor’s algorithm: pick a random 𝑥 relatively prime to 𝑁 and get 𝑠

! !
Then 𝑥: − 1 = 0 mod 𝑁 ⇒ 𝑥 − 1
" 𝑥 + 1 = 0 mod 𝑁
"

(if s is even)

!
If neither 𝑥 :/+ − 1 nor 𝑥 :/+ + 1 are multiples of 𝑁, we get a non-trivial divisor of 𝑁 by computing gcd(𝑥 " − 1, 𝑁)

IBM Quantum
Circuit Knitting: Shor’s
Example: 𝑁 = 15
Order-finding circuit

Output Output/22n r/s Guess for s

0 0/256 0/1 1

64 64/256 1/4 4

128 128/256 1/2 2

192 192/256 3/4 4

IBM Quantum
and 20/+ − 1 = 3 and gcd 3,15 = 3
Circuit Knitting: Regev’s factoring algorithm[*]
Shor’s complexity: 𝑂(𝑛+ log 𝑛) gates and 𝑂(𝑛) qubits[**]

Regev’s algorithm uses two key ideas to improve on Shor’s algorithm:

1) Work in higher dimensional space and replace 𝑥 by several integers 𝑦!, … , 𝑦=

+

ℒ= 𝑧!, … , 𝑧= ∈ ℤ= X 𝑤- ># = 1 𝑚𝑜𝑑 𝑁}

-

= 𝑧!, … , 𝑧= ∈ ℤ= X 𝑦- ># = 1 𝑚𝑜𝑑 𝑁} ⊂ ℤ=

-

2) Choose 𝑦!, … , 𝑦= to be very small compared to 𝑁

3"
This allows to perform modular exponentiation with only ~𝑂( = ) operations, which results in 𝑂(𝑛2/+ log 𝑛) gates

[*] Oded Regev, arXiv: 2308.06572 (2023)

[**] See Gidney and Ekerå, Quantum 5, 433 (2021)

IBM Quantum
Circuit Knitting: Regev’s
Shor’s complexity: 𝑂(𝑛+ log 𝑛) gates and 𝑂(𝑛) qubits
Regev’s algorithm requires 𝑂( 𝑛) calls to the quantum circuit (vs 𝑂(1) from Shor’s) and 𝑂(𝑛2/+ log 𝑛) gates

Two main limitations to Regev’s algorithm:

$
1) It requires 𝑂(𝑛") qubits, many more than Shor’s

Addressed by Ragavan and Vaikuntanathan[*], which recovered 𝑂(𝑛 log 𝑛) qubits

2) Lacks theoretical guarantees

Addressed by Pilatte[**]

Next developments:

• Reduce memory further

• Resource estimation for 𝑛 = 2048

[*] Ragavan and Vaikuntanathan, arXiv: 2310.00899 (2023)

[**]Cédric Pilatte, arXiv: 2404.16450 (2024)

IBM Quantum Regev’s result was extended to discrete logarithms by Ekerå and Gärtner: Ekera and Gartner, arXiv: 2311.05545 (2023)
Circuit Knitting: Multi-product Formulas
Multi-product Formulas (MPF) is a technique that reduce the approximation error attained by product formulas for certain
Hamiltonian simulation problems

Brief review of Product Formulas

𝑑
Solve 𝜌(𝑡) = −𝑖[𝐻, 𝜌 𝑡 ] 𝜌 𝑡 = 𝑒 !"#$ 𝜌 𝑒 "#$
𝑑𝑡

Assume 𝐻 = ∑=BC! 𝐹B 𝑆 𝑡 = 𝑒 6-?@% … 𝑒 6-?@" 𝑒 6-?@& = 𝑒 6-?A + 𝑂 𝑡 + (first order product formula)

Order 𝑝 product formula if 𝑆 𝑡 = 𝑒 6-?A + 𝑂(𝑡 5D!)

3? $
For some interesting systems, it can be proven that[*] 𝜌 𝑡 − 𝜌1 (𝑡) !~
1"
for second-order product formula (𝑛 is system size)

2 2
𝑘 Trotter steps: 𝜌1 𝑡 = 𝑆( )1 𝜌#& 𝑆( ))1
1 1

IBM Quantum [*] Childs et al. PRX 11 011020 (2021)

Circuit Knitting: Multi-product Formulas
Multi-product Formulas (MPF) is a technique that reduce the approximation error attained by product formulas for certain
Hamiltonian simulation problems

Multi-Product Formulas

F
Approximate the solution by a linear combination of product formulas 𝜇 𝑡 = ∑-C! 𝑐- 𝜌1# (𝑡)

Then it can be shown that for some interesting problems[*]

F
|𝑐- |
𝜌 𝑡 − 𝜇(𝑡) !~𝑛+𝑡 E f 0 = 𝑂(𝑛+𝑡 E/𝑘 0) (𝑘 = max 𝑘* , 𝑘' , … )
⋯ 𝑘-
-C!
𝑘%
𝑘!

Multi-product formulas can be

understood as a form of
Richardson extrapolation

[*] Zhuk et al. arXiv: 2306.12569 (2024)

IBM Quantum See also Carrera Vázquez et al. Quantum 7, 1067 (2023)
Other QCSC Workflows: Sample-based
Quantum Diagonalization (SQD)

The current belief is that

pre-fault-tolerant quantum computers
in isolation cannot deal with realistic
formulations of nature

IBM Quantum
Other QCSC Workflows: Sample-based
Quantum Diagonalization (SQD)
IBM Quantum

Robledo-Moreno et al. arXiv: 2405.05068 (2024)

Fe4S4 on 72 qubits (TZP-DKH basis set): 6.7M Pauli operators

10-10 precision on each operator for chemical accuracy

Each circuit must be executed 1020 times

77 qubits 6400 nodes @
Runtime at 10μs/circuit ~3M years
10570 quantum gates 32 GB
IBM Quantum 3590 two-qubit gates 1024 GB/s
48 cores
Other QCSC Workflows: Sample-based
Quantum Diagonalization (SQD)
Intuition
'(&
We want to compute 𝜓 𝑂 𝜓 for certain observable 𝑂 with |𝜓⟩ = ∑+3CM 𝑛 𝜓 |𝑛⟩

Then sampling on the computational basis, we can get the set of 𝑁9 bitstrings 𝑆NC 𝑥⟩ 𝑥 ∈ {0,1}O) , 𝑅 most frequent

q 𝑦 for |𝑥⟩, |𝑦⟩ ∈ 𝑆N

And we solve 𝐻N 𝑐 = 𝐸N 𝑐 . in a classical computer, where (𝐻N )QR = 𝑥 𝐻

Components

A quantum estimator that uses massive classical A class of quantum circuits of tunable depth for the
IBM Quantum computing to process individual quantum samples accurate preparation of molecular ground states
Quantum circuits for chemistry: Local Unitary Coupled Jastrow

IBM Quantum
HPC Quantum Estimator: Quantum-classical
workflow

Sampler()

IBM Quantum
 Typically, the data transfer between
quantum and classical is limited to
expectation values and circuit parameters

Postprocess Here we use largest possible data

transfer via the sampler primitive

Information from all the samples is used

to perform accurate, noise-resistant
estimations

IBM Quantum
Chemistry Beyond Exact Solutions on a Quantum-centric Supercomputer
N2 : Bond breaking on large basis set Fe2S2: Precision many-body physics Fe4S4: Pushing hardware capabilities

58 qubits 45 qubits 77 qubits

5204 quantum gates 3170 quantum gates 10570 quantum gates
IBM Quantum
1792 two-qubit gates 1100 two-qubit gates 3590 two-qubit gates
Main Takeaways

Quantum-centric supercomputing enables realistic applications for our

quantum processors, beyond problems tailored to the devices

Chemistry is a first example: classical distributed computing processes big

classical data, while quantum executes a few large quantum circuits

Quantum simulations of molecules beyond the reach of exact classical

solutions: 77 qubits, 3.5k two-qubit gates with a useful quantum signal

Processing of quantum data at the sample level: no false positive solutions

and certifiable advantage

Increased classical processing extracts better quantum signals from circuits

beyond exact simulations

IBM Quantum