動画数：214件
The visuals are crazy. How did you make them?
- The confusion
- | Introduction and Confusion About Grover's Algorithm
- | Classical Verifier Functions and Examples
- Example: Sudokus
The sudoku grid at has 11,447 solutions so this is already a good example of a function with multiple correct inputs.
Trivia: I wanted to try my hand at the example sudoku at , so I entered it into a grid on a website and asked it to check. It turns out that puzzle has 11447 solutions, so it cannot be solved logically. Oh well.
Don't try to reverse-engineer SHA-256, kids - you'll just make a hash of it.
- | Utility and Speedup of Grover's Algorithm
"Its not like the key value is hiding inside the function behind some curtain, its more of a difficult to find EMERGENT PHENONMENON of the function of itself". THIS, i believe is the primary source of the confusion. Its not necessarily the inputs or the outputs of the function: its the behavior of the function itself that is of interest. I believe this is the fundamental point that you need to elaborate on, and when you develop your exemples you need to tie it back to the behavior of the function itself.
- | Compiling Classical Functions into Quantum Logic
. This is a minor correction on terminology. When you take a function and turn it into logic gates in classical computing that's called synthesis, not compilation. I understand that using the correct term in the video won't help the average viewer understand the core point of the video any better, but maybe It could be adjacently useful for someone early into studying CompE.
- | Quantum State Vector Manipulation
- | Grover's algorithm leverages the translation of classical verifier functions into quantum operations that manipulate vector states, enabling the search for solutions without knowing them beforehand, thus bridging classical verification and quantum computation.
I think I had my confusion resolved within ~ min. I failed to grasp, that the quantum algorithm manipulates the probability distribution of the current 'state' and is programmed for a specific case (like a sudoku solver). Now I can just accept the mentioned operations (multiplication by -1, or flipping around some vector) exist and be happy with the explanation. I also wonder if I could have just reviewed the first video, but the opportunty to that experiment is now lost to me 😆Thanks!
- | Clarifying the Quantum Operation and Addressing Confusion
A quantum leap?
At about @-ish you're talking about whether it was too much of a leap - it wasn't, I'd come to that conclusion from what you said, but it still felt pretty magical I think mainly because you skimmed over it quite quickly. It was almost like sleight-of-hand in that I got the idea but it did leave me with a slight dissatisfaction/unsureness about whether I'd extrapolated correctly what you were driving at. This clarification was exactly what was needed, and honestly I can't say it doesn't work better as an addendum rather than being a diversion in the main video!
@@kindlin Well, he did sort of explain how it would be translations of the logic gates into operations on the state vector (which would be rotating it, flipping it in certain ways etc.), but that () going into more detail wouldn't actually give better clarity, which was the point of this video. So basically he said that's too into the weeds for this video 😉
Hey, I really respect you as an educator, I think you generally do great work, but I think you do yourself and your audience a disservice at when you imply a large language model like Claude can help explain a topic like this. You've done videos on how LLMs work- surely you know their output has no real relationship to the truth. They're great at producing probable sequences, but they're much more likely to produce plausible or almost-correct misinformation than any actual answers. Offering it for a complicated topic your audience may already be confused about is disappointing to say the least!
in Video
Also as a side-note, the Brooklyn Nine-Nine reference at was totally unexpected but I absolutely love it!! Instantly recognised it - name one law :) pretty cool to see that you (probably) like it too.
For me, the biggest revelation of this video was . In order to translate it to a quantum computer, you DO need to know the contents; it isn't just a "quantum wrapper" around a normal function. This is what I would have thought was the case, but, as you identified, the combination of the "black box" phrasing and showing that the function clearly knows the search value made it seem like this couldn't be the case. Then you would find the answer in the process of translating the function to quantum. Perhaps an example such as "can make platonic solid n-gon with pentagons" is a good example since it clearly doesn't "know" it's own answer, would theoretically be difficult to check, but it's also pretty clearly just 12.
that to return true we flip the ENTIRE input vector (every "bitstring's" vector), but then it feels like suddenly to return true we only flip the vector at a certain bitstring. This is almost certainly my misunderstanding of the difference between the k dimensional representation or whatever and the vector of a specific qubit, but it really is confusing me. Like in a classical sense it feels like I would need some huge number of "bitstring" positions to represent every sudoku position to even begin to use the verification function, how could a quantum computer even set up that environment to work under? Does it require a huge number of qubits to work? If each qubit could only represent
"Which specific key input does this is a difficult to find and emergent property of those logic gates"
- Linearity
i like that the "half of the reason for making this video" comes at the halfway timestamp
- | Quantum Superposition and Linearity
hate to break it to you but that is a misunderstanding of quantum superposition grant! It doesn't correspond to north and east. Mahesh Shenoy posted a video targeting this misconception.
that velocity analogy was helpful to understand superposition
When you can't even say my nameHas the memory gone? Are you feeling numb?Go and call my nameI can't play this game, so I ask again...
The state vector component magnitudes can be a complex number as well?? Yikes.. Just as I thought I was maybe starting to understand it just a little bit.. 😅
I think the confusion must come from the fact that we don't know the actual vector, only the measured result which comes from the probabilities. And the trouble is |1011⟩ gives the same probability as -|1011⟩ (it's squared right?) but even then, we only get one sample result when we measure it. So the function itself doesn't get us much.
this is the kind of explanation I was hoping for in the main video when i was confused about the same thing. "i know quantum computing is an entirely different beast than classical, so what logic gates do we have to work with and what do they do?" just as a baseline understanding to show that translating an arbitrary classical function into a quantum one is possible. The sudoku case is a great example as its easy to understand what the check function does, and the key value that gets its axis flipped by the quantum check function is not because it is "the sudoku solution we are looking for" but instead because its is "a valid sudoku solution"
- | Linearity in Complex Quantum Functions
At the term "solution" is a little overloaded. The mention of "every possible solution" means incorrect solutions also. A few seconds later "solution" is used to mean just the correct solution.
I think the part that confuses me the most is at . In classical computing it feels like this would be like generating every possible configuration (the shear size of the possible configurations here is what really breaks this for me), asking the function if it's valid (idc whether or not it's parallel, it just happens), and then returning some array of booleans where one of them is true, but due to some arbitrary physical limitation (quantum computing) it takes us a little bit to "retrieve" that solution from the result array. It feels as if the algorithm requires that the blackbox return some sort of state other than true false (I know I'm beating a dead horse sorry). Like I thought I understood from 2 bitstrings max (it has the 0 and 1 axis) then wouldn't we need tons of them to represent all possible states of a sudoku board in the input (very high dimensional) vector of the verification function? I really would love to understand this, and I think it comes from just a misunderstanding of the physical implementation of that input vector for the verification function.
As you see in , the quantum gate somehow flips a value (which is a fair function), but (a) why is it statistically very likely in every run the same vector index, (b) how does Z behave when the number of dimensions is low / in the RSA prime size and keeps its statistic significance on the vector index, and (c) why does the flipping happens in exactly the qubit that is statistically very likely to be of (cryptography) relevance here?
phase (I think this is where the "in parallel" analogies stem from ( in Video 2)). It's not so much a question or confusion around Grover's Algorithm. But that first step that causes us to need Grover's Algorithm is the confusing magic that is just too much. I know you said you didn't want to show how the gates works because showing classical gates wouldn't help you understand a calculator (2), but I think THAT is the crux of it for most people... even though your video clearly clarifies that it's about Grover's Algorithm with the parenthetical title. For me I think I do want to study up on quantum compilation, so thank you for calling that out.
Does the part at tell us that at the end it's just : "quantum computing does all thing in parralel but we need O(sqrt(N)) to decode the result" or is there something big I missed ?
That is an excellent point about whether quantum computing can be considered parallel or not. I think the most important part about it is what usefulness we can get from it that we can't get from other forms of computation. However, since we never actually get more than one input out despite the amount of "parallelization" we can get depending on the design of the machine, it depends on how we want to say we got the result.For instance, performing an operation on a superposition of North and East may not matter whether we do it on both directions at the same time or on the superposition itself, what matters is whether we need to pay attention to something happening to a specific direction, as in the case of quantum computing. If you need to know which cardinal direction you are closest to facing at the end of a bunch of turns, it may be more useful to think of each cardinal direction being operated on separately rather than as a single angle, for instance.Of course, it all depends on the problems, the framing, the operation, and the interpretation of results. I still like to think of Grover's algorithm as being a parallel operation on many elements of a vector with the same operation, even though one can only get a "scalar" result. At least that is how it makes sense to me.
This analogy really cleared things up for me. Choosing this basis for the state space certainly makes it look like the function "knows" which direction is the answer, but the function exists independent of what basis we chose.
I found the hiker explanation at very helpful! (Also it is comforting to know that even 3b1b, best at explaining there is, sometimes is unsure whether he's over- or under-explaining :)
I still don't get it, but I feel that the vector composition part at maybe helps a bit. What if instead of talking about a bunch of 3D vectors combining, it was illustrated as a bunch of 2D vectors, all added head to tail. Maybe each little vector is like a each state, and then the vector as a whole is what you get added up, and then the algorithm will change those and we can see how the vector as a whole changes. I'm just not sure what the analogy would be. Maybe it would be like rotating all but one vector? But then we can still subtract the two vectors to get the true answer. Maybe it's more like all of the vectors are random, except the one true one? So you can find the most likely average vector? But then I don't understand how that would pertain the iterating it.
- | Understanding the linearity of quantum operations helps clarify that Grover's algorithm, while theoretically powerful, offers limited practical speedup for extremely large problems, tempering expectations about quantum computing's impact.
so - if i understand it correctly, the key is simply the only one to respond properly or respond at all to you trying to flip it
I'd say Yes, because as someone else said, each section holds a unique piece of information that do not affect each other , but also because in every practical term of the process, specially in the context of this algorithm, it is applying the check algorith to all parts of the vector in the same function and command. I think for me personally the confusion came from the statement "not just running parallel" with an emphasis on "not", when the algorith relied on a check that was effectively just "running parallel" what needed emphasis was the "just", nevertheless, the rest of the explanations made sense in the context of assuming the shorter leaps in logic to be true, it was the major leap of assuming there was a function that was both impossible outside quantum and was not effectively just running parallel checks on all parts of the vector. Which just to clarify, to me and many others, that is what is happening because it is applying the function to each part of the vector at the same time as even with the linearity, it's not the same effect for all like in the cardinal directions example (even if it technically is because of rotating around an axis in this case, as with many others it will not be simply one rotation), I do understand the danger of the generalization of parallel computing, but I believe it would be more understandable for most if it is stated that there are more required steps BESIDES the parallel computing rather than saying there is no parallel computing.
- | Grover's Algorithm Basics
At about was the place where it all cleared up for meWe dont make, but already have the initial function that flips one value out of many (the quantum equivalent of sha256 for example)and then we apply to the result out new functionthats pretty much where i got confused in previous video
Great job on adding clarity! does a great job of explaining the conditions under which Grover's Algorithm applies, but your summary at
I think the root issue is that the point at was not emphasized enough, and the way it's visualized implies we know what the vector looks like. If it was a vector with all values "blurred" until we get the final output, that might have made it more clear that we can't see the vector the way the video portrays it
aah, so the operator that we're applying onto the state is the quantum translation of the original verifier. This is what was missing for me! This is fundamental to understand the whole idea. Thank you for explaining better.
that clicked for me
so how is the well chosen set of inputs chosen, and what is that other operation? Does it entirely depend on the original problem and the verifier? If so, how are they used to find the input set and the 2nd operation?
I think the animation in is clear
Instead, we need to do the full M steps of Grover's algorithm to slowly increase the likelihood of reading outcome |k> when we take a measurement of the latest vector output by the "circuit" after each of the M steps (the vector shown as "wires" between boxes at in the first quantum video, let's call those M vectors the "result" vectors, since the video doesn't give them a name). We keep doing more and more steps until we maximize the probability of measuring a "result" vector as outcome |k> (and M steps is the right number of steps for this). The fact that we have to do this M times is why it's not an O(1) algorithm. The fact that we have to do this M times is why it's partially misleading to say we're "testing all the outcomes in parallel" (since WE can't just connect a multitester lead to check the probability of an individual outcome of any given "result" vector) though I still think it's CRITICAL FOR TEACHING to say that the quantum computer is trying all the outcomes "in parallel" so people can have a sense of what's going on and why there would ever be any speedup.
sir you're under-explaining things and over-explaining things at the same time, it's quantum computing DUHH
- | Geometric Interpretation of Grover's Algorithm
this was the only part that was a little confusing from the last video for me, thank you
undermines the explanation, because one of the operations necessarily confines the state vector to the 'critical planes' which contain valid solutions.
at In fact, the fact that the vector is confined to a plane is a consequence of the fact that there is only 1 "right" solution we are looking for, which effectively create a single "cutting plane" for the algorithm. But if there were 2 solutions, it would not be a plane anymore, but a volume for instance.... (if my understanding is right).
- | Practical Limitations and Realistic Expectations
- Is this useful?
There are applications where you can narrow the search space such that the square-root speedup becomes practically relevant. E.g., if you are trying to crack an 8-character password based on its hash value, the difference is between O(2^64) and O(2^32), which under a few reasonable assumptions is years vs. minutes. Hence the trend toward using long passphrases instead of short passwords.
[] Even if other algorithms don't break cryptography, at least the Shor's Algorithm will.
-- the brown Pi shitting on the quantum computing hot shuff is a nice touch :)
I love the small easter egg at with π and φ 👌
- Misconceptions
The video starts with a "mystery function f(n)", and it really looks like a black box algorithm setting. ()
12 is my favorite number. i am somehow flattered that it's the one that is highlighted.
@ , 42 is always the answer to the universe. THanks for this great video otherwise.
I'm glad to know the answer at was 42. It verifies that Hitchhiker's Guide to the Galaxy was a quantum computing primer!
For a list of N elements, it takes (N+1)/2 attempts on average, not N/2.
as stated at ? If we have N numbers from 0 to N-1 and one of them is the key, the expected value of the number of required guesses is then essentially the same as the average position of the key in the sequence of N numbers, which is (1+2+3+....+N)/N = N(N+1)/(2N) = (N+1)/2. Did I miss something? Thanks again.
Because of this very setup, one can ”improve” almost any algorithm that can be checked in linear time by simply checking all the possible inputs. Bruteforcing a password for example is an O(n) operation.
going with the video, as far as I know this depends wildly on the setup you can getwith lowest being around O(1) when you have N qbit device and you can chug entire superspoition through that function and if it can bring one probability to a 100 and rest to 0 it would only need one cycle to preform whole operation but if that probability is just high like 50% of being right and 50% of beign wrong, maybe dependable on N etc. this will elongateand at the other side if the functon isn't very "quantable" or you have very small qbit register or whatever it can go as high as O(n)
omg this is soooooo satisfying to watch and understand-ish
About the misconceptions on the speed of quantum computers () :
It’s so weird to me that not only people guess this answer, but that it’s the most common guess.
well its probably also that when one answer is O(1) it sounds like a trick question so „it has to be that“ in the minds of people
quantum computers can't have exponential speedup, because they are turing complete and can be represented by a turing machine (albeit a ridiculously fast and large one). And if a turing machine can achieve exponential speedup, that would basically mean NP=P which is unproven and highly unlikely to be true.
On the topic of why people might guess O(log(n)) (at ): I think you're thinking too much with your math brain, not your CS brain. O(log(n)) is divide-and-conquer style solutions, where you can divide your "problem-space" into smaller and smaller chunks. For this problem, if the quantum chip could say yes or no on if the True value was contained in a set, you could take half of the remaining numbers for each step resulting in O(log(n)). Nearly all sublineair solutions are basically some version of this.
This actually is no longer correct! As of November 2024 a new variation on Grover’s Algorithm has been created known as the partial oracle Grover’s algorithm that *does* give an exponential speed up, with the caveat of only working sometimes (and other times slowing back down to a polynomial speed up) But for the question of “best possible time complexity” O(log(n)) is actually correct
I was able to guess the right answer because I knew square root can be found in probabiloties from your video with min of 2 dice rolls)
The factors of the big number are just first few digits of pi and e
i loved when you said that Shor‘s is the most famous example, while it’s actually the *only* relevant problem we know that is exponentially sped up
I got it right!
, well ceil(pi/4) is just a fancy name for 1 😛😛😛, didn't you mean something like ceil(pi*sqrt(n)/4)?
- The state vector
At , it’s interesting that this kind of broke my internal ordering/deviated from what I would have been inclined to do.
Love how "01000011" is actually 67 and 'C'. Such attention to detail!
"[...] teaching computer science without discussing hardware."Fun fact: In German, the term for computer science is "Informatik", which is like mathematics but for information. This word tells you that you can do CS without a machine, it is just about information processing. We just so happen to have machines that are scaringly good at processing information.
I planned to watch missed Asianometry episodes, but then, bam! This came in! I'm now at and already i love this video :D
"if you kept reading out from memory over and over, you would just keep seeing that same value" I'm afraid that might be incorrect, or at least somewhat misleading. In a quantum system, if you repeatedly measure a register that's in superposition (re-initialized each time to the same state), you'll observe outcomes according to the probability distribution defined by the amplitudes — not always the same value. Perhaps what you meant is: if the system has already been measured and thus collapsed into a definite state, then repeated readings would indeed return the same value — but that's a different scenario :)
“think of it as some super high dimensional space” yeah man i got what you are trying to say, continue
^k notion of dimensions at ) if that's ever a future idea of a video (especially in ER = EPR for describing how the Einstein Rosen bridge gets "longer" as the entangled black holes evaporate).
I love how you throw out in the vector demonstration around “instead k^2 dimensions instead of 3 dimensions” yeah super easy to comprehend, thanks
if you square any real number (positive or negative) you'll always get a positive number
Take ''Alot of people don't know what the state vector represents'' re why we square the magnitude of each component of the vector.- The sum of all possible state vectors equals zero, and a plot of this results in a unit n-sphere. The sum of square equals the square of the radius of the sphere (in this case 1²=1). But how do I know it's a unit nsphere? Cause the state vector consists of probability components. And the cumulative probability of any Universal set must equal 1.
just guessing but is state vector, wave function, because we square that to get the probability, right?
- Qubits
- "After all, something is going to happen"
Instead, we need to do the full M steps of Grover's algorithm to slowly increase the likelihood of reading outcome |k> when we take a measurement of the latest vector output by the "circuit" after each of the M steps (the vector shown as "wires" between boxes at in the first quantum video, let's call those M vectors the "result" vectors, since the video doesn't give them a name). We keep doing more and more steps until we maximize the probability of measuring a "result" vector as outcome |k> (and M steps is the right number of steps for this). The fact that we have to do this M times is why it's not an O(1) algorithm. The fact that we have to do this M times is why it's partially misleading to say we're "testing all the outcomes in parallel" (since WE can't just connect a multitester lead to check the probability of an individual outcome of any given "result" vector) though I still think it's CRITICAL FOR TEACHING to say that the quantum computer is trying all the outcomes "in parallel" so people can have a sense of what's going on and why there would ever be any speedup.
, it would have been extremely helpful for my quantum computing course. Howeevr, I need to correct you in . It's not just a unit circle, its something called a Bloch Sphere, which in itself is what we call a CP^1 or a complex projective space of dimension 1. Its because of this that we take |x|^2 instead of simply x^2, and that's because the coefficient of |0> and |1> can also be complex, with the restriction that |x|^2+|y|^2=1
“Added *bit* of *complex*ity” 😂
As someone who took introductory quantum mechanics course the first aha moment is at showing what a qubit REALLY is
TODO continue from
Nice Schrödinger's Cat reference at
- The vibe of quantum algorithms
I found this bit where the circuit is drawn just gorgeous
-bit CLA, seeing one pop up at gave me a sensible chuckle
I bet that circuit does something interesting. Waiting to hear from people that know.
Example: a coin (deterministic) + Quantum vector = would be to have a 50/50 probability it would land either "heads" or "tails?"
@ Minor pedagogical point - applying a Hadamard gate twice would actually take a |0> state to a (negative) |1> and not back to |0>. I find it useful to think of the Hadamard transformation as half of a bit flip. Leading directly to the intuition that two Hadamards simply flips the bit.
I have a suggestion for ur visuals as ur visuals are the best of the best but to touch the elite line u can put the anime style in this, particularly on
in this
- Grover’s Algorithm
Question here: At , why do you flip the sign of only the secret key? if it is supposed to be unknown???
but how do i know beforehand what is the secret key value im looking for? How would this work in practice if say i try to force a password?
perhaps it’s on my brain a whole lot lately, but every time you talk about using this algorithm as a search, my brain adds to the list of applications “finding the most probable next word in a sequence of words”
Nice video as always, but the logic gates circuit for the function at is just bad. You only need 3 2-input and gates & 2 not gates to verify a 0101 (5). Boolean algebra.
- Why is that: "Grover knew that given any ensemble of logic gates like this, you can translate it into a system of quantum gates, so that if in the classical case the function takes in some binary input and returns a one, for true, then in the quantum case, the effect of all of these gates is to flip the sign of that state; the state associated with the same bitstring."
But at , we have to translate the function to a quantum equivalent, that instead of verifying if the answer is correct, flips the sign of the correct coordinate. The "you can translate it" is not about a theoretical possibility here, you really have to (very carefully) translate the classical verification algorithm into the quantum "secret axis flipping" algorithm.
Great video as always! The only part that’s still unclear to me is how the system of quantum gates at is able to invert the amplitude of the key item. More specifically, how is it possible for this to happen in so few steps that the overall complexity remains proportional to √N? This is something many textbook explanations don’t really clarify, and I was really hoping for a more precise understanding of this part of Grover’s Algorithm from the video.
it reminds me of Cook-Levin theorem
I feel like the real magic is happening with the quantum gates (), and I really don't understand it. So to take all the input values then run them through the quantum gate, with the goal of reversing the logical value of the key, would take N time, right? And why couldn't the process just end once a value has been flipped? Everything else just seems like a cool algorithm to find a needle in a haystack, but what I want to know is how they take a haystack and turn the key straw into a needle in seemingly constant time.
I think tries to answer my question, but the operation does not feel "useless" it feels like: if we can flip the sign of the key component, then we are already done because we already know the key direction.
mentions that the quantum gate "simply" flips the key value. Wouldn't it have to process a N dimensional vector every time ? Isn't the difference between the quantum gates doing something very different here(parallelism?) that enables much of the speed gain?
I think you may misunderstand me (or I'm just not understanding). We only know the key direction because a value was flipped (turned negative). In order for the state vector to be originally flipped, the value corresponding to the solution for the given problem, the states needed to be passed through the quantum gate (). Once the specified state vector was given a negative value, then the probability shifting occurs. I don't understand how first process occurs, in what seems to be constant time.
why does he use the term "state vector" at then? Does me mean to say that a specific component of that state vector is flipped?
Something I don't really understand, if you need flipping the sign of the value at the position corresponding to the solution of the problem, then shouldn't that require that you know the solution already? I've probably missed something that tells about that, but just quickly asking it here.
Always love your videos. One thing a layperson like me might hold onto is, how does the Algorithm "know" which one is the secret key? And therefore even start to run that process show in
Another great video, I just didn't get one thing - you say quantum computer can put the key value on one axis and "average" all the other values into the other axis - but isn't the whole thing about not knowing what is the key value in the first place? If we don't know where to go, does it mean we just try every direction? And how do we know we went into the correct answer direction and not some random one?
How do we find equibalance of the non-key states ?
This reminded me of your lecture about AI embedding spaces, how with the growth of number of dimensions, you are guaranteed to find more and more perpendicular vectors.
Please explain this, i am ultra confused - : if we don't know key value how can we perform flipping it's sign or any other reflection operation regarding it's position.
*focuses in learning
Great explanation! Admittedly, I’m still a bit confused by how you “flip about the x-axis” (or flip the sign of the key value) when the x-axis seems to be defined by “not the key.” It seems the key needs to be known to flip the sign associated with the key value (flip the sign for the component associated with the key value?
when flipping the state vector around the "equal balance direction", how do you avoid also transforming the key vector?
- yes, indeed... "In general, if you can clearly describe and access one of these state vectors, it's also perfectly possible to reflect around it."
b does seem to imply this at , but I'm not sure this is what he meant.
if we can access the vector then it's possible to reflect around it but how we have the access to vector aligning the x axis
I doubt that's it, but just in case you're talking about applying a fast-exponentiation-like approach for the part by rotating the vector by 2theta, 4theta, 8theta and so on and so forth (choosing a recently obtained vector as an axis instead of |b> each time). That approach doesn't work because you cannot duplicate quantum states (no cloning theorem). Basically, if you want to use a quantum state twice you have to build two copies from scratch and that defeats the point.
This was extremely helpful to me, confirming the vague notion I had about what quantum computing is about while also providing intuition about what a quantum algorithm is.However, I am still confused at , where you "first flip around the x direction and then flip around this off-diagonal direction" these seem to be unlike each other. The x direction stands for the orthogonal to the (unique solution) y direction, so it is in fact the hyperplane of all directions that are not y. But the other direction is given by just your single initial-state vector. so flipping around it is not well defined, in any case not as a geometric reflection. So it looks like you are trying to compose a reflection with something that is not a reflection in order to obtain a rotation, and that does not seem to work (except in dimension 2).
After the first reflections, why can’t you then reflect around the new higher vector you created, to get to the top faster?
so its just a computer
This video is great. you could use classical computers to calculate the root of N but it is a bit expensive.
I started to understand at around
Until you finally mentioned at ish that... you can just check it, since the premise was that the answer is quickly verifiable.
- Support pitch
- Complex values
complex numbers elegant application
- Why square root?
The fascinating thing about the section is that I took the square visualisation of the beginning and basically immediately understood why it is squared thanks to Pythagoras. Because even if we consider parallelism, picturing it with a square or cube or whatever, leads us to consider "going along" all the edges at the same time. Which, in the simplest case of the square, means that we, well, have to put all of the possible outcomes into a square. Which we, of course, can't do without taking the square root.
ofc its pythagoras its always pythagoras
Hey I recognize this!!That's the Cover Art for Richard Hamming's The Art of doing Science and Engineering!
Wow, that created an optical illusion that glitched my mind HARD
"Panoply of additional directions" Beautifully put
why is the shortcut squareroot sized when the vector doesnt move the whole way (just an approximation of pi over 4)? Wouldnt that mean that the shortcut the vector takes is ALMOST squareroot sized? (Kinda like the almost pi endzone in your last video)
- Connection to block collisions
finally, *the* one Brown
- Additional resources
flashbang alert
Q 1 – Early stop at sixty degrees• Chance of measuring the correct item: 75%.• Grover iterations used: roughly 0.52 times the square root of the database size N, which is about 2/3 of the work in Grover's original algorithm.• Why: each Grover step rotates the state by a tiny fixed angle; stopping when the total turn reaches 60 degrees means you have not yet maximised the success amplitude, but you have saved time.
interesting so the function we're optimizing here is essentially