WEBVTT

1
00:00:00.080 --> 00:00:02.040
<v Speaker 1>You know that feeling right when you need to get

2
00:00:02.080 --> 00:00:04.879
<v Speaker 1>up to speed on something really complex fast, but you're

3
00:00:04.919 --> 00:00:06.519
<v Speaker 1>just drowning in articles and papers.

4
00:00:06.639 --> 00:00:09.160
<v Speaker 2>Yeah, totally information overload exactly.

5
00:00:09.919 --> 00:00:12.080
<v Speaker 1>So we're here to give you that shortcut, that deep

6
00:00:12.160 --> 00:00:16.079
<v Speaker 1>dive to get you properly informed. Today we're jumping into

7
00:00:16.120 --> 00:00:19.719
<v Speaker 1>a field that's honestly reshaping how we even think about computation.

8
00:00:19.960 --> 00:00:22.839
<v Speaker 2>It really is. We're talking quantum computing, and our mission

9
00:00:22.879 --> 00:00:27.039
<v Speaker 2>today is to untack the core ideas, look at the

10
00:00:27.160 --> 00:00:30.839
<v Speaker 2>tools making it accessible, which is amazing, and even touch

11
00:00:30.920 --> 00:00:33.159
<v Speaker 2>on some algorithms that sound like science.

12
00:00:32.880 --> 00:00:35.600
<v Speaker 1>Fiction, they really do. Our main guide here is the

13
00:00:35.640 --> 00:00:39.439
<v Speaker 1>second edition of Learn Quantum Computing with Python and IBM

14
00:00:39.560 --> 00:00:43.439
<v Speaker 1>Quantum by Robert Laredo. He's an IBM Mastered inventor, a

15
00:00:43.520 --> 00:00:46.079
<v Speaker 1>quantum ambassador, just brilliant and.

16
00:00:46.039 --> 00:00:48.840
<v Speaker 2>A great guy too. Donated his previous books royalties to

17
00:00:48.920 --> 00:00:52.399
<v Speaker 2>Doctors Without Borders. We're also pulling in insights from reviewers

18
00:00:52.399 --> 00:00:56.119
<v Speaker 2>like Haci Norlen, Mikhail Grossey, Sean Wagner, all deep in

19
00:00:56.200 --> 00:00:58.520
<v Speaker 2>the IBM Quantum and caskit world.

20
00:00:58.600 --> 00:01:01.119
<v Speaker 1>So whether you're prepping for that big meeting or just

21
00:01:01.200 --> 00:01:03.159
<v Speaker 1>trying to figure out what all the buzz is about.

22
00:01:03.479 --> 00:01:06.760
<v Speaker 1>Or maybe you're just super curious, which you should be. Huh. Yeah,

23
00:01:07.120 --> 00:01:10.319
<v Speaker 1>this deep dive should give you those aha moments. We're

24
00:01:10.319 --> 00:01:15.840
<v Speaker 1>aiming to show how these really abstract ideas are becoming concrete.

25
00:01:15.359 --> 00:01:18.400
<v Speaker 2>Tools, right without making your head explode hopefully.

26
00:01:19.040 --> 00:01:22.920
<v Speaker 1>Okay, so let's start at the beginning. Quantum mechanics sounds intimidating,

27
00:01:22.959 --> 00:01:25.000
<v Speaker 1>but it's the bedrock of all this. We're talking about

28
00:01:25.200 --> 00:01:28.280
<v Speaker 1>the rules governing the universe at the tiniest scales, the

29
00:01:28.319 --> 00:01:29.400
<v Speaker 1>sub atomic level.

30
00:01:29.560 --> 00:01:34.519
<v Speaker 2>Yeah, the foundations laid by you know, the giants Schrodinger, Plank, Heisenberg,

31
00:01:34.640 --> 00:01:38.560
<v Speaker 2>Drach Einstein. Their work described a world that's just fundamentally

32
00:01:38.640 --> 00:01:42.519
<v Speaker 2>weird compared to our everyday experience, and that weirdness is key, right,

33
00:01:42.560 --> 00:01:45.400
<v Speaker 2>Like the double slit experiment exactly, that's a classic. You

34
00:01:45.439 --> 00:01:49.519
<v Speaker 2>fire single particles like photons at two slits, you'd expect

35
00:01:49.519 --> 00:01:51.400
<v Speaker 2>two lines on the screen behind it, right, Yeah, it

36
00:01:51.480 --> 00:01:53.200
<v Speaker 2>makes sense, but you don't get that. You get an

37
00:01:53.239 --> 00:01:56.640
<v Speaker 2>interference pattern like waves canceling out and adding up. It

38
00:01:56.719 --> 00:02:01.200
<v Speaker 2>shows particles behaving like waves. This wave part duality. It's

39
00:02:01.239 --> 00:02:05.200
<v Speaker 2>not just a cool fact, it's something Quantum computers actively use.

40
00:02:05.480 --> 00:02:09.280
<v Speaker 1>So we all get classical bits on off zero one

41
00:02:09.680 --> 00:02:14.159
<v Speaker 1>transistors doing their thing. But the quantum version, the quibit. Yeah,

42
00:02:14.199 --> 00:02:16.199
<v Speaker 1>that's the heart of it. What makes it so different.

43
00:02:16.319 --> 00:02:20.479
<v Speaker 2>Well, the huge difference is superposition Equibit isn't just zero

44
00:02:20.639 --> 00:02:22.759
<v Speaker 2>or one. It can be zero, it can be one,

45
00:02:22.960 --> 00:02:25.439
<v Speaker 2>or it can be a combination of both at the

46
00:02:25.479 --> 00:02:26.240
<v Speaker 2>exact same.

47
00:02:26.039 --> 00:02:28.159
<v Speaker 1>Time, both like simultaneously.

48
00:02:28.400 --> 00:02:30.319
<v Speaker 2>Kind of think of it less like a hidden state

49
00:02:30.439 --> 00:02:33.680
<v Speaker 2>like a spinning coin before it lands, and more like, well,

50
00:02:33.719 --> 00:02:36.759
<v Speaker 2>the quantum state itself is a blend of possibilities until

51
00:02:36.840 --> 00:02:39.960
<v Speaker 2>you measure it. Measuring forces it to choose zero or one.

52
00:02:40.159 --> 00:02:42.719
<v Speaker 1>You mentioned a spinning coin, but you said it's not

53
00:02:42.879 --> 00:02:47.039
<v Speaker 1>like that. Yeah, that the quantum outcome is truly random.

54
00:02:47.120 --> 00:02:50.280
<v Speaker 1>That sounds profound. Are we saying there's no hidden instruction

55
00:02:50.360 --> 00:02:51.319
<v Speaker 1>determining the outcome?

56
00:02:51.439 --> 00:02:55.240
<v Speaker 2>That's exactly what standard quantum mechanics says. Yeah, it's fundamentally probabilistic,

57
00:02:55.319 --> 00:02:57.800
<v Speaker 2>not just we don't know enough, but actually random. And

58
00:02:57.840 --> 00:03:01.560
<v Speaker 2>that's a massive conceptual leap. It means quantum computers work

59
00:03:01.599 --> 00:03:03.240
<v Speaker 2>with probabilities directly.

60
00:03:03.240 --> 00:03:05.639
<v Speaker 1>Wow, Okay, that changes things.

61
00:03:05.479 --> 00:03:09.280
<v Speaker 2>It does, and that leads to the second key, difference entanglement.

62
00:03:09.599 --> 00:03:12.599
<v Speaker 2>This is the one Einstein called famously spooky action at

63
00:03:12.599 --> 00:03:13.120
<v Speaker 2>a distance.

64
00:03:13.479 --> 00:03:16.560
<v Speaker 1>Spooky action. I love that phrase. What does it actually

65
00:03:16.599 --> 00:03:17.479
<v Speaker 1>mean for quibits?

66
00:03:17.719 --> 00:03:20.599
<v Speaker 2>It means you can link two or more quibits together

67
00:03:20.680 --> 00:03:23.879
<v Speaker 2>in a special way, so intimately linked that measuring the

68
00:03:23.879 --> 00:03:26.560
<v Speaker 2>state of one quibbit instantly tells you the state of

69
00:03:26.560 --> 00:03:28.919
<v Speaker 2>the other, no matter how far apart they are, instantly

70
00:03:28.960 --> 00:03:32.599
<v Speaker 2>across any distance, instantly. If you have two entangled quibits

71
00:03:32.639 --> 00:03:34.879
<v Speaker 2>and measure one is zero, you know the other is zero.

72
00:03:35.240 --> 00:03:38.000
<v Speaker 2>If one's one, the other's one, always correlate. It's like

73
00:03:38.000 --> 00:03:41.639
<v Speaker 2>they're still connected, sharing the same fate. It's a crucial resource.

74
00:03:41.919 --> 00:03:47.400
<v Speaker 1>Okay, superposition entanglement. Yeah, and you mentioned interference. Going back

75
00:03:47.439 --> 00:03:49.960
<v Speaker 1>to the double slit thing. How does that play into algorithms?

76
00:03:50.120 --> 00:03:53.360
<v Speaker 2>Right? Interference Quantum algorithms are designed to leverage this. Think

77
00:03:53.400 --> 00:03:56.520
<v Speaker 2>of it like paths leading to the wrong answer interfere

78
00:03:56.599 --> 00:03:58.800
<v Speaker 2>destructively and cancel each other out.

79
00:03:59.080 --> 00:04:01.120
<v Speaker 1>Ah, so they just disappear effectively.

80
00:04:01.240 --> 00:04:05.360
<v Speaker 2>Yeah, while the paths leading to the right answer interfere constructively,

81
00:04:05.439 --> 00:04:08.759
<v Speaker 2>reinforcing each other. So the probability of measuring the correct

82
00:04:08.759 --> 00:04:13.159
<v Speaker 2>answer gets amplified. It's a way to sift through possibilities incredibly.

83
00:04:12.680 --> 00:04:17.079
<v Speaker 1>Efficiently and visualizing this yeah, it's hard to picture. Are

84
00:04:17.079 --> 00:04:18.040
<v Speaker 1>there tools for that?

85
00:04:18.439 --> 00:04:21.120
<v Speaker 2>There are. For a single quibut, we often use the

86
00:04:21.160 --> 00:04:25.519
<v Speaker 2>block sphere. It helps visualize its state, including its amplitude

87
00:04:25.519 --> 00:04:28.040
<v Speaker 2>and phase, like a point on a globe. But for

88
00:04:28.240 --> 00:04:32.000
<v Speaker 2>multiple entangled quibits that gets complicated. So there's a more

89
00:04:32.040 --> 00:04:34.959
<v Speaker 2>powerful tool called the q sphere, which can show the

90
00:04:35.120 --> 00:04:39.959
<v Speaker 2>combined state of many quibits, including those crucial phase relationships

91
00:04:40.000 --> 00:04:40.560
<v Speaker 2>between them.

92
00:04:40.959 --> 00:04:44.319
<v Speaker 1>This is fascinating, but maybe a bit abstract. How do

93
00:04:44.360 --> 00:04:46.439
<v Speaker 1>people actually use this stuff? Where do you start?

94
00:04:46.759 --> 00:04:50.000
<v Speaker 2>Great question? For many. The entry point is the IBM

95
00:04:50.120 --> 00:04:53.959
<v Speaker 2>Quantum Platform or IQP, and it's got a cool history.

96
00:04:54.800 --> 00:04:58.040
<v Speaker 2>IBM actually put the first quantum computer on the cloud

97
00:04:58.199 --> 00:05:01.199
<v Speaker 2>free for anyone to use, back in May twenty sixteen.

98
00:05:01.360 --> 00:05:04.680
<v Speaker 1>Wow, twenty sixteen. That feels like ages ago in this field, right.

99
00:05:04.839 --> 00:05:06.759
<v Speaker 2>It was called the IBM Quantum Experience.

100
00:05:06.800 --> 00:05:06.959
<v Speaker 1>Then.

101
00:05:07.120 --> 00:05:09.600
<v Speaker 2>Now it's this much more developed platform, the ITP.

102
00:05:09.920 --> 00:05:11.040
<v Speaker 1>What's actually on the platform.

103
00:05:11.079 --> 00:05:13.560
<v Speaker 2>It's got a few key parts. The main platform view

104
00:05:13.639 --> 00:05:16.680
<v Speaker 2>is your dashboard. You can see which quantum computers are online,

105
00:05:16.680 --> 00:05:18.920
<v Speaker 2>how busy they are, check on your jobs, see how

106
00:05:19.000 --> 00:05:20.079
<v Speaker 2>much computing time you've.

107
00:05:20.000 --> 00:05:22.079
<v Speaker 1>Used, like a mission control kind of. Yeah.

108
00:05:22.560 --> 00:05:25.680
<v Speaker 2>Then there's the documentation which is huge. Everything you need

109
00:05:25.720 --> 00:05:29.079
<v Speaker 2>to set up your coding environment, understand Kuskit, which we'll

110
00:05:29.079 --> 00:05:31.560
<v Speaker 2>get to its APIs. It's all there.

111
00:05:31.879 --> 00:05:33.560
<v Speaker 1>And you mentioned learning resources.

112
00:05:33.639 --> 00:05:37.560
<v Speaker 2>Oh yeah, the learning section is fantastic courses, tutorials from

113
00:05:37.600 --> 00:05:41.800
<v Speaker 2>beginner stuff right up to advanced topics, even quantum safe cryptography.

114
00:05:42.160 --> 00:05:45.360
<v Speaker 2>It really lowers the barrier to entry inside the platform.

115
00:05:45.399 --> 00:05:48.439
<v Speaker 1>I heard there's something called the composer, like a drag

116
00:05:48.480 --> 00:05:49.360
<v Speaker 1>and drop interface.

117
00:05:49.519 --> 00:05:52.879
<v Speaker 2>That's right. The composer is brilliant for visual learners or

118
00:05:52.959 --> 00:05:56.079
<v Speaker 2>just starting out. It's a graphical interface where you literally

119
00:05:56.240 --> 00:06:00.000
<v Speaker 2>drag quantum gates onto quibit lines to build a circuit.

120
00:06:00.000 --> 00:06:00.519
<v Speaker 1>Oh cool.

121
00:06:00.639 --> 00:06:02.959
<v Speaker 2>And the best part is the real time feedback. As

122
00:06:02.959 --> 00:06:06.480
<v Speaker 2>you build, you see visualizations update instantly, the state vector

123
00:06:06.560 --> 00:06:10.519
<v Speaker 2>view showing amplitudes, the probabilities view predicting outcomes. Even that

124
00:06:10.600 --> 00:06:13.079
<v Speaker 2>q sphere we talked about, you can pop a not

125
00:06:13.240 --> 00:06:15.680
<v Speaker 2>t git on there and see the probability flip from

126
00:06:15.680 --> 00:06:19.240
<v Speaker 2>one hundred percent zero to one hundred percent one right away.

127
00:06:19.160 --> 00:06:20.879
<v Speaker 1>So you can really see cause and effects.

128
00:06:20.959 --> 00:06:22.439
<v Speaker 2>Exactly. It makes it much more intuitive.

129
00:06:22.480 --> 00:06:24.720
<v Speaker 1>Okay, but what if you want to go beyond dragging

130
00:06:24.759 --> 00:06:25.959
<v Speaker 1>and dropping. You mentioned quiske It.

131
00:06:26.360 --> 00:06:30.639
<v Speaker 2>Yes, kiss git. That's IBM's open source software development kit

132
00:06:30.759 --> 00:06:34.399
<v Speaker 2>for quantum computing. It's built on Python, which makes it

133
00:06:34.399 --> 00:06:37.879
<v Speaker 2>accessible to a huge community of developers. It's really the

134
00:06:38.040 --> 00:06:41.920
<v Speaker 2>standard for working with IBM's quantum systems programmatically.

135
00:06:42.160 --> 00:06:44.120
<v Speaker 1>Is it just one monolithic.

136
00:06:43.720 --> 00:06:47.600
<v Speaker 2>Thing or no, It's cleverly layered. They think about different

137
00:06:47.600 --> 00:06:50.240
<v Speaker 2>developer roles. At the lowest level. You have kernel developers.

138
00:06:50.240 --> 00:06:53.600
<v Speaker 2>They're working right down near the hardware, figuring out the

139
00:06:53.639 --> 00:06:56.800
<v Speaker 2>precise microwave pulses needed to manipulate the quibbits.

140
00:06:57.079 --> 00:06:59.920
<v Speaker 1>Really deep stuff, okay, Hardware whisperers, ah yeah.

141
00:07:00.360 --> 00:07:03.600
<v Speaker 2>Then you have algorithm developers. They're using quiskit to design

142
00:07:03.680 --> 00:07:07.199
<v Speaker 2>the quantum circuits themselves. The algorithms. A big focus for

143
00:07:07.240 --> 00:07:10.680
<v Speaker 2>them is minimizing the impact of noise, making things run

144
00:07:10.720 --> 00:07:12.560
<v Speaker 2>better on today's imperfect hardware.

145
00:07:12.639 --> 00:07:15.519
<v Speaker 1>Right noise. We'll definitely need to talk more about that

146
00:07:15.839 --> 00:07:17.839
<v Speaker 1>and the third layer model developers.

147
00:07:17.959 --> 00:07:21.920
<v Speaker 2>These are folks who might be say chemists or financial analysts.

148
00:07:22.199 --> 00:07:24.639
<v Speaker 2>They want to use a quantum algorithm as part of

149
00:07:24.680 --> 00:07:29.120
<v Speaker 2>a larger workflow. They use quisk it to integrate quantum

150
00:07:29.120 --> 00:07:32.879
<v Speaker 2>computation into their existing applications, focusing on getting data in

151
00:07:32.959 --> 00:07:36.160
<v Speaker 2>and results out, often without needing to know every single

152
00:07:36.199 --> 00:07:37.000
<v Speaker 2>gate detail.

153
00:07:37.199 --> 00:07:39.240
<v Speaker 1>That makes a lot of sense. Can you run quiske

154
00:07:39.319 --> 00:07:40.480
<v Speaker 1>it on your own machine?

155
00:07:40.560 --> 00:07:43.560
<v Speaker 2>You can. You set it up locally, usually with Anaconda

156
00:07:43.600 --> 00:07:46.519
<v Speaker 2>for Python and Jupiter notebooks. It's great for simulating circuits,

157
00:07:46.800 --> 00:07:50.319
<v Speaker 2>but crucially you need your IBM Quantum API token to

158
00:07:50.399 --> 00:07:53.879
<v Speaker 2>actually send jobs to the real quantum computers in the cloud.

159
00:07:54.000 --> 00:07:55.279
<v Speaker 1>Gotcha, And if you get stuck.

160
00:07:55.439 --> 00:07:58.800
<v Speaker 2>There is a huge, very active community the quiskeuters on Slack.

161
00:07:58.839 --> 00:08:01.560
<v Speaker 2>It's amazing. You can ask questions, get help, see what

162
00:08:01.639 --> 00:08:04.480
<v Speaker 2>others are working on, connect with researchers. It's a really

163
00:08:04.480 --> 00:08:05.920
<v Speaker 2>supportive environment.

164
00:08:05.680 --> 00:08:08.120
<v Speaker 1>That's great to know. So we have quippits, we have

165
00:08:08.160 --> 00:08:11.319
<v Speaker 1>platforms like IBM Quantum and tools like quisket. Now, how

166
00:08:11.360 --> 00:08:14.399
<v Speaker 1>do we actually control the quibbuts? You mentioned gates in

167
00:08:14.439 --> 00:08:15.519
<v Speaker 1>the composer.

168
00:08:15.240 --> 00:08:18.399
<v Speaker 2>Right, Quantum logic gates. They are the fundamental operations you

169
00:08:18.439 --> 00:08:22.680
<v Speaker 2>perform on quibbots. But unlike classical gates, which just flip

170
00:08:22.720 --> 00:08:26.879
<v Speaker 2>bits based on simple rules, quantum gates are well, they're different.

171
00:08:26.959 --> 00:08:28.720
<v Speaker 2>They perform unitary transformations.

172
00:08:28.800 --> 00:08:33.840
<v Speaker 1>Unitary transformations sounds fancy. What does that mean? Practically?

173
00:08:34.000 --> 00:08:37.279
<v Speaker 2>It essentially means there are rotations in the Quibbets abstract

174
00:08:37.320 --> 00:08:41.639
<v Speaker 2>mathematical space. Think of the block sphere. A gate rotates

175
00:08:41.639 --> 00:08:44.440
<v Speaker 2>the Quibbitts state vector to a different point on that sphere.

176
00:08:44.879 --> 00:08:49.159
<v Speaker 2>And crucially, these transformations preserve the vector's length, which relates

177
00:08:49.200 --> 00:08:50.039
<v Speaker 2>to probability.

178
00:08:50.440 --> 00:08:52.559
<v Speaker 1>Okay, rotations, and you mentioned they're.

179
00:08:52.360 --> 00:08:56.200
<v Speaker 2>Reversible, almost all of them. Yes, reversibility is a key property.

180
00:08:56.559 --> 00:08:59.080
<v Speaker 2>If you apply a gate, you can almost always apply

181
00:08:59.159 --> 00:09:02.399
<v Speaker 2>another related gate its complex conjugator inverse to get back

182
00:09:02.440 --> 00:09:06.240
<v Speaker 2>exactly where you started. A HaTamar gate, for instance, applied twice,

183
00:09:06.360 --> 00:09:09.120
<v Speaker 2>brings you back to the initial state, unlike some classical

184
00:09:09.159 --> 00:09:11.679
<v Speaker 2>gates exactly think of a classical A and D gate.

185
00:09:12.039 --> 00:09:13.960
<v Speaker 2>If the output is zero, you don't know if the

186
00:09:13.960 --> 00:09:18.120
<v Speaker 2>inputs were zero, zero, zero, one, or ten. Information is lost.

187
00:09:18.399 --> 00:09:21.519
<v Speaker 2>Quantum gates generally don't lose information like that.

188
00:09:21.960 --> 00:09:24.639
<v Speaker 1>Okay, So what are some of the essential gates the

189
00:09:24.679 --> 00:09:25.519
<v Speaker 1>building blocks.

190
00:09:25.919 --> 00:09:29.399
<v Speaker 2>Well, for single clivits, the HaTamar gate or H gate

191
00:09:29.639 --> 00:09:32.919
<v Speaker 2>is absolutely fundamental. It's the main way we create superposition.

192
00:09:33.360 --> 00:09:35.960
<v Speaker 2>It takes a definite zero A state or one eight

193
00:09:36.000 --> 00:09:38.639
<v Speaker 2>to state and puts it into an equal mix of both.

194
00:09:38.759 --> 00:09:40.559
<v Speaker 1>The superposition workhorse. Got it.

195
00:09:40.639 --> 00:09:43.639
<v Speaker 2>Then you have the polygates X, Y, and Z. These

196
00:09:43.679 --> 00:09:46.279
<v Speaker 2>are basic rotations by one hundred and eighty degrees around

197
00:09:46.279 --> 00:09:49.159
<v Speaker 2>the respective axes on the block sphere. The X gate

198
00:09:49.279 --> 00:09:51.960
<v Speaker 2>is the quantum equivalent of the classical not T gate.

199
00:09:52.080 --> 00:09:54.720
<v Speaker 2>It flips zero to one a's and vice versa.

200
00:09:54.799 --> 00:09:56.240
<v Speaker 1>Simple flips what else.

201
00:09:56.440 --> 00:09:59.639
<v Speaker 2>For more precise control, especially over the quibt phase, which

202
00:09:59.679 --> 00:10:03.159
<v Speaker 2>is cre interference, you have phase gates, the ES gate,

203
00:10:03.320 --> 00:10:06.039
<v Speaker 2>the T gate, and their inversus s dagger T tigger.

204
00:10:06.200 --> 00:10:09.360
<v Speaker 2>They rotate the state around the z axis by specific.

205
00:10:08.840 --> 00:10:10.840
<v Speaker 1>Amounts, fine tuning the phase exactly.

206
00:10:10.960 --> 00:10:12.960
<v Speaker 2>And then there's the universal U gate. It's the most

207
00:10:13.039 --> 00:10:16.519
<v Speaker 2>general single quibut gate. With just three angle parameters, it

208
00:10:16.519 --> 00:10:20.639
<v Speaker 2>can perform any possible rotation, any single quibbit operation you

209
00:10:20.679 --> 00:10:21.320
<v Speaker 2>can imagine.

210
00:10:21.320 --> 00:10:24.200
<v Speaker 1>Wow, Okay, so that covers single quibts. But the real

211
00:10:24.279 --> 00:10:26.240
<v Speaker 1>power comes from interactions, right.

212
00:10:26.200 --> 00:10:31.080
<v Speaker 2>Entanglement precisely, yeah, and that requires multiquibit gates. The absolute

213
00:10:31.120 --> 00:10:34.240
<v Speaker 2>cornerstone here is the controlled knot gate or.

214
00:10:34.279 --> 00:10:36.720
<v Speaker 1>Cnot controlled not. What does it do?

215
00:10:36.960 --> 00:10:39.840
<v Speaker 2>It acts on two quibbits, a control quibbit and a

216
00:10:39.879 --> 00:10:43.440
<v Speaker 2>target quibt. If the control clibit is in the zero state,

217
00:10:43.519 --> 00:10:45.799
<v Speaker 2>it does nothing to the target. But if the control

218
00:10:45.879 --> 00:10:48.240
<v Speaker 2>quibit is in the one A state, it applies an

219
00:10:48.440 --> 00:10:51.399
<v Speaker 2>X gate a not gate to the target quibt flipping it.

220
00:10:51.639 --> 00:10:54.440
<v Speaker 1>Ah. So one quibt state controls an operation on another.

221
00:10:54.559 --> 00:10:57.759
<v Speaker 2>Yes, and this is the primary way we create entanglement

222
00:10:57.799 --> 00:10:59.639
<v Speaker 2>between equipbitts. It's fundamental.

223
00:10:59.720 --> 00:11:01.759
<v Speaker 1>What are the multiquibit gates are important?

224
00:11:01.879 --> 00:11:04.679
<v Speaker 2>Well, there's the Tafoli gate or CCX. It's like a

225
00:11:04.720 --> 00:11:08.480
<v Speaker 2>cnot but with two control quibots. The target quibit only

226
00:11:08.480 --> 00:11:10.600
<v Speaker 2>flips if both control quibots are one.

227
00:11:10.480 --> 00:11:12.080
<v Speaker 1>A okay, double control.

228
00:11:12.240 --> 00:11:15.360
<v Speaker 2>It's significant because the Toafoli gate is actually a universal

229
00:11:15.480 --> 00:11:18.960
<v Speaker 2>classical gate. You can build any classical circuit using just

230
00:11:19.039 --> 00:11:22.519
<v Speaker 2>to fullness in quantum. It shows how complex operations are

231
00:11:22.519 --> 00:11:28.399
<v Speaker 2>built up, often requiring decomposition into many simpler gates like hadamards, cnots.

232
00:11:27.840 --> 00:11:29.840
<v Speaker 1>And T gates interesting any others.

233
00:11:30.159 --> 00:11:32.840
<v Speaker 2>The swapgate is sometimes useful. It just swaps the states

234
00:11:32.879 --> 00:11:34.960
<v Speaker 2>of two quibuts. Does exactly what it says on the tin.

235
00:11:35.159 --> 00:11:39.000
<v Speaker 1>Okay, So you said almost all gates are reversible. What's

236
00:11:39.039 --> 00:11:41.200
<v Speaker 1>the exception where does the information get lost?

237
00:11:41.559 --> 00:11:45.320
<v Speaker 2>The exception is measurement. When you measure a quiboit to

238
00:11:45.360 --> 00:11:47.559
<v Speaker 2>find out if it's a zero or a one, the

239
00:11:47.679 --> 00:11:52.399
<v Speaker 2>quantum state collapses. All that complex superposition information, the amplitudes,

240
00:11:52.440 --> 00:11:55.320
<v Speaker 2>the phase. It's gone. You just get a classical bit

241
00:11:55.480 --> 00:11:58.360
<v Speaker 2>zero or one based on the probabilities dictated by the

242
00:11:58.360 --> 00:12:02.360
<v Speaker 2>state before measurement. It's the one irreversible step that makes sense.

243
00:12:02.399 --> 00:12:04.399
<v Speaker 1>You have to look eventually, and looking.

244
00:12:04.320 --> 00:12:07.639
<v Speaker 2>Changes things exactly. And you know, a really beautiful simple

245
00:12:07.679 --> 00:12:10.159
<v Speaker 2>circuit that uses these basic gates is the one that

246
00:12:10.200 --> 00:12:11.200
<v Speaker 2>creates the Bell state.

247
00:12:11.279 --> 00:12:11.879
<v Speaker 1>Bell states.

248
00:12:11.919 --> 00:12:15.639
<v Speaker 2>They're the four fundamental states of maximum entanglement. For two quibits.

249
00:12:16.000 --> 00:12:18.440
<v Speaker 2>For example, the A plus A state is an equal

250
00:12:18.440 --> 00:12:21.960
<v Speaker 2>superposition of zero, zero and eleven air. Both quibits are

251
00:12:22.039 --> 00:12:24.679
<v Speaker 2>zero or both are one perfectly correlated.

252
00:12:24.759 --> 00:12:25.519
<v Speaker 1>And how do you make that.

253
00:12:25.679 --> 00:12:28.480
<v Speaker 2>It's surprisingly simple. You start with two quibits and the

254
00:12:28.559 --> 00:12:31.159
<v Speaker 2>zero zero state, apply a Hadamar gate to the first

255
00:12:31.200 --> 00:12:34.279
<v Speaker 2>quibut to put it in superposition. Then apply a Cnot

256
00:12:34.440 --> 00:12:36.440
<v Speaker 2>gate with the first quibut as control and the second

257
00:12:36.519 --> 00:12:39.320
<v Speaker 2>is target boom bell state maximally entangled.

258
00:12:39.600 --> 00:12:42.399
<v Speaker 1>Wow, just two gates for that spooky action.

259
00:12:42.919 --> 00:12:47.840
<v Speaker 2>Yep, it's foundational for so many quantum algorithms and protocols.

260
00:12:47.919 --> 00:12:50.440
<v Speaker 1>Okay, so we've got the theory, the gates, the tools.

261
00:12:51.039 --> 00:12:53.960
<v Speaker 1>But running this on actual hardware, I imagine it's not

262
00:12:54.080 --> 00:12:57.120
<v Speaker 1>quite as clean as the simulations. You mentioned Noise earlier.

263
00:12:57.279 --> 00:13:00.639
<v Speaker 2>Oh yeah, noise is the big, big, big challenge in

264
00:13:00.679 --> 00:13:04.480
<v Speaker 2>the current era of quantum computing. These quantum states are

265
00:13:04.480 --> 00:13:08.159
<v Speaker 2>incredibly fragile. But first, let's talk about how you run

266
00:13:08.240 --> 00:13:11.720
<v Speaker 2>things efficiently on real hardware. That's where quisket run time

267
00:13:11.759 --> 00:13:12.159
<v Speaker 2>comes in.

268
00:13:12.279 --> 00:13:13.639
<v Speaker 1>Run time, what's that about.

269
00:13:13.799 --> 00:13:17.519
<v Speaker 2>It's IBM service designed to execute quantum circuits more effectively

270
00:13:17.559 --> 00:13:20.679
<v Speaker 2>on their cloud systems. It's about getting better performance and

271
00:13:20.720 --> 00:13:24.440
<v Speaker 2>managing the whole process better than just sending individual isolated jobs.

272
00:13:24.519 --> 00:13:25.279
<v Speaker 1>How does it do that?

273
00:13:25.679 --> 00:13:28.960
<v Speaker 2>One key feature is sessions. Imagine you have an algorithm

274
00:13:28.960 --> 00:13:31.320
<v Speaker 2>that needs to run a quantum circuit, then do some

275
00:13:31.399 --> 00:13:35.840
<v Speaker 2>classical processing, then run another related circuit, maybe iteratively.

276
00:13:35.480 --> 00:13:37.120
<v Speaker 1>Right, like machine learning or optimization.

277
00:13:37.519 --> 00:13:40.240
<v Speaker 2>Exactly if you submitted each circuit as a separate job

278
00:13:40.440 --> 00:13:42.039
<v Speaker 2>you keep going back to the end of the queue.

279
00:13:42.080 --> 00:13:44.679
<v Speaker 2>For the quantum computer, it would take forever and the

280
00:13:44.720 --> 00:13:48.360
<v Speaker 2>system's state might change between your runs. Sessions guarantee you

281
00:13:48.399 --> 00:13:51.600
<v Speaker 2>dedicated access to a quantum processor for a block of

282
00:13:51.639 --> 00:13:56.679
<v Speaker 2>related computations. It's huge for reducing weight times and ensuring consistency.

283
00:13:57.000 --> 00:14:00.240
<v Speaker 1>That sounds essential for complex tasks really is.

284
00:14:00.360 --> 00:14:03.559
<v Speaker 2>And within run time you interact using primitives. These are

285
00:14:03.600 --> 00:14:08.639
<v Speaker 2>like standardized interfaces for common quantum tasks. They abstract away

286
00:14:08.720 --> 00:14:11.200
<v Speaker 2>some of the hardware variation, like what kind of tasks.

287
00:14:11.240 --> 00:14:13.720
<v Speaker 2>The main ones currently are the sampler and the estimator.

288
00:14:14.000 --> 00:14:17.000
<v Speaker 2>The sampler primitive, for example, is designed for algorithms where

289
00:14:17.080 --> 00:14:20.879
<v Speaker 2>you primarily care about the probability distribution of the measurement outcomes.

290
00:14:20.919 --> 00:14:23.240
<v Speaker 2>You run the search up many times and it gives

291
00:14:23.279 --> 00:14:26.360
<v Speaker 2>you back the counts or quasi probabilities for each result.

292
00:14:26.759 --> 00:14:29.559
<v Speaker 1>Okay, so run time and primitives help manage the execution,

293
00:14:29.919 --> 00:14:31.919
<v Speaker 1>But what about the noise itself? What are we actually

294
00:14:31.960 --> 00:14:32.679
<v Speaker 1>fighting against?

295
00:14:32.919 --> 00:14:35.399
<v Speaker 2>Right the noise? There are a few main culprits. The

296
00:14:35.440 --> 00:14:38.360
<v Speaker 2>big one is decoherence. This is the general loss of

297
00:14:38.399 --> 00:14:40.559
<v Speaker 2>that delicate quantumness.

298
00:14:40.000 --> 00:14:41.639
<v Speaker 1>Losing the quantum magic.

299
00:14:41.360 --> 00:14:44.120
<v Speaker 2>Pretty much It breaks down into two main types. There's

300
00:14:44.200 --> 00:14:47.080
<v Speaker 2>T one time, or relaxation time. That's a long it

301
00:14:47.080 --> 00:14:49.519
<v Speaker 2>takes for a quibit in an excited state like one,

302
00:14:49.600 --> 00:14:52.879
<v Speaker 2>you to naturally decay back down to its ground state zero,

303
00:14:53.519 --> 00:14:55.360
<v Speaker 2>like a hot cup of coffee.

304
00:14:54.919 --> 00:14:56.679
<v Speaker 1>Cooling down, okay, losing energy.

305
00:14:56.879 --> 00:15:00.200
<v Speaker 2>Then there's T two time, or dephasing time. This is

306
00:15:00.240 --> 00:15:02.919
<v Speaker 2>about losing the phase coherence, the precise alignment of the

307
00:15:02.960 --> 00:15:06.799
<v Speaker 2>quantum wave. It's caused by random fluctuations in the Quibbitts environment.

308
00:15:07.039 --> 00:15:09.679
<v Speaker 2>Think of it like trying to keep a group of

309
00:15:09.720 --> 00:15:13.399
<v Speaker 2>spinners perfectly synchronized. When there's random jittering, they drift apart.

310
00:15:13.840 --> 00:15:16.360
<v Speaker 2>T two is usually much shorter than T one, making

311
00:15:16.360 --> 00:15:18.080
<v Speaker 2>phase control really tricky.

312
00:15:18.320 --> 00:15:20.960
<v Speaker 1>So energy loss and phase drift what else?

313
00:15:21.080 --> 00:15:24.840
<v Speaker 2>You also have gate errors. The physical pulses used to

314
00:15:24.879 --> 00:15:28.440
<v Speaker 2>implement quantum gits aren't perfectly precise, so rotation might be

315
00:15:28.440 --> 00:15:33.000
<v Speaker 2>slightly off or introduce unwanted phase shifts and finally, readout errors.

316
00:15:33.279 --> 00:15:36.279
<v Speaker 2>Even measuring the quibet's final state isn't perfect. Sometimes you

317
00:15:36.279 --> 00:15:38.080
<v Speaker 2>measure a zero when it was actually a one, or

318
00:15:38.200 --> 00:15:38.759
<v Speaker 2>vice versa.

319
00:15:38.840 --> 00:15:40.480
<v Speaker 1>Well, it sounds like a mindfield. How do you even

320
00:15:40.519 --> 00:15:42.759
<v Speaker 1>know how bad the noise is on a particular machine.

321
00:15:42.960 --> 00:15:45.960
<v Speaker 2>Quisket actually lets you characterize the noise. You can run

322
00:15:46.120 --> 00:15:50.399
<v Speaker 2>calibration experiments to measure T one T two gate errors,

323
00:15:50.480 --> 00:15:53.320
<v Speaker 2>readout errors for a specific device, and then build a

324
00:15:53.320 --> 00:15:55.960
<v Speaker 2>noise model based on that data. You can use this

325
00:15:56.120 --> 00:15:59.000
<v Speaker 2>model in simulations to predict how noise will affect your

326
00:15:59.039 --> 00:16:01.120
<v Speaker 2>algorithm before running it on the real thing.

327
00:16:01.360 --> 00:16:05.080
<v Speaker 1>That's useful. So knowing the enemy, how do you fight it?

328
00:16:05.360 --> 00:16:09.600
<v Speaker 2>Two main strategies, error suppression and aer mitigation suppression. First,

329
00:16:09.879 --> 00:16:13.000
<v Speaker 2>air suppression techniques try to actively reduce the effect of

330
00:16:13.039 --> 00:16:18.000
<v Speaker 2>noise during the computation itself. A key example is dynamical decoupling.

331
00:16:18.559 --> 00:16:20.799
<v Speaker 2>During times when equip it is supposed to be idle

332
00:16:20.840 --> 00:16:25.320
<v Speaker 2>waiting for other operations, it's vulnerable to dephasing. Dynamical decoupling

333
00:16:25.360 --> 00:16:29.600
<v Speaker 2>inserts sequences of carefully timed pulses, often simple excates that

334
00:16:29.639 --> 00:16:32.960
<v Speaker 2>effectively refocus the corbet's phase, canceling out some of the

335
00:16:33.000 --> 00:16:34.919
<v Speaker 2>slow drift caused by noise.

336
00:16:34.840 --> 00:16:36.600
<v Speaker 1>Like constantly nudging it back on track.

337
00:16:36.799 --> 00:16:39.000
<v Speaker 2>Kind of yeah. It actively fights the diffusion of the

338
00:16:39.080 --> 00:16:39.759
<v Speaker 2>quantum state.

339
00:16:39.879 --> 00:16:42.200
<v Speaker 1>Okay, and error mitigation, how is that different?

340
00:16:42.399 --> 00:16:46.159
<v Speaker 2>Aerror. Mitigation doesn't necessarily prevent the errors from happening. Instead,

341
00:16:46.320 --> 00:16:50.039
<v Speaker 2>it assumes errors will happen, runs the computation anyway, often

342
00:16:50.120 --> 00:16:54.279
<v Speaker 2>multiple times with variations, and then uses classical post processing

343
00:16:54.320 --> 00:16:58.320
<v Speaker 2>techniques to estimate what the ideal noise free result would

344
00:16:58.320 --> 00:16:58.600
<v Speaker 2>have been.

345
00:16:58.879 --> 00:17:01.519
<v Speaker 1>AH, so you clean up the results afterwards using.

346
00:17:01.320 --> 00:17:06.400
<v Speaker 2>Statistics essentially yes techniques like zero noise extrapolation ZNE, where

347
00:17:06.400 --> 00:17:09.160
<v Speaker 2>you deliberately amplify the noise and extrapolate back to the

348
00:17:09.279 --> 00:17:14.039
<v Speaker 2>zero noise point, or probabilistic error cancelation PECK, which learns

349
00:17:14.039 --> 00:17:17.240
<v Speaker 2>the errors and tries to invert them statistically. Quis GET

350
00:17:17.279 --> 00:17:20.759
<v Speaker 2>run Time incorporates these into different resilience levels you can choose.

351
00:17:21.200 --> 00:17:24.279
<v Speaker 2>They use extra classical computation, but are crucial for getting

352
00:17:24.359 --> 00:17:28.160
<v Speaker 2>useful answers from today's noisy intermediate scale quantum and ice

353
00:17:28.240 --> 00:17:30.200
<v Speaker 2>Q devices and ice Q that's.

354
00:17:30.079 --> 00:17:34.039
<v Speaker 1>The current era, right noisy, not quite fault tolerant yet exactly.

355
00:17:34.279 --> 00:17:36.640
<v Speaker 2>We don't have enough quibits or low enough error rates

356
00:17:36.640 --> 00:17:39.799
<v Speaker 2>for full quantum error correction yet, so suppression and mitigation

357
00:17:39.839 --> 00:17:40.880
<v Speaker 2>are absolutely vital.

358
00:17:41.319 --> 00:17:45.119
<v Speaker 1>This battle against noise really highlights the engineering challenge, but

359
00:17:45.240 --> 00:17:49.680
<v Speaker 1>it's leading somewhere exciting the idea of quantum advantage right.

360
00:17:50.240 --> 00:17:52.839
<v Speaker 2>Quantum advantage is the point where a quantum computer can

361
00:17:52.880 --> 00:17:56.720
<v Speaker 2>solve a specific problem faster or more accurately than the

362
00:17:56.759 --> 00:18:00.400
<v Speaker 2>best possible classical computer, regardless of how big or powerful

363
00:18:00.440 --> 00:18:01.559
<v Speaker 2>that classical computer is.

364
00:18:01.680 --> 00:18:03.480
<v Speaker 1>And are we seeing signs of that we are?

365
00:18:04.279 --> 00:18:07.920
<v Speaker 2>IBM Quantum had a significant result in twenty twenty three

366
00:18:08.200 --> 00:18:11.119
<v Speaker 2>using their one hundred and twenty seven quo bit Eagle processor.

367
00:18:11.519 --> 00:18:15.319
<v Speaker 2>They demonstrated calculations related to material science that were complex

368
00:18:15.400 --> 00:18:18.599
<v Speaker 2>enough to be beyond exact simulation by even the most

369
00:18:18.640 --> 00:18:22.839
<v Speaker 2>powerful classical supercomputers using brute force methods. It was a

370
00:18:22.920 --> 00:18:27.119
<v Speaker 2>major step showing potential for quantum utility even before fault tolerance.

371
00:18:27.279 --> 00:18:30.359
<v Speaker 1>That's huge. So what kinds of algorithms actually deliver this

372
00:18:30.440 --> 00:18:31.880
<v Speaker 1>speed up? Can we look at some example?

373
00:18:32.000 --> 00:18:35.440
<v Speaker 2>Absolutely, some of the earliest foundational algorithms really showed the

374
00:18:35.440 --> 00:18:37.880
<v Speaker 2>potential for speed up, even if the problems they solved

375
00:18:37.920 --> 00:18:39.319
<v Speaker 2>were a bit academic.

376
00:18:39.640 --> 00:18:41.599
<v Speaker 1>Like Deutsch's algorithm okay, wud that do?

377
00:18:41.799 --> 00:18:43.759
<v Speaker 2>It solves a very simple problem. You have a function

378
00:18:43.799 --> 00:18:45.640
<v Speaker 2>that takes one bit in and gives one bit out.

379
00:18:45.799 --> 00:18:48.640
<v Speaker 2>Is the function constant always output zero or always outputs

380
00:18:48.680 --> 00:18:50.920
<v Speaker 2>one or balanced output zero for one input one for

381
00:18:51.000 --> 00:18:51.240
<v Speaker 2>the other.

382
00:18:51.680 --> 00:18:53.759
<v Speaker 1>Classically, you'd have to test both inputs.

383
00:18:53.880 --> 00:18:58.160
<v Speaker 2>Right, two checks exactly two queries to the function. Quantumly,

384
00:18:58.279 --> 00:19:01.920
<v Speaker 2>Deutsch's algorithm solves it with just one query. It uses

385
00:19:01.960 --> 00:19:05.720
<v Speaker 2>superposition and interference to check both possibilities at once.

386
00:19:05.680 --> 00:19:08.680
<v Speaker 1>One query instead of two. Okay, maybe not world changing,

387
00:19:08.720 --> 00:19:09.799
<v Speaker 1>but it proved the concept.

388
00:19:09.960 --> 00:19:13.279
<v Speaker 2>It was revolutionary at the time. Then came Deutsch Jozza.

389
00:19:13.440 --> 00:19:17.440
<v Speaker 2>It generalizes the idea to functions with ended inputs. Determining

390
00:19:17.480 --> 00:19:20.680
<v Speaker 2>if that kind of function is constant or balanced Classically

391
00:19:21.160 --> 00:19:24.160
<v Speaker 2>could take potentially many queries up to two to the

392
00:19:24.200 --> 00:19:26.400
<v Speaker 2>power of n one plus one in the worst.

393
00:19:26.119 --> 00:19:27.319
<v Speaker 1>Case, exponentially harder.

394
00:19:27.480 --> 00:19:30.799
<v Speaker 2>Right, quantumly still just one query.

395
00:19:30.599 --> 00:19:32.279
<v Speaker 1>One query. That's astonishing.

396
00:19:32.400 --> 00:19:35.799
<v Speaker 2>It really demonstrates the power of quantum parallelism. And then

397
00:19:35.839 --> 00:19:39.880
<v Speaker 2>there's Bernstein Vaserani. It finds a hidden secret string used

398
00:19:39.880 --> 00:19:42.680
<v Speaker 2>in a specific type of function. Classically, you need end

399
00:19:42.720 --> 00:19:45.359
<v Speaker 2>queries where n is the length of the string. Quantumly,

400
00:19:45.519 --> 00:19:46.680
<v Speaker 2>again just one query.

401
00:19:46.799 --> 00:19:50.559
<v Speaker 1>Okay. These sound amazing, but maybe like mathematical puzzles, did

402
00:19:50.599 --> 00:19:52.240
<v Speaker 1>they connect to real world problems?

403
00:19:52.559 --> 00:19:55.559
<v Speaker 2>They were crucial stepping stones. They proved speed ups were

404
00:19:55.599 --> 00:19:58.960
<v Speaker 2>possible and inspired further insearch. They laid the groundwork for

405
00:19:59.000 --> 00:20:02.960
<v Speaker 2>algorithms with more or direct applications, like the quantum Fourier

406
00:20:03.079 --> 00:20:04.359
<v Speaker 2>transform QFT.

407
00:20:04.759 --> 00:20:08.640
<v Speaker 1>QFT related to the classical Fouria transform.

408
00:20:08.160 --> 00:20:10.920
<v Speaker 2>Very much, so it's a quantum version that operates on

409
00:20:11.039 --> 00:20:15.319
<v Speaker 2>quibit amplitudes. It's incredibly important because it's a key component

410
00:20:15.359 --> 00:20:17.960
<v Speaker 2>in some of the most powerful quantum algorithms we know,

411
00:20:18.359 --> 00:20:22.119
<v Speaker 2>most famously Shores algorithm for factoring large numbers.

412
00:20:21.920 --> 00:20:25.200
<v Speaker 1>AH, the one that potentially breaks modern cryptography.

413
00:20:25.319 --> 00:20:28.480
<v Speaker 2>That's the one. QFT allows Shores algorithm to find the

414
00:20:28.519 --> 00:20:32.799
<v Speaker 2>period of a function exponentially faster than any known classical method,

415
00:20:33.000 --> 00:20:35.200
<v Speaker 2>and finding that period is the key to factoring.

416
00:20:35.440 --> 00:20:38.759
<v Speaker 1>So QFT is a vital subroutine. What about searching? Is

417
00:20:38.759 --> 00:20:40.640
<v Speaker 1>there a quantum way to find a needle in a

418
00:20:40.680 --> 00:20:41.559
<v Speaker 1>haystack faster?

419
00:20:41.759 --> 00:20:45.000
<v Speaker 2>There is? That's Grover's search algorithm. Imagine you have a

420
00:20:45.119 --> 00:20:48.880
<v Speaker 2>huge unsorted database or list with n items, and you're

421
00:20:48.880 --> 00:20:50.480
<v Speaker 2>looking for one specific item.

422
00:20:50.599 --> 00:20:52.640
<v Speaker 1>Classically, you might have to check on average half of

423
00:20:52.720 --> 00:20:55.519
<v Speaker 1>them right and two worst case all in correct.

424
00:20:55.799 --> 00:20:59.000
<v Speaker 2>Grover's algorithm gives you a quadratic speed up. It can

425
00:20:59.039 --> 00:21:02.400
<v Speaker 2>find the item in roughly the square root of n iterations,

426
00:21:02.759 --> 00:21:05.880
<v Speaker 2>so for a million items, instead of five hundred thousand checks,

427
00:21:05.920 --> 00:21:07.640
<v Speaker 2>it's more like one thousand.

428
00:21:08.000 --> 00:21:10.920
<v Speaker 1>Square root en that's still a significant speed up for

429
00:21:11.000 --> 00:21:12.160
<v Speaker 1>large end. How does it work.

430
00:21:12.279 --> 00:21:16.160
<v Speaker 2>It's clever. It uses two main steps repeatedly. First, an

431
00:21:16.200 --> 00:21:20.240
<v Speaker 2>oracle operation marks the target item, usually by flipping its phase,

432
00:21:20.279 --> 00:21:22.599
<v Speaker 2>making it negative. It doesn't know which item is right,

433
00:21:22.640 --> 00:21:23.920
<v Speaker 2>but it can recognize it if.

434
00:21:23.759 --> 00:21:25.759
<v Speaker 1>It sees it, so it tags the winner right.

435
00:21:26.279 --> 00:21:29.599
<v Speaker 2>Then. The second step is a diffusion operator, sometimes called

436
00:21:29.720 --> 00:21:34.240
<v Speaker 2>amplitude amplification. This operation essentially takes the average amplitude of

437
00:21:34.279 --> 00:21:37.960
<v Speaker 2>all items and reflects every item's amplitude about that average.

438
00:21:38.160 --> 00:21:41.079
<v Speaker 2>The result is that the tagged items amplitude, which was negative,

439
00:21:41.119 --> 00:21:44.960
<v Speaker 2>gets boosted significantly, while all the others get reduced using

440
00:21:45.000 --> 00:21:47.920
<v Speaker 2>interference again exactly. You repeat these two steps about sen

441
00:21:48.039 --> 00:21:50.920
<v Speaker 2>in times, and the probability of measuring the correct item

442
00:21:50.920 --> 00:21:51.880
<v Speaker 2>becomes very high.

443
00:21:51.920 --> 00:21:55.440
<v Speaker 1>Okay, these algorithms are powerful, but building them gate by

444
00:21:55.519 --> 00:21:58.920
<v Speaker 1>gait dealing with noise models, it sounds complex for someone

445
00:21:58.920 --> 00:22:01.759
<v Speaker 1>who just wants to apply quantum to their field.

446
00:22:02.079 --> 00:22:05.400
<v Speaker 2>It definitely can be, and that's why IBM introduced quisket patterns.

447
00:22:05.839 --> 00:22:08.480
<v Speaker 2>It's a higher level way of thinking about and building

448
00:22:08.559 --> 00:22:11.519
<v Speaker 2>quantum applications patterns.

449
00:22:10.640 --> 00:22:12.480
<v Speaker 1>Like design patterns and software.

450
00:22:12.119 --> 00:22:13.160
<v Speaker 2>Engineering sort of.

451
00:22:13.240 --> 00:22:13.519
<v Speaker 1>Yeah.

452
00:22:13.720 --> 00:22:17.160
<v Speaker 2>The idea is to provide reusable templates or workflows that

453
00:22:17.279 --> 00:22:20.720
<v Speaker 2>abstract away a lot of the low level complexity. It

454
00:22:20.799 --> 00:22:24.119
<v Speaker 2>lets computational scientists or domain experts focus more on their

455
00:22:24.160 --> 00:22:28.119
<v Speaker 2>problem and less on the nitty gritty quantum circuit details

456
00:22:28.200 --> 00:22:29.359
<v Speaker 2>or hardware specifics.

457
00:22:29.480 --> 00:22:31.359
<v Speaker 1>How does it work? Is their standard process?

458
00:22:31.839 --> 00:22:35.559
<v Speaker 2>Yes. Quisket patterns generally follows four steps. First is map.

459
00:22:36.000 --> 00:22:38.240
<v Speaker 2>This is where you define your problem and figure out

460
00:22:38.319 --> 00:22:41.680
<v Speaker 2>the best way to encode your classical data or problem

461
00:22:41.759 --> 00:22:43.880
<v Speaker 2>structure into a quantum circuit or.

462
00:22:43.839 --> 00:22:47.240
<v Speaker 1>State, getting the problem into quantum language precisely.

463
00:22:47.839 --> 00:22:51.400
<v Speaker 2>Second is optimize. This step takes the con sexual circuit

464
00:22:51.400 --> 00:22:54.079
<v Speaker 2>and adapts it for the real world. It involves transpiling

465
00:22:54.119 --> 00:22:57.240
<v Speaker 2>it for the specific quantum hardware you'll use, and crucially

466
00:22:57.279 --> 00:23:00.119
<v Speaker 2>applying those error suppression and mitigation techniques.

467
00:22:59.759 --> 00:23:01.319
<v Speaker 1>We talk making it robust.

468
00:23:01.640 --> 00:23:04.599
<v Speaker 2>Third is execute. This is where you actually run the

469
00:23:04.680 --> 00:23:08.279
<v Speaker 2>optimized circuit, usually using qris gut runtime, and it's primitives

470
00:23:08.359 --> 00:23:11.359
<v Speaker 2>like the sampler on your chosen back end could be

471
00:23:11.400 --> 00:23:13.680
<v Speaker 2>a simulator or a real quantum device.

472
00:23:13.880 --> 00:23:15.200
<v Speaker 1>Run the job, and.

473
00:23:15.200 --> 00:23:18.279
<v Speaker 2>Fourth is post process. You take the raw results from

474
00:23:18.279 --> 00:23:22.200
<v Speaker 2>the quantum computer, which might be probability distributions or measurement counts,

475
00:23:22.519 --> 00:23:25.839
<v Speaker 2>and process them, analyze them, maybe feed them into a

476
00:23:25.839 --> 00:23:29.319
<v Speaker 2>classical algorithm, and format them into the answer you need

477
00:23:29.359 --> 00:23:30.119
<v Speaker 2>for your application.

478
00:23:30.839 --> 00:23:36.519
<v Speaker 1>Map, optimize, execute, post process. That sounds much more manageable.

479
00:23:36.519 --> 00:23:37.400
<v Speaker 1>Can you give an example?

480
00:23:37.440 --> 00:23:39.640
<v Speaker 2>Sure, The book uses a fun one called the rock

481
00:23:39.720 --> 00:23:43.079
<v Speaker 2>band problem. Imagine you have a logical expression describing which

482
00:23:43.200 --> 00:23:46.759
<v Speaker 2>musicians can play together. Maybe the drummer and bassis have issues,

483
00:23:46.759 --> 00:23:49.119
<v Speaker 2>but the singer needs the guitarist. Things like that. You

484
00:23:49.160 --> 00:23:51.279
<v Speaker 2>want to find valid band combinations.

485
00:23:51.400 --> 00:23:54.240
<v Speaker 1>Okay, a constraint satisfaction problem exactly.

486
00:23:54.799 --> 00:23:59.880
<v Speaker 2>Using quiskit patterns with Grover's algorithm, you wouldn't necessarily need

487
00:24:00.079 --> 00:24:03.799
<v Speaker 2>to manually build the oracle circuit that recognizes valid bands.

488
00:24:04.400 --> 00:24:07.720
<v Speaker 2>You could potentially just define the logical expression itself and

489
00:24:07.799 --> 00:24:11.240
<v Speaker 2>the pattern would handle mapping it to the appropriate Grover instance,

490
00:24:11.640 --> 00:24:14.880
<v Speaker 2>optimizing it, running it, and giving you back the satisfying

491
00:24:14.880 --> 00:24:16.880
<v Speaker 2>assignments with valid band lineups.

492
00:24:17.039 --> 00:24:20.200
<v Speaker 1>Wow, so it abstracts away the oracle construction. That's huge

493
00:24:20.200 --> 00:24:21.200
<v Speaker 1>for Grover's algorithm.

494
00:24:21.279 --> 00:24:24.559
<v Speaker 2>It aims too. Yes, it makes these powerful algorithms much

495
00:24:24.599 --> 00:24:27.079
<v Speaker 2>more accessible for solving practical problems.

496
00:24:27.319 --> 00:24:30.640
<v Speaker 1>So what a journey We've gone from the weirdness of

497
00:24:30.720 --> 00:24:34.319
<v Speaker 1>quantum mechanics superposition, entanglement.

498
00:24:33.920 --> 00:24:36.599
<v Speaker 2>Interference all the way through the practical tools like the

499
00:24:36.720 --> 00:24:41.960
<v Speaker 2>IBM Quantum platform and crisket, the gates that manipulate quibits, tackle.

500
00:24:41.640 --> 00:24:43.799
<v Speaker 1>The challenge of noise and how we fight it with

501
00:24:44.000 --> 00:24:44.759
<v Speaker 1>suppression and.

502
00:24:44.759 --> 00:24:48.880
<v Speaker 2>Mitigation, and explore these incredible algorithms like Deutsche Jersa Grovers

503
00:24:48.920 --> 00:24:52.480
<v Speaker 2>and the concepts behind QFT showing real quantum speed ups.

504
00:24:52.799 --> 00:24:55.319
<v Speaker 2>And finally, how things like quisket patterns are trying to

505
00:24:55.359 --> 00:24:56.880
<v Speaker 2>make it all easier to use.

506
00:24:57.279 --> 00:24:59.359
<v Speaker 1>It really feels like we're moving into a new phase,

507
00:24:59.359 --> 00:25:02.880
<v Speaker 1>doesn't it, This era of quantum utility where even noisy

508
00:25:02.920 --> 00:25:06.000
<v Speaker 1>machines can start tackling problems classical computers.

509
00:25:05.599 --> 00:25:09.079
<v Speaker 2>Struggle with absolutely And that brings us to the final

510
00:25:09.119 --> 00:25:12.440
<v Speaker 2>thought for you, the listener. As these quantum computers become

511
00:25:12.599 --> 00:25:17.079
<v Speaker 2>more capable, even before they're perfectly fault tolerant, think about this,

512
00:25:18.240 --> 00:25:23.440
<v Speaker 2>what problem in your field? Something that seems computationally intractable today, Yeah,

513
00:25:23.440 --> 00:25:27.079
<v Speaker 2>could potentially be unlocked by this technology. How might you

514
00:25:27.119 --> 00:25:30.079
<v Speaker 2>start thinking about mapping that problem onto a quantum state,

515
00:25:30.359 --> 00:25:32.519
<v Speaker 2>preparing for this next wave of computation.

516
00:25:33.200 --> 00:25:36.240
<v Speaker 1>That's a fantastic question to ponder. The journey really has

517
00:25:36.279 --> 00:25:39.319
<v Speaker 1>just begun, and who knows what possibilities will open up next.

518
00:25:39.319 --> 00:25:41.519
<v Speaker 1>It's an exciting time to be watching this space.
