├── 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 |
--------------------------------------------------------------------------------