├── QuantumComputingManimGL ├── Section0 │ ├── Lecture1 │ │ └── questions.py │ └── Lecture4 │ │ └── div.py ├── Section1 │ ├── Lecture1 │ │ └── vectors.py │ ├── Lecture10 │ │ └── projection.py │ ├── Lecture11 │ │ └── measure.py │ ├── Lecture12 │ │ └── bell.py │ ├── Lecture13 │ │ ├── linear.py │ │ └── tden.py │ ├── Lecture14 │ │ └── cnot.py │ ├── Lecture15 │ │ └── trace.py │ ├── Lecture16 │ │ └── phase.py │ ├── Lecture17 │ │ └── tor.py │ ├── Lecture18 │ │ └── serial.py │ ├── Lecture19 │ │ └── clone.py │ ├── Lecture2 │ │ └── productspaces.py │ ├── Lecture20 │ │ └── v.py │ ├── Lecture21 │ │ └── bool.py │ ├── Lecture3 │ │ ├── exp.py │ │ └── ortho.py │ ├── Lecture4 │ │ ├── hilberto.py │ │ └── tensorbro.py │ ├── Lecture5 │ │ └── tensorbro.py │ ├── Lecture6 │ │ └── eulerbro.py │ ├── Lecture7 │ │ └── qgates.py │ ├── Lecture8 │ │ └── bloch.py │ └── Lecture9 │ │ └── eigen.py ├── Section10 │ ├── Lecture1 │ │ └── qasm.py │ ├── Lecture2 │ │ └── photonics.py │ ├── Lecture3 │ │ └── ion.py │ └── Lecture4 │ │ └── squid.py ├── Section2 │ ├── Lecture1 │ │ └── qbsc.py │ ├── Lecture10 │ │ └── ram.py │ ├── Lecture11 │ │ └── alu.py │ ├── Lecture12 │ │ └── fourier.py │ ├── Lecture13 │ │ └── up.py │ ├── Lecture2 │ │ └── adder.py │ ├── Lecture3 │ │ └── sub.py │ ├── Lecture4 │ │ └── mux.py │ ├── Lecture5 │ │ └── add.py │ ├── Lecture6 │ │ └── mult.py │ ├── Lecture7 │ │ └── enc.py │ ├── Lecture8 │ │ └── latch.py │ └── Lecture9 │ │ └── shifter.py ├── Section3 │ ├── Lecture0 │ │ └── algos.py │ ├── Lecture1 │ │ └── jozha.py │ ├── Lecture10 │ │ └── walk.py │ ├── Lecture11 │ │ └── hhl.py │ ├── Lecture12 │ │ └── vqe.py │ ├── Lecture13 │ │ └── qaoa.py │ ├── Lecture14 │ │ └── lsf.py │ ├── Lecture2 │ │ └── simon.py │ ├── Lecture3 │ │ └── super.py │ ├── Lecture4 │ │ └── phase.py │ ├── Lecture5 │ │ └── shor.py │ ├── Lecture6 │ │ └── grover.py │ ├── Lecture7 │ │ └── teleport.py │ ├── Lecture8 │ │ └── counting.py │ └── Lecture9 │ │ └── hamiltonian.py ├── Section4 │ ├── Lecture1 │ │ └── sfields.py │ ├── Lecture2 │ │ └── cvqit.py │ ├── Lecture3 │ │ └── wigner.py │ ├── Lecture4 │ │ └── gaussian.py │ ├── Lecture5 │ │ └── cloning.py │ ├── Lecture6 │ │ └── time.py │ └── Lecture7 │ │ └── iqp.py ├── Section5 │ ├── Lecture1 │ │ └── plane.py │ ├── Lecture2 │ │ └── qembed.py │ ├── Lecture3 │ │ └── ansatz.py │ ├── Lecture4 │ │ └── feature.py │ ├── Lecture5 │ │ └── shift.py │ ├── Lecture6 │ │ └── barren.py │ ├── Lecture7 │ │ └── relevant.py │ └── qml.py ├── Section6 │ ├── Lecture1 │ │ └── qsvm.py │ ├── Lecture2 │ │ └── pca.py │ ├── Lecture3 │ │ └── vqc.py │ ├── Lecture4 │ │ └── kmeans.py │ ├── Lecture5 │ │ └── cnn.py │ ├── Lecture6 │ │ └── qonn.py │ └── Lecture7 │ │ └── gan.py ├── Section7 │ ├── Lecture1 │ │ └── causes.py │ ├── Lecture2 │ │ └── shor.py │ ├── Lecture3 │ │ └── logical.py │ └── Lecture4 │ │ └── xzzx.py ├── Section8 │ ├── Lecture1 │ │ └── entropy.py │ ├── Lecture10 │ │ └── bennet.py │ ├── Lecture11 │ │ └── broadcast.py │ ├── Lecture12 │ │ └── hiding.py │ ├── Lecture13 │ │ └── delete.py │ ├── Lecture2 │ │ └── kullback.py │ ├── Lecture3 │ │ └── holevo.py │ ├── Lecture4 │ │ └── heat.py │ ├── Lecture5 │ │ └── distance.py │ ├── Lecture6 │ │ └── principle.py │ ├── Lecture7 │ │ └── solovay.py │ ├── Lecture8 │ │ └── ssa.py │ └── Lecture9 │ │ └── knill.py └── Section9 │ ├── Lecture1 │ └── channel.py │ ├── Lecture2 │ └── locc.py │ ├── Lecture3 │ └── repeater.py │ └── Lecture4 │ └── key.py ├── QuantumComputingNotebooks ├── Section0 │ └── Lecture2 │ │ └── Intro.ipynb ├── Section1 │ ├── Lecture1 │ │ └── vector.ipynb │ ├── Lecture10 │ │ ├── projer.ipynb │ │ └── projsvd.ipynb │ ├── Lecture12 │ │ └── bellcoder.ipynb │ ├── Lecture13 │ │ └── densitycoder.ipynb │ ├── Lecture15 │ │ └── tracecode.ipynb │ ├── Lecture16 │ │ └── toffolibro.ipynb │ ├── Lecture17 │ │ └── fredkincode.ipynb │ ├── Lecture2 │ │ └── inout.ipynb │ ├── Lecture3 │ │ └── lorthoin.ipynb │ ├── Lecture5 │ │ └── krocker.ipynb │ ├── Lecture7 │ │ └── qgatepy.ipynb │ ├── Lecture8 │ │ └── blocher.ipynb │ ├── Lecture9 │ │ └── eigj.ipynb │ ├── randnumgen.ipynb │ ├── vector-Copy1.ipynb │ └── vector.ipynb ├── Section10 │ └── Lecture1 │ │ └── OpenQASM.ipynb ├── Section2 │ ├── Lecture1 │ │ └── QBSC.ipynb │ ├── Lecture11 │ │ └── ALU.ipynb │ ├── Lecture12 │ │ └── Fourier.ipynb │ ├── Lecture13 │ │ └── ++--.ipynb │ ├── Lecture2 │ │ └── Adder.ipynb │ ├── Lecture3 │ │ └── Subber.ipynb │ ├── Lecture4 │ │ └── muxer.ipynb │ ├── Lecture5 │ │ └── Adder4bit.ipynb │ ├── Lecture6 │ │ └── mult2x2.ipynb │ ├── Lecture7 │ │ └── EncodeDecode.ipynb │ └── Lecture9 │ │ └── ShifterRotator.ipynb ├── Section3 │ ├── Lecture1 │ │ └── Jozha.ipynb │ ├── Lecture10 │ │ └── Quantum Walk.ipynb │ ├── Lecture11 │ │ └── HHL.ipynb │ ├── Lecture12 │ │ └── VQE.ipynb │ ├── Lecture13 │ │ └── QAOA.ipynb │ ├── Lecture14 │ │ └── LSF.ipynb │ ├── Lecture2 │ │ └── Simon.ipynb │ ├── Lecture3 │ │ └── SuperDense.ipynb │ ├── Lecture4 │ │ └── QPE.ipynb │ ├── Lecture5 │ │ └── Shor.ipynb │ ├── Lecture6 │ │ ├── Grover-7bit.ipynb │ │ └── Grover.ipynb │ ├── Lecture7 │ │ └── Teleport.ipynb │ └── Lecture9 │ │ └── Hamiltonian.ipynb ├── Section4 │ ├── Lecture1 │ │ └── Visualizer.ipynb │ ├── Lecture3 │ │ └── Visualizer2.ipynb │ └── Lecture4 │ │ └── BosonSampling.ipynb ├── Section5 │ ├── Lecture1 │ │ └── QuantumOps_Ms.ipynb │ ├── Lecture10 │ │ └── PennylaneVQEexample.ipynb │ ├── Lecture2 │ │ └── QuantumEmbedding.ipynb │ ├── Lecture3 │ │ └── Ansatz.ipynb │ ├── Lecture5 │ │ └── Grad.ipynb │ ├── Lecture8 │ │ └── QMLTensorFlow.ipynb │ └── Lecture9 │ │ └── QMLStateLearning.ipynb ├── Section6 │ ├── Lecture1 │ │ ├── QSVMPennylane.ipynb │ │ └── QSVMQiskit.ipynb │ ├── Lecture3 │ │ ├── VQC.ipynb │ │ └── qiskit-vqc.ipynb │ ├── Lecture4 │ │ └── KMC.ipynb │ ├── Lecture5 │ │ └── QCNN.ipynb │ └── Lecture6 │ │ └── QONN.ipynb ├── Section7 │ └── Lecture3 │ │ └── QuantumNoiseModel.ipynb └── Section9 │ └── Lecture2 │ └── EntanglementSwapping.ipynb └── README.md /QuantumComputingManimGL/Section0/Lecture1/questions.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Computing A-Z").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class questions(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Quantum Computing A-Z").scale(1) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | stuff = [] 23 | #stuff.append( Tex(r"").shift(DOWN*2) ) 24 | stuff.append( Tex(r"\text{Why did you make this course?}").shift(UP*0).scale(2) ) 25 | stuff.append( Tex(r"\text{Why is this course unique?}").shift(UP*0).scale(2) ) 26 | stuff.append( Tex(r"\text{Some Tips on taking the course?}").shift(UP*0).scale(2) ) 27 | stuff.append( Tex(r"\text{Who is this course for?}").shift(UP*0).scale(2) ) 28 | stuff.append( Tex(r"\text{Are you grateful for this opportunity?}").shift(UP*0).scale(1.5) ) 29 | stuff.append( Tex(r"\text{Anything else you would like to say?}").shift(UP*0).scale(1.5) ) 30 | self.play(ShowCreation(stuff[0])) 31 | for i in range(1, len(stuff)): 32 | waiter(10) 33 | self.play(FadeOut(stuff[i-1]), Write(stuff[i])) 34 | waiter(10) 35 | #self.play(FadeOut(Group(*stuff))) 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section0/Lecture4/div.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("DiVincenzo's Criteria for a Quantum Computer").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class div(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("DiVincenzo's Criteria for a Quantum Computer").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("DiVincenzo's Criteria for a Quantum Computer").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | ty = Tex(r"\text{What is a quantum computer? What is needed?}") 24 | self.play(FadeIn(ty)) 25 | waiter(10) 26 | self.play(FadeOut(ty)) 27 | 28 | stuff = [] 29 | #stuff.append( Tex(r"").shift(DOWN*2) ) 30 | stuff.append( Tex(r"\text{1. Scalable Physical System w/ Logical Qubits}").shift(UP*2) ) 31 | stuff.append( Tex(r"\text{2. Arbituary State Initialization}").shift(UP*1) ) 32 | stuff.append( Tex(r"\text{3. Long Relevant Decoherence Time}").shift(UP*0) ) 33 | stuff.append( Tex(r"\text{4. Universal Set of Quantum Gates}").shift(DOWN*1) ) 34 | stuff.append( Tex(r"\text{5. Ability to Measure Qubits}").shift(DOWN*2) ) 35 | for i in stuff: 36 | self.play(FadeIn(i)) 37 | waiter(15) 38 | waiter(15) 39 | #self.play(FadeOut(Group(*stuff))) 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture11/measure.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | 4 | class FirstScene(Scene): 5 | def construct(self): 6 | text = Text("3rd Postulate of QM, Measurement, Born Rule").scale(0.7) 7 | self.play(FadeIn(text)) 8 | self.wait(3) 9 | 10 | class m(Scene): 11 | def construct(self): 12 | text = Text("3rd Postulate of QM, Measurement, Born Rule") 13 | self.play(FadeIn(text)) 14 | self.wait(6) 15 | self.play(FadeOut(text)) 16 | title = Text("3rd Postulate of QM: Observables").shift(UP*3.5) 17 | self.play(Write(title)) 18 | 19 | content = Text("All observables are associated with eigenvalues when measured").scale(0.6).shift(DOWN*3.5) 20 | self.play(Write(content)) 21 | self.wait(4) 22 | item = Tex(r"B\ket{\psi} = \lambda\ket{\psi}") 23 | self.play(Write(item)) 24 | self.wait(8) 25 | item2 = Tex(r"\bra{\psi}B^\dag B\ket{\psi} = \lambda^\dag\lambda") 26 | self.play(Transform(item, item2)) 27 | self.wait(8) 28 | self.play(FadeOut(item)) 29 | 30 | 31 | #write down math 32 | title2 = Text("Measurement").shift(UP*3.5) 33 | self.play(Transform(title, title2)) 34 | 35 | poperator = Tex(r"\bra{v}P\ket{v} = \bra{v}\begin{bmatrix} 1 & 0 \\ 0 & 0 \end{bmatrix}\ket{v} = a_i^*a_i") 36 | self.play(FadeIn(poperator)) 37 | self.wait(5) 38 | poperator2 = Tex(r"\bra{v}P\ket{v} = \bra{v}\ket{0}\bra{0}\ket{v} = a_0^*a_0") 39 | self.play(Transform(poperator, poperator2)) 40 | self.wait(3) 41 | poperator3 = Tex(r"\bra{v}M_0\ket{v} = \bra{v}\ket{0}\bra{0}\ket{v} = a_0^*a_0").shift(DOWN*0.3) 42 | self.play(Transform(poperator, poperator3)) 43 | self.wait(3) 44 | itsap = Tex(r"M_0 = \ket{0}\bra{0}").shift(DOWN*2 + LEFT*3.5) 45 | itsapd = Tex(r"M_1 = \ket{1}\bra{1}").shift(DOWN*2 + RIGHT*3.5) 46 | self.play(Write(itsap), Write(itsapd)) 47 | self.wait(6) 48 | itsapq = Tex(r"M = \sum_{i=0}^{n} c_i\ket{i}\bra{i}").shift(UP*1) 49 | 50 | 51 | #born rule 52 | title3 = Text("Born Rule").shift(UP*3.5) 53 | self.play(Transform(title, title3)) 54 | expM = Tex(r"E(M) = \sum_{i=0}^{n}c_ia_i^*a_i").shift(UP*2.4) 55 | self.play(Write(expM)) 56 | self.wait(5) 57 | 58 | expM1 = Tex(r"E(M_0) = a_0^*a_0").shift(UP*2) 59 | self.play(Transform(expM, expM1)) 60 | self.wait(5) 61 | 62 | testsample = Tex(r"\{ a_0^*a_0 - 0.6, a_0^*a_0 + 3, a_0^*a_0 + 0.002, a_0^*a_0 - 2.01, a_0^*a_0 - 0.388 \}").shift(UP*0.7) 63 | self.play(Write(testsample)) 64 | self.wait(5) 65 | expM1 = Tex(r"E(M) = \sum_{i=0}^{n}c_ia_i^*a_i").shift(UP*2.4) 66 | 67 | self.play(FadeOut(testsample), FadeOut(expM), FadeOut(itsap), FadeOut(itsapd), FadeOut(poperator), FadeIn(expM1)) 68 | 69 | #example 70 | expMW = Tex(r"E(M) = c_0a_0^*a_0 + c_1a_1^*a_1").shift(UP*1) 71 | self.play(Write(expMW)) 72 | self.wait(5) 73 | 74 | expMWW = Tex(r"E(M) = c_0 \bra{v}\ket{0}\bra{0}\ket{v} + c_1 \bra{v}\ket{1}\bra{1}\ket{v}") 75 | self.play(Write(expMWW)) 76 | self.wait(5) 77 | 78 | expMWWW = Tex(r"E(M) = \bra{v} \sum_{i=0}^{n}c_i\ket{i}\bra{i} \ket{v} ").shift(DOWN*1) 79 | self.play(Write(expMWWW)) 80 | self.wait(5) 81 | 82 | #poperatorw2 = Tex(r"\bra{v}M\ket{v} = \bra{v} \sum_{i=0}^{n} c_i\ket{i}\bra{i} \ket{v} = E(M)").shift(DOWN*0.3) 83 | #self.play(Transform(poperator, poperatorw2)) 84 | 85 | poperatorw3 = Tex(r"\bra{v}M\ket{v} = E(M)").shift(DOWN*1) 86 | self.play(Transform(expMWWW, poperatorw3)) 87 | self.wait(5) 88 | 89 | self.play(FadeOut(expMW), FadeIn(itsapq)) 90 | itsapq2 = Tex(r"M = \sum_{i=0}^{n} \lambda_i\ket{\lambda_i}\bra{\lambda_i}").shift(DOWN*2) 91 | self.play(Transform(itsapq, itsapq2)) 92 | self.wait(5) 93 | itsbounding = SurroundingRectangle(itsapq) 94 | self.play(ShowCreation(itsbounding)) 95 | self.wait(5) 96 | itsGrouper = Group(itsapq, expMWW, expMWWW, itsbounding) 97 | self.play(FadeOut(itsGrouper)) 98 | 99 | 100 | #go back to postulate 101 | title6 = Text("3rd Postulate of QM: Observables").shift(UP*3.5) 102 | self.play(Transform(title, title6)) 103 | 104 | poperatorw4 = Tex(r"B\ket{v} = \lambda\ket{v}").shift(DOWN*0.3) 105 | self.play(FadeIn(poperatorw4)) 106 | self.wait(5) 107 | 108 | poperatorw5 = Tex(r"B\ket{v} = \sum_{i=0}^{n} \lambda_i\ket{i}\bra{i} \ket{v}") 109 | self.play(Transform(poperatorw4, poperatorw5)) 110 | self.wait(5) 111 | 112 | poperatorw5 = Tex(r"B\ket{v} = \sum_{i=0}^{n} \lambda_ia_i\ket{i}") 113 | self.play(Transform(poperatorw4, poperatorw5), FadeOut(expM1)) 114 | self.wait(5) 115 | 116 | poperatorw6 = Tex(r"B\ket{v} = \sum_{i=0}^{n} \lambda_ia_i\ket{i} = \lambda\ket{v}") 117 | self.play(Transform(poperatorw4, poperatorw6)) 118 | self.wait(5) 119 | 120 | #what measurement actually means, example 121 | self.play(FadeOut(poperatorw4), FadeOut(content)) 122 | title7 = Text(r"Measure").shift(UP*3.5) 123 | self.play(FadeOut(title),FadeIn(title7)) 124 | 125 | item = Tex(r"\ket{\psi} = \frac{i}{\sqrt{(5})} \begin{bmatrix} 1 \\ 0 \end{bmatrix} + \frac{2}{\sqrt{(5})} \begin{bmatrix} 0 \\ 1 \end{bmatrix}").shift(UP*2.5) 126 | self.play(Write(item)) 127 | self.wait(5) 128 | 129 | problem = Tex(r"Calculate \bra{\psi}M_0\ket{\psi}").shift(DOWN*3) 130 | self.play(Write(problem)) 131 | 132 | 133 | self.wait(14) 134 | 135 | sol1 = Tex(r"\bra{\psi} M_0 \ket{\psi} = (\frac{-i}{\sqrt{(5})} \bra{0} + \frac{2}{\sqrt{(5})} \bra{1}) \ \ (\ket{0}\bra{0}) \ \ (\frac{i}{\sqrt{(5})} \ket{0} + \frac{2}{\sqrt{(5})} \ket{1})").scale(0.95).shift(UP*1) 136 | self.play(Write(sol1)) 137 | self.wait(5) 138 | 139 | sol2 = Tex(r"\bra{\psi} M_0 \ket{\psi} = (\frac{-i}{\sqrt{(5})} \bra{0}\ket{0})(\frac{i}{\sqrt{(5})} \bra{0}\ket{0})").shift(DOWN*0.3) 140 | self.play(Write(sol2)) 141 | self.wait(5) 142 | 143 | sol3 = Tex(r"\bra{\psi} M_0 \ket{\psi} = \frac{1}{5}").shift(DOWN*1.7) 144 | self.play(Write(sol3)) 145 | self.wait(5) 146 | 147 | sol4 = Tex(r"\bra{\psi} M_0 \ket{\psi} = \frac{1}{5} = (\frac{i}{\sqrt{(5})})^*\frac{i}{\sqrt{(5})} ").shift(DOWN*1.7) 148 | self.play(Transform(sol3, sol4)) 149 | self.wait(5) 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture13/tden.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Relevance of Quantum Machine Learning").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class tden(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | 18 | title = Text("Density Matrix and Quantum Gates").shift(UP*3.5) 19 | self.play(FadeIn(title)) 20 | 21 | stuff = [] 22 | stuff.append( Tex(r"\text{Density Matrix: } \rho \quad \quad \text{Quantum Gate: } U").shift(UP*2.5) ) 23 | stuff.append( Tex(r"\rho = \ket{\psi}\bra{\psi}").shift(UP*1.5) ) 24 | stuff.append( Tex(r"U \rho U^\dag = U\ket{\psi}\bra{\psi}U^\dag = \big( U\ket{\psi} \big) \big( U\ket{\psi} \big)^\dag").shift(DOWN*0.5) ) 25 | 26 | for i in stuff: 27 | self.play(FadeIn(i)) 28 | waiter(7) 29 | waiter(14) 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture18/serial.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Parallel & Serial Gates").scale(0.7) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class serial(Scene): 12 | def construct(self): 13 | text = Text("Parallel & Serial Gates").scale(1.1) 14 | self.play(FadeIn(text)) 15 | self.wait(5) 16 | self.play(FadeOut(text)) 17 | 18 | title = Text("Serial Gates").shift(UP*3.5) 19 | self.play(Write(title)) 20 | 21 | offset = 2 22 | x = -5 23 | dq1 = r"\ket{\psi}" 24 | dq2 = r"\ket{\phi}" 25 | def update_q1(self): 26 | self.become(Tex(r"" + str(dq1) + "_1").shift(RIGHT*x + UP*1)) 27 | def update_q2(self): 28 | self.become(Tex(r"" + str(dq2) + "_2").shift(RIGHT*x + DOWN*offset + UP*1)) 29 | q1 = Tex(r"\ket{0}_1").shift(LEFT*5 + UP*0.7).add_updater(update_q1) 30 | q2 = Tex(r"\ket{0}_2").shift(LEFT*5 + DOWN*offset + UP*0.7).add_updater(update_q2) 31 | 32 | l1 = Line(np.array([-5, 0, 0]), np.array([5, 0, 0])) 33 | l2 = Line(np.array([-5, -offset, 0]), np.array([5, -offset, 0])) 34 | 35 | def update_qubit1(self): 36 | self.become(Dot(np.array([x,0,0]),fill_color=BLUE)) 37 | def update_qubit2(self): 38 | self.become(Dot(np.array([x,-offset,0]),fill_color=BLUE)) 39 | 40 | qubit1 = Dot(np.array([x,0,0]), fill_color=BLUE) 41 | qubit1.add_updater(update_qubit1) 42 | qubit2 = Dot(np.array([x,-offset,0]), fill_color=BLUE) 43 | qubit2.add_updater(update_qubit2) 44 | 45 | itsg = Group(q1, q2, qubit1, qubit2) 46 | self.play(FadeIn(itsg), FadeIn(l1), FadeIn(l2)) 47 | hadamardbro = Square(fill_color=YELLOW, fill_opacity=1, color=YELLOW).scale(0.5) 48 | hadamo = Text("H", fill_color=BLACK) 49 | hadamard1 = Group(hadamardbro, hadamo) 50 | hadamard1.shift(LEFT*1) 51 | self.play(FadeIn(hadamard1)) 52 | 53 | phasebro = Square(fill_color=GREEN, fill_opacity=1, color=GREEN).scale(0.5) 54 | phaser = Tex(r"R_\theta", fill_color=BLACK).scale(1.2) 55 | phase = Group(phasebro, phaser) 56 | phase.shift(RIGHT*1) 57 | self.play(FadeIn(phase)) 58 | 59 | whyitstrue = Text("Superoperator can represent serial gates").shift(UP*2) 60 | self.play(FadeIn(whyitstrue)) 61 | 62 | combiner = Rectangle(fill_color=YELLOW_D, fill_opacity=1, color=GREEN).scale(0.5) 63 | combino = Tex(r"R_\theta \cdot H", fill_color=BLACK).scale(1.2) 64 | combine = Group(combiner, combino) 65 | self.play(FadeOut(hadamard1), FadeOut(phase), FadeIn(combine)) 66 | self.wait(8) 67 | 68 | self.play(FadeOut(whyitstrue), FadeOut(combine)) 69 | 70 | title2 = Text("Parallel Gates").shift(UP*3.5) 71 | self.play(Transform(title, title2)) 72 | 73 | 74 | hadamardbro2 = Square(fill_color=YELLOW, fill_opacity=1, color=YELLOW).scale(0.5) 75 | hadamo2 = Text("H", fill_color=BLACK) 76 | hadamard2 = Group(hadamardbro2, hadamo2) 77 | hadamard2.shift(LEFT*1 + DOWN*offset) 78 | self.play(FadeIn(hadamard1), FadeIn(hadamard2)) 79 | self.wait(3) 80 | texer = Tex(r"(H \otimes H) \ket{\psi \otimes \phi} = H\ket{\psi} \otimes H\ket{\phi}").shift(UP*2) 81 | self.play(FadeIn(texer)) 82 | 83 | hadamardbro3 = Square(fill_color=YELLOW, fill_opacity=1, color=YELLOW).scale(1.8) 84 | hadamo3 = Tex(r"H \otimes H", fill_color=BLACK).scale(2) 85 | hadamard3 = Group(hadamardbro3, hadamo3) 86 | hadamard3.shift(DOWN*1) 87 | self.play(FadeOut(hadamard1), FadeOut(hadamard2), FadeIn(hadamard3)) 88 | self.wait(3) 89 | 90 | hadamardbro4 = Square(fill_color=YELLOW, fill_opacity=1, color=YELLOW).scale(1.8) 91 | hadamo4 = Tex(r"H^{\otimes 2}", fill_color=BLACK).scale(2) 92 | hadamard4 = Group(hadamardbro4, hadamo4) 93 | hadamard4.shift(DOWN*1) 94 | self.play(Transform(hadamard3, hadamard4)) 95 | self.wait(12) 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture19/clone.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("No Cloning Theorem, Forking").scale(0.7) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class clone(Scene): 12 | def construct(self): 13 | text = Text("No Cloning Theorem, Forking").scale(1.1) 14 | self.play(FadeIn(text)) 15 | self.wait(3) 16 | self.play(FadeOut(text)) 17 | 18 | 19 | title = Text("No Cloning Theorem").shift(UP*3.5) 20 | self.play(FadeIn(title)) 21 | theorem = Tex(r"\text{There is no Unitary Operator U s.t } U\ket{a}\ket{b} = \ket{a}\ket{a}").shift(DOWN*3.5) 22 | self.play(FadeIn(theorem)) 23 | self.wait(3) 24 | assumption = Tex(r"\text{Assume arbituary } \ket{\psi} \text { and } \ket{\phi}").scale(0.9).shift(UP*2.75) 25 | self.play(FadeIn(assumption)) 26 | self.wait(3) 27 | truth = Tex(r"U\ket{\phi}\ket{0} = \ket{\phi}\ket{\phi}").shift(UP*2) 28 | truth2 = Tex(r"U\ket{\psi}\ket{0} = \ket{\psi}\ket{\psi}").shift(UP*1.25) 29 | self.play(FadeIn(truth), FadeIn(truth2)) 30 | self.wait(3) 31 | itsun = Tex(r"\bra{\phi}\ket{\psi} = (\bra{\phi}\bra{0})(\ket{\psi}\ket{0})").shift(UP*0.5) 32 | self.play(FadeIn(itsun)) 33 | self.wait(3) 34 | itsun2 = Tex(r"\bra{\phi}\ket{\psi} = (\bra{\phi}\bra{0})U^\dag U(\ket{\psi}\ket{0})").shift(DOWN*0.25) 35 | self.play(FadeIn(itsun2)) 36 | self.wait(3) 37 | itsun3 = Tex(r"\bra{\phi}\ket{\psi} = (\bra{\phi}\bra{\phi})(\ket{\psi}\ket{\psi})").shift(DOWN*1) 38 | self.play(FadeIn(itsun3)) 39 | self.wait(3) 40 | itsun4 = Tex(r"\bra{\phi}\ket{\psi} = (\bra{\phi}\ket{\psi})^2").shift(DOWN*1.75) 41 | self.play(FadeIn(itsun4)) 42 | self.wait(3) 43 | itsun5 = Tex(r"\ket{\psi} = \ket{\phi} \ \ \ \ \ \bra{\phi}\ket{\psi} = 0").shift(DOWN*2.5) 44 | self.play(FadeIn(itsun5)) 45 | self.wait(3) 46 | itsnay = SurroundingRectangle(assumption) 47 | self.play(ShowCreation(itsnay)) 48 | grouper = Group(theorem, assumption, truth2, truth, itsun, itsun2, itsun3, itsun4, itsun5, itsnay) 49 | self.play(FadeOut(grouper)) 50 | 51 | reality = Text("You can only clone orthogonal states").shift(UP*0.5) 52 | re2 = Tex(r"\ket{10} \to \ket{11} ").shift(DOWN*0.5) 53 | tg = Group(reality, re2) 54 | self.play(FadeIn(tg)) 55 | self.wait(8) 56 | self.play(FadeOut(tg)) 57 | 58 | #forking 59 | title2 = Text("Forking").shift(UP*3.5) 60 | self.play(Transform(title, title2)) 61 | 62 | x = -5 63 | y = 0 64 | def update_dot1(self): 65 | self.become(Dot(np.array([x,y,0]),fill_color=BLUE)) 66 | def update_dot2(self): 67 | self.become(Dot(np.array([x,-y,0]),fill_color=BLUE)) 68 | electron1 = Dot(np.array([x,y,0]),fill_color=BLUE).add_updater(update_dot1) 69 | electron2 = Dot(np.array([x,-y,0]),fill_color=BLUE).add_updater(update_dot2) 70 | l1 = Line(np.array([-5, 0, 0]), np.array([0, 0, 0])) 71 | l2 = Line(np.array([0, 0, 0]), np.array([5, 2.5, 0])) 72 | l3 = Line(np.array([0, 0, 0]), np.array([5, -2.5, 0])) 73 | 74 | 75 | registers = Rectangle(height=1.5, fill_color=YELLOW, color=YELLOW, fill_opacity=1) 76 | registert = Text("Register").set_color(BLACK) 77 | register = Group(registers, registert) 78 | register.shift(RIGHT*4.5 + UP*2.5) 79 | 80 | ALUs = Rectangle(height=1.5, fill_color=YELLOW, color=YELLOW, fill_opacity=1) 81 | ALUt = Text("ALU").set_color(BLACK) 82 | ALU = Group(ALUs, ALUt) 83 | ALU.shift(RIGHT*4.5 + DOWN*2.5) 84 | 85 | 86 | itsallthesame = Group(l1, l2, l3, register, ALU, electron1, electron2) 87 | self.play(FadeIn(itsallthesame)) 88 | self.wait(2) 89 | 90 | while (x < 0): 91 | x += 0.05 92 | self.wait(0.001) 93 | 94 | while (x < 5): 95 | x += 0.05 96 | y += 0.025 97 | self.wait(0.001) 98 | x = -5 99 | y = 0 100 | while (x < 0): 101 | x += 0.05 102 | self.wait(0.001) 103 | 104 | while (x < 5): 105 | x += 0.05 106 | y += 0.025 107 | self.wait(0.001) 108 | 109 | 110 | x = -5 111 | y = 0 112 | while (x < 0): 113 | x += 0.05 114 | self.wait(0.001) 115 | 116 | while (x < 2): 117 | x += 0.05 118 | y += 0.025 119 | self.wait(0.001) 120 | electron2.remove_updater(update_dot2) 121 | xmark = Text("X").set_color(RED).shift(RIGHT*2 + DOWN*1) 122 | self.add(xmark) 123 | while (x < 5): 124 | x += 0.05 125 | y += 0.025 126 | self.wait(0.001) 127 | self.wait(10) 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture21/bool.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Boolean Algebra, Truth Tables").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class bool(Scene): 12 | def construct(self): 13 | text = Text("Boolean Algebra, Truth Tables").scale(1.0) 14 | self.play(FadeIn(text)) 15 | self.wait(3) 16 | self.play(FadeOut(text)) 17 | 18 | title = Text("Boolean Algebra").shift(UP*3.5) 19 | self.play(FadeIn(title)) 20 | 21 | thebase = Text("Base 2").shift(DOWN*3.5) 22 | 23 | add0 = Tex(r"00 + 00 = 00").shift(UP*2 + LEFT*3) 24 | add1 = Tex(r"01 + 00 = 01").shift(UP*1 + LEFT*3) 25 | add2 = Tex(r"00 + 01 = 01").shift(UP*0 + LEFT*3) 26 | add3 = Tex(r"01 + 01 = 10").shift(UP*-1 + LEFT*3) 27 | allofit = Group(thebase, add0, add1, add2, add3) 28 | self.play(FadeIn(allofit)) 29 | self.wait(10) 30 | itsavar = Tex(r"x + y").shift(RIGHT*2 + UP*2) 31 | self.play(FadeIn(itsavar)) 32 | self.wait(5) 33 | self.play(FadeOut(allofit), FadeOut(itsavar)) 34 | 35 | 36 | title2 = Text("Truth Table").shift(UP*3.5) 37 | self.play(Transform(title, title2)) 38 | 39 | table = Tex(r"\begin{tabular}{||c c||} \hline X & Y\\ [0.5ex] \hline\hline 0 & 0 \\ \hline 0 & 1 \\ \hline 1 & 0 \\ \hline 1 & 1 \\ [1ex] \hline \end{tabular}").shift(LEFT*5.75) 40 | self.play(FadeIn(table)) 41 | 42 | table2 = Tex(r"\begin{tabular}{||c c c||} \hline X & Y & OR\\ [0.5ex] \hline\hline 0 & 0 & 0 \\ \hline 0 & 1 & 1 \\ \hline 1 & 0 & 1 \\ \hline 1 & 1 & 1 \\ [1ex] \hline \end{tabular}").shift(LEFT*2.75) 43 | self.play(FadeIn(table2)) 44 | 45 | table3 = Tex(r"\begin{tabular}{||c c c||} \hline X & Y & AND\\ [0.5ex] \hline\hline 0 & 0 & 0 \\ \hline 0 & 1 & 0 \\ \hline 1 & 0 & 0 \\ \hline 1 & 1 & 1 \\ [1ex] \hline \end{tabular}").shift(RIGHT*1.125) 46 | self.play(FadeIn(table3)) 47 | 48 | table4 = Tex(r"\begin{tabular}{||c c c||} \hline X & Y & XOR\\ [0.5ex] \hline\hline 0 & 0 & 0 \\ \hline 0 & 1 & 1 \\ \hline 1 & 0 & 1 \\ \hline 1 & 1 & 0 \\ [1ex] \hline \end{tabular}").shift(RIGHT*5.125) 49 | self.play(FadeIn(table4)) 50 | self.wait(10) 51 | 52 | tables=Group(table, table2, table3, table4) 53 | self.play(FadeOut(tables)) 54 | 55 | 56 | 57 | 58 | title3 = Text("Truth Table - CNOT").shift(UP*3.5) 59 | self.play(Transform(title, title3)) 60 | cnottable = Tex(r"\begin{tabular}{||c c c c||} \hline X & Y & X & Y\\ [0.5ex] \hline\hline 0 & 0 & 0 & 0 \\ \hline 0 & 1 & 0 & 1 \\ \hline 1 & 0 & 1 & 1 \\ \hline 1 & 1 & 1 & 0 \\ [1ex] \hline \end{tabular}") 61 | self.play(Write(cnottable)) 62 | self.wait(7) 63 | 64 | 65 | title4 = Text("Truth Table - Toffoli").shift(UP*3.5) 66 | self.play(Transform(title, title4)) 67 | toffolitable = Tex(r"\begin{tabular}{||c c c c c c||} \hline X & Y & Z & X & Y & Z\\ [0.5ex] \hline\hline 0 & 0 & 0 & 0 & 0 & 0 \\ \hline 0 & 1 & 0 & 0 & 1 & 0 \\ \hline 1 & 0 & 0 & 1 & 0 & 0 \\ \hline 0 & 1 & 1 & 0 & 1 & 1 \\ \hline 1 & 0 & 1 & 1 & 0 & 1 \\ \hline 1 & 1 & 0 & 1 & 1 & 1 \\ \hline 1 & 1 & 1 & 1 & 1 & 0 \\ [1ex] \hline \end{tabular}") 68 | self.play(FadeOut(cnottable), Write(toffolitable)) 69 | self.wait(15) 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture4/hilberto.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | 4 | class FirstScene(ThreeDScene): 5 | def construct(self): 6 | text = Text("Postulate of Quantum Mechanics I, Hilbert Space") 7 | self.play(FadeIn(text)) 8 | self.wait(3) 9 | 10 | class Hilbi(ThreeDScene): 11 | def construct(self): 12 | text = Text("Postulate of Quantum Mechanics I, Hilbert Space").scale(0.8) 13 | self.play(FadeIn(text)) 14 | self.wait(4) 15 | self.play(FadeOut(text)) 16 | 17 | ithasbasis = Text("Basis Decomposition").shift(UP*3) 18 | bro = Tex(r"\ket{\psi}") 19 | itsanc2 = Tex(r"\ket{\psi} \in \mathbb{C}^2").shift(DOWN*3) 20 | self.play(FadeIn(ithasbasis)) 21 | self.play(Write(itsanc2)) 22 | self.play(Write(bro)) 23 | self.wait(1) 24 | bro2 = Tex(r"\ket{\psi} = \sum_{i=1}^{n} a_i\ket{B_i}").shift(UP*1.8) 25 | basisors = Tex(r"\left\{B_1, B_2, ... \right\}").shift(DOWN*0.5) 26 | conditions = Text("Linearly Independent, Span Covers Space, Mutually Orthogonal").shift(DOWN*1.75).scale(0.6) 27 | itsacomplex = Tex(r"a_i \in \mathbb{C}") 28 | itsacomplex.move_to(UP*0.5) 29 | self.play(Transform(bro, bro2)) 30 | self.play(Write(itsacomplex)) 31 | self.wait(6) 32 | self.play(Write(basisors)) 33 | self.wait(3) 34 | self.play(Write(conditions)) 35 | self.wait(6) 36 | 37 | bro3 = Tex(r"\ket{\psi} = \sum_{i=1}^{n} a_i\ket{B_i}").shift(UP*1.8) 38 | 39 | self.play(Transform(bro, bro3)) 40 | self.wait(6) 41 | 42 | itsanc23 = Tex(r"\ket{\psi} \in \mathbb{C}^2 + \langle , \rangle").shift(DOWN*3) 43 | self.play(Transform(itsanc2, itsanc23)) 44 | self.wait(4) 45 | 46 | itsanc24 = Tex(r"\ket{\psi} \in \mathbb{C}^2 + \langle , \rangle = \mathbb{H}^2").shift(DOWN*3) 47 | self.play(Transform(itsanc2, itsanc24)) 48 | 49 | self.wait(5) 50 | ithasbasis2 = Text("Postulate of Quantum Mechanics I").shift(UP*3) 51 | self.play(Transform(ithasbasis, ithasbasis2)) 52 | self.wait(10) 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture4/tensorbro.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | 4 | class FirstScene(ThreeDScene): 5 | def construct(self): 6 | text = Text("Tensor Product, Unitary Matrices, Quantum Gates") 7 | self.play(FadeIn(text)) 8 | self.wait(3) -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture5/tensorbro.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | 4 | class FirstScene(ThreeDScene): 5 | def construct(self): 6 | text = Text("Tensor Product, Unitary Matrices, Quantum Gates").scale(0.9) 7 | self.play(FadeIn(text)) 8 | self.wait(3) 9 | 10 | class TensorBro(ThreeDScene): 11 | def construct(self): 12 | text = Text("Tensor Product, Unitary Matrices, Quantum Gates").scale(0.9) 13 | self.play(FadeIn(text)) 14 | self.wait(4) 15 | self.play(FadeOut(text)) 16 | 17 | combiningqubits = Text("Representing Multiple Qubits").shift(UP*3) 18 | itsaqubits = Tex(r"\ket{\psi}, \ket{\varphi} \in \mathbb{H}^2").shift(DOWN*3) 19 | self.play(Write(combiningqubits)) 20 | self.play(Write(itsaqubits)) 21 | self.wait(2) 22 | qubits2 = Tex(r"\ket{\psi}\ket{\varphi}") 23 | self.play(Write(qubits2)) 24 | self.wait(5) 25 | 26 | itsaqubitsw = Tex(r"\ket{\psi}\ket{\varphi} \in \mathbb{H}^4").shift(DOWN*2) 27 | self.play(Write(itsaqubitsw)) 28 | self.wait(3) 29 | 30 | qubits3 = Tex(r"\ket{\psi}\ket{\varphi} = \begin{bmatrix} \psi_1 \\ \psi_2 \end{bmatrix} \begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix}") 31 | self.play(Transform(qubits2, qubits3)) 32 | self.wait(3) 33 | 34 | qubits4 = Tex(r"\ket{\psi}\ket{\varphi} = \begin{bmatrix} \psi_1 \\ \psi_2 \end{bmatrix} \begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} = \begin{bmatrix}\psi_1\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \\ \psi_2\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \end{bmatrix} ") 35 | self.play(Transform(qubits2, qubits4)) 36 | self.wait(3) 37 | 38 | qubits5 = Tex(r"\ket{\psi}\ket{\varphi} = \begin{bmatrix} \psi_1 \\ \psi_2 \end{bmatrix} \begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} = \begin{bmatrix}\psi_1\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \\ \psi_2\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \end{bmatrix} = \begin{bmatrix} \psi_1\varphi_1 \\ \psi_1\varphi_2 \\ \psi_2\varphi_1 \\ \psi_2\varphi_2 \end{bmatrix}") 39 | self.play(Transform(qubits2, qubits5)) 40 | self.wait(6) 41 | 42 | combiningqubits2 = Text("Tensor Product").shift(UP*3) 43 | self.play(Transform(combiningqubits, combiningqubits2)) 44 | 45 | qubits6 = Tex(r"\ket{\psi}\otimes\ket{\varphi} = \begin{bmatrix} \psi_1 \\ \psi_2 \end{bmatrix}\otimes \begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} = \begin{bmatrix}\psi_1\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \\ \psi_2\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \end{bmatrix} = \begin{bmatrix} \psi_1\varphi_1 \\ \psi_1\varphi_2 \\ \psi_2\varphi_1 \\ \psi_2\varphi_2 \end{bmatrix}") 46 | self.play(Transform(qubits2, qubits6)) 47 | self.wait(3) 48 | 49 | qubits7 = Tex(r"\ket{\psi\varphi} = \begin{bmatrix} \psi_1 \\ \psi_2 \end{bmatrix}\otimes \begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} = \begin{bmatrix}\psi_1\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \\ \psi_2\begin{bmatrix} \varphi_1 \\ \varphi_2 \end{bmatrix} \end{bmatrix} = \begin{bmatrix} \psi_1\varphi_1 \\ \psi_1\varphi_2 \\ \psi_2\varphi_1 \\ \psi_2\varphi_2 \end{bmatrix}") 50 | self.play(Transform(qubits2, qubits7)) 51 | self.wait(3) 52 | 53 | itsaqubitsw2 = Tex(r"\ket{\psi\varphi} \in \mathbb{H}^4").shift(DOWN*2) 54 | self.play(Transform(itsaqubitsw, itsaqubitsw)) 55 | self.wait(3) 56 | 57 | self.wait(2) 58 | qubits8 = Tex(r"\ket{\psi\varphi} = \begin{bmatrix} 1 \\ 0 \end{bmatrix}\otimes \begin{bmatrix} 0 \\ 1 \end{bmatrix} = \begin{bmatrix}1\begin{bmatrix} 0 \\ 1 \end{bmatrix} \\ 0\begin{bmatrix} 0 \\ 1 \end{bmatrix} \end{bmatrix}") 59 | self.play(Transform(qubits2, qubits8)) 60 | self.wait(3) 61 | 62 | # 63 | self.play(FadeOut(qubits2)) 64 | self.remove(qubits2) 65 | qubits9 = Tex(r"\ket{\psi\varphi} = \begin{bmatrix} 1 \\ 0 \end{bmatrix}\otimes \begin{bmatrix} 0 \\ 1 \end{bmatrix} = \begin{bmatrix}1\begin{bmatrix} 0 \\ 1 \end{bmatrix} \\ 0\begin{bmatrix} 0 \\ 1 \end{bmatrix} \end{bmatrix} = \begin{bmatrix} 0 \\ 1 \\ 0 \\ 0 \end{bmatrix}") 66 | self.play(FadeIn(qubits9)) 67 | self.wait(6) 68 | self.play(FadeOut(qubits9)) 69 | 70 | qubits10 = Tex(r"\begin{bmatrix} 0 \\ 1 \end{bmatrix}\otimes \begin{bmatrix} 1 \\ 0 \end{bmatrix}") 71 | self.play(FadeIn(qubits10)) 72 | self.wait(14) 73 | self.play(FadeOut(qubits10)) 74 | 75 | qubits11 = Tex(r"\begin{bmatrix}0\begin{bmatrix} 1 \\ 0 \end{bmatrix} \\ 1\begin{bmatrix} 1 \\ 0 \end{bmatrix} \end{bmatrix} = \begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix}") 76 | self.play(Write(qubits11)) 77 | self.wait(4) 78 | 79 | self.play(FadeOut(qubits11), FadeOut(combiningqubits), FadeOut(itsaqubitsw), FadeOut(itsaqubits)) 80 | 81 | #now do unitary matrices 82 | unitary = Text("Unitary Matrices").shift(UP*3) 83 | self.play(Write(unitary)) 84 | 85 | itsunitary = Tex(r"U") 86 | self.play(Write(itsunitary)) 87 | self.wait(4) 88 | 89 | itsunitary2 = Tex(r"U^\dag U = \mathbb{I}") 90 | self.play(Transform(itsunitary, itsunitary2)) 91 | self.wait(4) 92 | 93 | #property 1: Determinant is 1 94 | itsunitary21 = Tex(r"det(U^\dag U) = det(\mathbb{I})").shift(DOWN*2) 95 | self.play(Write(itsunitary21)) 96 | self.wait(3) 97 | 98 | itsunitary22 = Tex(r"det(U^\dag)det(U) = det(\mathbb{I})").shift(DOWN*2) 99 | self.play(Transform(itsunitary21, itsunitary22)) 100 | self.wait(3) 101 | 102 | itsunitary23 = Tex(r"det(U) = 1").shift(DOWN*2) 103 | self.play(Transform(itsunitary21, itsunitary23)) 104 | self.wait(8) 105 | 106 | self.play(FadeOut(unitary), FadeOut(itsunitary), FadeOut(itsunitary23)) 107 | 108 | #Quantum Gates 109 | qgate = Tex(r"\textrm{1. All Quantum Gates are Unitary Matrices}").shift(UP*3.5) 110 | self.play(Write(qgate)) 111 | 112 | itsagate = Tex(r"G") 113 | self.play(Write(itsagate)) 114 | 115 | itsunitary24 = Tex(r"det(G) = 1").shift(DOWN*2) 116 | self.play(Transform(itsunitary21, itsunitary24)) 117 | 118 | self.wait(5) 119 | 120 | itsagate2 = Tex(r"\ket{\psi_2} = G\ket{\psi_1}").shift(UP*1.25) 121 | self.play(Transform(itsagate, itsagate2)) 122 | 123 | self.wait(5) 124 | #Name Rule 2: The Euclidean Norm of Qubits is 1 125 | complexlaw2 = Tex(r"\textrm{2. The Euclidean Norm of all Qubits is 1 }") 126 | complexlaw2.move_to(UP * 2.85) 127 | self.play(FadeIn(complexlaw2)) 128 | 129 | self.wait(8) 130 | itsagate21 = Tex(r"\mid{(\ket{\psi_2})}\mid = det(G)*\mid{(\ket{\psi_1})}\mid") 131 | self.play(FadeIn(itsagate21)) 132 | 133 | self.wait(3) 134 | itsagate22 = Tex(r"\mid{(\ket{\psi_2})}\mid = 1*\mid{(\ket{\psi_1})}\mid") 135 | self.play(Transform(itsagate21, itsagate22)) 136 | 137 | self.wait(3) 138 | itsagate23 = Tex(r"\mid{(\ket{\psi_2})}\mid = \mid{(\ket{\psi_1})}\mid = 1") 139 | self.play(Transform(itsagate21, itsagate23)) 140 | self.wait(8) 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section1/Lecture6/eulerbro.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | 4 | class FirstScene(ThreeDScene): 5 | def construct(self): 6 | text = Text("Postulate II of Quantum Mechanics, Super Operators, Euler Formula").scale(0.7) 7 | self.play(FadeIn(text)) 8 | self.wait(3) 9 | 10 | class euler(ThreeDScene): 11 | def construct(self): 12 | text = Text("Postulate II of Quantum Mechanics, Super Operators, Euler Formula").scale(0.7) 13 | self.play(FadeIn(text)) 14 | self.wait(6) 15 | self.play(FadeOut(text)) 16 | combiningqubits = Text("The 2nd Postulate").shift(UP*3) 17 | itsaqubits = Tex(r"\ket{\psi}, \ket{\varphi} \in \mathbb{H}^2").shift(DOWN*3.5) 18 | self.play(Write(combiningqubits)) 19 | self.play(Write(itsaqubits)) 20 | self.wait(2) 21 | 22 | itsagate = Tex(r"G\ket{\psi_1} = \ket{\psi_2}") 23 | self.play(Write(itsagate)) 24 | self.wait(8) 25 | 26 | itsagate2 = Tex(r"U\ket{\psi_0} = \ket{\psi_t}").shift(UP*1) 27 | self.play(Transform(itsagate, itsagate2)) 28 | self.wait(8) 29 | 30 | thepostulate = Tex(r"\textrm{A qubit at any state in time after can be represented with a unitary matrix}").shift(DOWN*2.2).scale(0.8) 31 | self.play(Write(thepostulate)) 32 | self.wait(8) 33 | 34 | itsagate3 = Tex(r"\ket{\psi_0}").shift(UP*1) 35 | self.play(Transform(itsagate, itsagate3)) 36 | 37 | 38 | x = -5 39 | def update_qubit(self): 40 | self.become(Dot(np.array([x,-1,0]),fill_color=BLUE)) 41 | qubit = Dot(np.array([x,-1,0]), fill_color=BLUE) 42 | qubit.add_updater(update_qubit) 43 | qgate = Square(1, color=YELLOW).shift(DOWN*1 + LEFT*3) 44 | qgate2 = Square(1, color=YELLOW).shift(DOWN*1 + LEFT*1) 45 | qgate3 = Square(1, color=YELLOW).shift(DOWN*1 + RIGHT*1) 46 | qgate4 = Square(1, color=YELLOW).shift(DOWN*1 + RIGHT*3) 47 | line = Line(np.array([-15, -1, 0]), np.array([15, -1, 0])) 48 | self.add(line) 49 | self.play(ShowCreation(qubit)) 50 | self.play(ShowCreation(qgate)) 51 | self.play(ShowCreation(qgate2)) 52 | self.play(ShowCreation(qgate3)) 53 | self.play(ShowCreation(qgate4)) 54 | self.wait(5) 55 | 56 | 57 | g1 = False 58 | g2 = False 59 | g3 = False 60 | g4 = False 61 | def update_vector(self): 62 | self.next_to(qubit, UP, buff=1.5) 63 | itsagate.add_updater(update_vector) 64 | 65 | t = 0 66 | while(t < 1000): 67 | x += 0.01 68 | t += 1 69 | if (t>200 and g1 == False): 70 | qgate11 = Square(1, fill_color=YELLOW, fill_opacity=1).shift(DOWN*1 + LEFT*3) 71 | itsagate4 = Tex(r"U_1\ket{\psi_0}") 72 | self.play(Transform(qgate, qgate11)) 73 | self.play(Transform(itsagate, itsagate4)) 74 | g1 = True 75 | if (t>400 and g2 == False): 76 | qgate22 = Square(1, fill_color=YELLOW, fill_opacity=1).shift(DOWN*1 + LEFT*1) 77 | itsagate5 = Tex(r"U_2U_1\ket{\psi_0}") 78 | self.play(Transform(qgate2, qgate22)) 79 | self.play(Transform(itsagate, itsagate5)) 80 | g2 = True 81 | if (t>600 and g3 == False): 82 | qgate33 = Square(1, fill_color=YELLOW, fill_opacity=1).shift(DOWN*1 + RIGHT*1) 83 | itsagate6 = Tex(r"U_3U_2U_1\ket{\psi_0}") 84 | self.play(Transform(qgate3, qgate33)) 85 | self.play(Transform(itsagate, itsagate6)) 86 | g3 = True 87 | if (t>800 and g4 == False): 88 | qgate44 = Square(1, fill_color=YELLOW, fill_opacity=1).shift(DOWN*1 + RIGHT*3) 89 | itsagate7 = Tex(r"U_4U_3U_2U_1\ket{\psi_0}") 90 | self.play(Transform(qgate4, qgate44)) 91 | self.play(Transform(itsagate, itsagate7)) 92 | g4 = True 93 | self.wait(0.001) 94 | 95 | self.wait(5) 96 | itsagate.remove_updater(update_vector) 97 | itsagate8 = Tex(r"\varepsilon\ket{\psi_0}=U_4U_3U_2U_1\ket{\psi_0} = \ket{\psi_t}").shift(UP*0.5) 98 | self.play(Transform(itsagate, itsagate8)) 99 | self.wait(6) 100 | 101 | itsagate9 = Tex(r"\varepsilon = U_4U_3U_2U_1").shift(UP*0.5) 102 | self.play(Transform(itsagate, itsagate9)) 103 | self.wait(3) 104 | 105 | self.play(FadeOut(qubit), FadeOut(line), FadeOut(qgate), FadeOut(qgate2), FadeOut(qgate3), FadeOut(qgate4)) 106 | 107 | itsagate100 = Tex(r"(\varepsilon)^\dag = (U_4U_3U_2U_1)^\dag").shift(DOWN*0.5) 108 | self.play(ShowCreation(itsagate100)) 109 | self.wait(5) 110 | itsagate101 = Tex(r"(\varepsilon)^\dag = (U_1^T U_2^T U_3 ^T U_4^T)^*").shift(DOWN*0.5) 111 | self.play(Transform(itsagate100, itsagate101)) 112 | self.wait(3) 113 | itsagate102 = Tex(r"(\varepsilon)^\dag = (U_1^\dag U_2^\dag U_3^\dag U_4^\dag)").shift(DOWN*0.5) 114 | self.play(Transform(itsagate100, itsagate102)) 115 | 116 | self.wait(3) 117 | self.play(FadeOut(itsagate)) 118 | itsagate110 = Tex(r"(\varepsilon)^\dag \varepsilon= (U_1^\dag U_2^\dag U_3^\dag U_4^\dag)(U_4U_3U_2U_1)") 119 | self.play(Transform(itsagate100, itsagate110)) 120 | self.wait(3) 121 | itsagate111 = Tex(r"(\varepsilon)^\dag \varepsilon= U_1^\dag U_2^\dag U_3^\dag (U_4^\dag U_4)U_3U_2U_1") 122 | self.play(Transform(itsagate100, itsagate111)) 123 | self.wait(8) 124 | itsagate112 = Tex(r"(\varepsilon)^\dag \varepsilon= U_1^\dag U_2^\dag U_3^\dag U_3U_2U_1") 125 | self.play(Transform(itsagate100, itsagate112)) 126 | itsagate113 = Tex(r"(\varepsilon)^\dag \varepsilon= U_1^\dag U_2^\dag U_2U_1") 127 | self.play(Transform(itsagate100, itsagate113)) 128 | itsagate114 = Tex(r"(\varepsilon)^\dag \varepsilon= U_1^\dag U_1") 129 | self.play(Transform(itsagate100, itsagate114)) 130 | itsagate115 = Tex(r"(\varepsilon)^\dag \varepsilon= \mathbb{I}") 131 | self.play(Transform(itsagate100, itsagate115)) 132 | 133 | combiningqubits2 = Text("Super Operator").shift(UP*3) 134 | self.play(Transform(combiningqubits, combiningqubits2)) 135 | self.wait(6) 136 | self.play(FadeOut(itsagate100), FadeOut(thepostulate), FadeOut(itsaqubits)) 137 | 138 | 139 | #Euler Formula 140 | combiningqubits3 = Text("Euler Formula").shift(UP*3) 141 | self.play(Transform(combiningqubits, combiningqubits3)) 142 | self.wait(5) 143 | eulernation = Tex(r"a + bi = Re^{i\theta} = R*(\cos{\theta} + i\sin{\theta})").shift(UP*1.8) 144 | self.play(ShowCreation(eulernation)) 145 | self.wait(10) 146 | eulerfudge = Tex(r"\ket{\psi} = a_1\begin{bmatrix} 1 \\ 0 \end{bmatrix} + a_2\begin{bmatrix} 0 \\ 1 \end{bmatrix}") 147 | self.play(ShowCreation(eulerfudge)) 148 | self.wait(5) 149 | eulerfudge2 = Tex(r"\ket{\psi} = R_1e^{i\theta}\begin{bmatrix} 1 \\ 0 \end{bmatrix} + R_2e^{i\phi}\begin{bmatrix} 0 \\ 1 \end{bmatrix}") 150 | self.play(Transform(eulerfudge, eulerfudge2)) 151 | self.wait(12) 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section10/Lecture1/qasm.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("OpenQASM: Quantum Assembly").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class qasm(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("OpenQASM: Quantum Assembly").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("OpenQASM: Quantum Assembly").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{General Code for Quantum Computers}").shift(UP*2.6) ) 27 | stuff.append( Tex(r"\text{Quantum Algorithms}").shift(UP*1.5) ) 28 | stuff.append( Tex(r"\downarrow").shift(UP*0.9) ) 29 | stuff.append( Tex(r"\text{Quantum Coding Languages}").shift(UP*0.3) ) 30 | stuff.append( Tex(r"\downarrow").shift(DOWN*0.3) ) 31 | stuff.append( Tex(r"\text{Quantum Assembly}").shift(DOWN*0.9) ) 32 | stuff.append( Tex(r"\downarrow").shift(DOWN*1.5) ) 33 | stuff.append( Tex(r"\text{Quantum Instruction Set Architecture} \to \{H, P, CX, CCX \} \ \ \{D, S, K, V, BS \}").shift(DOWN*2.1).scale(0.8) ) 34 | stuff.append( Tex(r"\downarrow").shift(DOWN*2.7) ) 35 | stuff.append( Tex(r"\text{Quantum Chip} \to \text{Photons/Ions/SQUID}").shift(DOWN*3.3) ) 36 | for i in stuff: 37 | self.play(FadeIn(i.shift(UP*0.2))) 38 | waiter(5) 39 | sss = SurroundingRectangle(stuff[5]).scale(1.2) 40 | self.play(ShowCreation(sss)) 41 | waiter(10) 42 | #self.play(FadeOut(Group(*stuff))) 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section10/Lecture2/photonics.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Photonics Hardware").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class photonics(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Photonics Hardware").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Photonics Hardware").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{China Quantum Supremacy December 2020}").shift(UP*2.6) ) 27 | stuff.append( ImageMobject("./chinaphotonics.png").shift(DOWN*1).scale(1.4) ) 28 | for i in stuff: 29 | self.play(FadeIn(i)) 30 | waiter(2) 31 | waiter(5) 32 | self.play(FadeOut(Group(*stuff))) 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | stuff = [] 41 | #stuff.append( Tex(r"").shift(DOWN*2) ) 42 | stuff.append( ImageMobject("./chinaphotonics2.png").shift(DOWN*0.5).scale(1.4) ) 43 | for i in stuff: 44 | self.play(FadeIn(i)) 45 | waiter(2) 46 | waiter(5) 47 | self.play(FadeOut(Group(*stuff))) 48 | 49 | 50 | 51 | 52 | 53 | 54 | stuff = [] 55 | #stuff.append( Tex(r"").shift(DOWN*2) ) 56 | stuff.append( ImageMobject("./polarize.png").shift(DOWN*0.5).scale(1.4) ) 57 | for i in stuff: 58 | self.play(FadeIn(i)) 59 | waiter(2) 60 | waiter(5) 61 | self.play(FadeOut(Group(*stuff))) 62 | 63 | 64 | 65 | 66 | 67 | 68 | stuff = [] 69 | #stuff.append( Tex(r"").shift(DOWN*2) ) 70 | stuff.append( Tex(r"\text{Xanadu Silicone Photonics}").shift(UP*2.7) ) 71 | stuff.append( ImageMobject("./siliconep.jpeg").shift(DOWN*0.5).scale(1.4) ) 72 | for i in stuff: 73 | self.play(FadeIn(i)) 74 | waiter(2) 75 | waiter(5) 76 | self.play(FadeOut(Group(*stuff))) 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | stuff = [] 87 | #stuff.append( Tex(r"").shift(DOWN*2) ) 88 | stuff.append( ImageMobject("./small.png").shift(DOWN*0).scale(1.4) ) 89 | stuff.append( Tex(r"\text{Hong-Ou-Mandel Effect w/ N photons}").shift(DOWN*3.3) ) 90 | for i in stuff: 91 | self.play(FadeIn(i)) 92 | waiter(5) 93 | waiter(10) 94 | #self.play(FadeOut(Group(*stuff))) 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section10/Lecture3/ion.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Ion Trapping Technique").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class ion(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Ion Trapping Technique").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Ion Trapping Technique").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | axes = Axes(x_range=(-1, 10, 1), y_range=(-1, 10, 1), height=6, width=12, axis_config={"stroke_color": GREY_A, "stroke_width": 2, }, y_axis_config={"include_tip": False, } ) 25 | axes.add_coordinate_labels(font_size=20, num_decimal_places=1, ) 26 | axes.shift(LEFT*0) 27 | 28 | func = lambda t : (t-4.5)**2 29 | graph = axes.get_graph(func, color=BLUE, step_size=0.001, ) 30 | ball = Dot(color=RED).scale(2).move_to(axes.c2p(2.5, 4+1)) 31 | x = 2.5 32 | y = 5 33 | t = 1000 34 | def ballUpdater(self): 35 | x = t/400 * np.cos(t*np.pi/100) + 4.5 36 | y = (x-4.5)**2 37 | self.become( Dot(color=RED).scale(2).move_to(axes.c2p(x, y)) ) 38 | ball.add_updater(ballUpdater) 39 | 40 | 41 | 42 | stuff = [] 43 | #stuff.append( Tex(r"").shift(DOWN*2) ) 44 | stuff.append( Tex(r"\text{Step 1: Create Potential Well via EM}").shift(UP*1) ) 45 | stuff.append( Tex(r"\text{Step 2: Put Object w/ Low KE in Well}").shift(UP*0) ) 46 | stuff.append( Tex(r"\text{Step 3: Its now Trapped}").shift(DOWN*1) ) 47 | for i in stuff: 48 | self.play(FadeIn(i)) 49 | waiter(3) 50 | waiter(5) 51 | self.play(FadeOut(Group(*stuff))) 52 | 53 | 54 | 55 | 56 | stuff = [] 57 | #stuff.append( Tex(r"").shift(DOWN*2) ) 58 | stuff.append( axes ) 59 | stuff.append( graph ) 60 | stuff.append( ball ) 61 | for i in stuff: 62 | self.play(FadeIn(i)) 63 | waiter(2) 64 | waiter(5) 65 | while (t > 50): 66 | t -= 1 67 | self.wait(0.001) 68 | waiter(10) 69 | self.play(FadeOut(Group(*stuff))) 70 | 71 | 72 | 73 | 74 | 75 | stuff = [] 76 | #stuff.append( Tex(r"").shift(DOWN*2) ) 77 | stuff.append( Tex(r"\text{Step 1: Create 3D Potential Well via EM}").shift(UP*1).set_color(BLACK) ) 78 | stuff.append( Tex(r"\text{Step 1: Create \& Spin 3D Potential Well via EM}").shift(UP*0) ) 79 | stuff.append( Tex(r"\text{Step 2: Put Object w/ Low KE in Well}").shift(DOWN*1) ) 80 | stuff.append( Tex(r"\text{Step 3: Its now Trapped}").shift(DOWN*2) ) 81 | for i in stuff: 82 | self.play(FadeIn(i)) 83 | waiter(3) 84 | waiter(5) 85 | self.play(FadeOut(Group(*stuff))) 86 | 87 | 88 | corona = ImageMobject("./iontrap.jpeg").shift(DOWN*0.5).scale(1.5) 89 | self.play(FadeIn(corona)) 90 | waiter(10) 91 | 92 | 93 | 94 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section2/Lecture10/ram.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum RAM").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class ram(Scene): 12 | def construct(self): 13 | text = Text("Quantum RAM").scale(1.0) 14 | self.play(FadeIn(text)) 15 | #self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | title = Text("Quantum RAM").shift(UP*3.5) 19 | self.play(FadeIn(title)) 20 | 21 | #encoder 22 | denc1 = Rectangle(fill_opacity=1, fill_color=YELLOW).rotate(PI/2).scale(1.2).set_color(YELLOW) 23 | denc2 = Text("Denc").set_color(BLACK) 24 | dencx = [] 25 | dency = [] 26 | rects = [] 27 | for i in range(0, 3): 28 | for j in range(0, 3): 29 | if (i == j and j == 1): 30 | pass 31 | else: 32 | rects.append(Square(color=BLUE, fill_color=BLUE, fill_opacity=1).scale(0.5).shift(RIGHT*i*2 + DOWN*j*2 + UP*2)) 33 | self.add(*rects) 34 | for i in range(0, 3): 35 | for k in range(0, 3): 36 | if (i == k and k ==1): 37 | pass 38 | else: 39 | dencx.append(Line(np.array([0, ((k+3*i)+0.5)/2-2.5, 0]), np.array([2*k + 4, -2*(2-i)+2, 0]))) 40 | dencx[i].generate_target() 41 | for i in range(0, 3): 42 | dency.append(Line(np.array([-5, (i+0.5)/2-1, 0]), np.array([0, (i+0.5)/2-1, 0]))) 43 | dency[i].generate_target() 44 | dency[i].target.shift(LEFT*4) 45 | denc = Group(*dencx, *dency, denc1, denc2).shift(LEFT*4) 46 | self.play(FadeIn(denc)) 47 | 48 | for i in range(0, 8): 49 | dencx[i].generate_target() 50 | 51 | for k in range(0, 8): 52 | for i in range(0, 8): 53 | dencx[i].target.set_color(RED) 54 | current = bin(i)[2:][::-1] 55 | for j in range(0, len(current)): 56 | if (int(current[j]) == 1): 57 | dency[j].target.set_color(RED) 58 | else: 59 | dency[j].target.set_color(WHITE) 60 | for j in range(len(current), 3): 61 | dency[j].target.set_color(WHITE) 62 | for r in range(0, 3): 63 | self.play(MoveToTarget(dency[r], run_time=0.01)) 64 | for q in range(0, 8): 65 | self.play(MoveToTarget(dencx[q], run_time=0.01)) 66 | dencx[i].target.set_color(WHITE) 67 | current = bin(i)[2:][::-1] 68 | for j in range(0, len(current)): 69 | if (current[j] == 1): 70 | dency[j].target.set_color(WHITE) 71 | self.wait(0.1) 72 | self.wait(8) 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section2/Lecture5/add.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Adder Circuit").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class add(Scene): 12 | def construct(self): 13 | text = Text("Quantum Adder Circuit").scale(1.0) 14 | self.play(FadeIn(text)) 15 | self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | title = Text("Quantum 4-bit Adder").shift(UP*3.5) 19 | self.play(Write(title)) 20 | 21 | #draw full adder 22 | number1 = Tex(r"X").shift(UP*2.5 + LEFT*1) 23 | number2 = Tex(r"Y").shift(UP*2.5 + RIGHT*1) 24 | number3 = Tex(r"C_{in}").shift(RIGHT*4) 25 | 26 | number4 = Tex(r"C_{out}").shift(LEFT*4) 27 | number5 = Tex(r"Sum").shift(DOWN*2.5) 28 | 29 | fadder1 = Rectangle(width=4, length=2, color=RED, fill_color=RED, fill_opacity=1) 30 | fadder2 = Text("Full Adder").set_color(BLACK) 31 | 32 | input1 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 33 | input1.rotate(PI).shift(UP*1.3 + LEFT*1) 34 | 35 | input2 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 36 | input2.rotate(PI).shift(UP*1.3 + RIGHT*1) 37 | 38 | input3 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 39 | input3.rotate(PI/2).shift(RIGHT*2.5 + DOWN*0.25) 40 | 41 | output1 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 42 | output1.rotate(PI/2).shift(LEFT*2.5 + DOWN*0.25) 43 | 44 | output2 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 45 | output2.rotate(PI).shift(DOWN*1.8) 46 | 47 | fadder = Group(number1, number2, number3, number4, number5, fadder1, fadder2, input1, input2, input3, output1, output2) 48 | fadder.scale(0.9).shift(DOWN*1) 49 | self.play(FadeIn(fadder)) 50 | 51 | 52 | firstNum = Tex(r"X = 10").shift(UP*2.5 + LEFT*1) 53 | secondNum = Tex(r"Y = 11").shift(UP*2.5 + RIGHT*1) 54 | nums = Group(firstNum, secondNum) 55 | self.play(FadeIn(nums)) 56 | 57 | self.wait(3) 58 | 59 | firstNum2 = Tex(r"X = 10 = x_1x_0").shift(UP*2.5 + LEFT*2) 60 | secondNum2 = Tex(r"Y = 11 = y_1y_0").shift(UP*2.5 + RIGHT*2) 61 | nums2 = Group(firstNum2, secondNum2) 62 | self.play(Transform(nums, nums2)) 63 | 64 | 65 | number1.generate_target() 66 | number2.generate_target() 67 | number1.target = Tex(r"x_0").shift(UP*1.1 + LEFT*0.9) 68 | number2.target = Tex(r"y_0").shift(UP*1.1 + RIGHT*0.9) 69 | self.play(MoveToTarget(number1), MoveToTarget(number2)) 70 | 71 | self.wait(3) 72 | 73 | fadder.generate_target() 74 | fadder.target.scale(0.6).shift(RIGHT*3 + UP*1) 75 | self.play(MoveToTarget(fadder)) 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | #draw anotehr full addder 84 | #draw full adder 85 | number11 = Tex(r"x_1").shift(UP*2.5 + LEFT*1) 86 | number21 = Tex(r"y_1").shift(UP*2.5 + RIGHT*1) 87 | number31 = Tex(r"C_{in}").shift(RIGHT*4) 88 | 89 | number41 = Tex(r"C_{out}").shift(LEFT*4) 90 | number51 = Tex(r"Sum").shift(DOWN*2.5) 91 | 92 | fadder11 = Rectangle(width=4, length=2, color=RED, fill_color=RED, fill_opacity=1) 93 | fadder21 = Text("Full Adder").set_color(BLACK) 94 | 95 | input11 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 96 | input11.rotate(PI).shift(UP*1.3 + LEFT*1) 97 | 98 | input21 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 99 | input21.rotate(PI).shift(UP*1.3 + RIGHT*1) 100 | 101 | input31 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 102 | input31.rotate(PI/2).shift(RIGHT*2.5 + DOWN*0.25) 103 | 104 | output11 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 105 | output11.rotate(PI/2).shift(LEFT*2.5 + DOWN*0.25) 106 | 107 | output21 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 108 | output21.rotate(PI).shift(DOWN*1.8) 109 | 110 | fadderq = Group(number11, number21, number31, number41, number51, fadder11, fadder21, input11, input21, input31, output11, output21) 111 | fadderq.scale(0.9).shift(DOWN*1.025).scale(0.6).shift(LEFT*2 + UP*1) 112 | self.play(FadeIn(fadderq)) 113 | 114 | self.wait(3) 115 | 116 | 117 | #new number 118 | number5.generate_target() 119 | number51.generate_target() 120 | number5.target = Tex(r"z_0").shift(DOWN*1.5 + RIGHT*3) 121 | number51.target = Tex(r"z_1").shift(DOWN*1.5 + LEFT*2) 122 | 123 | number41.generate_target() 124 | number41.target = Tex(r"z_2").shift(LEFT*4.5) 125 | 126 | self.play(MoveToTarget(number5), MoveToTarget(number51), MoveToTarget(number41)) 127 | 128 | thesummation = Tex(r"Z = 101 = z_2z_1z_0").shift(DOWN*2.5) 129 | self.play(Write(thesummation)) 130 | 131 | self.wait(6) 132 | 133 | self.play(FadeOut(fadder), FadeOut(fadderq), FadeOut(thesummation), FadeOut(nums)) 134 | 135 | 136 | 137 | 138 | 139 | 140 | #4 bit adder 141 | 142 | 143 | 144 | #draw full adder 145 | number4 = Tex(r"C_{out}").shift(LEFT*4) 146 | number5 = Tex(r"Sum").shift(DOWN*2.5) 147 | 148 | fadder1 = Rectangle(width=4, length=2, color=RED, fill_color=RED, fill_opacity=1) 149 | fadder2 = Text("Full Adder").set_color(BLACK) 150 | 151 | input1 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 152 | input1.rotate(PI).shift(UP*1.3 + LEFT*1) 153 | 154 | input2 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 155 | input2.rotate(PI).shift(UP*1.3 + RIGHT*1) 156 | 157 | input3 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 158 | input3.rotate(PI/2).shift(RIGHT*2.5 + DOWN*0.25) 159 | 160 | output1 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 161 | output1.rotate(PI/2).shift(LEFT*2.5 + DOWN*0.25) 162 | 163 | output2 = Arrow(DOWN*0.5, UP*1, fill_color=WHITE) 164 | output2.rotate(PI).shift(DOWN*1.8) 165 | 166 | fadder = Group(number4, number5, fadder1, fadder2, input1, input2, input3, output1, output2) 167 | fadder.scale(0.3).shift(RIGHT*4.5) 168 | self.play(FadeIn(fadder)) 169 | fadder2 = fadder.copy().shift(LEFT*2.5) 170 | fadder3 = fadder.copy().shift(LEFT*5) 171 | fadder4 = fadder.copy().shift(LEFT*7.5) 172 | self.play(FadeIn(fadder2), FadeIn(fadder3), FadeIn(fadder4)) 173 | 174 | 175 | 176 | self.wait(12) 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section3/Lecture0/algos.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Algorithms").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class algo(Scene): 12 | def construct(self): 13 | text = Text("Quantum Algorithms").scale(1.3) 14 | self.play(FadeIn(text)) 15 | self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | title = Text("What its all about").shift(UP*3.5) 19 | self.play(FadeIn(title)) 20 | 21 | items = [] 22 | items.append( Text("1. Amplitude Amplification").shift(LEFT*3.5 + UP*2).scale(0.8) ) 23 | items.append( Text("2. Period Finding - QFT").shift(LEFT*3.5 + UP*1).scale(0.8) ) 24 | items.append( Text("3. Quantum Walks").shift(LEFT*3.65 + DOWN*0).scale(0.8) ) 25 | items.append( Text("4. Classical/Quantum Hybrids").shift(LEFT*1.5 + DOWN*1).scale(0.8) ) 26 | 27 | self.play(FadeIn(items[0])) 28 | self.wait(5) 29 | stuff1 = [] 30 | stuff1.append( Tex(r"a\ket{0} + ").shift(UP*2 + RIGHT*1) ) 31 | stuff1.append( Tex(r"b\ket{1} + ").shift(UP*2 + RIGHT*1.5 + RIGHT*1) ) 32 | stuff1.append( Tex(r"c\ket{2}").shift(UP*2 + RIGHT*2.75 + RIGHT*1) ) 33 | self.play(FadeIn(Group(*stuff1))) 34 | self.wait(10) 35 | self.play(ScaleInPlace(stuff1[0], 0.5, run_time=3.0), ScaleInPlace(stuff1[1], 1.5, run_time=3.0), ScaleInPlace(stuff1[2], 0.5, run_time=3.0)) 36 | self.wait(5) 37 | 38 | self.play(FadeIn(items[1])) 39 | self.wait(5) 40 | stuff2 = [] 41 | stuff2.append( Tex(r"a\ket{0} + ").shift(UP*1 + RIGHT*1) ) 42 | stuff2.append( Tex(r"b\ket{1} + ").shift(UP*1 + RIGHT*1.5 + RIGHT*1) ) 43 | stuff2.append( Tex(r"a\ket{2} + ").shift(UP*1 + RIGHT*3 + RIGHT*1) ) 44 | stuff2.append( Tex(r"b\ket{3}").shift(UP*1 + RIGHT*4.25 + RIGHT*1) ) 45 | self.play(FadeIn(Group(*stuff2))) 46 | self.wait(10) 47 | stuff21 = [] 48 | stuff21.append( Tex(r"p\ket{0} + ").shift(UP*1 + RIGHT*1).scale(0.5) ) 49 | stuff21.append( Tex(r"q\ket{1} + ").shift(UP*1 + RIGHT*1.5 + RIGHT*1).scale(0.5) ) 50 | stuff21.append( Tex(r"r\ket{2} + ").shift(UP*1 + RIGHT*3 + RIGHT*1).scale(1.5) ) 51 | stuff21.append( Tex(r"s\ket{3}").shift(UP*1 + RIGHT*4.5 + RIGHT*1).scale(0.5) ) 52 | self.play(Transform(Group(*stuff2), Group(*stuff21), run_time=3.0)) 53 | self.wait(5) 54 | 55 | self.play(FadeIn(items[2])) 56 | self.wait(10) 57 | self.play(FadeIn(items[3])) 58 | self.wait(30) 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section3/Lecture11/hhl.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("HHL Algorithm").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class hhl(Scene): 12 | def construct(self): 13 | text = Text("HHL Algorithm").scale(1.1) 14 | self.play(FadeIn(text)) 15 | self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | title = Text("Linear Systems").shift(UP*3.5) 19 | self.play(FadeIn(title)) 20 | 21 | system = [] 22 | system.append( Tex(r"A\vec{x} = \vec{b}").shift(UP*3 + LEFT*4) ) 23 | system.append( Tex(r"\vec{x} = A^{-1}\vec{b}").shift(UP*2 + LEFT*4) ) 24 | system.append( Tex(r"A\ket{x} = \ket{b}").shift(UP*3 + RIGHT*4) ) 25 | system.append( Tex(r"\ket{x} = A^{-1}\ket{b}").shift(UP*2 + RIGHT*4) ) 26 | system.append( Tex(r"A \to \{ \ket{u_j}\} & \{ \lambda_j\}").shift(UP*2.5) ) 27 | system.append( Tex(r"A = P^{-1}DP").shift(UP*1.5) ) 28 | system.append( Tex(r"A^{-1} = P^{-1}\frac{1}{D}P \to \{ \frac{1}{\lambda_j}\}").shift(UP*0.5) ) 29 | system.append( Tex(r"\ket{b} = \sum_{j=0}^{n}c_j\ket{u_j}").shift(DOWN*0 + LEFT*5) ) 30 | system.append( Tex(r"\ket{x} = \sum_{j=0}^{n}c_j\frac{1}{\lambda_j}\ket{u_j}").shift(DOWN*0 + RIGHT*5) ) 31 | system.append( Text(r"Hamiltonian Simulation").shift(DOWN*1).scale(0.7) ) 32 | system.append( Text(r"Quantum Phase Estimation").shift(DOWN*2).scale(0.7) ) 33 | system.append( Text(r"General Born Rule").shift(DOWN*3).scale(0.7) ) 34 | 35 | for i in system: 36 | self.play(FadeIn(i)) 37 | self.wait(10) 38 | self.play(FadeOut(Group(*system))) 39 | 40 | title2 = Text("HHL Algorithm").shift(UP*3.5) 41 | self.play(Transform(title, title2)) 42 | steps = [] 43 | steps.append( Tex(r"\text{Step 0: Prepare 1 bit Ancilla, n bit register to store eigenvalues, n bit to store } \ket{b} ").shift(UP*3).scale(0.7) ) 44 | steps.append( Tex(r"\ket{0}_a \ket{0}_r \ket{b}_m \to \sum_{j=0}c_j\ket{0}_a \ket{0}_r\ket{u_j}").shift(UP*2.25).scale(0.7) ) 45 | steps.append( Tex(r"\text{Step 1: Implement Hamiltonian Simulation of } A \to e^{iA} ").shift(UP*1.5).scale(0.7) ) 46 | steps.append( Tex(r"\text{Step 2: Perform Quantum Phase Estimation on } e^{iA} \to \lambda_j \to Eigenvalues \to Register").shift(UP*0.75).scale(0.7) ) 47 | steps.append( Tex(r"\sum_j c_j \ket{0}_a \ket{0}_r \ket{u_j} \to \sum_j c_j \ket{0}_a \ket{\lambda_j}_r \ket{u_j}").shift(UP*0).scale(0.7) ) 48 | steps.append( Tex(r"\text{Step 3: Perform Controlled Rotation on Ancilla} ").shift(DOWN*0.75).scale(0.7) ) 49 | steps.append( Tex(r"\ket{0}_a \to ((1-\frac{C^2}{\lambda_j^2})^{0.5}\ket{0}_a + \frac{C}{\lambda_j}\ket{1}_a \to \sum_{j=0} c_j ((1-\frac{C^2}{\lambda_j^2})^{0.5}\ket{0}_a + \frac{C}{\lambda_j}\ket{1}_a)\ket{\lambda_j}_r\ket{u_j}").shift(DOWN*1.5).scale(0.7) ) 50 | steps.append( Tex(r"\text{Step 4: Perform REVERSE Quantum Phase Estimation on } e^{iA} \to \ket{\lambda_j}_r \to \ket{0}_r").shift(DOWN*2.25).scale(0.7) ) 51 | steps.append( Tex(r"\sum_{j=0} c_j ((1-\frac{C^2}{\lambda_j^2})^{0.5}\ket{0}_a + \frac{C}{\lambda_j}\ket{1}_a)\ket{\lambda_j}_r\ket{u_j} \to \sum_{j=0} c_j ((1-\frac{C^2}{\lambda_j^2})^{0.5}\ket{0}_a + \frac{C}{\lambda_j}\ket{1}_a)\ket{0}_r\ket{u_j}").shift(DOWN*3).scale(0.7) ) 52 | steps.append( Tex(r"\text{Step 5: Measure Ancilla (Apply General Born Rule), if its 1, we have Inverse }").shift(DOWN*3.75).scale(0.7) ) 53 | steps.append( Tex(r"\sum_{j=0} c_j ((1-\frac{C^2}{\lambda_j^2})^{0.5}\ket{0}_a + \frac{C}{\lambda_j}\ket{1}_a)\ket{0}_r\ket{u_j} \to \sum_{j=0} c_j (\frac{C}{\lambda_j}\ket{1}_a)\ket{0}_r\ket{u_j}").shift(DOWN*4.5).scale(0.7) ) 54 | steps.append( Tex(r"\ket{x} = \sum_{j=0} c_j \frac{C}{\lambda_j}\ket{u_j}").shift(DOWN*5.85) ) 55 | 56 | frame = self.camera.frame 57 | frame.generate_target() 58 | for i in range(0, len(steps)): 59 | self.play(FadeIn(steps[i])) 60 | if (i == 8): 61 | frame.target.shift(DOWN*3) 62 | self.play(MoveToTarget(frame, run_time=2.0)) 63 | self.wait(10) 64 | frame.target.shift(UP*3) 65 | self.play(MoveToTarget(frame, run_time=2.0)) 66 | self.play(FadeOut(Group(*steps))) 67 | 68 | applyit = Tex(r"\begin{bmatrix} \frac{3}{2} & \frac{1}{2} \\ \frac{1}{2} & \frac{3}{2} \end{bmatrix}\begin{bmatrix} x_0 \\ x_1 \end{bmatrix} = \begin{bmatrix} 1 \\ 0 \end{bmatrix}").shift(UP*0).scale(2.5) 69 | self.play(FadeIn(applyit)) 70 | self.wait(15) 71 | 72 | 73 | 74 | 75 | 76 | 77 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section3/Lecture14/lsf.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Least Square Fitting").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | 12 | 13 | class lsf(Scene): 14 | def construct(self): 15 | wait = True 16 | def waiter(n): 17 | if (wait == True): 18 | self.wait(n) 19 | text = Text("Quantum Least Square Fitting").scale(1.0) 20 | self.play(FadeIn(text)) 21 | waiter(4) 22 | self.play(FadeOut(text)) 23 | 24 | title = Text("Least Square Fitting").shift(UP*3.5) 25 | self.play(FadeIn(title)) 26 | 27 | linreg = Text("Type of Linear Regression").shift(DOWN*3.5).scale(0.7) 28 | self.play(FadeIn(linreg)) 29 | 30 | corona = ImageMobject("./stat.png").scale(1.5) 31 | self.play(FadeIn(corona)) 32 | waiter(10) 33 | self.play(FadeOut(corona)) 34 | 35 | 36 | eq = Tex(r"\hat{x} = (A^TA)^{-1}A^T\vec{b} = A^+\vec{b}").shift(UP*2.75) 37 | self.play(FadeIn(eq)) 38 | waiter(10) 39 | 40 | stuff = [] 41 | stuff.append( Text("1. Perform PseudoInverse").shift(UP*1.125).scale(0.7) ) 42 | stuff.append( Text("2. Use HHL to get Coefficients").shift(UP*0).scale(0.7) ) 43 | stuff.append( Text("3. Calculate Fit Parameter").shift(DOWN*1.125).scale(0.7) ) 44 | 45 | for i in stuff: 46 | self.play(FadeIn(i)) 47 | waiter(5) 48 | waiter(10) 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section4/Lecture1/sfields.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Photonics & QuModes").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class sfields(Scene): 12 | def construct(self): 13 | text = Text("Quantum Photonics & QuModes").scale(1.0) 14 | self.play(FadeIn(text)) 15 | self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | 19 | title = Text("Qubits vs QuModes").shift(UP*3.5) 20 | self.play(FadeIn(title)) 21 | 22 | 23 | stuff = [] 24 | stuff.append( Tex(r"\ket{\psi} = a\ket{0} + b\ket{1} = \sum_{x=0}^n a_x\ket{x}").shift(UP*1) ) 25 | stuff.append( Tex(r"\ket{\psi} = \int \psi (x)\ket{x}dx").shift(DOWN*1) ) 26 | 27 | for i in stuff: 28 | self.play(FadeIn(i)) 29 | self.wait(4) 30 | 31 | for i in stuff: 32 | self.play(FadeOut(i)) 33 | 34 | 35 | 36 | #3d 37 | toanalyse = Tex(r"\ket{\psi} = \int \psi (x)\ket{x}dx").shift(DOWN*2) 38 | self.play(FadeIn(toanalyse)) 39 | 40 | axes = ThreeDAxes(axis_config={"include_tip": False,"include_ticks":False,"stroke_width":1}) 41 | grid = NumberPlane(axis_config={"stroke_opacity":0},background_line_style={"stroke_opacity":0.2},x_min=-5,x_max=5,y_min=-5,y_max=5) 42 | self.play(FadeIn(Group(axes, grid))) 43 | labelX = Tex(r"\ket{x}").shift(RIGHT*4.5) 44 | labelY = Tex(r"\ket{p}").shift(UP*2.75) 45 | self.play(FadeIn(Group(labelX, labelY))) 46 | 47 | frame = self.camera.frame 48 | self.play( 49 | frame.increment_phi, 50 * DEGREES, 50 | frame.increment_theta, -30 * DEGREES, 51 | run_time=2 52 | ) 53 | #frame.generate_target() 54 | #frame.target.set_width(20) 55 | #self.play(MoveToTarget(frame)) 56 | 57 | a = 0 58 | b = 0 59 | def update_dot(self): 60 | self.become( Dot(np.array([a,b,0]), fill_color=RED) ) 61 | 62 | cval = Dot(np.array([a,b,0]), fill_color=RED) 63 | self.play(FadeIn(cval)) 64 | cval.add_updater(update_dot) 65 | t = np.pi/2 66 | 67 | for i in range(500): 68 | t += 0.01 69 | a = 2*np.sin(t + np.pi/2) 70 | b = 2*np.sin(2*t) 71 | self.wait(0.0001) 72 | 73 | while(a > 1): 74 | a -= 0.1 75 | self.wait(0.0001) 76 | a = 1 77 | while (b > 0): 78 | b -= 0.1 79 | self.wait(0.0001) 80 | b = 0 81 | 82 | 83 | def spin(m, dt): 84 | m.increment_theta(0.1 * dt) 85 | frame.add_updater(spin) 86 | 87 | self.wait(4) 88 | 89 | toanalyse2 = Tex(r"1 = \int \psi (0)\ket{0}dx = \int \psi (0)\begin{bmatrix} 1 \\ 0 \end{bmatrix} dx").shift(DOWN*2) 90 | self.play(Transform(toanalyse, toanalyse2)) 91 | self.wait(4) 92 | 93 | integralr = Line(np.array([1, 0, 0]), np.array([1, 0, 1.3]), color=GREEN) 94 | self.play(FadeIn(integralr)) 95 | 96 | self.wait(2) 97 | toanalyse3 = Tex(r"\ket{\psi} = \int \psi (x)\ket{x}dx").shift(DOWN*3.5) 98 | self.play(Transform(toanalyse, toanalyse3)) 99 | 100 | 101 | # Gauss surface 102 | op = np.matrix([[1, 0], [0, 1]]) 103 | dispop = np.exp(op) 104 | gaussian = ParametricSurface( 105 | lambda u, v: [u, v, np.absolute(np.linalg.det(np.exp( -1*np.matrix([u, v])*op*np.transpose(np.matrix([u, v])) ) ))],#np.exp(-(u**2) - v**2)], 106 | u_range=(-5, 5), 107 | v_range=(-2.5, 2.5), 108 | resolution=(90, 90), 109 | ) 110 | gaussian.set_color(GREEN, 1).shift(RIGHT*1) 111 | gaussian.stretch(2, 2) 112 | self.play( 113 | FadeIn(gaussian), 114 | frame.set_phi, 70 * DEGREES, 115 | frame.set_theta, 10 * DEGREES, 116 | run_time=3 117 | ) 118 | self.wait(5) 119 | self.play( 120 | frame.increment_phi, -20 * DEGREES, 121 | frame.set_theta, -120 * DEGREES, 122 | run_time=2 123 | ) 124 | title2 = Text("QuModes - Vacuum State").shift(UP*3.5) 125 | self.play(Transform(title, title2)) 126 | self.wait(15) 127 | 128 | 129 | 130 | gaussian.generate_target() 131 | gaussian.target.stretch(0.5, 0) 132 | gaussian.target.set_color(RED) 133 | self.play(MoveToTarget(gaussian)) 134 | title3 = Text("QuModes - Squeezed State").shift(UP*3.5) 135 | self.play(FadeOut(title), FadeIn(title3)) 136 | self.wait(15) 137 | 138 | self.play(Rotating(gaussian, np.pi/2, run_time=2 ) ) 139 | title4 = Text("QuModes - Rotation").shift(UP*3.5) 140 | self.play(Transform(title3, title4)) 141 | self.wait(5) 142 | 143 | gaussian.target.shift(LEFT*3+ DOWN*1) 144 | self.play(MoveToTarget(gaussian)) 145 | title5 = Text("QuModes - Displacement").shift(UP*3.5) 146 | self.play(Transform(title3, title5)) 147 | self.wait(5) 148 | 149 | 150 | 151 | 152 | 153 | self.play(FadeOut(Group(gaussian)))#, cval, integralr))) 154 | 155 | # Gauss surface 156 | 157 | theta = 0.1*62.8 158 | op = np.matrix([[np.cos(theta), 1j*np.sin(theta)], [1j*np.sin(theta), -np.cos(theta)]]) 159 | gaussianc = ParametricSurface( 160 | lambda u, v: [u, v, np.imag(np.linalg.det(np.exp(1j*np.matrix([u, v])*op*np.matrix([[u, 0], [0, v]])*np.transpose(np.matrix([u, v])) ) )) ],#np.exp(-1j*(u**3) -1j*(v**3) )], 161 | u_range=(-2, 2), 162 | v_range=(-2, 2), 163 | resolution=(50, 50), 164 | ) 165 | gaussianc.set_color(GREEN, 1)#.shift(RIGHT*1) 166 | self.play(FadeIn(gaussianc)) 167 | self.wait(0.0001) 168 | 169 | title6 = Text("QuModes - Cubic Phase").shift(UP*3.5) 170 | self.play(Transform(title3, title6)) 171 | self.wait(30) 172 | """ 173 | self.play(FadeOut(Group(axes, grid, toanalyse, labelX, labelY, gaussianc))) 174 | frame.remove_updater(spin) 175 | frame.target.set_euler_angles( 176 | theta=0 * DEGREES, 177 | phi=0 * DEGREES, 178 | ) 179 | self.play(MoveToTarget(frame)) 180 | self.wait(10) 181 | """ 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section4/Lecture2/cvqit.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Continuous Variable Quantum Information Theory").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class cvqit(Scene): 12 | def construct(self): 13 | text = Text("Continuous Variable Quantum Information Theory").scale(0.9) 14 | self.play(FadeIn(text)) 15 | self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | 19 | title = Text("Operators").shift(UP*3.5).scale(0.9) 20 | self.play(FadeIn(title)) 21 | 22 | stuff = [] 23 | stuff.append( Tex(r"\hat{a} \to \text{Annihilation Operator}").shift(UP*3) ) 24 | stuff.append( Tex(r"\hat{a}^\dag \to \text{Creation Operator}").shift(UP*2.5) ) 25 | stuff.append( Tex(r"\hat{x} = c(\hat{a} + \hat{a}^\dag) \to \text{Position Operator}").shift(UP*2) ) 26 | stuff.append( Tex(r"\hat{p} = -ic(\hat{a} - \hat{a}^\dag) \to \text{Momentum Operator}").shift(UP*1.5) ) 27 | stuff.append( Tex(r"[\hat{x}, \hat{p}] = xp - px = 2ic^2 \to \text{Commutator}").shift(UP*1) ) 28 | stuff.append( Tex(r"[\hat{a}_i, \hat{a}_j^\dag] = \mathbb{I}").shift(UP*0.5) ) 29 | stuff.append( Tex(r"\hat{H}(\hat{x}, \hat{p}) \to U=e^{-iHt} \to \text{Hamiltonian Simulation}").shift(DOWN*0.125) ) 30 | stuff.append( Tex(r"\hat{H} \to \hat{x}^2 \text{ or } \hat{p}^2 \to \text{Gaussian States}").shift(DOWN*0.75) ) 31 | stuff.append( Tex(r"D(\alpha) = {e^{\alpha \hat{a}^\dag + \alpha^* \hat{a}}} \to \text{Displacement Operator}").shift(DOWN*1.5) ) 32 | stuff.append( Tex(r"S(z) = {e^{z^* \hat{a}^2 - z \hat{a}^{\dag 2}}} \to \text{Squeeze Operator}").shift(DOWN*2.125) ) 33 | stuff.append( Tex(r"R(\theta) = {e^{i\theta n}} \to \text{Rotation Operator}").shift(DOWN*2.75) ) 34 | stuff.append( Tex(r"V(\gamma) = e^{i\gamma x^3} \to \text{Cubic Phase Operator}").shift(DOWN*3.375) ) 35 | 36 | for i in stuff: 37 | self.play(FadeIn(i)) 38 | self.wait(7) 39 | self.play(FadeOut(Group(*stuff))) 40 | 41 | 42 | stuff2 = [] 43 | stuff2.append( Tex(r"X(x) = D(x), x \in \mathbb{R} \to \text{Analogous: Pauli X}").shift(UP*2.9) ) 44 | stuff2.append( Tex(r"Z(p) = D(ip), p \in \mathbb{R} \to \text{Analogous: Pauli Z}").shift(UP*2.25) ) 45 | stuff2.append( Tex(r"\hat{a}\ket{0} = 0 \to \hat{a}\ket{n} = \sqrt{n}\ket{n-1}").shift(UP*1.5) ) 46 | stuff2.append( Tex(r"\hat{a}^\dag \ket{n} = \sqrt{n+1}\ket{n+1}").shift(UP*0.75) ) 47 | stuff2.append( Tex(r"Beamsplitter").shift(DOWN*0.75).scale(1.25) ) 48 | stuff2.append( Tex(r"BS_{ij}(\theta, \phi) = e^{\theta(e^{i\phi}\hat{a}_i^\dag \hat{a}_j - e^{-i\phi}\hat{a}_i \hat{a}_j^\dag )}").shift(DOWN*1.75).scale(2) ) 49 | stuff2.append( Text(r"Annihilation Operators for Specific QuModes").shift(DOWN*3).scale(0.9) ) 50 | for i in stuff2: 51 | self.play(FadeIn(i)) 52 | self.wait(7) 53 | self.wait(15) 54 | self.play(FadeOut(Group(*stuff2))) 55 | 56 | 57 | #create graph w/ qumodes 58 | title2 = Text("QuModes & Operators").shift(UP*3.5).scale(0.9) 59 | self.play(Transform(title, title2)) 60 | axes = Axes(x_range=(0, 1), y_range=(-3, 3, 0.5), height=5, width=10, axis_config={"stroke_color": GREY_A, "stroke_width": 2, }, y_axis_config={"include_tip": False, } ) 61 | axes.add_coordinate_labels(font_size=20, num_decimal_places=1, ) 62 | axes.shift(DOWN*1.2).scale(0.8) 63 | 64 | self.play(FadeIn(axes)) 65 | func = lambda t : math.sin(t*1*np.pi) 66 | time = 0 67 | sin_graph = axes.get_graph(func, color=RED, step_size=0.01, ) 68 | def update_graph(self): 69 | func = lambda t : math.cos(time) * math.sin(t*1*np.pi) 70 | self.become( axes.get_graph(func, color=RED, step_size=0.01, ) ) 71 | sin_graph.add_updater(update_graph) 72 | self.play(ShowCreation(sin_graph)) 73 | 74 | stuff = Tex(r"\ket{1, 0, 0, 0}").shift(UP*2.5) 75 | self.play(FadeIn(stuff)) 76 | time = 0 77 | rotates = 4 78 | self.wait(5) 79 | while(time < np.pi*rotates): 80 | time += 0.1 81 | self.wait(0.001) 82 | 83 | 84 | def update_graph2(self): 85 | func = lambda t : math.cos(time) * math.sin(t*2*np.pi) 86 | self.become( axes.get_graph(func, color=YELLOW, step_size=0.01, ) ) 87 | sin_graph.remove_updater(update_graph) 88 | sin_graph.add_updater(update_graph2) 89 | stuff2 = Tex(r"a_0a_1^\dag\ket{1, 0, 0, 0} = \ket{0, 1, 0, 0}").shift(UP*2.5) 90 | self.play(Transform(stuff, stuff2)) 91 | time = 0 92 | self.wait(5) 93 | while(time < np.pi*rotates): 94 | time += 0.1 95 | self.wait(0.001) 96 | 97 | 98 | 99 | def update_graph3(self): 100 | func = lambda t : math.cos(time) * math.sin(t*3*np.pi) 101 | self.become( axes.get_graph(func, color=GREEN, step_size=0.01, ) ) 102 | sin_graph.remove_updater(update_graph2) 103 | sin_graph.add_updater(update_graph3) 104 | stuff2 = Tex(r"a_1a_2^\dag\ket{0, 1, 0, 0} = \ket{0, 0, 1, 0}").shift(UP*2.5) 105 | self.play(Transform(stuff, stuff2)) 106 | time = 0 107 | self.wait(5) 108 | while(time < np.pi*rotates): 109 | time += 0.1 110 | self.wait(0.001) 111 | 112 | 113 | 114 | def update_graph4(self): 115 | func = lambda t : math.cos(time) * math.sin(t*4*np.pi) 116 | self.become( axes.get_graph(func, color=BLUE, step_size=0.01, ) ) 117 | sin_graph.remove_updater(update_graph3) 118 | sin_graph.add_updater(update_graph4) 119 | stuff2 = Tex(r"a_2a_3^\dag\ket{0, 0, 1, 0} = \ket{0, 0, 0, 1}").shift(UP*2.5) 120 | self.play(Transform(stuff, stuff2)) 121 | time = 0 122 | self.wait(5) 123 | while(time < np.pi*rotates): 124 | time += 0.1 125 | self.wait(0.001) 126 | 127 | 128 | height = 1 129 | def update_graph5(self): 130 | func = lambda t : math.cos(time) * math.sin(t*1*np.pi) * height 131 | self.become( axes.get_graph(func, color=RED, step_size=0.01, ) ) 132 | sin_graph.remove_updater(update_graph4) 133 | sin_graph.add_updater(update_graph5) 134 | stuff2 = Tex(r"a_3a_0^\dag a_0^\dag\ket{0, 0, 0, 1} = \ket{2, 0, 0, 0}").shift(UP*2.5) 135 | self.play(FadeOut(stuff), FadeIn(stuff2)) 136 | self.wait(0.5) 137 | height += 1 138 | self.wait(0.5) 139 | time = 0 140 | self.wait(5) 141 | while(time < np.pi*rotates): 142 | time += 0.1 143 | self.wait(0.001) 144 | 145 | 146 | height1 = 2 147 | height2 = 1 148 | height3 = 2 149 | height4 = 1 150 | def update_graph5(self): 151 | func = lambda t : (math.cos(time) * math.sin(t*1*np.pi) * height1 + math.cos(time*0.1 + 1.1) * math.sin(t*2*np.pi) * height2 + math.cos(time*2 + 2.4) *math.sin(t*3*np.pi) * height3 + math.cos(time*0.5 - 1) *math.sin(t*4*np.pi) * height4) 152 | self.become( axes.get_graph(func, color=PURPLE, step_size=0.01, ) ) 153 | sin_graph.remove_updater(update_graph4) 154 | sin_graph.add_updater(update_graph5) 155 | stuff4 = Tex(r"a_1^\dag a_2^\dag a_2^\dag a_3^\dag\ket{2, 0, 0, 0} = \ket{2, 1, 2, 1}").shift(UP*2.5) 156 | stuff3 = Text("Different Time Evolution!").shift(UP*2).scale(0.5) 157 | self.play(FadeOut(stuff2), FadeIn(stuff4), FadeIn(stuff3)) 158 | 159 | time = 0 160 | self.wait(5) 161 | while(time < np.pi*(rotates + 8)): 162 | time += 0.1 163 | self.wait(0.001) 164 | 165 | 166 | self.wait(10) 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section4/Lecture7/iqp.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Instantaneous Quantum Polynomial").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class iqp(Scene): 12 | def construct(self): 13 | text = Text("Instantaneous Quantum Polynomial") 14 | self.play(FadeIn(text)) 15 | self.wait(4) 16 | self.play(FadeOut(text)) 17 | 18 | 19 | title = Text("Instantaneous Quantum Polynomial").shift(UP*3.5) 20 | self.play(FadeIn(title)) 21 | 22 | stuff = [] 23 | stuff.append( Tex(r"\text{IQP Protocol: } H^{\otimes N}UH^{\otimes N}\ket{0}^{\otimes N}").shift(UP*2.75) ) 24 | stuff.append( Tex(r"S^{\otimes N}U + \text{Homodyne Measure } \hat{p} \to \text{Run Multiple Times}").shift(UP*2) ) 25 | stuff.append( Tex(r"1. \text{ Squeezed States} \to \text{Momentum in 'Superposition'}").shift(UP*1.25) ) 26 | stuff.append( Tex(r"2. \ \ U = \{ Z(p), CZ(s), V(\gamma) \}").shift(UP*0.5) ) 27 | stuff.append( Tex(r"3. \text{ Homodyne Measure of Momentum}").shift(DOWN*0.25) ) 28 | stuff.append( ImageMobject("./iqp").shift(DOWN*2.25).scale(0.75) ) 29 | for i in stuff: 30 | self.play(FadeIn(i)) 31 | self.wait(10) 32 | self.wait(20) 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section5/Lecture1/plane.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("QML - Pennylane").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class plane(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Quantum Machine Learning - Pennylane") 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Machine Learning").shift(UP*3.25) 23 | self.play(FadeIn(title)) 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{1. Supervised Learning}").shift(LEFT*3.5 + UP*2).scale(1.2) ) 27 | stuff.append( Tex(r"\text{2. Unsupervised Learning}").shift(LEFT*3.5 + DOWN*0.5).scale(1.2) ) 28 | stuff.append( Tex(r"\text{- Regression (Linear Regression, Decision Tree, Neural Network)}").shift(UP*1.3).scale(0.8) ) 29 | stuff.append( Tex(r"\text{- Classification (Logistic Regression, SVM, Naive Bayes)}").shift(UP*0.6) ) 30 | stuff.append( Tex(r"\text{- Clustering (K-Means, Density Based)}").shift(DOWN*1.2) ) 31 | stuff.append( Tex(r"\text{- Dimensionality Reduction (PCA)}").shift(DOWN*1.9) ) 32 | for i in stuff: 33 | self.play(FadeIn(i)) 34 | waiter(5) 35 | waiter(3) 36 | self.play(FadeOut(Group(*stuff))) 37 | 38 | 39 | 40 | 41 | 42 | 43 | title2 = Text("Quantum Machine Learning").shift(UP*3.25) 44 | self.play(Transform(title, title2)) 45 | stuff = [] 46 | #stuff.append( Tex(r"").shift(DOWN*2) ) 47 | stuff.append( Tex(r"\text{1. Classical Machine Learning w/ Quantum Functions}").shift(UP*2) ) 48 | stuff.append( Tex(r"\text{2. Quantum Algorithms for Quantum Machine Learning}").shift(DOWN*0.5) ) 49 | stuff.append( SurroundingRectangle(stuff[0]) ) 50 | for i in stuff: 51 | self.play(ShowCreation(i)) 52 | waiter(5) 53 | waiter(15) 54 | #self.play(FadeOut(Group(*stuff))) 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section5/Lecture4/feature.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Feature Maps").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class feature(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Quantum Feature Maps").scale(1.1) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Quantum Feature Maps").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | axes = ThreeDAxes(axis_config={"include_tip": False,"include_ticks":False,"stroke_width":1}) 26 | grid = NumberPlane(axis_config={"stroke_opacity":0},background_line_style={"stroke_opacity":0.2},x_min=-5,x_max=5,y_min=-5,y_max=5) 27 | self.play(FadeIn(Group(axes, grid))) 28 | 29 | 30 | dots = [] 31 | for i in range(0, 20): 32 | r = random.randint(100, 150)/100 33 | t = random.randint(1, 360) 34 | ang = t * 3.14159/180 35 | x = r*np.cos(ang) 36 | y = r*np.sin(ang) 37 | dots.append( Dot(np.array([x, y, 1]), color=RED).scale(1) ) 38 | for i in range(0, 20): 39 | r = random.randint(250, 300)/100 40 | t = random.randint(1, 360) 41 | ang = t * 3.14159/180 42 | x = r*np.cos(ang) 43 | y = r*np.sin(ang) 44 | dots.append( Dot(np.array([x, y, -2]), color=BLUE).scale(1.2) ) 45 | 46 | 47 | self.play(FadeIn(Group(*dots))) 48 | waiter(10) 49 | 50 | 51 | frame = self.camera.frame 52 | frame.generate_target() 53 | self.play( 54 | frame.increment_phi, 50 * DEGREES, 55 | frame.increment_theta, -30 * DEGREES, 56 | run_time=2 57 | ) 58 | def spin(m, dt): 59 | m.increment_theta(0.1 * dt) 60 | frame.add_updater(spin) 61 | waiter(5) 62 | sq = Square(7, fill_color=YELLOW, fill_opacity=0.2) 63 | self.play(FadeIn(sq)) 64 | waiter(10) 65 | self.play(FadeOut(Group(sq, *dots))) 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | def qubit3d(xPos, yPos): 74 | sphere = Sphere(radius = 1, point=ORIGIN, color=RED) 75 | sphereMesh = SurfaceMesh(sphere, resolution=(7, 7), flat_stroke=True, color=GREY) 76 | 77 | labelpX = Tex(r'\ket{-}').shift(RIGHT*1.5) 78 | labelrX = Tex(r'\ket{+}').shift(LEFT*1.5) 79 | 80 | labelpY = Tex(r'\ket{-i}').shift(UP*1.5) 81 | labelrY = Tex(r'\ket{+i}').shift(DOWN*1.5) 82 | 83 | labelpZ = Tex(r'\ket{0}').rotate(PI/2, axis=RIGHT).shift(OUT*1.5) 84 | labelrZ = Tex(r'\ket{1}').rotate(PI/2, axis=RIGHT).shift(IN*1.5) 85 | 86 | x = Line(np.array([-1, 0, 0]), np.array([1, 0, 0]), fill_color=GREY_E, color=GREY_E) 87 | y = Line(np.array([0, -1, 0]), np.array([0, 1, 0]), fill_color=GREY_E, color=GREY_E) 88 | z = Line(np.array([0, 0, -1]), np.array([0, 0, 1]), fill_color=GREY_E, color=GREY_E) 89 | #self.add_fixed_in_frame_mobjects(labelX, labelY, labelZ) 90 | vect = Vector(direction=[0, 0, 1]) 91 | qubitG1 = Group(sphereMesh, x, y, z, labelpX, labelpY, labelpZ, labelrX, labelrY, labelrZ) 92 | qubitG1.shift(RIGHT*xPos + UP*yPos) 93 | return qubitG1 94 | def vect3d(x, y, direction): 95 | return Vector(direction=[0, 0, direction]).shift(RIGHT*x + UP*y) 96 | the3dqubs = [] 97 | the3dqubs.append(qubit3d(0, 0)) 98 | self.add(*the3dqubs) 99 | frame.target.set_width(7) 100 | self.play(MoveToTarget(frame)) 101 | 102 | dots3d = [] 103 | cols3d = [] 104 | pos3d = [] 105 | totalDots = 30 106 | for i in range(0, totalDots): 107 | col = BLUE 108 | if (random.randint(0, 1) == 0): 109 | col = RED 110 | r = random.randint(1, 100)/100 111 | phi = random.randint(0, 180) * 3.14159/180 112 | theta = random.randint(0, 360) * 3.14159/180 113 | 114 | x = r * np.cos(phi) * np.sin(theta) 115 | y = r * np.sin(phi) * np.sin(theta) 116 | z = r * np.cos(theta) 117 | dots3d.append( Sphere(radius = 0.1, fill_color=col, fill_opacity=1, color=col).shift(LEFT*x + UP*y + OUT*z) ) 118 | cols3d.append( col ) 119 | pos3d.append( [r, phi, theta] ) 120 | self.play(FadeIn(Group(*dots3d))) 121 | waiter(10) 122 | number = Text("0").shift(UP*2 + RIGHT*2) 123 | self.play(FadeIn(number)) 124 | for j in range(8): 125 | for i in range(0, totalDots): 126 | pos3d[i][0] = pos3d[i][0] + (1 - pos3d[i][0])*0.2 127 | if cols3d[i] == RED: 128 | pos3d[i][1] = (pos3d[i][1]*180/3.14159 + (180 - pos3d[i][1]*180/3.14159)*0.2) * 3.14159/180 129 | else: 130 | pos3d[i][1] = (pos3d[i][1]*180/3.14159)* 0.8 * 3.14159/180 131 | x = pos3d[i][0] * np.cos(pos3d[i][2]) * np.sin(pos3d[i][1]) 132 | y = pos3d[i][0] * np.sin(pos3d[i][2]) * np.sin(pos3d[i][1]) 133 | z = pos3d[i][0] * np.cos(pos3d[i][1]) 134 | dots3d[i].generate_target() 135 | dots3d[i].target.move_to(LEFT*x + UP*y + OUT*z) 136 | self.play(MoveToTarget(dots3d[i]), run_time=0.1) 137 | if (j < 4): 138 | number2 = Text(str(j)).shift(UP*2 + LEFT*2) 139 | else: 140 | number2 = Text(str(j)).shift(DOWN*2 + LEFT*2) 141 | self.play(Transform(number, number2)) 142 | waiter(0.2) 143 | waiter(20) 144 | """ 145 | self.play(FadeOut(Group(axes, grid, sq, *dots))) 146 | frame.remove_updater(spin) 147 | frame.target.set_euler_angles( 148 | theta=0 * DEGREES, 149 | phi=0 * DEGREES, 150 | ) 151 | self.play(MoveToTarget(frame)) 152 | self.wait(10) 153 | """ 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section5/Lecture6/barren.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Barren Plateus, Narrow Gorge Phenomenon").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class barren(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Barren Plateus, Narrow Gorge Phenomenon").scale(1.0) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Barren Plateus").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | 26 | 27 | axes = Axes((-3, 10), (-1, 8)) 28 | axes.add_coordinate_labels() 29 | 30 | self.play(Write(axes, lag_ratio=0.01, run_time=1)) 31 | 32 | parabola = axes.get_graph(lambda x: 0.25 * x**2) 33 | parabola.set_stroke(BLUE) 34 | self.play(ShowCreation(parabola) ) 35 | self.wait() 36 | 37 | # You can use axes.input_to_graph_point, abbreviated 38 | # to axes.i2gp, to find a particular point on a graph 39 | dot = Dot(color=RED) 40 | dot.move_to(axes.i2gp(2, parabola)) 41 | self.play(FadeIn(dot, scale=0.5)) 42 | 43 | # A value tracker lets us animate a parameter, usually 44 | # with the intent of having other mobjects update based 45 | # on the parameter 46 | x_tracker = ValueTracker(2) 47 | f_always( 48 | dot.move_to, 49 | lambda: axes.i2gp(x_tracker.get_value(), parabola) 50 | ) 51 | 52 | #add more here 53 | self.play(x_tracker.animate.set_value(1.6), run_time=0.2) 54 | self.play(x_tracker.animate.set_value(1.2), run_time=0.4) 55 | self.play(x_tracker.animate.set_value(0.8), run_time=0.8) 56 | self.play(x_tracker.animate.set_value(0.4), run_time=1.2) 57 | self.play(x_tracker.animate.set_value(0.2), run_time=1.2) 58 | self.play(x_tracker.animate.set_value(0.1), run_time=1.2) 59 | self.play(x_tracker.animate.set_value(0), run_time=1.2) 60 | self.wait() 61 | 62 | 63 | 64 | step_graph = axes.get_graph( 65 | lambda x: 2.0 if x > 3 else 1.0, 66 | discontinuities=[3], 67 | color=GREEN, 68 | ) 69 | step_label = axes.get_graph_label(step_graph, Text("Step"), x=4) 70 | self.play( 71 | ReplacementTransform(parabola, step_graph), 72 | FadeIn(step_label), 73 | FadeOut(x_tracker) 74 | ) 75 | 76 | x2_tracker = ValueTracker(5) 77 | f_always(dot.move_to, lambda: axes.i2gp(x2_tracker.get_value(), step_graph) ) 78 | self.play(x2_tracker.animate.set_value(5.1), run_time=1) 79 | waiter(1) 80 | x2_tracker = ValueTracker(8) 81 | f_always(dot.move_to, lambda: axes.i2gp(x2_tracker.get_value(), step_graph) ) 82 | waiter(1) 83 | x2_tracker = ValueTracker(6) 84 | f_always(dot.move_to, lambda: axes.i2gp(x2_tracker.get_value(), step_graph) ) 85 | waiter(1) 86 | x2_tracker = ValueTracker(7) 87 | f_always(dot.move_to, lambda: axes.i2gp(x2_tracker.get_value(), step_graph) ) 88 | waiter(5) 89 | 90 | 91 | self.play(FadeOut(Group(axes, dot, step_graph, step_label))) 92 | 93 | 94 | 95 | 96 | 97 | stuff = [] 98 | #stuff.append( Tex(r"") ) 99 | stuff.append( Tex(r"\ket{\psi (\theta)} \to \ket{0_n}").shift(DOWN*2.5) ) 100 | stuff.append( Tex(r"C_g = \bra{\psi (\theta)} (\mathbb{I} - \ket{0_n}\bra{0_n}) \ket{\psi (\theta)}").shift(DOWN*3.25) ) 101 | #stuff.append( Tex(r"").shift(DOWN*0) ) 102 | 103 | for i in stuff: 104 | self.play(FadeIn(i)) 105 | waiter(10) 106 | axes = ThreeDAxes(axis_config={"include_tip": False,"include_ticks":False,"stroke_width":1}) 107 | grid = NumberPlane(axis_config={"stroke_opacity":0},background_line_style={"stroke_opacity":0.2},x_min=-5,x_max=5,y_min=-5,y_max=5) 108 | self.play(FadeIn(Group(axes, grid))) 109 | labelX = Tex(r"\ket{x}").shift(RIGHT*4.5) 110 | #labelY = Tex(r"\ket{p}").shift(UP*2.75) 111 | #self.play(FadeIn(Group(labelX))) 112 | 113 | frame = self.camera.frame 114 | self.play( 115 | frame.increment_phi, 50 * DEGREES, 116 | frame.increment_theta, -30 * DEGREES, 117 | run_time=2 118 | ) 119 | def spin(m, dt): 120 | m.increment_theta(0.1 * dt) 121 | frame.add_updater(spin) 122 | # Gauss surface 123 | op = np.matrix([[1, 0], [0, 1]]) 124 | dispop = np.exp(op) 125 | gaussian = ParametricSurface( 126 | lambda u, v: [u, v, -3*np.absolute(np.linalg.det(np.exp( -1*np.matrix([6*u, 6*v])*op*np.transpose(np.matrix([u, v])) ) )) - 2],#np.exp(-(u**2) - v**2)], 127 | u_range=(-2.5, 2.5), 128 | v_range=(-2.5, 2.5), 129 | resolution=(90, 90), 130 | ) 131 | gaussian.set_color(GREEN, 1) 132 | gaussian.stretch(2, 2) 133 | self.play( 134 | FadeIn(gaussian), 135 | frame.set_phi, 70 * DEGREES, 136 | frame.set_theta, 10 * DEGREES, 137 | run_time=3 138 | ) 139 | 140 | title2 = Text("Narrow Gorge Phenomenon").shift(UP*3.5) 141 | self.play(Transform(title, title2)) 142 | 143 | 144 | self.wait(5) 145 | self.play( 146 | frame.increment_phi, 50 * DEGREES, 147 | frame.set_theta, -100 * DEGREES, 148 | run_time=2 149 | ) 150 | self.play(FadeOut(stuff[1])) 151 | stuff[1] = Tex(r"C_l = \bra{\psi (\theta)} (\mathbb{I} - \sum_{j=1}^n \ket{0}\bra{0}_j \otimes \mathbb{I}) \ket{\psi (\theta)}").shift(DOWN*3.25) 152 | 153 | 154 | 155 | gaussianc = ParametricSurface( 156 | lambda u, v: [u, v, -2*np.absolute(np.linalg.det(np.exp( -1*np.matrix([u*0.25, v*0.25])*op*np.transpose(np.matrix([u, v])) ) )) - 1],#np.exp(-(u**2) - v**2)], 157 | u_range=(-2.5, 2.5), 158 | v_range=(-2.5, 2.5), 159 | resolution=(90, 90), 160 | ) 161 | gaussianc.set_color(GREEN, 1) 162 | gaussianc.stretch(2, 2) 163 | self.play( 164 | FadeTransform(gaussian, gaussianc), 165 | frame.set_phi, 50 * DEGREES, 166 | frame.set_theta, 10 * DEGREES, 167 | run_time=3 168 | ) 169 | self.play(FadeIn(stuff[1])) 170 | self.wait(5) 171 | self.play( 172 | frame.increment_phi, 20 * DEGREES, 173 | frame.set_theta, -120 * DEGREES, 174 | run_time=2 175 | ) 176 | waiter(30) 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section5/Lecture7/relevant.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Relevance of Quantum Machine Learning").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class relevant(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Relevance of Quantum Machine Learning").scale(1.0) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Relevance of Quantum Machine Learning").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | stuff = [] 26 | stuff.append( Tex(r"\text{- Refresher on older material (ie: algorithms)}").shift(UP*1.5) ) 27 | stuff.append( Tex(r"\text{- Apply new material learned (ie: Quantum Embedding)}").shift(UP*0.5) ) 28 | stuff.append( Tex(r"\text{- Learn Something New (ie: Fisher Information Matrix)}").shift(DOWN*0.5) ) 29 | 30 | for i in stuff: 31 | self.play(FadeIn(i)) 32 | waiter(5) 33 | waiter(10) 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section5/qml.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("QML w/ Qiskit & Pytorch").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class time(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("QML w/ Qiskit & Pytorch") 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section6/Lecture3/vqc.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Variational Quantum Classifiers (VQC)").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class vqc(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Variational Quantum Classifiers (VQC)").scale(1) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Variational Quantum Classifiers (VQC)").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | 26 | stuff = [] 27 | #stuff.append( Tex(r"").shift(DOWN*2) ) 28 | stuff.append( Tex(r"\text{1. Data} \to \text{\# Features, \# Classes }").shift(UP*2) ) 29 | stuff.append( Tex(r"\text{2. Classical \& Quantum Nodes (Python Functions)}").shift(UP*1.2) ) 30 | stuff.append( Tex(r"\text{- \# Features} \to \text{Throughput}").shift(UP*0.6).scale(0.8) ) 31 | stuff.append( Tex(r"\text{- \# Classes} \to \text{\# Nodes}").shift(UP*0).scale(0.8) ) 32 | stuff.append( Tex(r"\text{3. Cost Function} \propto \text{Correct Predictions} ").shift(UP*-0.6) ) 33 | stuff.append( Tex(r"\text{4. Optimization} \to \text{Pre-Built Functions} ").shift(UP*-1.4) ) 34 | stuff.append( Tex(r"\text{Example: Iris Data Set}").shift(UP*-3) ) 35 | for i in stuff: 36 | self.play(FadeIn(i)) 37 | waiter(7) 38 | waiter(10) 39 | #self.play(FadeOut(Group(*stuff))) 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section6/Lecture5/cnn.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Convolutional Neural Network (CNN)").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class cnn(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Quantum Convolutional Neural Network (CNN)").scale(1) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Convolutional Neural Network (CNN)").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | cool = ImageMobject("./cnn.jpeg").scale(1.5) 26 | self.play(FadeIn(cool)) 27 | waiter(2) 28 | self.play(FadeOut(cool)) 29 | 30 | 31 | 32 | stuff = [] 33 | #stuff.append( Tex(r"").shift(DOWN*2) ) 34 | stuff.append( Tex(r"\text{1. Convolution (Filter)} \to \text{Feature Map}").shift(UP*2) ) 35 | stuff.append( Tex(r"\text{2. Activation Function} \to \{ ReLU, Linear, Sigmoid, Tanh \}").shift(UP*1) ) 36 | stuff.append( Tex(r"\text{3. Max Pooling} \to \text{Largest Value in Feature Map}").shift(UP*0) ) 37 | stuff.append( Tex(r"\text{4. Input Result Into Neural Network}").shift(DOWN*1) ) 38 | stuff.append( SurroundingRectangle(stuff[0]) ) 39 | for i in stuff: 40 | self.play(FadeIn(i)) 41 | waiter(15) 42 | waiter(14) 43 | #self.play(FadeOut(Group(*stuff))) 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section6/Lecture6/qonn.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Optical Neural Network (QONN)").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class qonn(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Quantum Optical Neural Network (QONN)").scale(1) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Quantum Optical Neural Network (QONN)").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | 26 | 27 | 28 | stuff = [] 29 | #stuff.append( Tex(r"").shift(DOWN*2) ) 30 | stuff.append( Tex(r"\text{Similar to regular Quantum Machine Learning}").shift(UP*2) ) 31 | stuff.append( Tex(r"\text{Quantum Functions} \to \text{Quantum Optical Functions}").shift(UP*1) ) 32 | stuff.append( Tex(r"\text{Look at an example!}").shift(UP*0) ) 33 | for i in stuff: 34 | self.play(FadeIn(i)) 35 | waiter(7) 36 | waiter(10) 37 | #self.play(FadeOut(Group(*stuff))) 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section6/Lecture7/gan.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Generative Adversarial Networks (GAN)").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class gan(Scene): 12 | def construct(self): 13 | wait = False 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Quantum Generative Adversarial Networks (GAN)").scale(1) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Generative Adversarial Networks (GAN)").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | 26 | 27 | stuff = [] 28 | #stuff.append( Tex(r"").shift(DOWN*2) ) 29 | stuff.append( Tex(r"\text{1. Convolution (Filter)} \to \text{Feature Map}").shift(UP*2) ) 30 | stuff.append( SurroundingRectangle(stuff[0]) ) 31 | for i in stuff: 32 | self.play(FadeIn(i)) 33 | waiter(7) 34 | waiter(2) 35 | self.play(FadeOut(Group(*stuff))) 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section7/Lecture3/logical.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Stabilizer Code & Quantum Noise Models").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | 11 | class logical(Scene): 12 | def construct(self): 13 | wait = True 14 | def waiter(n): 15 | if (wait == True): 16 | self.wait(n) 17 | text = Text("Stabilizer Code & Quantum Noise Models").scale(1.0) 18 | self.play(FadeIn(text)) 19 | waiter(4) 20 | self.play(FadeOut(text)) 21 | 22 | title = Text("Stabilizer Code").shift(UP*3.5) 23 | self.play(FadeIn(title)) 24 | 25 | stuff = [] 26 | #stuff.append( Tex(r"").shift(DOWN*2) ) 27 | stuff.append( Tex(r"\text{How to map all Error Syndromes?}").shift(UP*2.75) ) 28 | stuff.append( Tex(r"\begin{tabular}{ c c c c c c c c c c } $M_1$ & Z & Z & - & - & - & - & - & - & - \\ $M_2$ & - & Z & Z & - & - & - & - & - & - \\ $M_3$ & - & - & - & Z & Z & - & - & - & - \\ $M_4$ & - & - & - & - & Z & Z & - & - & - \\ $M_5$ & - & - & - & - & - & - & Z & Z & - \\ $M_6$ & - & - & - & - & - & - & - & Z & Z \\ $M_7$ & X & X & X & X & X & X & - & - & - \\ $M_8$ & - & - & - & X & X & X & X & X & X \end{tabular}").shift(DOWN*0) ) 29 | stuff.append( Line(np.array([-3.5, -2.25, 0]), np.array([-3.5, 2.25, 0])) ) 30 | stuff.append( Tex(r"\text{Shor Code Error Syndromes}").shift(DOWN*3) ) 31 | 32 | for i in stuff: 33 | self.play(FadeIn(i)) 34 | waiter(10) 35 | waiter(10) 36 | #self.play(FadeOut(Group(*stuff))) 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture10/bennet.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Bennet's Laws, Partial Transpose, Entanglement Measures").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class bennet(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Bennet's Laws, Partial Transpose, Entanglement Measures").scale(0.8) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Bennet's Laws").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{Bennet's Laws of Quantum Information: }").shift(UP*2 + LEFT*2) ) 27 | stuff.append( Tex(r"\text{1 qubit } \geq \text{ 1 bit} \quad \quad \quad \to \text{Classical}").shift(UP*1) ) 28 | stuff.append( Tex(r"\text{1 qubit } \geq \text{ 1 ebit} \quad \quad \quad \to \text{Entanglement Bit}").shift(UP*0 + RIGHT*0.9) ) 29 | stuff.append( Tex(r"\text{1 ebit + 1 qubit } \geq \text{ 2 bits} \quad \quad \quad \to \text{Superdense Coding}").shift(DOWN*1 + RIGHT*0.1) ) 30 | stuff.append( Tex(r"\text{1 ebit + 2 bits } \geq \text{ 1 qubit} \quad \quad \quad \to \text{Quantum Teleportation}").shift(DOWN*2 + RIGHT*0.6) ) 31 | 32 | for i in stuff: 33 | self.play(FadeIn(i)) 34 | waiter(7) 35 | waiter(3) 36 | self.play(FadeOut(Group(*stuff))) 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | title2 = Text("Partial Transpose").shift(UP*3.5) 52 | self.play(Transform(title, title2)) 53 | 54 | 55 | stuff = [] 56 | #stuff.append( Tex(r"").shift(DOWN*2) ) 57 | stuff.append( Tex(r"\rho \to \mathbb{H}_A \otimes \mathbb{H}_B").shift(UP*2.5) ) 58 | stuff.append( Tex(r"\rho = \sum_{ijkl} a_{ij}^{kl} \ket{i}\bra{j} \otimes \ket{k}\bra{l}").shift(UP*1.25) ) 59 | stuff.append( Tex(r"\rho^{T_B} = (\mathbb{I} \otimes T)\rho = \sum_{ijkl} a_{ij}^{kl} \ket{i}\bra{j} \otimes (\ket{k}\bra{l})^T = \sum_{ijkl} a_{ij}^{kl} \ket{i}\bra{j} \otimes \ket{l}\bra{k}").shift(UP*0) ) 60 | stuff.append( Tex(r"\text{Peres–Horodecki or PPT Criterion: }").shift(DOWN*2 + LEFT*1).scale(1.2) ) 61 | stuff.append( Tex(r"\text{If all the eigenvalues of } \rho^{T_B} \text{ are positive, }").shift(DOWN*2.75) ) 62 | stuff.append( Tex(r"\text{the state is seperable, otherwise it is entangled}").shift(DOWN*3.25) ) 63 | for i in stuff: 64 | self.play(FadeIn(i)) 65 | waiter(7) 66 | self.play(FadeOut(Group(*stuff))) 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | title2 = Text("Types of Entanglement Measures").shift(UP*3.5) 87 | self.play(Transform(title, title2)) 88 | 89 | 90 | stuff = [] 91 | #stuff.append( Tex(r"").shift(DOWN*2) ) 92 | stuff.append( Tex(r"\text{1. Relative Entropy Entanglement (REE)}").shift(UP*1.5) ) 93 | stuff.append( Tex(r"\text{2. Logarithmic Negativity}").shift(UP*0.5) ) 94 | stuff.append( Tex(r"\text{3. Distillation Entanglement}").shift(DOWN*0.5) ) 95 | stuff.append( Tex(r"\text{4. Squashed Entanglement}").shift(DOWN*1.5) ) 96 | for i in stuff: 97 | self.play(FadeIn(i)) 98 | waiter(7) 99 | self.play(FadeOut(Group(*stuff))) 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | title2 = Text("Logarithmic Negativity").shift(UP*3.5) 109 | self.play(Transform(title, title2)) 110 | 111 | 112 | stuff = [] 113 | #stuff.append( Tex(r"").shift(DOWN*2) ) 114 | stuff.append( Tex(r"\mathbb{N}(\rho) = \frac{\mid\mid\rho^{T_B}\mid\mid-1}{2}").shift(UP*2.5) ) 115 | stuff.append( Tex(r"\mid\mid\rho^{T_B}\mid\mid = Tr \sqrt{(\rho^{T_B})^\dag \rho^{T_B}}").shift(UP*1.25) ) 116 | stuff.append( Tex(r"\mathbb{N}(\rho) = \Bigg( Tr \bigg( (\rho^{T_B})^\dag \rho^{T_B})^{0.5} \bigg) -1 \Bigg)/2").shift(DOWN*0) ) 117 | stuff.append( Tex(r"\mathbb{N}(\rho) = \right| \sum_{\lambda_i < 0} \lambda_i \right| ").shift(DOWN*1.5) ) 118 | stuff.append( Tex(r"E_N = \log \bigg( 2*\mathbb{N}(\rho) - 1 \bigg)").shift(DOWN*3) ) 119 | for i in stuff: 120 | self.play(FadeIn(i)) 121 | waiter(7) 122 | waiter(20) 123 | #self.play(FadeOut(Group(*stuff))) 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture11/broadcast.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("No-Broadcast Theorem, Superbroadcasting").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class broadcast(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("No-Broadcasting Theorem, Superbroadcasting").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("No-Broadcasting Theorem").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"U\ket{0...0}\ket{\psi} = \ket{\psi}^n").shift(UP*1) ) 27 | stuff.append( Tex(r"\text{Not Possible - No-Cloning Theorem}").shift(UP*0) ) 28 | stuff.append( Tex(r"\text{Cannot Copy Pure States}").shift(UP*-1) ) 29 | for i in stuff: 30 | self.play(FadeIn(i)) 31 | waiter(7) 32 | self.play(FadeOut(Group(*stuff))) 33 | 34 | 35 | 36 | 37 | 38 | title2 = Text("Superbroadcasting").shift(UP*3.5) 39 | self.play(FadeOut(title), FadeIn(title2)) 40 | stuff = [] 41 | #stuff.append( Tex(r"").shift(DOWN*2) ) 42 | stuff.append( Tex(r"\text{Can copy non-commuting mixed states}").shift(UP*-3.2) ) 43 | stuff.append( Tex(r"\rho = \rho_A \otimes \rho_B \to \text{multiple qubits s.t}").shift(UP*2.5) ) 44 | stuff.append( Tex(r"\rho_A = \ket{\psi^n}\bra{\psi^n} \quad \quad \rho_B = \ket{0^m}\bra{0^m}").shift(UP*1.25) ) 45 | stuff.append( Tex(r"U \rho U^\dag = U \rho_A \otimes \rho_B U^\dag = U \rho_A \otimes \rho_A U^\dag ").shift(UP*0) ) 46 | stuff.append( Tex(r"n = 4 \quad \quad m = 2 ").shift(UP*-1) ) 47 | stuff.append( Tex(r"\text{Different Qubits Can Produce The Same Mixed State}").shift(UP*-2.2).scale(1) ) 48 | for i in stuff: 49 | self.play(FadeIn(i)) 50 | waiter(7) 51 | waiter(10) 52 | #self.play(FadeOut(Group(*stuff))) 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture12/hiding.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("No-Hiding Theorem, No-Communication Theorem").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class hiding(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("No-Hiding Theorem, No-Communication Theorem").scale(0.9) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("No-Hiding Theorem").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\ket{\psi} \otimes \ket{A} \to \ket{\psi^\prime} \otimes \ket{A^\prime(\psi)}").shift(UP*2.5) ) 27 | stuff.append( Tex(r"\text{If less information in } \psi \text{ then more information in A (Environment)}").shift(UP*1.5).scale(0.9) ) 28 | stuff.append( Tex(r"\text{Conservation of Quantum Information}").shift(UP*0.5) ) 29 | for i in stuff: 30 | self.play(FadeIn(i)) 31 | waiter(7) 32 | self.play(FadeOut(Group(*stuff))) 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | title2 = Text("No-Communication Theorem").shift(UP*3.5) 47 | self.play(Transform(title, title2)) 48 | 49 | 50 | stuff = [] 51 | #stuff.append( Tex(r"").shift(DOWN*2) ) 52 | stuff.append( Tex(r"\text{Given 2 people each with only an ebit, }").shift(UP*2.5) ) 53 | stuff.append( Tex(r"\text{they cannot communicate useful information.}").shift(UP*2.0) ) 54 | stuff.append( Tex(r"\text{Entanglement is 50/50} \to \text{Means of Connection not Communication}").shift(UP*0.5).scale(0.9) ) 55 | stuff.append( Tex(r"\text{Superdense Coding uses Bits and Qubits}").shift(DOWN*0.5) ) 56 | 57 | for i in stuff: 58 | self.play(FadeIn(i)) 59 | waiter(7) 60 | waiter(10) 61 | #self.play(FadeOut(Group(*stuff))) 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture13/delete.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("No-Teleportation Theorem, No-Deleting Theorem").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class delete(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("No-Teleportation Theorem, No-Deleting Theorem").scale(0.9) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("No-Teleportation Theorem").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{Classical Bits} \to \text{Quantum Bits} \to \text{Classical Bits}").shift(UP*2.5) ) 27 | stuff.append( Tex(r"\text{Quantum Bits} \to \text{Classical Bits} \to \text{Quantum Bits?}").shift(UP*1.5) ) 28 | stuff.append( Tex(r"\text{According to Theorem, NO!}").shift(UP*0.5) ) 29 | stuff.append( Tex(r"\text{Quantum State cannot be determined from 1 Measurement}").shift(UP*-0.5) ) 30 | for i in stuff: 31 | self.play(FadeIn(i)) 32 | waiter(7) 33 | self.play(FadeOut(Group(*stuff))) 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | title2 = Text("No-Deleting Theorem").shift(UP*3.5) 52 | self.play(Transform(title, title2)) 53 | 54 | 55 | stuff = [] 56 | #stuff.append( Tex(r"").shift(DOWN*2) ) 57 | stuff.append( Tex(r"U\ket{\psi}_A\ket{\psi}_B = \ket{\psi}_A\ket{0}_B?").shift(UP*2.5) ) 58 | stuff.append( Tex(r"\text{According to No-Deleting Theorem, No!}").shift(UP*1.5) ) 59 | stuff.append( Tex(r"\text{Corrollary of No-Hiding Theorem and Duel of No-Cloning Theorem}").shift(UP*0.5).scale(0.9) ) 60 | stuff.append( Tex(r"U\ket{\psi}_A\ket{\psi}_B\ket{A}_C = \ket{\psi}_A\ket{0}_B\ket{A^\prime}_C").shift(UP*-0.5)) 61 | for i in stuff: 62 | self.play(FadeIn(i)) 63 | waiter(7) 64 | waiter(10) 65 | #self.play(FadeOut(Group(*stuff))) 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture2/kullback.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Kullback Leibler Divergence, Quantum Relative Entropy").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class kullback(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Kullback Leibler Divergence, Quantum Relative Entropy").scale(0.8) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | #print(YELLOW) 21 | title = Text("Kullback Leibler Divergence (Relative Entropy)").shift(UP*3.5) 22 | self.play(FadeIn(title)) 23 | 24 | 25 | stuff = [] 26 | #stuff.append( Tex(r"").shift(DOWN*2) ) 27 | stuff.append( Tex(r"\text{Measure how different two probability distributions are}").shift(UP*2.7) ) 28 | stuff.append( Tex(r"D_{KL}(P \mid \mid Q) = \sum_{x \in X} P(x) \log \frac{P(x)}{Q(x)}").shift(UP*1.7) ) 29 | stuff.append( Tex(r"D_{KL}(P \mid \mid Q) = \sum_{x \in X} P(x) (\log P(x) - \log Q(x))").shift(UP*0.3) ) 30 | stuff.append( Tex(r"D_{KL}(P \mid \mid Q) = H(P, Q) - H(P)").shift(DOWN*0.8) ) 31 | stuff.append( Tex(r"D_{KL} \geq 0").shift(DOWN*1.7) ) 32 | stuff.append( Tex(r"\lim_{x \to -\infty} D_{KL}(P_n \mid \mid Q) = 0").shift(DOWN*2.6) ) 33 | stuff.append( Tex(r"\lim_{x \to -\infty} P_n \to Q").shift(DOWN*3.5) ) 34 | for i in stuff: 35 | self.play(FadeIn(i)) 36 | waiter(10) 37 | self.play(FadeOut(Group(*stuff))) 38 | 39 | 40 | 41 | #GRAPH OF x * ln(x) 42 | axes = Axes(x_range=(-3, 3, 0.5), y_range=(-0.1, 1, 0.2), height=2, width=12, axis_config={"stroke_color": GREY_A, "stroke_width": 2, }, y_axis_config={"include_tip": False, } ) 43 | axes.add_coordinate_labels(font_size=20, num_decimal_places=1, ) 44 | axes.shift(UP*2).scale(0.7) 45 | 46 | self.play(FadeIn(axes)) 47 | func = lambda t : np.exp(-t*t) 48 | sin_graph = axes.get_graph(func, color='#FFFF00', step_size=0.01, ) 49 | self.play(ShowCreation(sin_graph)) 50 | obj = Tex(r"y = e^{-x^2}").shift(UP*0.5) 51 | self.play(FadeIn(obj)) 52 | #self.play(FadeOut(Group(obj, axes, sin_graph))) 53 | 54 | 55 | #GRAPH OF x * ln(x) 56 | axes2 = Axes(x_range=(-3, 3, 0.5), y_range=(-0.1, 1, 0.2), height=2, width=12, axis_config={"stroke_color": GREY_A, "stroke_width": 2, }, y_axis_config={"include_tip": False, } ) 57 | axes2.add_coordinate_labels(font_size=20, num_decimal_places=1, ) 58 | axes2.shift(DOWN*0.9).scale(0.7) 59 | 60 | self.play(FadeIn(axes2)) 61 | k = 10 62 | func2 = lambda t : np.exp(-t*t*k) 63 | sin_graph2 = axes2.get_graph(func2, color='#FFFF00', step_size=0.01, ) 64 | self.play(ShowCreation(sin_graph2)) 65 | obj2 = Tex(r"y = e^{-k*x^2}").shift(DOWN*2.3) 66 | self.play(FadeIn(obj2)) 67 | #self.play(FadeOut(Group(obj2, axes2, sin_graph2))) 68 | 69 | def KL(a, b): 70 | a = np.asarray(a, dtype=np.float) 71 | b = np.asarray(b, dtype=np.float) 72 | return np.sum(np.where(a != 0, a * np.log(a / b), 0)) 73 | 74 | 75 | values1 = np.arange(-3, 3, 0.01)#[1.346112,1.337432,1.246655] 76 | values2 = np.arange(-3, 3, 0.01)#[1.033836,1.082015,1.117323] 77 | for i in range(0, len(values1)): 78 | values1[i] = np.exp(-values1[i]*values1[i]) 79 | for i in range(0, len(values2)): 80 | values2[i] = np.exp(-k*values2[i]*values2[i]) 81 | objKL = Tex(r"D_{KL} = \ " + str(KL(values1, values2))).shift(DOWN*3.25) 82 | self.play(FadeIn(objKL)) 83 | 84 | 85 | k = 10 86 | mlp = 0 87 | for i in range(0, 100): 88 | mlp += 1 89 | k -= 0.097 90 | func3 = lambda t : np.exp(-t*t*k) 91 | self.remove(sin_graph2) 92 | sin_graph2 = axes2.get_graph(func3, color='#FF' + hex(int(k * 17))[2:] + 'AA', step_size=0.01, ) 93 | self.add(sin_graph2) 94 | values1 = np.arange(-3, 3, 0.01)#[1.346112,1.337432,1.246655] 95 | values2 = np.arange(-3, 3, 0.01)#[1.033836,1.082015,1.117323] 96 | for i in range(0, len(values1)): 97 | values1[i] = np.exp(-values1[i]*values1[i]) 98 | for i in range(0, len(values2)): 99 | values2[i] = np.exp(-k*values2[i]*values2[i]) 100 | self.remove(objKL) 101 | objKL = Tex(r"D_{KL} = \ " + str(np.abs(KL(values1, values2)))).shift(DOWN*3.25) 102 | self.add(objKL) 103 | self.wait(0.01) 104 | if (mlp > 92): 105 | self.wait(0.5) 106 | 107 | waiter(10) 108 | self.play(FadeOut(Group(axes, axes2, obj, obj2, sin_graph, sin_graph2, objKL))) 109 | 110 | 111 | 112 | title2 = Text("Quantum Relative Entropy").shift(UP*3.5) 113 | self.play(Transform(title, title2)) 114 | 115 | 116 | stuff = [] 117 | #stuff.append( Tex(r"").shift(DOWN*2) ) 118 | stuff.append( Tex(r"\text{Measure distinguishability of two diff. quantum states}").shift(UP*2.7) ) 119 | stuff.append( Tex(r"S(\rho) = -Tr(\rho \log (\rho))").shift(UP*1.7) ) 120 | stuff.append( Tex(r"S(\rho \mid \mid \sigma) = -Tr(\rho \log (\sigma)) - S(\rho)").shift(UP*0.7) ) 121 | stuff.append( Tex(r"S(\rho \mid \mid \sigma) = -Tr(\rho \log (\sigma)) + Tr(\rho \log (\rho))").shift(DOWN*0.3) ) 122 | stuff.append( Tex(r"S(\rho \mid \mid \sigma) = Tr(\rho \log (\rho)) - Tr(\rho \log (\sigma))").shift(DOWN*1.3) ) 123 | stuff.append( Tex(r"S(\rho \mid \mid \sigma) = Tr(\rho (\log (\rho) - \log (\sigma)))").shift(DOWN*2.3) ) 124 | stuff.append( Tex(r"\rho = \sum_j p_j \ket{\psi_j} \bra{\psi_j}").shift(DOWN*3.3) ) 125 | 126 | 127 | 128 | for i in stuff: 129 | self.play(FadeIn(i)) 130 | waiter(10) 131 | self.play(FadeOut(Group(*stuff))) 132 | 133 | 134 | 135 | title2 = Text("Relative Entropy of Entanglement (REE)").shift(UP*3.5) 136 | self.play(Transform(title, title2)) 137 | stuff = [] 138 | #stuff.append( Tex(r"").shift(DOWN*2) ) 139 | stuff.append( Tex(r"\text{Measure how entangled a system is}").shift(UP*2.7) ) 140 | stuff.append( Tex(r"\text{State Space (Hilbert): } H = \bigotimes_k H_k").shift(UP*1.7) ) 141 | stuff.append( Tex(r"D_{REE}(\rho) = \min_\sigma S(\rho \mid \mid \sigma)").shift(UP*0.7) ) 142 | #entagability 143 | stuff.append( ImageMobject("./entangability.png").shift(DOWN*1.4).scale(0.7) ) 144 | stuff.append( Tex(r"D_{REE}(\rho) = 0 \to \text{Not Entangled}").shift(DOWN*3.3) ) 145 | for i in stuff: 146 | self.play(FadeIn(i)) 147 | waiter(10) 148 | waiter(10) 149 | #self.play(FadeOut(Group(*stuff))) 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture3/holevo.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Holevo's Theorem").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class holevo(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Holevo's Theorem").scale(1.2) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | #print(YELLOW) 21 | title = Text("Holevo's Theorem").shift(UP*3.5) 22 | self.play(FadeIn(title)) 23 | 24 | 25 | stuff = [] 26 | #stuff.append( Tex(r"").shift(DOWN*2) ) 27 | stuff.append( Tex(r"\text{How many bits can be transmitted in a Qubit?}").shift(UP*2.7) ) 28 | stuff.append( Tex(r"Z \to 3n \quad \quad Y \in Z \to 2n \quad \quad X \in Y \to n").shift(UP*1.8) ) 29 | stuff.append( Tex(r"I(Y, Z) = H(Y) + H(Z) - H(Y, Z)").shift(UP*0.9) ) 30 | stuff.append( Tex(r"I(Y, Z) = 2n + 3n - 3n = 2n").shift(DOWN*0) ) 31 | stuff.append( Tex(r"I(X, Z) = n + 3n - 3n = n").shift(DOWN*0.9) ) 32 | stuff.append( Tex(r"Z \to Y \to X").shift(DOWN*1.8) ) 33 | stuff.append( Tex(r"I_{acc}(\sigma, \rho) \to \text{What can be accessed?}").shift(DOWN*2.7) ) 34 | 35 | for i in stuff: 36 | self.play(FadeIn(i)) 37 | waiter(10) 38 | self.play(FadeOut(Group(*stuff))) 39 | 40 | stuff = [] 41 | #stuff.append( Tex(r"").shift(DOWN*2) ) 42 | stuff.append( Tex(r"I_{acc}(\sigma, \rho) = \max_{\sigma_z} I(X, Y)").shift(UP*2.7) ) 43 | stuff.append( Tex(r"\text{Density Matrix: } \rho").shift(UP*1.8) ) 44 | stuff.append( Tex(r"\rho = \frac{1}{2^n} \sum^{2^n} \ket{i}\bra{i} \otimes \ket{i}\bra{i}").shift(UP*0.8) ) 45 | stuff.append( Tex(r"\rho_a = Tr_b(\rho) = \frac{1}{2^n} \sum^{2^n} \ket{i}\bra{i} Tr(\ket{i}\bra{i})").shift(DOWN*0.3) ) 46 | stuff.append( Tex(r"\rho_a = \rho_b = \frac{1}{2^n} \sum^{2^n} \ket{i}\bra{i}").shift(DOWN*1.5) ) 47 | stuff.append( Tex(r"H(\rho_a) = H(\rho_b) = \log 2^n").shift(DOWN*2.4) ) 48 | stuff.append( Tex(r"I(\rho_a, \rho_b) = \log 2^n").shift(DOWN*3.3) ) 49 | for i in stuff: 50 | self.play(FadeIn(i)) 51 | waiter(10) 52 | self.play(FadeOut(Group(*stuff))) 53 | 54 | 55 | 56 | stuff = [] 57 | #stuff.append( Tex(r"").shift(DOWN*2) ) 58 | stuff.append( Tex(r"I_{acc}(\sigma, \rho) = \max_{\sigma_z} I(\rho_a, \rho_b) = \log 2^n").shift(UP*2.7) ) 59 | stuff.append( Tex(r"\text{Max. Entanglement -> Max. Transmission}").shift(UP*1.8) ) 60 | stuff.append( Tex(r"\text{if seperable: } \rho = \rho_a \otimes \rho_b \to I(\rho_a, \rho_b) = 0").shift(UP*0.9) ) 61 | stuff.append( Tex(r"\text{Holevo Information: } \chi = S(\rho) - \sum_i p_i S(\rho_i)").shift(UP*0) ) 62 | stuff.append( Tex(r"\text{Holevo's Theorem: } I(\rho_a, \rho_b) \leq \chi").shift(DOWN*1.3) ) 63 | stuff.append( Tex(r"I(\rho_a, \rho_b) \leq S(\rho) - \sum_i p_i S(\rho_i) \leq \log 2^n = n bits").shift(DOWN*3.2) ) 64 | for i in stuff: 65 | self.play(FadeIn(i)) 66 | waiter(10) 67 | waiter(10) 68 | self.play(FadeOut(Group(*stuff))) 69 | 70 | 71 | title2 = Text("Holevo's Theorem - Superdense Coding").shift(UP*3.5) 72 | self.play(Transform(title, title2)) 73 | 74 | stuff = [] 75 | #stuff.append( Tex(r"").shift(DOWN*2) ) 76 | stuff.append( Tex(r"\text{4 Qubits: } I_{acc}(\sigma, \rho) = \log (2^4) = \text{4 bits} \to 0-15").shift(DOWN*3.4) ) 77 | stuff.append( Tex(r"\text{Maximally Entangle}").shift(DOWN*2.8) ) 78 | stuff.append( Tex(r"\text{Alice}").shift(UP*1 + LEFT*4.5) ) 79 | stuff.append( Tex(r"\text{Bob}").shift(DOWN*1 + LEFT*4.5) ) 80 | for i in stuff: 81 | self.play(FadeIn(i)) 82 | waiter(4) 83 | 84 | qubCoords = [] 85 | qubs = [] 86 | qubs2 = [] 87 | def superdenseQubit(): 88 | c = Circle(color=YELLOW).scale(0.5) 89 | d = Tex(r"\psi") 90 | return Group(c, d) 91 | def underlayQubit(col): 92 | c = Circle(color=col, fill_color=col, fill_opacity=0.2).scale(0.5) 93 | return c 94 | 95 | for i in range(4): 96 | qubs.append(superdenseQubit()) 97 | qubCoords.append( [-3 + 2*i, 1, 0] ) 98 | for i in range(4): 99 | qubs[i].generate_target() 100 | qubs[i].target.move_to(qubCoords[i]) 101 | self.play(MoveToTarget(qubs[i])) 102 | 103 | qubCoords[3] = [3, -1, 0] 104 | qubs[3].target.move_to(qubCoords[3]) 105 | self.play(MoveToTarget(qubs[3])) 106 | 107 | for i in range(3): 108 | col = RED 109 | if (i == 1): 110 | col = GREEN 111 | if (i == 2): 112 | col = GREEN 113 | qubs2.append(underlayQubit(col)) 114 | qubCoords.append( [-3 + 2*i, 1, 0] ) 115 | for i in range(3): 116 | qubs2[i].move_to(qubCoords[i]) 117 | qubs2[i].generate_target() 118 | self.play(MoveToTarget(qubs2[i])) 119 | waiter(10) 120 | for i in range(3): 121 | qubCoords[i] = [-3 + 2*i, -1, 0] 122 | qubs[i].target.move_to(qubCoords[i]) 123 | qubs2[i].target.move_to(qubCoords[i]) 124 | self.play(MoveToTarget(qubs[i]), MoveToTarget(qubs2[i])) 125 | 126 | 127 | waiter(30) 128 | #self.play(FadeOut(Group(*stuff))) 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture4/heat.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Landauer Principle").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class heat(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Landauer Principle, Margolus-Levitin Theorem").scale(1) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | #print(YELLOW) 21 | title = Text("Landauer Principle").shift(UP*3.5) 22 | self.play(FadeIn(title)) 23 | 24 | 25 | stuff = [] 26 | #stuff.append( Tex(r"").shift(DOWN*2) ) 27 | stuff.append( Tex(r"\text{Where does heat come from in a computer?}").shift(UP*2.5) ) 28 | stuff.append( Tex(r"\text{- Electric Resistance of Current Carrier}").shift(UP*1.5 + RIGHT*1.2) ) 29 | stuff.append( Tex(r"\text{- Information Loss}").shift(UP*0.5 + LEFT*1) ) 30 | stuff.append( Tex(r"\text{Principle: Irreversible Computing Processes Increases Entropy}").shift(DOWN*3).scale(1) ) 31 | 32 | for i in stuff: 33 | self.play(FadeIn(i)) 34 | waiter(5) 35 | waiter(10) 36 | self.play(FadeOut(Group(*stuff))) 37 | 38 | 39 | 40 | 41 | 42 | stuff = [] 43 | #stuff.append( Tex(r"").shift(DOWN*2) ) 44 | stuff.append( Tex(r"\text{Quantum Gates are Reversible}").shift(UP*2) ) 45 | stuff.append( Tex(r"\text{Landauer Principle does not apply to Quantum Computers}").shift(UP*1).scale(1) ) 46 | stuff.append( Tex(r"\text{Benefit of Quantum Computers}").shift(UP*0).scale(1) ) 47 | 48 | for i in stuff: 49 | self.play(FadeIn(i)) 50 | waiter(5) 51 | waiter(5) 52 | self.play(FadeOut(Group(*stuff))) 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | stuff = [] 61 | #stuff.append( Tex(r"").shift(DOWN*2) ) 62 | stuff.append( Tex(r"\text{Lower theoretical limit of energy consumption of computation}").shift(UP*2.5) ) 63 | stuff.append( Tex(r"\text{Boltzmann Entropy Formula: } S = k_B \ln(W)").shift(UP*1.5) ) 64 | stuff.append( Tex(r"W \to \text{\# of Possible States}").shift(UP*0.5) ) 65 | stuff.append( Tex(r"E = ST").shift(DOWN*0.5) ) 66 | stuff.append( Tex(r"E = k_B T \ln(W)").shift(DOWN*1.5) ) 67 | stuff.append( Tex(r"W_{bit} = 2 \to \{ 0, 1\}").shift(DOWN*2.5) ) 68 | # 69 | 70 | for i in stuff: 71 | self.play(FadeIn(i)) 72 | waiter(7) 73 | self.play(FadeOut(Group(*stuff))) 74 | 75 | 76 | 77 | 78 | 79 | stuff = [] 80 | #stuff.append( Tex(r"").shift(DOWN*2) ) 81 | stuff.append( Group(Tex(r"E = k_B T \ln(W)").shift(UP*2.5), Tex(r"E_{bit} = k_B T \ln(2) = 2.856 * 10^{-21} \text{ Joules}").shift(UP*1.5)) ) 82 | stuff.append( Tex(r"E_{terabyte} = 2.2848 * 10^{-12} \text{ Joules}").shift(UP*0.5) ) 83 | stuff.append( Tex(r"\text{Koomey's Law: Computation per Joule doubles every 1.57 Years}").shift(DOWN*0.5) ) 84 | stuff.append( Tex(r"\text{Performance per Watt: } 10^3 \text{ MegaFlops} \to 10^6 \text{ FLOPS}").shift(DOWN*1.5) ) 85 | stuff.append( Tex(r"\text{Max Operations per Joule per Second?}").shift(DOWN*2.5) ) 86 | # 87 | 88 | for i in stuff: 89 | self.play(FadeIn(i)) 90 | waiter(10) 91 | self.play(FadeOut(Group(*stuff))) 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | title2 = Text("Margolus-Levitin Theorem").shift(UP*3.5) 105 | self.play(Transform(title, title2)) 106 | 107 | stuff = [] 108 | #stuff.append( Tex(r"").shift(DOWN*2) ) 109 | stuff.append( Tex(r"\text{Koomey's Law: Computation per Joule doubles every 1.57 Years}").shift(UP*2.5) ) 110 | stuff.append( Tex(r"\text{Performance per Watt: } 10^6 \text{ FLOPS} \to 10^{11}-10^{19} \text{ OPS}").shift(UP*1.5) ) 111 | stuff.append( Tex(r"\text{Theorem: A maximum of } 6*10^{33} \text{ Operations can be done with 1 joule in 1 second}").shift(DOWN*3.2).scale(0.8) ) 112 | 113 | stuff2 = [] 114 | #stuff.append( Tex(r"").shift(DOWN*2) ) 115 | stuff2.append( Tex(r"\text{Quantum Limit: System w/ Avg. Energy E}").shift(UP*0.5) ) 116 | stuff2.append( Tex(r"\text{Time to Orthogonal State = } \frac{h}{4E} \to \text{Flip }\ket{0} \text{ to } \ket{1} ").shift(DOWN*0.5) ) 117 | stuff2.append( Tex(r"\text{Bremermann's limit, Bekenstein bound, Limits of computation}").shift(DOWN*2).scale(0.9).set_color(YELLOW) ) 118 | # 119 | 120 | for i in stuff: 121 | self.play(FadeIn(i)) 122 | waiter(2) 123 | for i in stuff2: 124 | self.play(FadeIn(i)) 125 | waiter(10) 126 | waiter(20) 127 | #self.play(FadeOut(Group(*stuff, *stuff2))) 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture5/distance.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Distance Measures for Quantum Information").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class distance(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Distance Measures for Quantum Information").scale(1) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Trace Distance").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{How Different are 2 Quantum States}").shift(DOWN*3.3) ) 27 | stuff.append( Tex(r"0 \leq T(\rho, \sigma) = \frac{1}{2}Tr(\mid \rho - \sigma \mid) \leq \frac{1}{2}").shift(UP*2.6) ) 28 | stuff.append( Tex(r"\rho = \sum_i r_i \ket{i}\bra{i}").shift(UP*1.4 + LEFT*2.5) ) 29 | stuff.append( Tex(r"\sigma = \sum_i s_i \ket{i}\bra{i}").shift(UP*1.4 + RIGHT*2.5) ) 30 | stuff.append( Tex(r"\rho = \frac{3}{4} \ket{0}\bra{0} + \frac{1}{4}\ket{1}\bra{1}").shift(UP*0.2 + LEFT*3) ) 31 | stuff.append( Tex(r"\sigma = \frac{2}{3} \ket{0}\bra{0} + \frac{1}{3}\ket{1}\bra{1}").shift(UP*0.2 + RIGHT*3) ) 32 | for i in stuff: 33 | self.play(FadeIn(i)) 34 | waiter(5) 35 | 36 | stuff2 = [] 37 | #stuff.append( Tex(r"").shift(DOWN*2) ) 38 | stuff2.append( Tex(r"T(\rho, \sigma) = \frac{1}{2}Tr(\mid \frac{1}{12}\ket{0}\bra{0} - \frac{1}{12}\ket{1}\bra{1} \mid) = \frac{1}{2}Tr(\frac{1}{12}\ket{0}\bra{0} + \frac{1}{12}\ket{1}\bra{1})").shift(DOWN*1).scale(0.9) ) 39 | stuff2.append( Tex(r"T(\rho, \sigma) = \frac{1}{2}(\frac{1}{24}) = \frac{1}{48}").shift(DOWN*2.2) ) 40 | for i in stuff2: 41 | self.play(FadeIn(i)) 42 | waiter(5) 43 | waiter(10) 44 | self.play(FadeOut(Group(*stuff, *stuff2))) 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | stuff = [] 53 | #stuff.append( Tex(r"").shift(DOWN*2) ) 54 | stuff.append( Tex(r"T(\rho, \sigma) = \frac{1}{2}Tr(\mid \rho - \sigma \mid)").shift(UP*2.5) ) 55 | stuff.append( Tex(r"\vec{r} \to \text{Bloch Vector for } \rho").shift(UP*1.5 + LEFT*4) ) 56 | stuff.append( Tex(r"\vec{s} \to \text{Bloch Vector for } \sigma").shift(UP*1.5 + RIGHT*4) ) 57 | stuff.append( Tex(r"\rho = \frac{\mathbb{I} + \vec{r} \cdot \{X,Y,Z\} }{2}").shift(UP*0.2 + LEFT*3) ) 58 | stuff.append( Tex(r"\sigma = \frac{\mathbb{I} + \vec{s} \cdot \{X,Y,Z\} }{2}").shift(UP*0.2 + RIGHT*3) ) 59 | stuff.append( Tex(r"T(\rho, \sigma) = \frac{1}{4} \mid (\vec{r} - \vec{s}) \cdot \{X,Y,Z\} \mid").shift(DOWN*1) ) 60 | stuff.append( Tex(r"T(\rho, \sigma) = \frac{1}{2} \mid \vec{r} - \vec{s} \mid").shift(DOWN*2.2) ) 61 | stuff.append( Tex(r"\text{Trace Distance is half distance on Bloch Sphere!}").shift(DOWN*3.3) ) 62 | for i in stuff: 63 | self.play(FadeIn(i)) 64 | waiter(5) 65 | waiter(10) 66 | self.play(FadeOut(Group(*stuff))) 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | stuff = [] 75 | #stuff.append( Tex(r"").shift(DOWN*2) ) 76 | stuff.append( Tex(r"T(\rho, \sigma) = \frac{1}{2}Tr(\mid \rho - \sigma \mid)").shift(UP*2.5) ) 77 | stuff.append( Tex(r"\rho^{AB} = \frac{1}{2} \ket{\psi_A}\bra{\psi_A} + \frac{1}{2} \ket{\psi_B}\bra{\psi_B}").shift(UP*1.5) ) 78 | stuff.append( Tex(r"\sigma^{AB} = \frac{1}{2} \ket{\phi_A}\bra{\phi_A} + \frac{1}{2} \ket{\phi_B}\bra{\phi_B}").shift(UP*0.3) ) 79 | stuff.append( Tex(r"T(\rho^A, \sigma^A) \leq T(\rho^{AB}, \sigma^{AB})").shift(DOWN*0.9) ) 80 | stuff.append( Tex(r"T(\rho^B, \sigma^B) \leq T(\rho^{AB}, \sigma^{AB})").shift(DOWN*2) ) 81 | stuff.append( Tex(r"\text{Partial Info. of System is more similar than full info. of System}").shift(DOWN*3.3).scale(0.8) ) 82 | for i in stuff: 83 | self.play(FadeIn(i)) 84 | waiter(5) 85 | waiter(10) 86 | self.play(FadeOut(Group(*stuff))) 87 | 88 | #Trace Distance Measure as half substract trace + example 89 | #partial 1,2 a distance less than full 1,2 a,b distance 90 | 91 | 92 | 93 | title2 = Text("Fidelity").shift(UP*3.5) 94 | self.play(Transform(title, title2)) 95 | stuff = [] 96 | #stuff.append( Tex(r"").shift(DOWN*2) ) 97 | stuff.append( Tex(r"F(\rho, \sigma) = Tr\big( \rho^{0.5}\sigma^{0.5} \big)").shift(UP*2.5) ) 98 | stuff.append( Tex(r"F(\rho, \sigma) = \max_{\ket{\phi}} \mid \bra{\psi}\ket{\phi} \mid").shift(UP*1.5) ) 99 | stuff.append( Tex(r"A(\rho, \sigma) = arccos(F(\rho, \sigma))").shift(UP*0.5) ) 100 | stuff.append( Tex(r"\text{Angle b/w Bloch Vectors}").shift(DOWN*3.3).scale(0.8) ) 101 | stuff.append( Tex(r"A(\rho, \tau) \leq A(\rho, \sigma) + A(\sigma, \tau) \to \text{Triangle Inequality}").shift(DOWN*0.5) ) 102 | stuff.append( Tex(r"\text{How similar two different Quantum States}").shift(DOWN*1.5) ) 103 | stuff.append( Tex(r"1 - F(\rho, \sigma) \leq T(\rho, \sigma) \leq \sqrt{1 - F(\rho, \sigma)^2}").shift(DOWN*2.5) ) 104 | 105 | for i in stuff: 106 | self.play(FadeIn(i)) 107 | waiter(5) 108 | waiter(15) 109 | #Fidelity Measure 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture6/principle.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Uncertainty Principle").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class principle(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Uncertainty Principle").scale(1) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Uncertainty Principle").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\langle A \rangle = \bra{\psi}A\ket{\psi}").shift(UP*2.6) ) 27 | stuff.append( Tex(r"\text{Classical: }\sigma_A^2 = (A - \langle A \rangle)^2").shift(UP*1.6) ) 28 | stuff.append( Tex(r"\text{Quantum: }\sigma_A^2 = \langle (A - \langle A \rangle)^2 \rangle").shift(UP*0.6) ) 29 | stuff.append( Tex(r"\sigma_A^2 = \bra{\psi} (A - \langle A \rangle)^2 \ket{\psi}").shift(DOWN*0.4) ) 30 | stuff.append( Tex(r"\sigma_A^2 = \braket{(A - \langle A \rangle)\psi}").shift(DOWN*1.4) ) 31 | stuff.append( Tex(r"\sigma_A^2 = \braket{f}").shift(DOWN*2.4) ) 32 | for i in stuff: 33 | self.play(FadeIn(i)) 34 | waiter(5) 35 | 36 | self.play(FadeOut(Group(*stuff))) 37 | 38 | 39 | stuff = [] 40 | #stuff.append( Tex(r"").shift(DOWN*2) ) 41 | stuff.append( Tex(r"\sigma_A^2 \sigma_B^2 = \braket{f}\braket{g}").shift(UP*2.6) ) 42 | stuff.append( Tex(r"\text{Schwarz Inequality: } \braket{f}\braket{g} \geq \mid \bra{f}\ket{g} \mid^2").shift(UP*1.6) ) 43 | stuff.append( Tex(r"\sigma_A^2 \sigma_B^2 \geq \mid \bra{f}\ket{g} \mid^2").shift(UP*0.6) ) 44 | stuff.append( Tex(r"\mid z\mid^2 = Re(z)^2 + Im(z)^2 \geq Im(z)^2 = \bigg(\frac{(z-z^*)}{2i}\bigg)^2").shift(DOWN*0.4) ) 45 | stuff.append( Tex(r"\sigma_A^2 \sigma_B^2 \geq \bigg(\frac{1}{2i} (\bra{f}\ket{g} - \bra{g}\ket{f})\bigg)^2").shift(DOWN*1.4) ) 46 | stuff.append( Tex(r"\bra{f}\ket{g} - \bra{g}\ket{f} \to ?").shift(DOWN*2.4) ) 47 | for i in stuff: 48 | self.play(FadeIn(i)) 49 | waiter(5) 50 | 51 | self.play(FadeOut(Group(*stuff))) 52 | 53 | 54 | 55 | 56 | 57 | stuff = [] 58 | #stuff.append( Tex(r"").shift(DOWN*2) ) 59 | stuff.append( Tex(r"\bra{f}\ket{g} = \bra{(A - \langle A \rangle)\psi} \ket{(B - \langle B \rangle)\psi}").shift(UP*2.6) ) 60 | stuff.append( Tex(r"\bra{f}\ket{g} = \bra{\psi} AB - A\langle B \rangle - \langle A \rangle B + \langle A \rangle \langle B \rangle \ket{\psi}").shift(UP*1.6) ) 61 | stuff.append( Tex(r"\bra{f}\ket{g} = \langle AB \rangle - \langle A \rangle \langle B \rangle - \langle A \rangle \langle B \rangle + \langle A \rangle \langle B \rangle").shift(UP*0.6) ) 62 | stuff.append( Tex(r"\bra{f}\ket{g} = \langle AB \rangle - \langle A \rangle \langle B \rangle ").shift(DOWN*0.4) ) 63 | stuff.append( Tex(r"\bra{g}\ket{f} = \langle BA \rangle - \langle A \rangle \langle B \rangle ").shift(DOWN*1.4) ) 64 | stuff.append( Tex(r"\bra{f}\ket{g} - \bra{g}\ket{f} = \langle AB \rangle - \langle BA \rangle").shift(DOWN*2.4) ) 65 | stuff.append( Tex(r"\bra{f}\ket{g} - \bra{g}\ket{f} = \langle [A, B] \rangle").shift(DOWN*3.3) ) 66 | for i in stuff: 67 | self.play(FadeIn(i)) 68 | waiter(5) 69 | 70 | self.play(FadeOut(Group(*stuff))) 71 | 72 | 73 | 74 | 75 | stuff = [] 76 | #stuff.append( Tex(r"").shift(DOWN*2) ) 77 | stuff.append( Tex(r"\sigma_A^2 \sigma_B^2 \geq (\frac{1}{2i} (\bra{f}\ket{g} - \bra{g}\ket{f}))^2").shift(UP*2.5) ) 78 | stuff.append( Tex(r"\bra{f}\ket{g} - \bra{g}\ket{f} = \langle [A, B] \rangle").shift(UP*1.5) ) 79 | 80 | for i in stuff: 81 | self.play(FadeIn(i)) 82 | waiter(5) 83 | result = Tex(r"\sigma_A^2 \sigma_B^2 \geq \bigg(\frac{\langle [A, B] \rangle}{2i} \bigg)^2").shift(DOWN*2.5).scale(1.5) 84 | self.play(FadeIn(result)) 85 | 86 | self.play(FadeOut(Group(*stuff))) 87 | 88 | 89 | stuff = [] 90 | #stuff.append( Tex(r"").shift(DOWN*2) ) 91 | stuff.append( Tex(r"[x, p] = ih").shift(UP*2.5 + LEFT*2) ) 92 | stuff.append( Tex(r"\sigma_x^2 \sigma_p^2 \geq \bigg(\frac{ih}{2i} \bigg)^2").shift(UP*2.5 + RIGHT*2) ) 93 | stuff.append( Tex(r"\sigma_x^2 \sigma_p^2 \geq \frac{h^2}{4}").shift(UP*1) ) 94 | stuff.append( Tex(r"\text{Heisenberg Uncertainty Principle: } \sigma_x \sigma_p \geq \frac{h}{2}").shift(DOWN*0.5) ) 95 | for i in stuff: 96 | self.play(FadeIn(i)) 97 | waiter(5) 98 | result2 = Tex(r"\sigma_A^2 \sigma_B^2 \geq \bigg(\frac{Tr(\rho [A, B]}{2i} \bigg)^2").shift(DOWN*2.5).scale(1.5) 99 | self.play(Transform(result, result2)) 100 | waiter(15) 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture8/ssa.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Wehrl entropy, Strong Subadditivity of Quantum Entropy (SSA)").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class ssa(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Wehrl entropy, SSA, Lieb's Theorem").scale(1.1) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Wehrl Entropy").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"Q_\rho(x, p) = \int \phi(x, p \mid y)^* \rho(y, y^\prime) \phi(x, p \mid y^\prime) dy dy^\prime").shift(UP*2.6) ) 27 | stuff.append( Tex(r"\phi(x, p \mid y) = \pi^{-0.25} e^{-\mid y-x \mid^2 /2 + ipx }").shift(UP*1.6) ) 28 | stuff.append( Tex(r"S_W(\rho) = -\int Q_\rho(x, p) \log(Q_\rho(x, p)) dx dp").shift(UP*0.6) ) 29 | stuff.append( Tex(r"\text{1. } S_W(\rho) \geq 1 \to \text{Wehrl Conjecture (Proven) }").shift(DOWN*1.5) ) 30 | stuff.append( Tex(r"\text{2. } S_W(\rho) > S(\rho) \to \text{Von Neumann Quantum Entropy} }").shift(DOWN*2.5) ) 31 | for i in stuff: 32 | self.play(FadeIn(i)) 33 | waiter(7) 34 | self.play(FadeOut(Group(*stuff))) 35 | 36 | 37 | 38 | title2 = Text("Strong Subadditivity of Quantum Entropy (SSA)").shift(UP*3.5) 39 | self.play(Transform(title, title2)) 40 | stuff = [] 41 | #stuff.append( Tex(r"").shift(DOWN*2) ) 42 | stuff.append( Tex(r"\text{Given Von Neumann Quantum Entropy } S(\rho)=-Tr(\rho \log(\rho))").shift(UP*2.5) ) 43 | stuff.append( Tex(r"\text{and Tripartite Quantum State } \rho^{ABC}:").shift(UP*1.9 + LEFT*2) ) 44 | stuff.append( Tex(r"S(\rho^{ABC}) + S(\rho^B) \leq S(\rho^{AB}) + S(\rho^{BC})").shift(UP*0) ) 45 | stuff.append( Tex(r"\text{Where: } S(\rho^{AB}) = -Tr(\rho^{AB} \log(\rho^{AB}))").shift(DOWN*1) ) 46 | stuff.append( Tex(r"\text{Quantum Entropy is a Concave Function}").shift(DOWN*3) ) 47 | 48 | for i in stuff: 49 | self.play(FadeIn(i)) 50 | waiter(7) 51 | self.play(FadeOut(Group(*stuff))) 52 | 53 | 54 | axes = Axes((-5, 7), (-1, 5)) 55 | axes.add_coordinate_labels() 56 | 57 | self.play(Write(axes, lag_ratio=0.01, run_time=1)) 58 | 59 | parabola = axes.get_graph(lambda x: -0.25 * x**2+3, step_size=0.001) 60 | parabola.set_stroke(BLUE) 61 | self.play(ShowCreation(parabola) ) 62 | self.wait() 63 | 64 | # You can use axes.input_to_graph_point, abbreviated 65 | # to axes.i2gp, to find a particular point on a graph 66 | dot = Dot(color=RED) 67 | dot.move_to(axes.i2gp(2, parabola)) 68 | self.play(FadeIn(dot, scale=0.5)) 69 | 70 | linedots = [] 71 | dot2 = Dot(color=WHITE) 72 | dot2.move_to(axes.i2gp(3, parabola)) 73 | x2_tracker = ValueTracker(3) 74 | f_always(dot2.move_to, lambda: axes.i2gp(x2_tracker.get_value(), parabola) ) 75 | linedots.append(dot2) 76 | 77 | dot3 = Dot(color=WHITE) 78 | dot3.move_to(axes.i2gp(1, parabola)) 79 | x3_tracker = ValueTracker(1) 80 | f_always(dot3.move_to, lambda: axes.i2gp(x3_tracker.get_value(), parabola) ) 81 | linedots.append(dot3) 82 | 83 | 84 | 85 | def lupdater(self): 86 | self.become( Line(linedots[0], linedots[1]) ) 87 | line = Line(linedots[0], linedots[1]).set_color(WHITE) 88 | line.add_updater(lupdater) 89 | 90 | self.play(FadeIn(linedots[0], scale=0.5)) 91 | self.play(FadeIn(linedots[1], scale=0.5)) 92 | self.play(FadeIn(line)) 93 | # A value tracker lets us animate a parameter, usually 94 | # with the intent of having other mobjects update based 95 | # on the parameter 96 | x_tracker = ValueTracker(2) 97 | f_always(dot.move_to, lambda: axes.i2gp(x_tracker.get_value(), parabola) ) 98 | self.play(x_tracker.animate.set_value(4), x2_tracker.animate.set_value(5), x3_tracker.animate.set_value(3),run_time=3) 99 | self.play(x_tracker.animate.set_value(-2), x2_tracker.animate.set_value(-1), x3_tracker.animate.set_value(-3), run_time=3) 100 | self.wait() 101 | waiter(5) 102 | 103 | self.play(FadeOut(Group(*linedots, line, axes, parabola, dot))) 104 | 105 | 106 | title2 = Text("Lieb's Theorem").shift(UP*3.5) 107 | self.play(Transform(title, title2)) 108 | stuff = [] 109 | #stuff.append( Tex(r"").shift(DOWN*2) ) 110 | stuff.append( Tex(r"\text{Given Concave Function f and } 0 \leq \lambda \leq 1").shift(UP*2.5 + LEFT*2) ) 111 | stuff.append( Tex(r"f(\lambda x_1 + (1-\lambda)x_2) \geq \lambda f(x_1) + (1-\lambda)f(x_2)").shift(UP*1.5) ) 112 | stuff.append( Tex(r"\text{Can we do the same w/ Matrices?}").shift(DOWN*1) ) 113 | for i in stuff: 114 | self.play(FadeIn(i)) 115 | waiter(7) 116 | self.play(FadeOut(Group(*stuff))) 117 | 118 | 119 | stuff = [] 120 | #stuff.append( Tex(r"").shift(DOWN*2) ) 121 | stuff.append( Tex(r"\text{Given Positive Matrices } R_1, R_2, Q_1, Q_2, T_1, T_2,").shift(UP*2.5 ) ) 122 | stuff.append( Tex(r"0 = [ R_1, R_2 ] = [ Q_1, Q_2 ] = [ T_1, T_2 ]").shift(UP*1.7) ) 123 | stuff.append( Tex(r"R_1 \geq Q_1 + T_1").shift(UP*0.5) ) 124 | stuff.append( Tex(r"R_2 \geq Q_2 + T_2").shift(DOWN*0.5) ) 125 | stuff.append( Tex(r"R_1^t * R_2^{1-t} \geq Q_1^1 Q_2^{1-t} + T_1^{t} T_2^{1-t}").shift(DOWN*1.5) ) 126 | stuff.append( Tex(r"f(A,B) = Tr(X^\dag A^t X B^{1-t}) \to \text{is Concave}").shift(DOWN*3) ) 127 | for i in stuff: 128 | self.play(FadeIn(i)) 129 | waiter(7) 130 | self.play(FadeOut(Group(*stuff))) 131 | 132 | 133 | stuff = [] 134 | #stuff.append( Tex(r"").shift(DOWN*2) ) 135 | stuff.append( Tex(r"Q_1(X) = \lambda A_1 X").shift(UP*2.7) ) 136 | stuff.append( Tex(r"Q_2(X) = \lambda X B_1").shift(UP*2.1) ) 137 | stuff.append( Tex(r"T_1(X) = (1-\lambda) A_2 X").shift(UP*1.5) ) 138 | stuff.append( Tex(r"T_2(X) = (1-\lambda) X B_2").shift(UP*0.9) ) 139 | stuff.append( Tex(r"R_1(X) = Q_1 + T_1").shift(UP*0.3) ) 140 | stuff.append( Tex(r"R_2(X) = Q_2 + T_2").shift(DOWN*0.3) ) 141 | stuff.append( Tex(r"R_1^t * R_2^{1-t} \geq Q_1^1 Q_2^{1-t} + T_1^{t} T_2^{1-t}").shift(DOWN*1.5) ) 142 | stuff.append( Tex(r"f(A,B) = Tr(X^\dag A^t X B^{1-t}) \to \text{let f be Trace Function").shift(DOWN*2.3) ) 143 | stuff.append( Tex(r"S(\rho^{ABC}) + S(\rho^B) \leq S(\rho^{AB}) + S(\rho^{BC})").shift(DOWN*3.2) ) 144 | 145 | for i in stuff: 146 | self.play(FadeIn(i)) 147 | waiter(7) 148 | waiter(15) 149 | #self.play(FadeOut(Group(*stuff))) 150 | 151 | 152 | 153 | 154 | 155 | 156 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section8/Lecture9/knill.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Gottesman–Knill theorem, Eastin–Knill theorem").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class knill(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Gottesman–Knill theorem, Eastin–Knill theorem").scale(0.9) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Gottesman–Knill theorem").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{Theorem: The following components can be effectively simulated on a classical computer: }").shift(UP*2.5).scale(0.7) ) 27 | stuff.append( Tex(r"\text{1. State Preparation of Qubits}").shift(UP*1.5) ) 28 | stuff.append( Tex(r"\text{2. Clifford Gates: } \{ H, S, CNOT\}").shift(UP*0.75) ) 29 | stuff.append( Tex(r"\text{3. Measurement}").shift(UP*0) ) 30 | for i in stuff: 31 | self.play(FadeIn(i)) 32 | waiter(7) 33 | self.play(FadeOut(Group(*stuff))) 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | title2 = Text("Eastin–Knill theorem").shift(UP*3.5) 47 | self.play(Transform(title, title2)) 48 | 49 | 50 | stuff = [] 51 | #stuff.append( Tex(r"").shift(DOWN*2) ) 52 | stuff.append( Tex(r"\text{Theorem: No Quantum Error Correction code can have a continuous}").shift(UP*2.7).scale(0.9) ) 53 | stuff.append( Tex(r"\text{symmetry acting transversely on physical qubits}").shift(UP*2.2).scale(0.9) ) 54 | stuff.append( Tex(r"\text{Transversal: Affecting 2 different Logical Qubits}").shift(UP*1.3) ) 55 | 56 | for i in stuff: 57 | self.play(FadeIn(i)) 58 | waiter(7) 59 | 60 | stuff2 = [] 61 | for i in range(3): 62 | for j in range(3): 63 | stuff2.append( Dot().set_color(YELLOW).shift(LEFT*0.75 + RIGHT*i + DOWN*j + UP*0) ) 64 | stuff2.append( Rectangle(height=3, width=0.8).shift(LEFT*0.75 + RIGHT*i + DOWN*1).set_color(GREEN) ) 65 | 66 | for i in stuff2: 67 | self.play(FadeIn(i, run_time=0.1)) 68 | 69 | stuff2[2].generate_target() 70 | stuff2[2].target.set_color(RED) 71 | self.play(MoveToTarget(stuff2[2])) 72 | stuff2[2].target.set_color(YELLOW) 73 | self.play(MoveToTarget(stuff2[2])) 74 | 75 | 76 | stuff2[5].generate_target() 77 | stuff2[5].target.set_color(RED) 78 | self.play(MoveToTarget(stuff2[5])) 79 | stuff2[5].target.set_color(YELLOW) 80 | self.play(MoveToTarget(stuff2[5])) 81 | 82 | 83 | 84 | stuff2[8].generate_target() 85 | stuff2[8].target.set_color(RED) 86 | self.play(MoveToTarget(stuff2[8])) 87 | stuff2[8].target.set_color(YELLOW) 88 | self.play(MoveToTarget(stuff2[8])) 89 | 90 | ellipse= Ellipse(width=3, height=1, color=BLUE).shift(RIGHT*0.25 + UP*0) 91 | self.play(FadeIn(ellipse)) 92 | 93 | 94 | stuff2[4].generate_target() 95 | stuff2[4].target.set_color(RED) 96 | self.play(MoveToTarget(stuff2[4])) 97 | waiter(5) 98 | stuff2[0].generate_target() 99 | stuff2[0].target.set_color(RED) 100 | stuff2[8].target.set_color(RED) 101 | self.play(MoveToTarget(stuff2[0]), MoveToTarget(stuff2[8])) 102 | finale = Tex(r"\text{Any Universal Set of Quantum Gates cannot be Implemented Fault-Tolerantly}").shift(DOWN*3.3).scale(0.8) 103 | self.play(FadeIn(finale)) 104 | waiter(20) 105 | #self.play(FadeOut(Group(*stuff))) 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section9/Lecture1/channel.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Channels, Channel Capacity").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class channel(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Quantum Channels, Channel Capacity").scale(0.9) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Quantum Channels").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Group(Tex(r"\text{Any processing of quantum info (storage or transfer)}").shift(UP*2.7), Tex(r"\text{can be represented by quantum channel}").shift(UP*2)) ) 27 | stuff.append( Tex(r"\text{Memoryless: Output depends only on immediate input}").shift(UP*1) ) 28 | stuff.append( Tex(r"\text{Density Matrix: } \rho").shift(UP*0.4) ) 29 | stuff.append( Tex(r"\text{Krauss Operators: } \sum_k B_k^*B_k = \mathbb{I}").shift(DOWN*0.7) ) 30 | stuff.append( Tex(r"\text{Quantum Operation: } \Phi(\rho) = \sum_k B_k^* \rho B_k").shift(DOWN*1.8) ) 31 | stuff.append( Tex(r"\text{Quantum Channel only transmits Quantum Information: } \Phi").shift(DOWN*2.7) ) 32 | stuff.append( Tex(r"\text{(Schrödinger picture) Does not send classical info, only quantum }").shift(DOWN*3.3) ) 33 | for i in stuff: 34 | self.play(FadeIn(i)) 35 | waiter(7) 36 | self.play(FadeOut(Group(*stuff))) 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | stuff = [] 51 | #stuff.append( Tex(r"").shift(DOWN*2) ) 52 | stuff.append( Group(Tex(r"\text{Let } H_A \text{ and } H_B \text{ be state spaces where}").shift(UP*2.7), Tex(r"\text{information can be transmitted and recieved: } H_A \to H_B").shift(UP*2.1)) ) 53 | stuff.append( Tex(r"\text{Properties of } \Phi").shift(UP*1.2 + LEFT*1.5) ) 54 | stuff.append( Tex(r"\text{1. } \Phi \text{ is linear}").shift(UP*0.5) ) 55 | stuff.append( Tex(r"\text{2. } \Phi \text{ is a positive map}").shift(DOWN*0.5) ) 56 | stuff.append( Tex(r"\text{3. } \Phi \text{ preserves trace} \to Tr(\Phi(\rho)) = Tr(\rho)").shift(DOWN*1.5) ) 57 | stuff.append( Tex(r"\text{4. When } dim(H_A) < dim(H_B): \mathbb{I}_n \otimes \Phi \text{ is a positive map}").shift(DOWN*2.5) ) 58 | for i in stuff: 59 | self.play(FadeIn(i)) 60 | waiter(7) 61 | self.play(FadeOut(Group(*stuff))) 62 | 63 | 64 | 65 | stuff = [] 66 | #stuff.append( Tex(r"").shift(DOWN*2) ) 67 | stuff.append( Tex(r"\text{Let } L(H_A) \text{ be a family of linear maps on } H_A").shift(UP*2.5) ) 68 | stuff.append( Tex(r"\Psi : L(H_A) \to L(H_B)").shift(UP*1.5) ) 69 | stuff.append( Tex(r"\text{Now we Include Classical Information}").shift(UP*0) ) 70 | stuff.append( Tex(r"\Psi : L(H_A) \otimes C(X) \to L(H_B)").shift(DOWN*1) ) 71 | for i in stuff: 72 | self.play(FadeIn(i)) 73 | waiter(7) 74 | self.play(FadeOut(Group(*stuff))) 75 | 76 | 77 | 78 | 79 | stuff = [] 80 | #stuff.append( Tex(r"").shift(DOWN*2) ) 81 | stuff.append( Tex(r"\text{Time Evolution: } \rho \to \Phi(\rho) = U_t\rho U_t^*").shift(UP*2.5) ) 82 | stuff.append( Tex(r"\text{Error Correction: } \Phi_{BF} = \{ \Phi_1, \Phi_2 \}").shift(UP*1.5) ) 83 | stuff.append( Group(Tex(r"\Phi_1 = \sqrt{p} \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} ").shift(UP*0 + LEFT*2), Tex(r"\Phi_2 = \sqrt{1-p} \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} ").shift(UP*0 + RIGHT*2)) ) 84 | stuff.append( Tex(r"\Phi(\rho) = \Phi_1(\rho) + \Phi_2(\rho) = \sqrt{p} \ \ \mathbb{I}\rho\mathbb{I}^* + \sqrt{1-p} \ \ X\rho X^*").shift(DOWN*1.5) ) 85 | stuff.append( Tex(r"\text{Quantum Teleportation}").shift(DOWN*3) ) 86 | for i in stuff: 87 | self.play(FadeIn(i)) 88 | waiter(7) 89 | self.play(FadeOut(Group(*stuff))) 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | title2 = Text("Channel Capacity").shift(UP*3.5) 102 | self.play(Transform(title, title2)) 103 | 104 | 105 | stuff = [] 106 | #stuff.append( Tex(r"").shift(DOWN*2) ) 107 | stuff.append( Tex(r"\text{How many (Qu)bits can be sent through 1 use of the channel?}").shift(UP*2.5) ) 108 | stuff.append( Tex(r"Alice \stackrel{N}{\to} Bob").shift(UP*1).scale(2) ) 109 | stuff.append( Tex(r"\text{Capacity: } C(N) = \max_{p(X)} I(A:B)").shift(DOWN*1) ) 110 | stuff.append( Tex(r"\text{Just a classical channel}").shift(DOWN*3) ) 111 | for i in stuff: 112 | self.play(FadeIn(i)) 113 | waiter(7) 114 | self.play(FadeOut(Group(*stuff))) 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | stuff = [] 123 | #stuff.append( Tex(r"").shift(DOWN*2) ) 124 | stuff.append( Group(Tex(r"\text{Clasical Channel } N").shift(UP*2 + LEFT*3.75).scale(1.5), Tex(r"\text{Classical Capacity}").shift(UP*0.5 + LEFT*4), Tex(r"C(N)").shift(UP*1 + LEFT*4) ) ) 125 | stuff.append( Tex(r"\text{Quantum Channel } \mathbb{N}").shift(UP*2 + RIGHT*3.5).scale(1.5) ) 126 | stuff.append( Tex(r"\text{Classical Capacity } C(\mathbb{N})").shift(DOWN*-0.5 + RIGHT*4) ) 127 | stuff.append( Tex(r"\text{Quantum Capacity } Q(\mathbb{N})").shift(DOWN*0.5 + RIGHT*4) ) 128 | stuff.append( Tex(r"\text{Private Classical Capacity } P(\mathbb{N})").shift(DOWN*1.5 + RIGHT*3.25) ) 129 | stuff.append( Tex(r"\text{Entanglement Assisted Classical Capacity } C_E(\mathbb{N})").shift(DOWN*2.5 + RIGHT*1.5) ) 130 | for i in stuff: 131 | self.play(FadeIn(i)) 132 | waiter(7) 133 | waiter(10) 134 | #self.play(FadeOut(Group(*stuff))) 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section9/Lecture2/locc.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("LOCC, Entanglement Swapping").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class locc(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("LOCC, Entanglement Swapping").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("LOCC").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | #stuff.append( Tex(r"").shift(DOWN*2) ) 26 | stuff.append( Tex(r"\text{Local Operations and Classical Communication }").shift(UP*2.5) ) 27 | stuff.append( Tex(r"\stackrel{Local}{Quantum} \ \ \stackrel{Classical}{\to} \ \ \stackrel{Local}{Quantum}").shift(DOWN*0).scale(2) ) 28 | stuff.append( Tex(r"\text{Quantum Teleportation }").shift(DOWN*2.5) ) 29 | 30 | for i in stuff: 31 | self.play(FadeIn(i)) 32 | waiter(7) 33 | self.play(FadeOut(Group(*stuff))) 34 | 35 | 36 | 37 | 38 | 39 | stuff = [] 40 | #stuff.append( Tex(r"").shift(DOWN*2) ) 41 | stuff.append( Tex(r"\text{Alice and Bob share a bell state, 1 qubit each}").shift(UP*2.5) ) 42 | stuff.append( Group(Tex(r"\ket{\Psi_0} = \frac{1}{\sqrt{(2})} \bigg( \ket{00} + \ket{11} \bigg) ").shift(DOWN*-1.5 + LEFT*3.5), Tex(r"\ket{\Psi_1} = \frac{1}{\sqrt{(2})} \bigg( \ket{01} + \ket{10} \bigg) ").shift(DOWN*-1.5 + RIGHT*3.5)) ) 43 | stuff.append( Tex(r"\text{Alice measures 0: Could be either} \to \text{Classical Channel}").shift(DOWN*0) ) 44 | stuff.append( Tex(r"\text{Bob measures 1: } \ket{\Psi_1} \to \text{Success from LOCC}").shift(DOWN*0.8) ) 45 | stuff.append( Tex(r"\text{Entire Process: LOCC Operation } LOCC_1").shift(DOWN*1.6) ) 46 | stuff.append( Tex(r"LOCC_1 \subset LOCC_r \subset LOCC_{r+1} \subset LOCC_{\mathbb{N}}").shift(DOWN*2.3) ) 47 | stuff.append( Tex(r"\text{What can you do with LOCC? - LOCC Protocols}").shift(DOWN*3.3) ) 48 | for i in stuff: 49 | self.play(FadeIn(i)) 50 | waiter(7) 51 | self.play(FadeOut(Group(*stuff))) 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | title2 = Text("LOCC Protocols").shift(UP*3.5) 60 | self.play(Transform(title, title2)) 61 | 62 | 63 | stuff = [] 64 | #stuff.append( Tex(r"").shift(DOWN*2) ) 65 | stuff.append( Tex(r"\text{1. State Preparation}").shift(UP*1.5) ) 66 | stuff.append( Tex(r"\text{2. State Discrimination}").shift(UP*0.5) ) 67 | stuff.append( Tex(r"\text{3. Entanglement Conversion}").shift(UP*-0.5) ) 68 | 69 | for i in stuff: 70 | self.play(FadeIn(i)) 71 | waiter(7) 72 | self.play(FadeOut(Group(*stuff))) 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | title2 = Text("Entanglement Swapping").shift(UP*3.5) 86 | self.play(Transform(title, title2)) 87 | 88 | 89 | stuff = [] 90 | #stuff.append( Tex(r"").shift(DOWN*2) ) 91 | stuff.append( Tex(r"Alice").shift(UP*1.5 + LEFT*4) ) 92 | stuff.append( Tex(r"Bob").shift(UP*1.5 + RIGHT*4) ) 93 | 94 | 95 | stuff.append( Dot().shift(LEFT*2 + UP*2).scale(3).set_color(RED) ) 96 | stuff.append( Dot().shift(RIGHT*2 + UP*2).scale(3).set_color(RED) ) 97 | stuff.append( Dot().shift(LEFT*2 + UP*1).scale(3).set_color(BLUE) ) 98 | stuff.append( Dot().shift(RIGHT*2 + UP*1).scale(3).set_color(BLUE) ) 99 | 100 | stuff.append( Tex(r"1").shift(LEFT*2.5 + UP*2.2) ) 101 | stuff.append( Tex(r"2").shift(RIGHT*2.5 + UP*2.2) ) 102 | stuff.append( Tex(r"3").shift(RIGHT*2.5 + UP*1.2) ) 103 | stuff.append( Tex(r"4").shift(LEFT*2.5 + UP*1.2) ) 104 | 105 | stuff.append( Line(np.array([-2, 2, 0]), np.array([2, 2, 0])) ) 106 | stuff.append( Line(np.array([-2, 1, 0]), np.array([2, 1, 0])) ) 107 | for i in stuff: 108 | self.play(FadeIn(i)) 109 | 110 | 111 | stuff2 = [] 112 | #stuff.append( Tex(r"").shift(DOWN*2) ) 113 | stuff2.append( Tex(r"1. \ \ \ \ CNOT_{\{2, 3\} }").shift(DOWN*0.4).scale(1.3) ) 114 | stuff2.append( Tex(r"2. \ \ \ \ CNOT_{\{3, 2\} }").shift(DOWN*1.2).scale(1.3) ) 115 | stuff2.append( Tex(r"3. \ \ \ \ CNOT_{\{1, 4\} }").shift(DOWN*2).scale(1.3) ) 116 | 117 | for i in stuff2: 118 | self.play(FadeIn(i)) 119 | waiter(5) 120 | self.play(FadeOut(stuff[-1]), FadeOut(stuff[-2])) 121 | 122 | 123 | 124 | stuff3 = [] 125 | #stuff.append( Tex(r"").shift(DOWN*2) ) 126 | stuff3.append( Line(np.array([-2, 2, 0]), np.array([2, 1, 0])).set_color(YELLOW) ) 127 | stuff3.append( Line(np.array([-2, 1, 0]), np.array([2, 2, 0])).set_color(YELLOW) ) 128 | stuff3.append( Tex(r"\text{Completely LOCC!! No Qubits Transfered, Only Bits!}").shift(DOWN*3.3) ) 129 | for i in stuff3: 130 | self.play(FadeIn(i)) 131 | waiter(15) 132 | #self.play(FadeOut(Group(*stuff))) 133 | 134 | 135 | 136 | 137 | 138 | 139 | -------------------------------------------------------------------------------- /QuantumComputingManimGL/Section9/Lecture4/key.py: -------------------------------------------------------------------------------- 1 | from manimlib import * 2 | import numpy as np 3 | import random 4 | 5 | class FirstScene(Scene): 6 | def construct(self): 7 | text = Text("Quantum Key Distribution").scale(0.9) 8 | self.play(FadeIn(text)) 9 | self.wait(3) 10 | class key(Scene): 11 | def construct(self): 12 | wait = True 13 | def waiter(n): 14 | if (wait == True): 15 | self.wait(n) 16 | text = Text("Quantum Key Distribution").scale(1.0) 17 | self.play(FadeIn(text)) 18 | waiter(4) 19 | self.play(FadeOut(text)) 20 | title = Text("Quantum Key Distribution").shift(UP*3.5) 21 | self.play(FadeIn(title)) 22 | 23 | 24 | stuff = [] 25 | thesetter = Group(Tex(r"Alice").shift(LEFT*6), Tex(r"Bob").shift(RIGHT*6), Dot().shift(LEFT*4.5).scale(1), Dot().shift(RIGHT*4.5).scale(1), Dot().shift(LEFT*0.25).scale(1), Dot().shift(RIGHT*0.25).scale(1), Line(np.array([0.25, 0, 0]), np.array([4.5, 0, 0])), Line(np.array([-4.5, 0, 0]), np.array([-0.25, 0, 0])) ) 26 | theclassicaller = Group(Dot().shift(LEFT*4.5 + UP*1).scale(1).set_color(ORANGE), Dot().shift(RIGHT*4.5 + UP*1).scale(1).set_color(ORANGE), Line(np.array([-4.5, 1, 0]), np.array([4.5, 1, 0])).set_color(ORANGE) ) 27 | 28 | 29 | #stuff.append( Tex(r"").shift(DOWN*2) ) 30 | stuff.append( Tex(r"\text{BB84 Protocol}").shift(UP*2.7) ) 31 | stuff.append( thesetter.shift(UP*2) ) 32 | stuff.append( Group(Dot().shift(LEFT*0.25 + UP*2).scale(3).set_color(BLUE), Dot().shift(RIGHT*0.25 + UP*2).scale(3).set_color(BLUE)) ) 33 | stuff.append( theclassicaller.shift(UP*0.5) ) 34 | for i in stuff: 35 | self.play(FadeIn(i)) 36 | #self.play(FadeOut(Group(*stuff))) 37 | 38 | stuff2 = [] 39 | #stuff.append( Tex(r"").shift(DOWN*2) ) 40 | stuff2.append( Tex(r"\text{Measure Z: } \ket{0} or \ket{1} \to \{1,-1\}").shift(DOWN*-1 + LEFT*3.5) ) 41 | stuff2.append( Tex(r"\text{Measure X: } \ket{+} or \ket{-} \to \{1,-1\}").shift(DOWN*-1 + RIGHT*3.5) ) 42 | stuff2.append( Tex(r"\ket{\psi} \quad \text{Measure ZZXZXX: } \to \ket{10+1--} \to [-1, 1, 1, -1, -1, -1]").shift(DOWN*-0.3).scale(0.9) ) 43 | stuff2.append( Tex(r"\text{Encode X and Z: } \ket{\psi} = \ket{+1-+00}").shift(DOWN*0.4) ) 44 | stuff2.append( Tex(r"\text{Measure ZZZZZZ: } \ket{011000} \ \ \ket{110100} \ \ \ket{010100}").shift(DOWN*1.1) ) 45 | stuff2.append( Tex(r"\text{Measure ZZZZZZ: } \ket{p1pp00} \to 100").shift(DOWN*1.8) ) 46 | stuff2.append( Tex(r"\text{Measure XZZXZX: } \ket{+11+0-} \ \ \ket{+10+0-} \ \ \ket{+11+0+}").shift(DOWN*2.5) ) 47 | stuff2.append( Tex(r"\text{Measure XZZXZX: } \ket{+1p+0p} \to +1+0").shift(DOWN*3.3) ) 48 | for i in stuff2: 49 | self.play(FadeIn(i)) 50 | waiter(6) 51 | self.play(FadeOut(Group(*stuff2))) 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | step1 = Tex(r"\text{1. Encoding Qubit w/ Random Basis XZXZZZ: } \ket{-0+1-1}").shift(DOWN*-0.2) 61 | self.play(FadeIn(step1)) 62 | waiter(3) 63 | 64 | #send qubit 65 | qubit = Dot().shift(LEFT*4.5 + UP*2).scale(3).set_color(RED) 66 | self.play(FadeIn(qubit)) 67 | qubit.generate_target() 68 | qubit.target.shift(RIGHT*4.25) 69 | self.play(MoveToTarget(qubit)) 70 | self.remove(stuff[-2], qubit) 71 | qubit.shift(RIGHT*0.5) 72 | self.add(qubit) 73 | qubit.target.shift(RIGHT*4.75) 74 | self.play(MoveToTarget(qubit)) 75 | self.wait(0.5) 76 | self.remove(qubit) 77 | 78 | step2 = Tex(r"\text{2. Choose Random Basis to Measure ZXXZXZ: } \ket{-0+1-1} \to \ket{0++1-1}").shift(DOWN*0.6).scale(0.8) 79 | self.play(FadeIn(step2)) 80 | waiter(7) 81 | step3 = Tex(r"\text{3. Send Measurement Basis via Classical Channel: } ZXXZXZ \to Alice").shift(DOWN*1.4).scale(0.9) 82 | self.play(FadeIn(step3)) 83 | 84 | waiter(3) 85 | #send basis 86 | basis = Text(r"ZXXZXZ").shift(RIGHT*4.5 + UP*1.5).scale(0.7).set_color(RED) 87 | self.play(FadeIn(basis)) 88 | basis.generate_target() 89 | basis.target.shift(LEFT*9) 90 | self.play(MoveToTarget(basis, run_time=10)) 91 | self.wait(0.5) 92 | 93 | 94 | step4 = Tex(r"\text{4. Send Incorrect Basis for Removal } --XZXZ").shift(DOWN*2.2) 95 | self.play(FadeIn(step4)) 96 | waiter(6) 97 | self.remove(basis) 98 | basis = Text(r"--XZXZ").shift(LEFT*4.5 + UP*1.5).scale(0.7).set_color(BLUE) 99 | self.add(basis) 100 | basis.generate_target() 101 | basis.target.shift(RIGHT*9) 102 | self.play(MoveToTarget(basis, run_time=10)) 103 | self.wait(0.5) 104 | 105 | 106 | 107 | 108 | step5 = Tex(r"\text{5. Alice and Bob now have Secret Key: } +1-1").shift(DOWN*3) 109 | self.play(FadeIn(step5)) 110 | waiter(1) 111 | hw = Tex(r"\text{Homework: Implement in Qiskit! }").shift(UP*1).scale(0.8) 112 | self.play(FadeIn(hw)) 113 | 114 | waiter(15) 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section0/Lecture2/Intro.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Essentials" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "pip install numpy" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "pip install scipy" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "metadata": {}, 27 | "source": [ 28 | "pip install matplotlib" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "pip install qiskit" 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "## Quantum Optics" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "pip install strawberryfields" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "## Quantum Optics & Machine Learning" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "pip install scikit-learn" 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "pip install tensorflow" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "pip install qiskit-nature" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "pip install pennylane" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "## Miscellaneous" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "pip install networkx" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src" 106 | ] 107 | } 108 | ], 109 | "metadata": { 110 | "kernelspec": { 111 | "display_name": "Python 3", 112 | "language": "python", 113 | "name": "python3" 114 | }, 115 | "language_info": { 116 | "codemirror_mode": { 117 | "name": "ipython", 118 | "version": 3 119 | }, 120 | "file_extension": ".py", 121 | "mimetype": "text/x-python", 122 | "name": "python", 123 | "nbconvert_exporter": "python", 124 | "pygments_lexer": "ipython3", 125 | "version": "3.7.6" 126 | } 127 | }, 128 | "nbformat": 4, 129 | "nbformat_minor": 4 130 | } 131 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section1/Lecture1/vector.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 96, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 128, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "a = 1 + 1j\n", 19 | "b = 1 - 1j" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 129, 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [ 28 | "x = np.array([a, b])" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 130, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "def normalize(vector):\n", 38 | " def coeffLength(coeff):\n", 39 | " return np.real(coeff*np.conj(coeff))\n", 40 | " def totalLength():\n", 41 | " sum = 0\n", 42 | " for i in vector:\n", 43 | " sum += coeffLength(i)\n", 44 | " return sum**(0.5)\n", 45 | " totalSum = np.array(totalLength())\n", 46 | " return vector/totalSum" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 131, 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "text/plain": [ 57 | "array([0.5+0.5j, 0.5-0.5j])" 58 | ] 59 | }, 60 | "execution_count": 131, 61 | "metadata": {}, 62 | "output_type": "execute_result" 63 | } 64 | ], 65 | "source": [ 66 | "normalize(x)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 132, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "#inner product" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 153, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "def innerproduct(A, B):\n", 85 | " return np.transpose(np.matrix(A).getH()*B)" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 154, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "data": { 95 | "text/plain": [ 96 | "matrix([[2.+0.j, 0.+2.j],\n", 97 | " [0.-2.j, 2.+0.j]])" 98 | ] 99 | }, 100 | "execution_count": 154, 101 | "metadata": {}, 102 | "output_type": "execute_result" 103 | } 104 | ], 105 | "source": [ 106 | "innerproduct(x, x)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | } 116 | ], 117 | "metadata": { 118 | "kernelspec": { 119 | "display_name": "Python 3", 120 | "language": "python", 121 | "name": "python3" 122 | }, 123 | "language_info": { 124 | "codemirror_mode": { 125 | "name": "ipython", 126 | "version": 3 127 | }, 128 | "file_extension": ".py", 129 | "mimetype": "text/x-python", 130 | "name": "python", 131 | "nbconvert_exporter": "python", 132 | "pygments_lexer": "ipython3", 133 | "version": "3.7.6" 134 | } 135 | }, 136 | "nbformat": 4, 137 | "nbformat_minor": 4 138 | } 139 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section1/Lecture3/lorthoin.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 6, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 7, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "a = 1 + 1j\n", 19 | "b = 1 - 1j" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 8, 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [ 28 | "x = np.array([a, b])" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 9, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "def normalize(vector):\n", 38 | " def coeffLength(coeff):\n", 39 | " return np.real(coeff*np.conj(coeff))\n", 40 | " def totalLength():\n", 41 | " sum = 0\n", 42 | " for i in vector:\n", 43 | " sum += coeffLength(i)\n", 44 | " return sum**(0.5)\n", 45 | " totalSum = np.array(totalLength())\n", 46 | " return vector/totalSum" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 10, 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "text/plain": [ 57 | "array([0.5+0.5j, 0.5-0.5j])" 58 | ] 59 | }, 60 | "execution_count": 10, 61 | "metadata": {}, 62 | "output_type": "execute_result" 63 | } 64 | ], 65 | "source": [ 66 | "normalize(x)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 11, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "#inner product, #outerproduct" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 14, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "def innerproduct(A, B):\n", 85 | " return B*np.matrix(A).getH()" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 24, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stdout", 95 | "output_type": "stream", 96 | "text": [ 97 | "[[4.+0.j]]\n" 98 | ] 99 | } 100 | ], 101 | "source": [ 102 | "print(innerproduct(x, x))" 103 | ] 104 | }, 105 | { 106 | "cell_type": "code", 107 | "execution_count": 18, 108 | "metadata": {}, 109 | "outputs": [], 110 | "source": [ 111 | "def outerproduct(A, B):\n", 112 | " return np.transpose(np.matrix(A).getH()*B)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 19, 118 | "metadata": {}, 119 | "outputs": [ 120 | { 121 | "data": { 122 | "text/plain": [ 123 | "matrix([[2.+0.j, 0.+2.j],\n", 124 | " [0.-2.j, 2.+0.j]])" 125 | ] 126 | }, 127 | "execution_count": 19, 128 | "metadata": {}, 129 | "output_type": "execute_result" 130 | } 131 | ], 132 | "source": [ 133 | "outerproduct(x, x)" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": null, 139 | "metadata": {}, 140 | "outputs": [], 141 | "source": [ 142 | "#linearly indep orthogonal" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 103, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [ 151 | "matrix = np.array(\n", 152 | " [\n", 153 | " [0, 1 ,5 ,20, 6],\n", 154 | " [3, 0, 4, 15, 6],\n", 155 | " [0, 1, 9, 36, 6],\n", 156 | " [1, 7, 0, 0, 6]\n", 157 | " ])" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 98, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "vectorA = np.array([1, 1j])\n", 167 | "vectorB = np.array([1j, 1])" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": 99, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [ 176 | "def isLinIndep(M):\n", 177 | " return (M.shape[1] == np.linalg.matrix_rank(M))" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 100, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "data": { 187 | "text/plain": [ 188 | "True" 189 | ] 190 | }, 191 | "execution_count": 100, 192 | "metadata": {}, 193 | "output_type": "execute_result" 194 | } 195 | ], 196 | "source": [ 197 | "isLinIndep(matrix)" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 101, 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [ 206 | "def isOrtho(A, B):\n", 207 | " return (innerproduct(A, B) == 0)" 208 | ] 209 | }, 210 | { 211 | "cell_type": "code", 212 | "execution_count": 102, 213 | "metadata": {}, 214 | "outputs": [ 215 | { 216 | "data": { 217 | "text/plain": [ 218 | "matrix([[ True]])" 219 | ] 220 | }, 221 | "execution_count": 102, 222 | "metadata": {}, 223 | "output_type": "execute_result" 224 | } 225 | ], 226 | "source": [ 227 | "isOrtho(vectorA, vectorB)" 228 | ] 229 | }, 230 | { 231 | "cell_type": "code", 232 | "execution_count": null, 233 | "metadata": {}, 234 | "outputs": [], 235 | "source": [] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": {}, 241 | "outputs": [], 242 | "source": [] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": null, 254 | "metadata": {}, 255 | "outputs": [], 256 | "source": [] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": null, 261 | "metadata": {}, 262 | "outputs": [], 263 | "source": [] 264 | } 265 | ], 266 | "metadata": { 267 | "kernelspec": { 268 | "display_name": "Python 3", 269 | "language": "python", 270 | "name": "python3" 271 | }, 272 | "language_info": { 273 | "codemirror_mode": { 274 | "name": "ipython", 275 | "version": 3 276 | }, 277 | "file_extension": ".py", 278 | "mimetype": "text/x-python", 279 | "name": "python", 280 | "nbconvert_exporter": "python", 281 | "pygments_lexer": "ipython3", 282 | "version": "3.7.6" 283 | } 284 | }, 285 | "nbformat": 4, 286 | "nbformat_minor": 4 287 | } 288 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section1/vector.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 2, 15 | "metadata": {}, 16 | "outputs": [], 17 | "source": [ 18 | "a = 1 + 1j\n", 19 | "b = 1 - 1j" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 3, 25 | "metadata": {}, 26 | "outputs": [], 27 | "source": [ 28 | "x = np.array([a, b])" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 4, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "def normalize(vector):\n", 38 | " def coeffLength(coeff):\n", 39 | " return np.real(coeff*np.conj(coeff))\n", 40 | " def totalLength():\n", 41 | " sum = 0\n", 42 | " for i in vector:\n", 43 | " sum += coeffLength(i)\n", 44 | " return sum**(0.5)\n", 45 | " totalSum = np.array(totalLength())\n", 46 | " return vector/totalSum" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 5, 52 | "metadata": {}, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "text/plain": [ 57 | "array([0.5+0.5j, 0.5-0.5j])" 58 | ] 59 | }, 60 | "execution_count": 5, 61 | "metadata": {}, 62 | "output_type": "execute_result" 63 | } 64 | ], 65 | "source": [ 66 | "normalize(x)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 6, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [ 75 | "#inner product, #outerproduct" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 7, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "def innerproduct(A, B):\n", 85 | " return B*np.matrix(A).getH()" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 8, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "data": { 95 | "text/plain": [ 96 | "matrix([[4.+0.j]])" 97 | ] 98 | }, 99 | "execution_count": 8, 100 | "metadata": {}, 101 | "output_type": "execute_result" 102 | } 103 | ], 104 | "source": [ 105 | "innerproduct(x, x)" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 9, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [ 114 | "def outerproduct(A, B):\n", 115 | " return np.transpose(np.matrix(A).getH()*B)" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 10, 121 | "metadata": {}, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "text/plain": [ 126 | "matrix([[2.+0.j, 0.+2.j],\n", 127 | " [0.-2.j, 2.+0.j]])" 128 | ] 129 | }, 130 | "execution_count": 10, 131 | "metadata": {}, 132 | "output_type": "execute_result" 133 | } 134 | ], 135 | "source": [ 136 | "outerproduct(x, x)" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 11, 142 | "metadata": { 143 | "scrolled": true 144 | }, 145 | "outputs": [], 146 | "source": [ 147 | "import qiskit" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [] 170 | } 171 | ], 172 | "metadata": { 173 | "kernelspec": { 174 | "display_name": "Python 3", 175 | "language": "python", 176 | "name": "python3" 177 | }, 178 | "language_info": { 179 | "codemirror_mode": { 180 | "name": "ipython", 181 | "version": 3 182 | }, 183 | "file_extension": ".py", 184 | "mimetype": "text/x-python", 185 | "name": "python", 186 | "nbconvert_exporter": "python", 187 | "pygments_lexer": "ipython3", 188 | "version": "3.8.8" 189 | } 190 | }, 191 | "nbformat": 4, 192 | "nbformat_minor": 4 193 | } 194 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section2/Lecture11/ALU.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "from IPython.core.display import display, HTML\n", 10 | "display(HTML(\"\"))" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "import numpy as np\n", 20 | "from qiskit import *\n", 21 | "%matplotlib inline\n", 22 | "from math import pi, sqrt\n", 23 | "import random" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 2, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "backend = Aer.get_backend('statevector_simulator')\n", 33 | "def getBloch(quantumC):\n", 34 | " return visualization.plot_bloch_multivector(execute(quantumC, backend).\n", 35 | " result().get_statevector())" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 3, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "def stateGenerator(state):\n", 45 | " state = state[::-1]\n", 46 | " current = int(state, 2)\n", 47 | " newState = [0 for i in range(0, 2**(len(state)))]\n", 48 | " newState[current] = 1\n", 49 | " return newState" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 4, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "def getMeasure(quantumC, n):\n", 59 | " measures = []\n", 60 | " for i in range(0, n):\n", 61 | " outcome = execute(quantumC, backend).result()\n", 62 | " hist = outcome.get_counts()\n", 63 | " for i in hist.keys():\n", 64 | " measures.append(i)\n", 65 | " return measures" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 5, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "def makeALUCirc(n, op, inp):\n", 75 | " initState = op + inp\n", 76 | " print(initState)\n", 77 | " qr = QuantumRegister(n)\n", 78 | " qc = ClassicalRegister(n)\n", 79 | " circ = QuantumCircuit(qr, qc)\n", 80 | " initializedState = stateGenerator(initState)\n", 81 | " circ.initialize(initializedState, qr)\n", 82 | " return circ" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": 6, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [ 91 | "opLUT = {'+': '11000',\n", 92 | " '-': '11100',\n", 93 | " 'xor': '10000',\n", 94 | " 'xnor': '10100',\n", 95 | " 'nop': '00000',\n", 96 | " '+1': '11010',\n", 97 | " '-1': '11111',\n", 98 | " 'neg': '00100',\n", 99 | " }\n", 100 | "#Look Up Table - FPGA, Dictionary in Python" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": 7, 106 | "metadata": {}, 107 | "outputs": [], 108 | "source": [ 109 | "def performOp(inp1, inp2, op):\n", 110 | " circuit = makeALUCirc(7, opLUT[op], str(inp1) + str(inp2))\n", 111 | " circuit.csx(0, 6)\n", 112 | " circuit.csx(5, 6)\n", 113 | " circuit.cx(0, 5)\n", 114 | " circuit.crx(-pi/2, 5, 6)\n", 115 | " circuit.cx(0, 5)\n", 116 | " circuit.csx(1, 6)\n", 117 | " circuit.csx(3, 6)\n", 118 | " circuit.cx(1, 3)\n", 119 | " circuit.crx(-pi/2, 3, 6)\n", 120 | " circuit.cx(2, 6)\n", 121 | " circuit.cx(4, 6)\n", 122 | " circuit.measure(6, 6)\n", 123 | " return getMeasure(circuit, 1)[0][0]" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 27, 129 | "metadata": {}, 130 | "outputs": [ 131 | { 132 | "name": "stdout", 133 | "output_type": "stream", 134 | "text": [ 135 | "0000010\n" 136 | ] 137 | }, 138 | { 139 | "data": { 140 | "text/plain": [ 141 | "'0'" 142 | ] 143 | }, 144 | "execution_count": 27, 145 | "metadata": {}, 146 | "output_type": "execute_result" 147 | } 148 | ], 149 | "source": [ 150 | "performOp(1, 0, 'nop')" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": null, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": null, 170 | "metadata": {}, 171 | "outputs": [], 172 | "source": [] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": null, 184 | "metadata": {}, 185 | "outputs": [], 186 | "source": [] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [] 194 | } 195 | ], 196 | "metadata": { 197 | "kernelspec": { 198 | "display_name": "Python 3", 199 | "language": "python", 200 | "name": "python3" 201 | }, 202 | "language_info": { 203 | "codemirror_mode": { 204 | "name": "ipython", 205 | "version": 3 206 | }, 207 | "file_extension": ".py", 208 | "mimetype": "text/x-python", 209 | "name": "python", 210 | "nbconvert_exporter": "python", 211 | "pygments_lexer": "ipython3", 212 | "version": "3.7.6" 213 | } 214 | }, 215 | "nbformat": 4, 216 | "nbformat_minor": 4 217 | } 218 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section2/Lecture4/muxer.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "from IPython.core.display import display, HTML\n", 10 | "display(HTML(\"\"))" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": null, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "import numpy as np\n", 20 | "from qiskit import *\n", 21 | "%matplotlib inline\n", 22 | "from math import pi, sqrt\n", 23 | "import random" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": null, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "backend = Aer.get_backend('statevector_simulator')\n", 33 | "def getBloch(quantumC):\n", 34 | " return visualization.plot_bloch_multivector(execute(quantumC, backend).\n", 35 | " result().get_statevector())" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "def stateGenerator(state):\n", 45 | " state = state[::-1]\n", 46 | " current = int(state, 2)\n", 47 | " newState = [0 for i in range(0, 2**(len(state)))]\n", 48 | " newState[current] = 1\n", 49 | " return newState" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "def getMeasure(quantumC, n):\n", 59 | " measures = []\n", 60 | " for i in range(0, n):\n", 61 | " outcome = execute(circ, backend).result()\n", 62 | " hist = outcome.get_counts()\n", 63 | " for i in hist.keys():\n", 64 | " measures.append(i)\n", 65 | " return measures" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "def makeCirc(n, m):\n", 75 | " initState = ''\n", 76 | " for i in range(0, n-m):\n", 77 | " initState += str(random.randint(0, 1))\n", 78 | " for i in range(0, m):\n", 79 | " initState += str(0)\n", 80 | " print(initState)\n", 81 | " qr = QuantumRegister(n)\n", 82 | " qc = ClassicalRegister(n)\n", 83 | " circ = QuantumCircuit(qr, qc)\n", 84 | " initializedState = stateGenerator(initState)\n", 85 | " circ.initialize(initializedState, qr)\n", 86 | " return circ" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "circ = makeCirc(6, 0)\n", 96 | "#getBloch(circ)" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [] 147 | } 148 | ], 149 | "metadata": { 150 | "kernelspec": { 151 | "display_name": "Python 3", 152 | "language": "python", 153 | "name": "python3" 154 | }, 155 | "language_info": { 156 | "codemirror_mode": { 157 | "name": "ipython", 158 | "version": 3 159 | }, 160 | "file_extension": ".py", 161 | "mimetype": "text/x-python", 162 | "name": "python", 163 | "nbconvert_exporter": "python", 164 | "pygments_lexer": "ipython3", 165 | "version": "3.7.6" 166 | } 167 | }, 168 | "nbformat": 4, 169 | "nbformat_minor": 4 170 | } 171 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section2/Lecture9/ShifterRotator.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "from IPython.core.display import display, HTML\n", 10 | "display(HTML(\"\"))" 11 | ] 12 | }, 13 | { 14 | "cell_type": "code", 15 | "execution_count": 1, 16 | "metadata": {}, 17 | "outputs": [], 18 | "source": [ 19 | "import numpy as np\n", 20 | "from qiskit import *\n", 21 | "%matplotlib inline\n", 22 | "from math import pi, sqrt\n", 23 | "import random" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 2, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "backend = Aer.get_backend('statevector_simulator')\n", 33 | "def getBloch(quantumC):\n", 34 | " return visualization.plot_bloch_multivector(execute(quantumC, backend).\n", 35 | " result().get_statevector())" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 3, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [ 44 | "def stateGenerator(state):\n", 45 | " state = state[::-1]\n", 46 | " current = int(state, 2)\n", 47 | " newState = [0 for i in range(0, 2**(len(state)))]\n", 48 | " newState[current] = 1\n", 49 | " return newState" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 4, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [ 58 | "def getMeasure(quantumC, n):\n", 59 | " measures = []\n", 60 | " for i in range(0, n):\n", 61 | " outcome = execute(quantumC, backend).result()\n", 62 | " hist = outcome.get_counts()\n", 63 | " for i in hist.keys():\n", 64 | " measures.append(i)\n", 65 | " return measures" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 5, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "def makeCirc3(n, m, o, inp=None):\n", 75 | " initState = ''\n", 76 | " for i in range(0, o):\n", 77 | " initState += str(1)\n", 78 | " if inp != None:\n", 79 | " initState = inp\n", 80 | " else:\n", 81 | " for i in range(0, n-o-m):\n", 82 | " initState += str(random.randint(0, 1))\n", 83 | " for i in range(0, m):\n", 84 | " initState += str(0)\n", 85 | " print(initState)\n", 86 | " qr = QuantumRegister(n)\n", 87 | " qc = ClassicalRegister(n)\n", 88 | " circ = QuantumCircuit(qr, qc)\n", 89 | " initializedState = stateGenerator(initState)\n", 90 | " circ.initialize(initializedState, qr)\n", 91 | " return circ" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 27, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "def shifterCircuitMaker(n, inp=None):\n", 101 | " shifterCircuit = makeCirc3(n, 0, 1, inp)\n", 102 | " for i in range(0, n-2):\n", 103 | " shifterCircuit.cswap(0, i+1, i+2)\n", 104 | " for i in range(0, n-1):\n", 105 | " shifterCircuit.measure(i, i)\n", 106 | " return shifterCircuit" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 28, 112 | "metadata": {}, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "111110011111\n" 119 | ] 120 | } 121 | ], 122 | "source": [ 123 | "shiftCircuit = shifterCircuitMaker(12)" 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": 29, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [ 132 | "def applyShift(circ, n):\n", 133 | " result = getMeasure(circ, 1)[0][::-1]\n", 134 | " return shifterCircuitMaker(n, result)" 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": 30, 140 | "metadata": {}, 141 | "outputs": [ 142 | { 143 | "name": "stdout", 144 | "output_type": "stream", 145 | "text": [ 146 | "111100111110\n", 147 | "111001111100\n", 148 | "110011111000\n", 149 | "100111110000\n", 150 | "101111100000\n", 151 | "111111000000\n", 152 | "111110000000\n", 153 | "111100000000\n", 154 | "111000000000\n", 155 | "110000000000\n" 156 | ] 157 | } 158 | ], 159 | "source": [ 160 | "for i in range(0, 10):\n", 161 | " shiftCircuit = applyShift(shiftCircuit, 12)" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [ 170 | "def shifterCircuitMaker(n, inp=None):\n", 171 | " shifterCircuit = makeCirc3(n, 0, 1, inp)\n", 172 | " for i in range(0, n-2):\n", 173 | " shifterCircuit.cswap(0, i+1, i+2)\n", 174 | " for i in range(0, n-1):\n", 175 | " shifterCircuit.measure(i, i)\n", 176 | " return shifterCircuit\n", 177 | "def applyShift(circ, n):\n", 178 | " result = getMeasure(circ, 1)[0][::-1]\n", 179 | " return shifterCircuitMaker(n, result)" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": null, 185 | "metadata": {}, 186 | "outputs": [], 187 | "source": [] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": null, 192 | "metadata": {}, 193 | "outputs": [], 194 | "source": [] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": null, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [] 209 | } 210 | ], 211 | "metadata": { 212 | "kernelspec": { 213 | "display_name": "Python 3", 214 | "language": "python", 215 | "name": "python3" 216 | }, 217 | "language_info": { 218 | "codemirror_mode": { 219 | "name": "ipython", 220 | "version": 3 221 | }, 222 | "file_extension": ".py", 223 | "mimetype": "text/x-python", 224 | "name": "python", 225 | "nbconvert_exporter": "python", 226 | "pygments_lexer": "ipython3", 227 | "version": "3.7.6" 228 | } 229 | }, 230 | "nbformat": 4, 231 | "nbformat_minor": 4 232 | } 233 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section3/Lecture12/VQE.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "from qiskit import *\n", 11 | "%matplotlib inline\n", 12 | "from math import pi, sqrt\n", 13 | "import random\n", 14 | "import time\n", 15 | "\n", 16 | "from qiskit.visualization import plot_histogram\n", 17 | "from qiskit.visualization import array_to_latex\n", 18 | "from qiskit_textbook.tools import random_state\n", 19 | "\n", 20 | "from qiskit_nature.drivers import PySCFDriver, UnitsType #Python Chemistry Library\n", 21 | "from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem #2'nd Quantization\n", 22 | "\n", 23 | "#pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src\n", 24 | "\n", 25 | "#pip install qiskit-nature\n", 26 | "#pip install pyscf\n", 27 | "import warnings\n", 28 | "warnings.filterwarnings('ignore')\n", 29 | "\n" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [ 38 | "\"\"\"\n", 39 | " /$$$$$$$$ /$$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$ /$$$$$$ /$$ /$$ /$$$$$$ /$$$$$$$$\n", 40 | "| $$_____/| $$__ $$ /$$__ $$| $$$ /$$$ /$$__ $$|_ $$_/ /$$__ $$| $$ /$$/|_ $$_/|__ $$__/\n", 41 | "| $$ | $$ \\ $$| $$ \\ $$| $$$$ /$$$$ | $$ \\ $$ | $$ | $$ \\__/| $$ /$$/ | $$ | $$ \n", 42 | "| $$$$$ | $$$$$$$/| $$ | $$| $$ $$/$$ $$ | $$ | $$ | $$ | $$$$$$ | $$$$$/ | $$ | $$ \n", 43 | "| $$__/ | $$__ $$| $$ | $$| $$ $$$| $$ | $$ | $$ | $$ \\____ $$| $$ $$ | $$ | $$ \n", 44 | "| $$ | $$ \\ $$| $$ | $$| $$\\ $ | $$ | $$/$$ $$ | $$ /$$ \\ $$| $$\\ $$ | $$ | $$ \n", 45 | "| $$ | $$ | $$| $$$$$$/| $$ \\/ | $$ | $$$$$$/ /$$$$$$| $$$$$$/| $$ \\ $$ /$$$$$$ | $$ \n", 46 | "|__/ |__/ |__/ \\______/ |__/ |__/ \\____ $$$|______/ \\______/ |__/ \\__/|______/ |__/ \n", 47 | " \\__/ \n", 48 | "\"\"\"" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 2, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [ 57 | "# Use PySCF, a classical computational chemistry software\n", 58 | "# package, to compute the one-body and two-body integrals in\n", 59 | "# electronic-orbital basis, necessary to form the Fermionic operator\n", 60 | "driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',\n", 61 | " unit=UnitsType.ANGSTROM,\n", 62 | " basis='sto3g')\n", 63 | "problem = ElectronicStructureProblem(driver) #Fermionic Operator\n", 64 | "\n", 65 | "\n", 66 | "# generate the second-quantized operators\n", 67 | "second_q_ops = problem.second_q_ops()\n", 68 | "main_op = second_q_ops[0]\n", 69 | "\n", 70 | "num_particles = (problem.molecule_data_transformed.num_alpha,\n", 71 | " problem.molecule_data_transformed.num_beta)\n", 72 | "\n", 73 | "num_spin_orbitals = 2 * problem.molecule_data.num_molecular_orbitals\n", 74 | "\n", 75 | "# setup the classical optimizer for VQE\n", 76 | "from qiskit.algorithms.optimizers import L_BFGS_B\n", 77 | "optimizer = L_BFGS_B()\n", 78 | "\n", 79 | "# setup the mapper and qubit converter\n", 80 | "from qiskit_nature.mappers.second_quantization import ParityMapper\n", 81 | "from qiskit_nature.converters.second_quantization import QubitConverter\n", 82 | "mapper = ParityMapper()\n", 83 | "converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)\n", 84 | "# map to qubit operators\n", 85 | "qubit_op = converter.convert(main_op, num_particles=num_particles)\n", 86 | "\n", 87 | "#Convert Fermionic Operators to Pauli Matrices -> To Circuit" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 3, 93 | "metadata": {}, 94 | "outputs": [], 95 | "source": [ 96 | "# setup the initial state for the ansatz\n", 97 | "from qiskit_nature.circuit.library import HartreeFock #Computational Chemistry Algorithm \n", 98 | "init_state = HartreeFock(num_spin_orbitals, num_particles, converter)\n", 99 | "\n", 100 | "# setup the ansatz for VQE\n", 101 | "from qiskit.circuit.library import TwoLocal\n", 102 | "ansatz = TwoLocal(num_spin_orbitals, ['ry', 'rz'], 'cz')\n", 103 | "\n", 104 | "# add the initial state\n", 105 | "ansatz.compose(init_state, front=True)\n", 106 | "\n", 107 | "# set the backend for the quantum computation\n", 108 | "backend = Aer.get_backend('aer_simulator_statevector')\n", 109 | "\n", 110 | "# setup and run VQE\n", 111 | "from qiskit.algorithms import VQE\n", 112 | "algorithm = VQE(ansatz,optimizer=optimizer,quantum_instance=backend)" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 4, 118 | "metadata": {}, 119 | "outputs": [ 120 | { 121 | "name": "stdout", 122 | "output_type": "stream", 123 | "text": [ 124 | "-0.965935001118535\n", 125 | "=== GROUND STATE ENERGY ===\n", 126 | " \n", 127 | "* Electronic ground state energy (Hartree): -0.965935001119\n", 128 | " - computed part: -0.965935001119\n", 129 | "~ Nuclear repulsion energy (Hartree): 0.719968994449\n", 130 | "> Total ground state energy (Hartree): -0.24596600667\n", 131 | " \n", 132 | "=== MEASURED OBSERVABLES ===\n", 133 | " \n", 134 | " \n", 135 | "=== DIPOLE MOMENTS ===\n", 136 | " \n", 137 | "~ Nuclear dipole moment (a.u.): [0.0 0.0 1.3889487]\n", 138 | " \n" 139 | ] 140 | } 141 | ], 142 | "source": [ 143 | "result = algorithm.compute_minimum_eigenvalue(qubit_op)\n", 144 | "print(result.eigenvalue.real)\n", 145 | "\n", 146 | "electronic_structure_result = problem.interpret(result)\n", 147 | "print(electronic_structure_result)" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [] 156 | } 157 | ], 158 | "metadata": { 159 | "kernelspec": { 160 | "display_name": "Python 3", 161 | "language": "python", 162 | "name": "python3" 163 | }, 164 | "language_info": { 165 | "codemirror_mode": { 166 | "name": "ipython", 167 | "version": 3 168 | }, 169 | "file_extension": ".py", 170 | "mimetype": "text/x-python", 171 | "name": "python", 172 | "nbconvert_exporter": "python", 173 | "pygments_lexer": "ipython3", 174 | "version": "3.7.6" 175 | } 176 | }, 177 | "nbformat": 4, 178 | "nbformat_minor": 4 179 | } 180 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section3/Lecture3/SuperDense.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "from qiskit import *\n", 11 | "%matplotlib inline\n", 12 | "from math import pi, sqrt\n", 13 | "import random\n", 14 | "from qiskit.visualization import plot_histogram\n", 15 | "from qiskit_textbook.tools import simon_oracle\n", 16 | "#pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": null, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "backend = Aer.get_backend('statevector_simulator')\n", 26 | "def getBloch(quantumC):\n", 27 | " return visualization.plot_bloch_multivector(execute(quantumC, backend).\n", 28 | " result().get_statevector())" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "def stateGenerator(state):\n", 38 | " state = state[::-1]\n", 39 | " current = int(state, 2)\n", 40 | " newState = [0 for i in range(0, 2**(len(state)))]\n", 41 | " newState[current] = 1\n", 42 | " return newState" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [ 51 | "def getMeasure(quantumC, n):\n", 52 | " measures = []\n", 53 | " for i in range(0, n):\n", 54 | " outcome = execute(quantumC, backend).result()\n", 55 | " hist = outcome.get_counts()\n", 56 | " for i in hist.keys():\n", 57 | " measures.append(i)\n", 58 | " return measures" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [ 67 | "def makeCirc(n, state):\n", 68 | " initState = state\n", 69 | " print(initState)\n", 70 | " qr = QuantumRegister(n)\n", 71 | " qc = ClassicalRegister(n)\n", 72 | " circ = QuantumCircuit(qr, qc)\n", 73 | " initializedState = stateGenerator(initState)\n", 74 | " circ.initialize(initializedState, qr)\n", 75 | " return circ" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [ 84 | "def getHisto(n, circ):\n", 85 | " qasm_sim = Aer.get_backend('qasm_simulator')\n", 86 | " shots = n\n", 87 | " qobj = assemble(circ, shots=shots)\n", 88 | " results = qasm_sim.run(qobj).result()\n", 89 | " counts = results.get_counts()\n", 90 | " return counts" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": null, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "def " 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": null, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [] 122 | } 123 | ], 124 | "metadata": { 125 | "kernelspec": { 126 | "display_name": "Python 3", 127 | "language": "python", 128 | "name": "python3" 129 | }, 130 | "language_info": { 131 | "codemirror_mode": { 132 | "name": "ipython", 133 | "version": 3 134 | }, 135 | "file_extension": ".py", 136 | "mimetype": "text/x-python", 137 | "name": "python", 138 | "nbconvert_exporter": "python", 139 | "pygments_lexer": "ipython3", 140 | "version": "3.7.6" 141 | } 142 | }, 143 | "nbformat": 4, 144 | "nbformat_minor": 4 145 | } 146 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section3/Lecture9/Hamiltonian.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 14, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import numpy as np\n", 10 | "from qiskit import *\n", 11 | "%matplotlib inline\n", 12 | "from math import pi, sqrt\n", 13 | "import random\n", 14 | "from qiskit.visualization import plot_histogram\n", 15 | "from qiskit_textbook.tools import random_state\n", 16 | "#pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src\n", 17 | "\n", 18 | "import warnings\n", 19 | "warnings.filterwarnings('ignore')\n", 20 | "\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 4, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [ 29 | "backend = Aer.get_backend('statevector_simulator')\n", 30 | "def getBloch(quantumC):\n", 31 | " return visualization.plot_bloch_multivector(execute(quantumC, backend).result().get_statevector())\n", 32 | " " 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 5, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "def stateGenerator(state):\n", 42 | " state = state[::-1]\n", 43 | " current = int(state, 2)\n", 44 | " newState = [0 for i in range(0, 2**(len(state)))]\n", 45 | " newState[current] = 1\n", 46 | " return newState" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 6, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "def getMeasure(quantumC, n):\n", 56 | " measures = []\n", 57 | " for i in range(0, n):\n", 58 | " outcome = execute(quantumC, backend).result()\n", 59 | " hist = outcome.get_counts()\n", 60 | " for i in hist.keys():\n", 61 | " measures.append(i)\n", 62 | " return measures" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 7, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "def makeCirc(n, state):\n", 72 | " initState = state\n", 73 | " print(initState)\n", 74 | " qr = QuantumRegister(n)\n", 75 | " qc = ClassicalRegister(n)\n", 76 | " circ = QuantumCircuit(qr, qc)\n", 77 | " initializedState = stateGenerator(initState)\n", 78 | " circ.initialize(initializedState, qr)\n", 79 | " return circ" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": 8, 85 | "metadata": {}, 86 | "outputs": [], 87 | "source": [ 88 | "def getHisto(n, circ):\n", 89 | " qasm_sim = Aer.get_backend('qasm_simulator')\n", 90 | " shots = n\n", 91 | " qobj = assemble(circ, shots=shots)\n", 92 | " results = qasm_sim.run(qobj).result()\n", 93 | " counts = results.get_counts()\n", 94 | " return counts" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": null, 121 | "metadata": {}, 122 | "outputs": [], 123 | "source": [] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [] 152 | } 153 | ], 154 | "metadata": { 155 | "kernelspec": { 156 | "display_name": "Python 3", 157 | "language": "python", 158 | "name": "python3" 159 | }, 160 | "language_info": { 161 | "codemirror_mode": { 162 | "name": "ipython", 163 | "version": 3 164 | }, 165 | "file_extension": ".py", 166 | "mimetype": "text/x-python", 167 | "name": "python", 168 | "nbconvert_exporter": "python", 169 | "pygments_lexer": "ipython3", 170 | "version": "3.7.6" 171 | } 172 | }, 173 | "nbformat": 4, 174 | "nbformat_minor": 4 175 | } 176 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section5/Lecture3/Ansatz.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import random\n", 10 | "import matplotlib.pyplot as plt\n", 11 | "from pprint import pprint\n", 12 | "\n", 13 | "from pennylane import numpy as np\n", 14 | "import pennylane as qml\n", 15 | "from pennylane.templates import AngleEmbedding, AmplitudeEmbedding, BasisEmbedding\n", 16 | "from pennylane.operation import Tensor\n", 17 | "#https://pennylane.readthedocs.io/en/stable/introduction/templates.html" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 2, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "dev1 = qml.device(\"default.qubit\", wires=2)" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 3, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "@qml.qnode(dev1)\n", 36 | "def circuit(params):\n", 37 | " qml.RX(params[0], wires=0)\n", 38 | " qml.RY(params[1], wires=1)\n", 39 | " return qml.expval(qml.PauliZ(0)) #0 or 1: Z, + or -: X, +i or -i: Y" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "## Ansatz" 47 | ] 48 | }, 49 | { 50 | "cell_type": "code", 51 | "execution_count": 96, 52 | "metadata": {}, 53 | "outputs": [], 54 | "source": [ 55 | "n_qubits = 4\n", 56 | "dev2 = qml.device(\"default.qubit\", wires=n_qubits)\n", 57 | "\n", 58 | "def ansatz0():\n", 59 | " if (random.randint(0, 5) > 2):\n", 60 | " qml.RX(np.pi/2, wires=0)\n", 61 | " if (random.randint(0, 10) > 5):\n", 62 | " qml.RX(np.pi/2, wires=2)\n", 63 | "\n", 64 | "def ansatz1():\n", 65 | " #Qubits 1, 2\n", 66 | " qml.Hadamard(wires=0)\n", 67 | " qml.Hadamard(wires=1)\n", 68 | " qml.CNOT(wires=[1, 0])\n", 69 | " qml.Hadamard(wires=0)\n", 70 | " #Qubits 3, 4\n", 71 | " qml.Hadamard(wires=2)\n", 72 | " qml.Hadamard(wires=3)\n", 73 | " qml.CNOT(wires=[3, 2])\n", 74 | " qml.Hadamard(wires=2)\n", 75 | " \n", 76 | "def ansatz2():\n", 77 | " #Qubits 1, 2\n", 78 | " qml.Hadamard(wires=0)\n", 79 | " qml.Hadamard(wires=1)\n", 80 | " qml.CNOT(wires=[1, 0])\n", 81 | " qml.Hadamard(wires=0)\n", 82 | " \n", 83 | "def ansatz3():\n", 84 | " #Qubits 3, 4\n", 85 | " qml.Hadamard(wires=2)\n", 86 | " qml.Hadamard(wires=3)\n", 87 | " qml.CNOT(wires=[3, 2])\n", 88 | " qml.Hadamard(wires=2)\n", 89 | "\n", 90 | " \n", 91 | "\n", 92 | "def ansatzQFT():\n", 93 | " qml.QFT(wires=[0, 1, 2, 3])\n", 94 | "\n", 95 | "\n", 96 | "\n", 97 | "@qml.qnode(dev2)\n", 98 | "def circuitMix():\n", 99 | " ansatz0()\n", 100 | " ansatz1()\n", 101 | " return [qml.expval(qml.PauliZ(i)) for i in range(n_qubits)]\n", 102 | "\n", 103 | "\n", 104 | "@qml.qnode(dev2)\n", 105 | "def circuitShake():\n", 106 | " ansatz0()\n", 107 | " if (random.randint(0, 20) > 10):\n", 108 | " ansatz2()\n", 109 | " else:\n", 110 | " ansatz3()\n", 111 | " return [qml.expval(qml.PauliZ(i)) for i in range(n_qubits)]\n", 112 | "\n", 113 | "\n", 114 | "@qml.qnode(dev2)\n", 115 | "def circuitQFT():\n", 116 | " qml.RX(np.pi/2, wires=0)\n", 117 | " qml.RX(np.pi/2, wires=2)\n", 118 | " ansatzQFT()\n", 119 | " return [qml.expval(qml.PauliZ(i)) for i in range(n_qubits)]" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 97, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [ 128 | "def rounder(x):\n", 129 | " y = []\n", 130 | " for i in x:\n", 131 | " if i < -0.9:\n", 132 | " y.append(-1)\n", 133 | " elif i > -0.1 and i < 0.1:\n", 134 | " y.append(0)\n", 135 | " elif i > 0.9:\n", 136 | " y.append(1)\n", 137 | " else:\n", 138 | " y.append(i)\n", 139 | " return y" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 98, 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | "[0, 0, 1, 0]\n" 152 | ] 153 | } 154 | ], 155 | "source": [ 156 | "print(rounder(circuitMix()))" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 99, 162 | "metadata": {}, 163 | "outputs": [ 164 | { 165 | "name": "stdout", 166 | "output_type": "stream", 167 | "text": [ 168 | "[1, 0, 1, 1]\n" 169 | ] 170 | } 171 | ], 172 | "source": [ 173 | "print(rounder(circuitShake()))" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 100, 179 | "metadata": {}, 180 | "outputs": [ 181 | { 182 | "name": "stdout", 183 | "output_type": "stream", 184 | "text": [ 185 | "[0, tensor(0.60355339, requires_grad=True), 0, 0]\n" 186 | ] 187 | } 188 | ], 189 | "source": [ 190 | "print(rounder(circuitQFT()))" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": {}, 197 | "outputs": [], 198 | "source": [] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": null, 210 | "metadata": {}, 211 | "outputs": [], 212 | "source": [] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": null, 224 | "metadata": {}, 225 | "outputs": [], 226 | "source": [] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": null, 231 | "metadata": {}, 232 | "outputs": [], 233 | "source": [] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": {}, 239 | "outputs": [], 240 | "source": [] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": null, 245 | "metadata": {}, 246 | "outputs": [], 247 | "source": [] 248 | } 249 | ], 250 | "metadata": { 251 | "kernelspec": { 252 | "display_name": "Python 3", 253 | "language": "python", 254 | "name": "python3" 255 | }, 256 | "language_info": { 257 | "codemirror_mode": { 258 | "name": "ipython", 259 | "version": 3 260 | }, 261 | "file_extension": ".py", 262 | "mimetype": "text/x-python", 263 | "name": "python", 264 | "nbconvert_exporter": "python", 265 | "pygments_lexer": "ipython3", 266 | "version": "3.7.6" 267 | } 268 | }, 269 | "nbformat": 4, 270 | "nbformat_minor": 4 271 | } 272 | -------------------------------------------------------------------------------- /QuantumComputingNotebooks/Section5/Lecture5/Grad.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import random\n", 10 | "import matplotlib.pyplot as plt\n", 11 | "from pprint import pprint\n", 12 | "\n", 13 | "from pennylane import numpy as np\n", 14 | "import pennylane as qml\n", 15 | "#https://pennylane.readthedocs.io/en/stable/introduction/templates.html" 16 | ] 17 | }, 18 | { 19 | "cell_type": "code", 20 | "execution_count": 2, 21 | "metadata": {}, 22 | "outputs": [], 23 | "source": [ 24 | "dev1 = qml.device(\"default.qubit\", wires=2)" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 3, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "@qml.qnode(dev1)\n", 34 | "def circuit(params):\n", 35 | " qml.Rot(params[0], params[1], params[2], wires=0)\n", 36 | " qml.RY(params[0], wires=1)\n", 37 | " return qml.expval(qml.PauliZ(0) @ qml.PauliZ(1)) #0 or 1: Z, + or -: X, +i or -i: Y" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "## Parameter Shift Rule" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 4, 50 | "metadata": {}, 51 | "outputs": [ 52 | { 53 | "name": "stdout", 54 | "output_type": "stream", 55 | "text": [ 56 | "[1.67472672 2.35038915 2.15641592]\n" 57 | ] 58 | } 59 | ], 60 | "source": [ 61 | "params = np.random.random([3])*np.pi\n", 62 | "print(params)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": 22, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [ 71 | "def pshift(circuit, params, i):\n", 72 | " h = 0.001\n", 73 | " pparams = [i for i in params]\n", 74 | " pparams[i] = pparams[i] + h\n", 75 | " f1 = circuit(params)\n", 76 | " f2 = circuit(pparams)\n", 77 | " return (f2-f1)/h" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 25, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "text/plain": [ 88 | "tensor(0., requires_grad=True)" 89 | ] 90 | }, 91 | "execution_count": 25, 92 | "metadata": {}, 93 | "output_type": "execute_result" 94 | } 95 | ], 96 | "source": [ 97 | "pshift(circuit, params, 2)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "## Gradient w/ Pennylane" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 27, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "text/plain": [ 115 | "-3.469446951953614e-18" 116 | ] 117 | }, 118 | "execution_count": 27, 119 | "metadata": {}, 120 | "output_type": "execute_result" 121 | } 122 | ], 123 | "source": [ 124 | "dcircuit = qml.grad(circuit)\n", 125 | "dcircuit(params)[2]" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "metadata": {}, 146 | "outputs": [], 147 | "source": [] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [] 155 | } 156 | ], 157 | "metadata": { 158 | "kernelspec": { 159 | "display_name": "Python 3", 160 | "language": "python", 161 | "name": "python3" 162 | }, 163 | "language_info": { 164 | "codemirror_mode": { 165 | "name": "ipython", 166 | "version": 3 167 | }, 168 | "file_extension": ".py", 169 | "mimetype": "text/x-python", 170 | "name": "python", 171 | "nbconvert_exporter": "python", 172 | "pygments_lexer": "ipython3", 173 | "version": "3.7.6" 174 | } 175 | }, 176 | "nbformat": 4, 177 | "nbformat_minor": 4 178 | } 179 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # QuantumComputingAZ 2 | All the material used to create quantum computing course on Udemy. 3 | 4 | ## Content 5 | The content created here was used for a online course I made on Udemy called "Quantum Computing A-Z". In it contains all the Jupyter Notebooks for practicing the code as well as the Manim code used for the math animations. All of this is open sourced. 6 | 7 | ## Course Students 8 | If you are student, download the "QuantumComputingNotebooks" and install all dependencies listed in "QuantumComputingNotebooks\Section0\Lecture2\Intro.ipynb" after installing Anaconda and launching Jupyter Notebook. 9 | 10 | ## Terms of Use 11 | All code in the course is open-sourced and code can be used for commercial reasons for profit. 12 | --------------------------------------------------------------------------------