Quantum Dynamic Programming in Qibo
How to use quantum computers programmed by quantum information?
Can quantum states program a quantum computer?
Can quantum information be the source code?
What would it be good for?
Kay Giang - NTU Singapore
J. Son et al, arxiv:2403.09187
Introduction to
Dynamic Quantum Algorithm
What is a dynamic quantum algorithm?
Dynamic Quantum Algorithm
- Consider a data qubit σ and an instruction qubit ρ
- Make an infinitesimal rotation by applying partial SWAP (δSWAP) gate, realized by Heisenberg interaction
- Discard the instruction qubits and prepare a fresh copy of ρ
Toy model example: Density Matrix Eponentiation
Goal: Approximate the unitary eitρ
σ
\sigma
ρ
\rho
XX+YY+ZZ
XX + YY + ZZ
ρ
\rho
XX+YY+ZZ
XX + YY + ZZ
Kjaergaard et al., arxiv:2001.08838
Dynamic Quantum Algorithm
4. Repeat the partial SWAP and fresh preparation
σ→eidtMρσe−idtMρ+O(M−1)
\sigma \to e^{idtM\rho}\sigma e^{-idtM\rho} + O(M^{-1})
5. If the infinitesimal rotation duration is dt then after M steps we will have
6. The circuit will be exactly the same even if we use different qubit states
σ
\sigma
ρ
\rho
XX+YY+ZZ
XX + YY + ZZ
ρ
\rho
XX+YY+ZZ
XX + YY + ZZ
Kjaergaard et al., arxiv:2001.08838
Density Matrix Exponentiation
- Density matrix ρ is Hermitian → can use as operator
- In summary:
- DME implements an infinitesimal rotation about an axis defined by instruction qubit 𝜌 on data qubit 𝜎 (where δ=θ/N):σ→e−iρδσeiρδ
- After Trotterization, DME implements: U=e−iρθ
- Again, this is dynamic because ρ is only determined at runtime
Dynamic Quantum Algorithm
- Quantum algorithms that are dynamic: their operation is revealed on runtime.
- Question 1: How to use quantum computers programmed by quantum information?
-
Answer: Using dynamic quantum algorithm, which:
- Take an unknown density matrix
- Design a circuit that will meaningfully use this quantum information as an instruction
Dynamic Quantum Algorithm
- Question 2: Can quantum information be the source code?
- Answer: Kimmel et al. (arxiv 1608.00281) shows that this model is basis of a universal model for quantum computation
- Questions 3: What would QDP be good for?
-
Answer:
- Example usage: QDP provide a universal circuit that compute the Schmidt spectrum
- QDP also gives more useful examples
Static vs Dynamic
- Usual quantum computing is static: To change operation, we have to change the circuit
- Dynamic quantum computing: To change operation, only need to change instruction qubit
Normal way we do quantum computing: Static
Dynamic Quantum Computing
Kjaergaard et al., arxiv:2001.08838
Existing literature
Kjaergaard et al., arxiv:2001.08838
Motivation for
Quantum Dynamic Programming
What is Quantum Dynamic Programming (QDP) good for?
What is a quantum recursion
- Definition:
- The recursive state is instructing the propagation
- Dynamic: The unitary is different for different states
-
Problems:
- What is a meaningful U(ψ)?
- To calculate ∣ψ2⟩ will we need to recalculate ∣ψ1⟩ and calculate U(ψ1)?
- For higher order terms, do we need to recalculate all lower terms?
- Solution: QDP shows how to do it in a quantum coherent way.
∣ψ1⟩=U(ψ0)∣ψ0⟩
\ket{\psi_1} = U(\psi_0) \ket {\psi_0}\\
U(ψ0)=U(ψ1)if ψ0=ψ1
U(\psi_0) \neq U(\psi_1)\\
\text{if } \psi_0 \neq \psi_1
∣ψ2⟩=U(ψ1)∣ψ1⟩
\ket{\psi_2} = U(\psi_1) \ket{\psi_1}\\
Quantum recursion examples
- Examples of meaningful unitaries for quantum recursions:
- Grover rotation:
G(ψ1)=U0†G(ψ0)U0=id−2∣ψ1⟩⟨ψ1∣G^{(\psi_1)} = U_0^\dagger G^{(\psi_0)}U_0=\mathbb{id} - 2\ket{\psi_1}\bra{\psi_1} - Grover search: Add static unitaries Q and R that don’t depend on the state:
- Density Matrix Exponentiation: Give rise to dynamic Grover rotation implementation:
- Grover rotation:
G=id−2∣ψ⟩⟨ψ∣
U(ψ)=QG(ψ)R with Q,R∈U(D)
G=eiψs
G = e^{i\psi s}
Quantum recursion examples
- Reduced group commutator:
eisDeitρe−isD - We can use this to diagonalize
eisDeitρe−isDe^{isD}e^{it\rho}e^{-isD}
Marek DBI paper, arxiv:2206.11772
QDP paper, arxiv:2403.09187
Unfolding quantum recursions
Consider Grover reflector: G=id−2∣ψ⟩⟨ψ∣
Q,R∈U(D), initial state ∣ψ0⟩, ∣ψk+1⟩=QG(ψk)R∣ψk⟩
G(ψ1)=1−2∣ψ1⟩⟨ψ1∣=1−2U(ψ0)∣ψ0⟩⟨ψ0∣U(ψ0)†=U(ψ0)(1−2∣ψ0⟩⟨ψ0∣)U(ψ0)†=U(ψ0)G(ψ0)U(ψ0)†
\begin{align*}
G^{(\psi_1)}
&=\mathbb{1} - 2\ket{\psi_1}\bra{\psi_1}\\
&=\mathbb{1} - 2U(\psi_0) \ket{\psi_0}\bra{\psi_0}U(\psi_0)^\dagger\\
&=U(\psi_0)(\mathbb{1}-2\ket{\psi_0}\bra{\psi_0})U(\psi_0)^\dagger\\
&= U(\psi_0) G^{(\psi_0)}U(\psi_0)^\dagger
\end{align*}
U(ψ0)∣ψ1⟩=QG(ψ0)R=QG(ψ0)R∣ψ0⟩
\begin{align*}
U(\psi_0) &= QG^{(\psi_0)}R\\
\ket{\psi_1} &= QG^{(\psi_0)}R\ket{\psi_0}
\end{align*}
However, it's more complicated to get ∣ψ2⟩. To do this, we need to get U(ψ1). Ordinary idea:
Reflection of ψ1 is the rotated reflection of ψ0
To get ∣ψ1⟩ is simple:
∣ψ2⟩=QG(ψ1)R∣ψ1⟩=Q(QG(ψ0)R)G(ψ0)(QG(ψ0)R)†RQG(ψ0)R∣ψ0⟩
\begin{align*}
\ket{\psi_2} &= QG^{(\psi_1)}R\ket{\psi_1}\\
&={Q(QG^{(\psi_0)}R)G^{(\psi_0)}(QG^{(\psi_0)}R)^\dagger R QG^{(\psi_0)}R\ket{\psi_0}}
\end{align*}
Motivation for QDP
- Unfolding the recursion make the depth grow exponentially
- Using placeholder memory is not straightforward with quantum computing
- Notice that the unitary U(ψ) depends on ∣ψ⟩. Can we use the state to steer the evolution?
- Quantum Dynamic Programming (QDP), a framework that uses copies of the recursive state to implement the recursion step unitary
- This is dynamic because the instruction state is revealed only on runtime
- QDP yields exponential reduction in circuit depth than when unfolding
Quantum Dynamic Programming
J. Son et al, arxiv:2403.09187
Quantum Dynamic Programming
- QDP speed up recursion of the form (single memory call):
U(N,ρ)= V2eiN(ρ)V1 where N is any Hermitian-preserving map - Memory call: Idealized transformation we want to make. It asks for memory (instruction state ρ).
- General case:
- Problem: We can't implement this naturally in qunatum mechanics
Quantum Dynamic Programming
- Solution: QDP approximate this memory call unitary:
- QDP does this by using memory usage query:
where N is the operator of the memory usage query, the partial transpose of the Choi matrix corresponding to N- Consume (trace out) an instruction state
- Repeat this procedure M times, we obtain
Es(N,ρ)(σ)=Trρ[e−iNs(ρ⊗σ)eiNs]
\mathcal{E}_s^{(N,\rho)}(\sigma) = Tr_\rho [e^{-iNs} (\rho\otimes\sigma) e^{iNs}]
E(N,ρ)(σ)=eiN(ρ)σe−iN(ρ)
E^{(\mathcal{N},\rho)}(\sigma) = e^{i\mathcal{N}(\rho)} \sigma e^{-i\mathcal{N}(\rho)}
EQDP(N,ρ,M):=(E1/M(N,ρ))M=E(N,ρ)+O(1/M)
\mathcal{E}^{(\mathcal{N},\rho,M)}_{QDP} \coloneqq (\mathcal{E}^{(\mathcal{N},\rho)}_{1/M})^M = E^{(\mathcal{N},\rho)} + O(1/M)
Quantum Dynamic Programming
Example: Density Matrix Exponentiation
- Memory call unitary:
E(N,ρ)(σ)=eiρθσe−iρθ - Memory call operator: Nρ=ρ→N=id
- Memory usage query operator: N=δSWAP
- Memory usage query: σ→Trρ[e−iSWAPδ(σ⊗ρ)eiSWAPδ]
Quantum Dynamic Programming
Example: Double bracket iteration
- Double bracket iteration step with instruction operator H:
- Memory call operator: N=−is[D,ρ]
- Memory usage query:
- Memory usage query operator:
ρn+1=esn[D,ρn]ρne−sn[D,ρn]
\rho_{n+1} = e^{s_n[D,\rho_n]}\rho_ne^{-s_n[D,\rho_n]}
Es(N,ρ)(σ)=Trρ[e−iNs(ρ⊗σ)eiNs]
\mathcal{E}_s^{(N,\rho)}(\sigma) = Tr_\rho [e^{-iNs} (\rho\otimes\sigma) e^{iNs}]
Quantum Dynamic Programming
Example: Oblivious Schmidt decomposition
- Bipartite pure state ∣ψ⟩ has a Schmidt decomposition:
∣ψ⟩AB=j∑λj∣ϕj⟩A∣χj⟩B
|\psi\rangle_{AB} = \sum_j \sqrt{\lambda_j} |\phi_j\rangle_A|\chi_j\rangle_B
- Double bracket iteration of OSD:
eiN(ψn)=esn[D,ρn(A)]⊗IB
e^{i\mathcal{N}(\psi_n)} = e^{s_n[D,\rho_n^(A)]}\otimes \mathbb{I}_B
- Memory usage query:
- Memory usage query operator:
Density Matrix Exponentiation (DME) in Qibo
Memory usage query in DME
- Goal: DME approximate the rotation (the memory call):
U=e−iρθ - DME replace the infinitesimal angle memory call unitary (where δ=θ/N): σ→e−iρδσeiρδ by the memory usage query σ→Trρ[e−iSWAPδ(σ⊗ρ)eiSWAPδ]
-
DME then does N memory usage queries (Trotterization):
DME(ρ,N,θ)=e−iρθ+O(Nθ2)
DME(\rho,N,\theta) = e^{-i\rho\theta} + O\left(\frac{\theta^2}{N}\right)
DME flowchart
Trρ[e−iSWAPδ(σ⊗ρ)eiSWAPδ]=e−iρδσeiρδ+O(δ2)
\text{Tr}_\rho[e^{-i\text{SWAP}\delta}(\sigma\otimes\rho) e^{i\text{SWAP}\delta}] \\
= e^{-i\rho\delta}\sigma e^{i\rho\delta}+O(\delta^2)
Problem of Entanglement
- To use quantum info from ρ, we need it to interact and correlate with σ
- How do we avoid entanglement between ρ and σ?
- Example: the Bell state circuit create entanglement
How DME avoid entanglement
- DME uses a series of partial SWAP gate, realized by Heisenberg interaction: HHeisenberg=eit(XX+YY+ZZ)
- DME relies on the relation:
- Where, after the partial SWAP, by tracing out the instruction qubit, we get in first order the desired rotation
- The data qubit is in a pure state since the rotation is infinitesimal
DME in Qibo
DME tutorial notebook
QDP code structure
QDP code structure
There are 2 important parts of a QDP circuit:
- Memory call circuit:
- How many instruction qubit to use
- How to get N copies of the instruction qubit
- Memory usage query (circuit):
- Define the operator used to generate the unitary rotation
- (in the case of DME the 𝛿SWAP)
- Memory call circuit: How many instruction qubit to use, how to get N copies of the instruction qubit
- Memory usage query (circuit): Define the operator used to generate the unitary rotation (in the case of DME the 𝛿SWAP)
- 𝛿SWAP is decomposed into 3 CNOTs and single qubit rotations
Conclusion
Conclusion
- QDP applications:
- Useful for 2+ qubits
- We need 3 CNOTs per step
- DME has been realized only once
- Only for 2 qubits
- Maybe we can compile it better?
- Oblivious Schmidt Decomposition (OSD) is from March this year
- It is interesting already for 4 qubits
- Can be an original algorithm for demonstration
- DME and OSD implementation in Qibo
Quantum Dynamic Programming in Qibo How to use quantum computers programmed by quantum information? Can quantum states program a quantum computer? Can quantum information be the source code? What would it be good for? Kay Giang - NTU Singapore J. Son et al, arxiv: 2403.09187