It depends how much circuit optimization you consider to be cheating. The hard part of Shor's algorithm is computing `pow(g, e, modulus=N)` where g is a unifor

It depends how much circuit optimization you consider to be cheating. The hard part of Shor's algorithm is computing `pow(g, e, modulus=N)` where g is a uniformly random number, e is a uniformly superposed number, and N is the number you want to factor. But note that 15 is one less than a power of 2, so modular arithmetic mod 15 can use special circuits that are surprisingly efficient. Since it's easy to check if a number is one less than a power of 2, there's no obstacle to using this optimization on a "real" problem. On the other hand, most products of two primes aren't one less than a power of 2 and so this case is absurdly rare. So is using the more optimized circuit allowed or isn't it? It get so much worse. In [1] it's shown that, if you know the factors behind a factoring problem of any size, you can derive constant sized quantum circuits that "solve it". Basically, you can force Shor's algorithm into a trivial corner case and then implement the corner case. For all intents and purposes this makes the quantum computer irrelevant. E.g. I used this result for an April fool's post where I "factored" the largest number ever "with" a quantum computer [2]. The other problem with Shor's algorithm on small cases is that as soon as you get a "correct" output from the quantum part the following classical part will succeed. But for small cases there are too few possible outputs. Even if the quantum computer is totally broken and generating random noise, the algorithm will still succeed pretty quickly. So you need to define success as some kind of noise metric to beat, instead of as actually solving the problem. Here is maybe something that will answer the intent of your question. I haven't checked on this particular chip, but from experience with running things on various quantum computers and from the numbers in the data sheet, I can confidently say that this chip will struggle to count to 10 before suffering an error. A 4-qubit increment circuit is going to use at least 10 two-qubit gates [3], you need to increment 10 times, and the listed two qubit gate error rates are around 1%. So presumably the success rate is going to be on the order of (99%)^(10*10) ~= 35%. Disclaimer: I work on the google quantum team. 1: https://arxiv.org/abs/1301.7007 https://arxiv.org/abs/1301.7007 2: https://algassert.com/post/2000 https://algassert.com/post/2000 3: https://quantumcomputing.stackexchange.com/a/3975/119 https://quantumcomputing.stackexchange.com/a/3975/119