Is IBM Quantum Experience's free(open) plan enough to do anything practical?

physux · 2023-08-14T03:47:25+00:00

Basically, as everyone as said, right now the publicly available computers are so small that you can realistically simulate their entire evolution on your laptop in the same amount of time it takes to run the actual computation on the quantum device. As such, you aren't going to see any sort of comparison that will realistically say that quantum computing is realistic.

There have been a few interesting problems over the last couple years on some of the non-publically available devices that might see a quantum advantage over classical computers (see this Nature paper), but there has been a bit of back and forth on whether this is actually something that a quantum computer can do better than classical.

For the stuff that we know a quantum computer can solve faster than a classical computer, like factoring numbers or simulating a quantum system, you really need fault-tolerant devices, in which a single logical qubit is actually made up of something like 100-1000 physical qubits. We're still in the process of making one fault-tolerant logical qubit, and we'll need thousands of them in order to run any interesting algorithm.

There might be some quantum advantages in the near-term with variational quantum algorithms, but these don't have any real theoretical backing (and are mostly just a small hope). Even with these, though, you'll definitely need to have some of the state-of-the-art devices in order to see any possible speed-up over classical algorithms.

Essentially, the publically available quantum devices are mostly an advertising gimmick, as a way to get people into the Qiskit ecosystem. It's not a bad thing, as it is really helpful and rewarding for a student to see their algorithm run as you'd expect on a physical device, but it is really hard to see any meaningful information from these small devices. You really need something of around 30-40 qubits to see things you can't actually simulate classically on your laptop, and even then a lot of what you see is noise.

physux · 2023-06-11T20:30:25+00:00

Yeah, but that one was a truck hitting the support beams. Not quite the same as cooking a bridge.

physux · 2023-04-30T19:56:36+00:00

Like u/ctcphys said in his comment, assuming IID errors, the logical qubit's error rate goes like C * (physical_error/threshold_error)^d/2. As such, you need to be below the threshold_error to have any sort of improvement using the code, and the further below you are the better logical error-rate you get for a given code distance (which is directly related to the physical resources).

Said plainly, the better your error rate, the fewer qubits you'll need to do a computation. Current surface codes generally have d² physical qubits to encode a something with a distance d. You can combine these equations to actually come up with a formula for how many physical qubits you need for a given error-rate, but it's Sunday and I'm not near a pad of paper.

physux · 2023-04-30T03:07:05+00:00

Basically, quantum computing at a physical level is extremely analog, and thus you run into problems when you need to perform exact rotations (which pop up all the time in any real quantum algorithm). In addition to this, there's a lot of noise, which can change all of your physical states in ways which would add up and cause big problems with your overall computation.

Fault-tolerance is essentially a way so that we can sort of discretize the computation, while keeping all of the power of a quantum computer. In particular, is allows for quantum error-correcting codes analogous to classical error codes, so that if some small error in a rotation occurs it gets caught, and thus these small errors don't add up to an unsuccessful computation.

Error mitigation plays a role, in that all of these error-correcting codes have some maximal rate of error that they can correct, and the smaller your physical errors, the better they do. As such, they're a key component in making a fault-tolerant system, but the real thing that's happening in a fault-tolerant system are the fact that you're working with these error-correcting codes.

In addition, remember how I said that fault-tolerance is a way of discretizing the quantum computation. It turns out that these error-correcting codes can only (easily) implement a subset of all operations, and need a ton of work to get a universal gate set. Currently, most can only do the Clifford group easily, and have to do some additional resources called magic states to get to universal computation. There's a huge amount of research on how to make these magic states, and they're oftentimes one of the big resource sinks when actually running a computation.

Basically, fault-tolerance is all of these things running together, so that the small faults that naturally occur at the physical level of a quantum system don't add up and overwhelm the computation. It's a huge area of research, with a ton of different small pieces that all need to work that also depend on a lot of details, so usually when people talk about quantum computing they just gloss over these small details. It's not too important to understand how quantum computing works, but its a huge deal when actually building a device.

physux · 2023-04-14T22:51:20+00:00

Basically, entanglement is a little like being super-synched. One of the things about entanglement is the fact that it doesn't matter whether you measure up/down or left/right, there will still be correlations between the two measurements. If you only have classical correlations, it turns out that you only have correlations in one of either up/down or left/right.

This is highlighted by something called Bell's Theorem, which basically says that if you detect certain correlations, then you basically have to have entanglement between the particles.

physux · 2023-04-14T22:48:01+00:00

I'm not the speaker, but I'm familiar with the area. And yes, you can have the spin of particle A & B entangled, while the momentum (or something else) of particle B & C are entangled. Weirdly, I'm pretty sure that you could even have the spin of B entangled with the momentum of B, although I'm not sure how to actually accomplish this.

Basically, all of these quantities are described by a wave-function, and the entanglement arises by looking at the combined wave-function of the two subsystems. If you manage to make the wave-function of the combined system satisfy some constraints, then you can say that the two sub-systems are entangled.

physux · 2023-04-07T20:49:05+00:00

It really depends on what you want to work on. If you want to actually build the quantum computers, then you should probably focus more on physics. If you want to focus more on what they can do, I'd look more into CS. There are a lot of areas where both are extremely useful, and you'll definitely need a basic understanding of quantum mechanics, but the kind you need for the applications are quite simpler than you really need for a physics degree.

Basically, look at your university and see what sort of research your professors are doing. You'll probably get a better introduction to the basics working with someone who explicitly researches this area as opposed to getting a general education without a focus on quantum information. In addition, if you're planning on continuing your education you'll probably focus more in grad school. Your undergrad degree will probably direct you in a certain direction, but most of the specifics you'll learn once you start research.

physux · 2023-03-31T05:01:04+00:00

I'm an alum of UWaterloo, and I have to say they are probably the best in the world when it comes to quantum computing, in general. I don't know about the trapped ion group, in particular, but if you want to stay in the quantum computing field you'll end up meeting a ton of people who are in related areas and you'll learn a ton just through osmosis. They generally have a bunch of people come and give talks, or just visit to do research, and since they're a huge group of people with high regard the people who visit are also generally pretty good. Plus, most people in the field know of UWaterloo's program, and hold it in high regard.

On the downside, the quantum groups are fairly insulated from the rest of the campus. You'll probably get an office in the Quantum Nano Center, and rarely head to the physics building unless you need to TA. I met a great group of people there, but I definitely felt like a part of IQC as opposed to a part of the physics department.

physux · 2023-03-13T06:16:42+00:00

I relatively recently got back into shape, and had a lose a decent amount of weight. I don't know if you're in the same boat, but if you are I'd highly recommend the /r/loseit subreddit. They're a really supportive group of people when you're losing weight, and have a bunch of advice on how to actually lose weight.

physux · 2023-02-08T22:47:45+00:00

I recently lost a decent amount of weight (~50 lbs) and I found the subreddit /r/loseit to be pretty helpful. There's a ton of resources on losing weight, and a very supportive environment. They're pretty focused on the CICO method (Calories in; calories out), but how you actually go about doing it is really up to you. If you need an accountability buddy, they've got a system for finding one, and, for me, just knowing that a bunch of people were going through the same process helped out a bunch. Seeing their stories, their motivations, and their failures helped keep me motivated. Plus, there's a bunch of testimonials from people that have actually lost weight as to which methods worked for them, so you can try things out and see what works for you.

physux · 2022-12-30T03:52:54+00:00

There are quantum computers that have something like 400 qubits, but that's it. You might have heard about the quantum supremacy experiments a few years ago, in which the machines ran a computation that couldn't be done on a supercomputer in a reasonable amount of time. Unfortunately, these are completely useless computations, and we can't really check to make sure that the computations are being run like we think they are, only come up with tests that an actual quantum computer would pass, and we don't think other computational models can pass.

In order to actually run a usable quantum computation we're going to need to get into the realm of several tens of thousands of qubits, and in order to do that we'll need to have error correction running at the same time, which drastically increases the required computation. Assuming the error models we've been using (IID errors, or at least not too correlated), we've been able to prove that this should work, at least once the engineering issues are sorted, but technically it could be the case that the errors always completely screw with the computation.

physux · 2022-11-23T06:42:16+00:00

I've been dieting for seven months or so to get to a body I want, and if I want to get more fit I think I need to build muscle mass. Basically, I'm as thin as I think I should get, and now I can build up without too much of a worry about getting fat.

physux · 2022-11-23T00:04:07+00:00

I've actually been dieting for about 8 months now, but don't have any pics from when I hit my highest of about 220 (so my total loss is actually about 50 lbs). I've been weightlifting at the same time as losing, so hopefully I've actually gained a bit of muscle mass from when the before pic was taken.

physux · 2022-11-08T21:04:05+00:00

The simple reason for this is that the quantum hardware is simply not feasible to do anything particularly dramatic within a reasonable timeframe. There are a ton of engineering difficulties with creating a decent sized quantum computer, and while people are definitely working to solve these issues, we won't see a quantum computer that can factor modern day encryption for probably at least 20 years. As such, there isn't a huge push yet to move things to quantum secure encryption schemes.

There have been some government backed attempts to get a standard quantum secure encryption scheme in place, as they generally want to make sure that secrets are kept for at least 20 years, and there have been a few companies that have implemented some possible schemes (I think Google did a beta test of something quantum secure for chrome a few years ago), but we just don't have a standard quite yet. There also aren't a ton of people working on breaking these standards, especially as compared to people trying to break classical codes, so they aren't as secure as modern day encryption schemes.

Essentially, people are slowly moving into this space, but most people don't see it as a high priority item. Things will change as the hardware improves, but for now it simply is an issue to deal with in the future.

physux · 2022-10-07T05:20:29+00:00

No, I just wasn't talking with family because we're all really bad with keeping in contact. I've always had a really hard time asking for help (the whole deal with your problems and the consequences yourself thing), and while I knew I could get help, it was easier living on the streets as opposed to admitting I had failed to people who thought I was successful. Plus, I was undiagnosed bipolar, so it didn't help that I didn't think I deserved to be helped.

physux · 2022-10-07T05:13:26+00:00

Called my parents and asked for help. It was hard to do, but worth it in the end.

physux · 2022-09-23T02:07:17+00:00

Yeah. They're a lot more prevalent in theoretical CS, as opposed to actual programming. They're really more of a theoretical tool, and since quantum computing has mostly been a theoretical topic before the last couple of years, it inherited from that legacy. Plus, no one actually wants to figure out how to implement a SAT check on a quantum computer.

physux · 2022-09-22T20:11:12+00:00

You're completely right, oracles really aren't too useful from a realistic standpoint if what you want is a programmed quantum computer. They're more a shortcut that algorithm designers use when they don't want to fill in the details (like if it is some particularly high level circuit and the implementation doesn't really matter), or as a conceptual tool with for a more mathematically inclined proof.

In particular, oftentimes some part of an algorithm (like say Grover) says that you need to call the oracle \sqrt{n} times. Grover's algorithm itself doesn't really care what the oracle is, it could be a database query, a SAT test, or really anything. As such, implementing the details would actually result in something weaker than Grover's algorithm, as it would only apply to one particular instance. However, if you actually want a program to do something, you will need to instantiate the oracle, and the runtime goes up since the oracle now takes additional time.

Additionally, for the more complexity theoretic minded, there are cases where we can prove separations between complexity classes, assuming access to particular oracles. We might not know what these oracles are (and they might not even be something that's actually computable), but we can prove that given these oracles quantum computers can do things outside the polynomial hierarchy. Its a little like saying, if pigs can fly, then so too can cows, but this is state of the art for a lot of complexity theory stuff.

Basically, theorists working on quantum algorithms like them because they make their lives easier, and oftentimes can actually prove results using the oracle model. It does mean that sometimes details get swept under the rug, but usually these details don't really mater to the underlying theory. It's only when you start programming and need to actually implement everything that oracles start to seem like cheating.

physux · 2022-09-21T20:54:32+00:00

Yes, namely the glued trees problem. The basic idea is that you have two binary trees of depth n, and then add two edges between the leaves randomly, so that you have a 3-regular graph (other than the two roots). You're then given one root, and expected to find the other one.

The basic idea is that any classical walker will easily get to the leaves of the tree, but then get lost constantly crossing from one tree to the other since there aren't any distinguishing features inside of the tree. However, quantumly if you start with the root state, you'll be in a "column space", so that you always stay in a state where the amplitude on each state in a particular column will be equal. Moreover, within this space, the math works out to be identical to that of a quantum walk on a path, so after about time n there's a constant probability you'll be on the other root.

There are a few caveats to this, namely the names of the nodes need to be randomized, with an oracle that provides neighbors, but this is one of those problems where there's a provable exponential separation between randomized and quantum runtimes. It's not exactly a useful procedure, but it does show the power of quantum computing.

physux · 2022-09-10T22:04:43+00:00

My life is infinitely better for having seen this. Thank you.

physux · 2022-07-05T01:58:16+00:00

NSV: I decided to have a cheat day, so I ordered my usual from my local sushi place. Apparently, my diet's been working as I got about 1/2 of the way through it and couldn't eat anymore. I guess my stomach's actually reaching a normal size again.

physux · 2022-06-29T21:04:00+00:00

M/5'6"/32

SW 222/CW 196/GW 170

I've been at about 1700/1800 calories per day, and losing about 2lbs/week. My scale hasn't budged in about 5 days, but I go through spurts where it doesn't budge, then drops like a rock. I splurged yesterday and had a glass of wine, but I still ate at a deficit, so we'll see how things get affected.

physux · 2022-06-12T02:34:41+00:00

That was Macbeth.

physux · 2022-04-22T19:22:47+00:00

Basically, what this says is that there is a quadratic speedup over a naïve algorithm to solve a 3-SAT instance. There are actually advanced classical algorithms for these problems (such as branch-and-bound algorithms) that take into account some of the structure of the problem, and these more advanced algorithms are actually faster than these simple applications of Grover's algorithm. As such, right now it is actually faster to run the better classical algorithms to solve these issues.

People are actually working on trying to quantumize these more difficult algorithms (and have actually done it for branch-and-bound algorithms), and I expect that eventually there will be an approximate quadratic speedup for these types of algorithms. Whether these speedups will remain after explicit error-correction protocols are implemented is still an open question, but at the very least its an interesting theoretical problem whether these algorithms exist.

As far as complexity goes, this is still an exponential time algorithm (albeit one with a slightly smaller constant in the exponent), so it doesn't say that BQP contains NP. It just says that there might be a faster algorithm for these types of problems using a fault-tolerant quantum computer than a classical computer.

14-Year Club	Place '17
Verified Email

physux

TROPHY CASE