Title

layout: true
<slide-template title="Quantum Computing" subtitle="Grover's Search"></slide-template>

---
class: title-slide, center, middle

<title-slide titletype="Lecture" title="Quantum Computing" modulenumber="(CS5070)" subtitle="Grover's Search"></title-slide>

---
# .darkblue[Grover]'s Search Algorithm<br/>

.more-more-condensed[
- Basis of many other quantum algorithms
- .darkblue[Black box] function $f:${$0,...,2^b -1$} $\mapsto$ {$true, false$} with $N=2^b$
- Grover's search algorithm finds one $x \in${$0,...,2^b -1$},<br/>such that $f(x)=true$
  - if there is only .darkblue[one solution]: $\frac{\pi}{4}\cdot\sqrt{2^b}$ basic steps each of which calls $f$<br/>Let $f'(b)$ be runtime complexity of $f$ for testing $x$ to be true:<br/>.darkblue[$\Rightarrow O(\sqrt{2^b}\cdot f'(b))$]
  - if there are .darkblue[$k$] possible .darkblue[solutions]: .darkblue[$O(\sqrt{\frac{2^b}{k}}\cdot f'(b))$]
- Assuming $f'(b)=O(1)$ on following slides...
]

---
# .darkblue[Motivation] - Quadratic Speedup

.reference[Grover' Search: <a href="https://doi.org/10.1145/237814.237866" target="_blank">Original Paper</a> <a href="https://learn.qiskit.org/course/ch-algorithms/grovers-algorithm" target="_blank">Qiskit Textbook</a> <a href="https://doi.org/10.1002/3527603093.ch10" target="_blank">$k$ sol.</a> <a href="https://arxiv.org/abs/quant-ph/9605034" target="_blank">in ArXiv</a> Unknown Number of Solutions: <a href="https://doi.org/10.1002/3527603093.ch10" target="_blank">Randomized</a> <a href="https://arxiv.org/abs/quant-ph/9605034" target="_blank">in ArXiv</a> <a href="https://doi.org/10.1007/3-540-44679-6_55" target="_blank">Deterministic</a>]

<div class="textcenter">
<img src="../../img/qc/grover/GroverSpeedup.svg" align="top" class="fullwidth"></img>
</div>
.more-more-condensed.smaller-font[
<table class="result tablepadding fullwidth">
<tbody>
<tr>
<th rowspan="3">$N$</th><th rowspan="3">Linear<br/>Search<br/>$k=1$</th><th rowspan="3">Grover<br/>$k=1$</th><th colspan="3">$k=\frac{5}{100}\cdot N$</th><th colspan="3">$k=5$</th>
</tr>
<tr>
<th rowspan="2">known $k$</th><th colspan="2">unknown $k$</th><th rowspan="2">known $k$</th><th colspan="2">unknown $k$</th>
</tr>
<tr>
<th>randomized</th><th>deterministic</th><th>randomized</th><th>deterministic</th>
</tr>
<tr style="text-align:right">
<td>10</td><td>5</td><td>2.48</td><td rowspan="4">3.51</td><td rowspan="4">10.06</td><td rowspan="4">37.46</td><td>1.11</td><td>3.81</td><td>11.85</td>
</tr>
<tr style="text-align:right">
<td>100</td><td>50</td><td>7.85</td><td>3.51</td><td>10.06</td><td>37.47</td>
</tr>
<tr style="text-align:right">
<td>1000</td><td>500</td><td>24.84</td><td>11.11</td><td>31.82</td><td>118.48</td>
</tr>
<tr style="text-align:right">
<td>1000 000</td><td>500 000</td><td>785.40</td><td>351.24</td><td>1006.23</td><td>3746.57</td>
</tr>
</tbody>
</table>
]

---
# .darkblue[Grover's Search for $k$ Solutions]

---
# .darkblue[Grover's Search for Unknown Number of Solutions]

.reference[<a href="https://www.scottaaronson.com/qclec.pdf" target="_blank">Scott Aaronson. Introduction to Quantum Information Science Lecture Notes, 2021</a>]

.more-more-condensed[
- If you apply .darkblue[Grover's search with $k\approx$ number of solutions $k'$, then] there is a .darkblue[high probability for success]
- .darkblue[Several ways for unknown $k$:]
  - .darkblue[Successively applying Grover's search with $k=N, \frac{N}{2}, \frac{N}{4}, ..., \frac{N}{2^t}$] until solution is found 
     - <span class="bold">Runtime</span> complexity: With sufficiently high probability, a marked entry will be found by iteration $t=\log_{2}(\frac{N}{k'})+c$ for some constant $c$<br/>$\Rightarrow$ #iterations $\leq\frac{\pi}{4}\left(1+\sqrt{2}+\sqrt{4}+...+\sqrt{\frac{N}{k'\cdot 2^c}}\right)=O\left(\sqrt{\frac{N}{k'}}\right)$<br/>
  - .darkblue[Next slide: .bold[Randomized] version with $\frac{9}{4}\sqrt{\frac{N}{k'}}$ iterations]...
- These .darkblue[methods need to be called several times] in case of not finding a solution in preceding calls
  - The .darkblue[probability for success is] high, but .darkblue[never 100%]
]

---
# .darkblue[Grover's Search for Unknown Number of Solutions] - Silq code

.smaller-font[
```silq
// Popular Lehmer generator that uses the prime modulus 2^32−5
def random(state:!ℕ):(!ℕ)×(!ℚ) {
	upperlimit := (2^32 - 5);
	newstate := (state · 279470273) % upperlimit;
    newstateQ := newstate as !ℚ; // for the following division to get a rational number
	return (newstate, newstateQ / upperlimit);
}
// f oracle function, t oracle function as classical function for testing the result! 
def grover_unknown_k[n:!ℕ](f: const uint[n] !→ lifted 𝔹, t: !ℕ !→ !𝔹, seed:!ℕ):(!ℤ)×(!ℕ) {
	l := 6/5; // Any value of l strictly between 1 and 4/3 would do...
	m := 1 as !ℝ;
	state := seed; // work with seed to allow for repeated function calls with other results
	while(true){
		(zstate, z) := random(state);
		state = zstate;
		k := floor(z·m) coerce !ℕ;
		result := grover_k[n,k](f);
		if(t(result)){ // call of f would also work, but in this way hybrid approach is more visible
			return (result, state) as (!ℤ)×(!ℕ);
		}
		if(m>=sqrt(2^n)){ return (-1, state) as (!ℤ)×(!ℕ); } // different from cited paper: restart!
		m = min(l·m, sqrt(n));
	}
}```]

---
# .darkblue[Optimal Runtime Complexity of Grover's Search]

.reference[Proof of Optimality: <a href="https://doi.org/10.1103%2FPhysRevA.60.2746" target="_blank">$k=1$</a> <a href="https://arxiv.org/abs/quant-ph/9711070" target="_blank">in ArXiv</a> <a href="https://doi.org/10.1002/3527603093.ch10" target="_blank">Any $k$</a> <a href="https://arxiv.org/abs/quant-ph/9605034" target="_blank">in ArXiv</a>]

.more-more-condensed[
- .darkblue[Grover's algorithm for $k=1$ and any $k$: optimal up to sub-constant factors]
  - Any algorithm that accesses the database only by using the oracle must apply the oracle at least a $1-o(1)$ fraction as many times as Grover's algorithm
]

---
# .darkblue[Grover's Search as Basic Algorithm Used in other Approaches]

.more-more-condensed[
- Solving the .darkblue[collision problem]
- Finding .darkblue[Minimum]
  - .darkblue[Dynamic Programming]
- Solving .darkblue[NP-complete problems] by performing exhaustive searches over the set of possible solutions
  - results in quadratic speedup over classical solutions
      - but no polynomial-time solution for NP-complete problems because exponential speedup is <span class="bold">not</span> reached
  - Example: $k$-SAT
- ...
]

---
# .darkblue[Collision Problem]

.reference[<a href="https://doi.org/10.1007/BFb0054319" target="_blank">G. Brassard, P. Høyer, A. Tapp. Quantum cryptanalysis of hash and claw-free functions. LATIN'98: Theoretical Informatics, 1998</a> <a href="https://arxiv.org/abs/quant-ph/9705002v1" target="_blank">In ArXiv</a>]

.more-more-condensed[
- .darkblue[Given .small-font[$F:X\rightarrow Y$]] being .darkblue[either 1-to-1 (permutation) or 2-to-1]<br/>(i.e., .smaller-font[$\forall x_0\in X: \exists x_1\in X-\\\\{x_0\\\\}:F(x_0)=F(x_1)\wedge\forall x_2\in X-\\\\{x_0,x_1\\\\}:F(x_2)\neq F(x_0)$])<br/>
<div class="textcenter">
<img src="../../img/qc/grover/1to1Versus2to1.svg" align="top" style="width:75%"></img>
</div>
- .darkblue[Classical Randomized Solution]
  - Using .darkblue[Birthday Paradox]:  if we choose (distinct) queries at random, then with high probability we find a collision after .small-font[$\Theta\left(\sqrt{n}\right)$] queries
]

---
# .darkblue[Collision Problem]

.more-more-condensed[
- .darkblue[Quantum Solution]
<table>
<tbody>
<tr>
<td style="width:75%">
<ol>
<li>Randomly choose distinct .small-font[$x_i\in X$ with $i\in\\{1,...,k\\}$]</li>
<li>.small-font[$K:=\\{x_1,...,x_k\\}$]</li>
<li>if(.small-font[$\exists x_a,x_b\in K:x_a\neq x_b\wedge F(x_a)=F(x_b)$])<br/>then return collision .small-font[$(x_a,x_b)$]</li>
<li>Build oracle .small-font[$H:X-K\rightarrow \\{true, false\\}$]<br/>with .small-font[$H(x)=true$] if .small-font[$\exists x_a\in K:F(x)=F(x_a)$], otherwise .small-font[$H(x)=false$]</li>
<li>.small-font[$x_c:=$] Grover's Search over .small-font[$X-K$] with oracle .small-font[$H$]</li>
<li>If .small-font[$\exists x_a\in K:F(x_c)=F(x_a)$] then return collision .small-font[$(x_a,x_c)$] else no collision!</li>
</ol>
<ul><li>.darkblue[Runtime] .small-font[$O\left(k+\sqrt{\frac{N-k}{k}}\cdot H'\right)$],<br/>.darkblue[for] .small-font.darkblue[$k=\sqrt[3]{N}:O\left(\sqrt[3]{N}\cdot H'\right)$] with .small-font[$H'$] runtime of .small-font[$H$] .darkblue[and space .small-font[$\Theta\left(\sqrt[3]{N}\right)$]]</li></ul>
</td>
<td style="width:25%;vertical-align:top">
<img src="../../img/qc/grover/CollisionStep1.svg" align="top" class="fullwidth margin"></img><br/>
<img src="../../img/qc/grover/CollisionStep2.svg" align="top" class="fullwidth margin"></img><br/>
<img src="../../img/qc/grover/CollisionStep4.svg" align="top" class="fullwidth margin"></img>
</td>
</tbody>
</table>
]

---
# .darkblue[Applying Grover] - Finding .darkblue[Minimum]

.reference[adapted from: <a href="https://arxiv.org/abs/quant-ph/9607014" target="_blank">C. Dürr, P. Høyer. A quantum algorithm for finding the minimum, 1996</a>]

.more-more-condensed[
- Given function $f:\\{0,...,N-1\\} \mapsto ℝ$
- Algorithm to find minimal $f(x)$:
  1. Choose randomly $x'\in N$
  2. Threshold $t := f(x')$
  3. while(true)<br/>a) $r :=$ Grover's Search for unknown $k$ with oracle $f(x)\lt t$ <br/>b) if$\left(f(r)\lt t\right)$ $t:=f(r)$ else return $t$
- Runtime Complexity: $O\left(\frac{45}{4}\sqrt{N}+\frac{7}{10}lg^2(N)\right)$
<div class="textcenter">
<img src="../../img/qc/grover/FindMinimum.svg" align="top" style="width:30%"></img>
</div>
]

---
# .darkblue[Applying Grover] - Finding .darkblue[Minimum]

.more-more-condensed[
- Variants:
  - .darkblue[Application-oriented]: 
     - <span class="darkblue">Estimate</span> good <span class="darkblue">initial threshold $t$</span>, then continue original algorithm at 3. with threshold $t$
	 - Example (see also next lecture unit):
         - Transactions $T_1,...,T_p$ to be distributed to $m$ cores of a CPU
		 - Total runtime $l=\sum_{i=1}^p |T_i|$ of transactions
	     - Threshold $t\geq\frac{l}{m}$ for max. runtime on all cores
     - In some applications, the number $k$ of solutions of the oracle can be approximately estimated and used to speed up Grover's search 
  - .darkblue[Domain-oriented]:<br/>
    <span class="small-font">I) If given domain $[start, end]$ is "small", then continue original algorithm at 3. with $t:=end$<br/>
    II) $m:=\frac{end-start}{2}$<br/>
	III) If Grover's search with oracle $f(x)\lt m$ finds a solution $r$, then continue at I) with domain $[start,r]$ else with $[m+1,end]$</span>
]

---
# .darkblue[Dynamic Programming] -<br/>Example: Join Order Optimization

.more-more-condensed[
- Find best order (with minimal costs) to join relations $R_1,...,R_n$
- For simplicity of presentation: .small-font[$cost(R_1\bowtie R_2)=cost(R_2\bowtie R_1)$]
  - true for many join algorithms, but .em[not] for e.g. asynchronous hash join
- Classical Algorithm:
  1. Size of subsets to join: $s:=2$
  2. Initialize table: $\forall i\in\\{1,...,n\\}:t\left[\\{R_i\\}\right]=cost\left(\\{R_i\\}\right)$
  3. while($s\leq n$)
    <ul type="A"><li>$\forall S\subseteq\{R_1,...,R_n\}$ with $|S|=s:$<br/>
    <span class="smaller-font">$t[S]:=min\{t[S_1]+t[S_2]+cost(S_1\bowtie S_2)|S=S_1 \dot\cup S_2 \wedge S_1\neq \varnothing \wedge S_2\neq \varnothing\}$</span></li>
	<li>$s:=s+1$</li></ul>
  4. return $t\left[\\{R_1,...,R_n\\}\right]$
]

---
# .darkblue[Dynamic Programming] -<br/>Example: Join Order Optimization

---
# .darkblue[Dynamic Programming] -<br/>Example: Join Order Optimization

.more-more-condensed[
- Observations:
  - $\frac{2^s-2}{2}=2^{s-1}-1$ combinations for joining a subset of $s$ relations
     - For each relation, put it into the first set $S_1$ or into the second set $S_2$ excluding the cases $S_1=\varnothing \vee S_2=\varnothing$ as well as the symmetric cases
  - $\Rightarrow \left\lceil log_2(2^{s-1}-1)\right\rceil$ bits for joining a subset of $s$ relations<br/>$\Rightarrow$  Function for computing total number of bits for all choices during dynamic programming for join order optimization of $n$ relations:<br/>
  Algorithm $nr\\_of\\_bits(s)$<br/>if $s\leq2$ then return 0<br/>
  else return .small-font[$\left\lceil log_2(2^{s-1}-1)\right\rceil+max\\\\{bits(i)+bits(s-i)|i\in\{1,...,\left\lfloor\frac{s}{2}\right\rfloor\}\\\\}$]
  <br/>
  <table class="result tablepadding textcenter">
  <tbody>
  <tr>
  <th>$s$</th><th>2</th><th>3</th><th>4</th><th>5</th><th>6</th><th>7</th><th>8</th><th>9</th><th>10</th>
  </tr>
  <tr>
  <td class="smaller-font">$nr\_of\_bits(s)\equiv\sum_{i=2}^s \left\lceil log_2(2^{s-1}-1)\right\rceil$</td><td>0</td><td>2</td><td>5</td><td>9</td><td>14</td><td>20</td><td>27</td><td>35</td><td>44</td>
  </tr>
  </tbody>
  </table>
]

---
# .darkblue[Quantum Dynamic Programming] -<br/>Example: Join Order Optimization,<br/>.darkblue[Subset Choice]

---
# .darkblue[Quantum Dynamic Programming] -<br/>Example: Join Order Optimization,<br/>.darkblue[Subset Choice]

---
# .darkblue[Quantum Dynamic Programming] -<br/>Example: Join Order Optimization

.more-more-condensed[
- Algorithm .small-font[$SubsetChoice(s,b:uint\left[\left\lceil log_2(2^{s-1}-1)\right\rceil\right],[R_1,...,R_s])$]
  - if $b=0$ then $b=2^{s-1}-2$ // avoiding wasting $b=0$ for meaningful representation (otherwise it would represent all relations in one subset)
  - $S_1=\varnothing;S_2=\varnothing$
  - $\forall i\in \\{0,...,s-1\\}$:
     - if $b[i]=0$ then $S_1=S_1\cup R_i$ else $S_2=S_2\cup R_i$
  - return $(S_1,S_2)$
- Find minimum with following oracle function $f(x)$ in Grover's search:
  - return $recCost([R_1,...,R_n],x,0)[1]$ // see next slide!
]

---
# .darkblue[Quantum Dynamic Programming] -<br/>Example: Join Order Optimization

.more-more-condensed[
- Algorithm $recCost(R,x,b)$
  - $s:=|R|$
  - if $s=1$ then return $(b,cost(R[0]))$
  - if $s=2$ then return .small-font[$(b,cost(R[0])+cost(R[1])+cost(R[0]\bowtie R[1]))$]
  - $bits:=\left\lceil log_2(2^{s-1}-1)\right\rceil$
  - $(S_1,S_2):=SubsetChoice(s,x[b,bits-1],R)$
  - $b:=b+bits$
  - $l:=recCost(S_1,x,b)$
  - $b:=b+l[0]$
  - $r:=recCost(S_2,x,b)$
  - return $(b+r[0],l[1]+r[1]+cost(S_1\bowtie S_2))$
]

---
# .darkblue[Quantum Dynamic Programming] -<br/>Example: Join Order Optimization

.more-more-condensed[
- .darkblue[Hybrid approaches for reducing] number of .darkblue[qubits]
  - .darkblue[Quantum dynamic programming] for subsets of the problem .darkblue[combined with classical approach]
- .darkblue[All costs precomputed versus cost computation of joins within quantum circuit] based on histograms of input relations
  - .darkblue[Smaller quantum circuits versus larger speedup]
]

---
# .darkblue[$k$-SAT-Problem]

.reference[<a href="https://learn.qiskit.org/course/ch-applications/solving-satisfiability-problems-using-grovers-algorithm" target="_blank">Qiskit textbook, Solving Satisfiability Problems using Grover’s Algorithm</a>]

.more-more-condensed[
- .darkblue[Boolean satisfiability] problem: Problem of determining if there .darkblue[exists an interpretation that satisfies a given Boolean formula]
  - In other words: Do we find an assignment of Boolean variables to the values TRUE or FALSE in such a way that the formula evaluates to TRUE?<br/>$\Rightarrow$ .darkblue[Formula is satisfiable]
- $k$-SAT-Problem: Boolean satisfiability problem with $k$ variables
  - Every $k$-SAT-problem can be written as conjunctive normal form (CNF):<br/>$\bigwedge\bigvee(\lnot) x_i$
]

---
# .darkblue[$k$-SAT-Problem]

.more-more-condensed[
  - Example for 3SAT:<br/>.smaller-font[$f(v_1,v_2,v_3)=(\lnot v_1\vee\lnot v_2\vee\lnot v_3)\wedge(v_1\vee\lnot v_2\vee v_3)\wedge(v_1\vee v_2\vee\lnot v_3)\wedge(v_1\vee\lnot v_2\vee\lnot v_3)$]<br/>
  <table class="small-font result tablepadding textcenter margin-top">
  <tbody>
  <tr>
  <th>$v_1$</th><th>$v_2$</th><th>$v_3$</th><th>$f(v_1,v_2,v_3)$</th>
  </tr>
  <tr>
  <td>.darkgreen[true]</td><td>.darkgreen[true]</td><td>.darkgreen[true]</td><td>.darkred[false]</td>
  </tr> 
  <tr>
  <td>.darkgreen[true]</td><td>.darkgreen[true]</td><td>.darkred[false]</td><td>.darkgreen[true]</td>
  </tr> 
  <tr>
  <td>.darkgreen[true]</td><td>.darkred[false]</td><td>.darkgreen[true]</td><td>.darkgreen[true]</td>
  </tr> 
  <tr>
  <td>.darkgreen[true]</td><td>.darkred[false]</td><td>.darkred[false]</td><td>.darkgreen[true]</td>
  </tr> 
  <tr>
  <td>.darkred[false]</td><td>.darkgreen[true]</td><td>.darkgreen[true]</td><td>.darkred[false]</td>
  </tr> 
  <tr>
  <td>.darkred[false]</td><td>.darkgreen[true]</td><td>.darkred[false]</td><td>.darkred[false]</td>
  </tr> 
  <tr>
  <td>.darkred[false]</td><td>.darkred[false]</td><td>.darkgreen[true]</td><td>.darkred[false]</td>
  </tr> 
  <tr>
  <td>.darkred[false]</td><td>.darkred[false]</td><td>.darkred[false]</td><td>.darkgreen[true]</td>
  </tr> 
  </tbody>
  </table>
]

---
# .darkblue[$k$-SAT-Problem]

.reference[<a href="https://learn.qiskit.org/course/ch-applications/solving-satisfiability-problems-using-grovers-algorithm" target="_blank">Qiskit, Solving Satisfiability Problems using Grover’s Algorithm</a> <a href="https://doi.org/10.1145/3313276.3316359" target="_blank">Hansen at al., Faster k-SAT algorithms using biased-PPSZ. STOC, 2019</a>]

.more-more-condensed[
- Apply Grover's search with following oracle function:
 - $oracle(x:uint[k])$
 - $\forall i\in\{1,...,k\}: v_i:=x[i-1]$
 - return $f(v_1,...,v_k)$
- If Grover's search returns a solution,<br/>then $f(v_1,...,v_k)$ is satisfiable,<br/>else it is unsatisfiable (with a high probability)
- Laufzeit $O\left(\sqrt{N}\right)=O\left(1.414^n\right)$ with $n=k$
  - Classical approach for 3SAT: $O\left(1.307^n\right)$
  - Grover beats classical approaches for larger $k$
]

---
# .darkblue[Summary and Conclusions]

.more-more-condensed[
- .darkblue[Grover's search with quadratic speedup]
  - for known $k=1$ and $k\gt 1$
  - for unknown $k$
- .darkblue[Applications of Grover's search]
  - .darkblue[Collision Problem]
  - .darkblue[Finding minimum]
  - .darkblue[Quantum dynamic programming with] example of .darkblue[join order optimization]
  - .darkblue[$k$-SAT]
]