# Beware of Quantum Algorithms Dependent on Fine Granularity of Phase

Phase is central to quantum computing, but there is a risk that algorithm designers may lean too heavily on fine granularity or gradations of phase, seeking a precision that just isn’t there in the theory or actual physics or engineering of real qubits. This informal paper will explore the phase property of qubits, with an eye on the limits of precision or granularity of phase.

Unfortunately, this paper may provide much more in the way of questions than in actionable answers, but coming up with deep and clear questions is the first step to getting answers that are both meaningful and actionable. The focus here is coming up with better questions, which over time can be answered by both those who develop theory and those who develop real quantum computers.

Note: Quantum computing technology is a moving target, constantly evolving, so what might be true today — or at any other time — may not necessarily be true at some arbitrary time in the future.

# In a nutshell

What is phase?

- The quantum state of a quantum system has wave-like or cyclical behavior. A two-state quantum system such as a qubit has two waves which are not necessarily in sync. Their degree of synchronization — actually the
*difference*between them — is their*relative phase*or*relative phase angle*. That*relative phase angle*is known as the*phase*of the two-state quantum system (qubit.) - If the 0 and 1 states are the two main components of the state of a qubit, phase is the third component of the state of a qubit.

How fine is fine granularity of phase?

- Granted, it’s a vague and ambiguous term, but
*fine*granularity of phase generally means more gradations than an S or T gate (90 or 45-degree gradations.) Say 12 or 16 or more gradations. The open question is whether dozens, hundreds, thousands, or even billions or more gradations of phase are supported by both the theoretical physics of qubits and the technology and engineering of real qubits.

Key takeaways:

- Qubit values have a third component beyond superposition of binary 0 and 1 — phase.
- Using phase as a simple binary flag such as for constructive and destructive interference is probably reasonably safe.
- Two or three bits of precision of phase (three to eight gradations of phase) are probably reasonably safe as well. Such as the S and T gates (90 and 45-degree rotations.)
- But all bets are off beyond a few bits of precision — exactly where the
*breakpoint*occurs is indeterminate at this stage of the technology. - One would hope that 16 gradations of phase would work reasonably well, but even that is a question mark.
- Maybe 32 to 64 gradations, or even 128 to 256 gradations of phase might be workable for more advanced qubits.
- But one could be skeptical of hundreds or thousands, let alone millions or billions of gradations of phase.
- In any case, vendors of quantum computers (and service providers as well) need to fully document any limitations on phase for their qubits.
- Vendors of quantum computers should annotate their product roadmaps with number of gradations of phase supported at each stage of the roadmap, as well as the number of bits of precision supported for quantum Fourier transform (QFT) and quantum phase estimation (QPE) at each stage of the roadmap.
- Vendors also need to perform validation testing of phase limits to compare reality to theory for documented limitations. Confirm theory and documentation, or note any discrepancies.
- Even classical quantum simulators need clear technical documentation of precision and granularity of phase, including the degree to which phase limits can be configured.
- It should be easy to configure classical quantum simulators to precisely match the limitations of real quantum computers.
- The main characteristics of phase which need careful documentation are the minimum and maximum phases, the minimum increment between phases, and the expected uncertainty for phase.
- No, “Just try it and see what happens!” is not a reasonable or professional approach. Trial and error is not a plan.
- First things first, get the theory straight. Folklore won’t cut it.
- We need more information on implementation of phase angle rotations. Hardware and software — how the theory meets the road.
- Portability of algorithms and applications is problematic. Different machines have different capabilities and different limitations when it comes to phase. That said, there may be a least common denominator of capabilities and limitations for a particular collection of machines. General portability is problematic — for fine granularity of phase.
- As hardware evolves, the rules may change, sometimes incrementally, and sometimes in quantum leaps.
- Sector is too young for most people to run into phase granularity issues. Wait a few years as algorithms and applications become more ambitious.
- Do probability amplitudes have the same characteristics, limitations, and issues as phase? Possibly. Maybe. I would expect so. But I just don’t know and haven’t been able to verify one way or the other. Vendors need to supply detailed technical guidance.
- Unfortunately, there may be different stories and details on phase granularity depending on whether we’re talking about the present, current offerings, the near future, next year, the medium-term future, and the much longer-term future. Timing is everything. What’s true for today may no longer be true tomorrow, next week, next month, next year, in two years, in five years, in seven years, in ten years, or in twenty years.

# Topics covered in this paper

This informal paper will cover:

- In a nutshell
- Caveats
- What is phase?
- Cycles and waves
- Period or wavelength
- Four stages or phases of a single cycle of a wave
- Circles and sine waves
- Phase — quadrants of a cycle vs. fraction of a cycle
- Phase angle
- Phi for phase angle
- Units for phase (phase angle)
- Gradations of phase vs. granularity
- Theoretical gradations of phase vs. granularity
- Phase as a decimal fraction
- Why is two pi used everywhere when phase is used?
- Euler’s formula
- Range of phase
- Phase is a continuous value
- Is phase an infinitely-valued continuous value?
- Is phase a discrete continuous value?
- How can phase be discrete if two pi is irrational?
- What does a decimal phase fraction between 0.0 and 1.0 mean if two pi is irrational?
- Is phase multivalued?
- Are phase angles bright lines or fuzzy and uncertain?
- Are phase angles black and white or shades of gray?
- Is phase digital or analog?
- What is the resolution or precision of a phase angle?
- Aspects of phase in quantum computing
- How close can phase come to 0.0 and pi and not be treated as not having any phase?
- Phase granularity may be fine for smaller circuits
- Bloch sphere
- Rotations of the Bloch sphere
- Phase is rotation about the Z axis
- Phase is real in the range 0.0 to 1.0
- Theta and phi
- Phase is relative
- S and T gates should be reliable
- R-phi gate (or PHASE gate, phase shift) may or may not be reliable
- Phase cannot be measured directly
- Measuring phase — indirectly
- Phase as a binary flag or for constructive and destructive interference
- Degree of granularity
- Where is the “break” point for phase?
- Limitations due to theory, engineering, or portability
- Theoretical limitations
- Is there a Planck-type unit for phase?
- Levels of translation
- Precision of entries in unitary matrices
- Precision of exponentials in unitary matrices
- Precision for exponentials in a quantum Fourier transform (QFT)
- Precision of pi and sqrt(2) when used in unitary matrices
- Quantum vs. classical hardware issues
- Uses of phase in quantum algorithms
- Quantum algorithms which rely on granularity of phase
- QFT and QPE are not currently viable at-scale anyway
- Algorithms which use phase kickback
- Extreme granularity of phase for quantum Fourier transform (QFT)
- No, banding won’t facilitate precision of phase in quantum Fourier transforms
- Extreme granularity of phase for quantum phase estimation (QPE)
- When will quantum phase estimation (QPE) be viable?
- When will quantum Fourier transform (QFT) be viable?
- How does phase granularity scale as an algorithm is scaled?
- Shor’s algorithm as worst-case example so far
- Is Shor’s really the worst-case limit for quantum algorithms, or just the starting point for serious, heavy-duty quantum algorithms?
- Hardware vendors (and service providers) need to fully document any limitations on phase for their qubits
- What does current vendor documentation say about granularity of phase?
- Product roadmaps should detail the number of gradations of phase supported at each stage of the roadmap
- Product roadmaps should detail the number of bits of precision supported for quantum Fourier transform (QFT) and quantum phase estimation (QPE)
- Providers of quantum simulators need to fully document the behavior of phase
- No, “Just try it and see what happens!” is not a reasonable or professional approach
- Trial and error is not a plan
- Vendor validation testing of phase limits — compare to theory
- Publish reports for validation testing of phase limits
- Accumulated error after performing n x PHASE(1/n)
- Model categories of algorithm and application phase granularity as tee-shirt sizes — S, M, L, XL, XXL, XXXL
- What multiples of phase granularity are supported?
- Do probability amplitudes have the same characteristics, limitations, and issues as phase?
- Still at laboratory curiosity stage, so all bets are off
- Sector is too young for most people to run into phase granularity issues
- Need for hardware and architecture advances
- As hardware evolves, the rules may change
- First things first, get the theory straight
- What does the theory say about phase granularity?
- What are the actual physics of phase granularity?
- Impact of granularity and uncertainty on constructive and destructive interference
- How will phase interact with quantum error correction (QEC)?
- How stable is physical phase?
- We need more information on implementation of phase angle rotations
- Are trapped-ion qubits better for high-precision phase?
- Timeframe
- No specific granularity guidance I can offer — it’s all up in the air
- Conclusion

# Caveats

- This paper won’t delve deep into the all of the actual physics of phase, just deep enough to address the headline issue of precision and granularity of phase.
- No graphics, no diagrams, no Greek symbols, no math, no matrices. Just addressing the headline issue in as plain language as possible.
- Quantum computing technology is a moving target, constantly evolving, so what might be true today — or at any other time — may not necessarily be true at some arbitrary time in the future.

# What is phase?

In the subatomic world of quantum mechanics, everything simultaneously has both particle-like behavior and wave-like behavior.

A wave has cycles. Such as a sine wave.

Each cycle has various stages or phases, four overall stages for each cycle, a continuous curve, which can be conceptualized as either a full circle or a sine wave.

Phase or *phase angle* expresses the location on the circle or sine wave.

The two waves of a two-state quantum system such as a qubit each have their own stage or phase (phase angle) which may or may not be exactly in sync.

The degree of synchronization or *relative phase* (difference between the two phase angles) of the two waves is a key portion of the overall quantum state of a quantum system.

Qubit control permits the relative phase to be manipulated, rotated in particular.

# Cycles and waves

The concept of *phase* relates to the cyclical or periodic wave-like behavior of a quantum system.

# Period or wavelength

A *wave* has a period or wavelength. Wavelength corresponds to one complete *cycle* of the wave.

Wavelength has some physical linear magnitude in physics, but actual physical wavelength is immaterial to phase in quantum computing.

Generally, phase is some portion or fraction of wavelength. Or more correctly, a fraction of a single cycle.

# Four stages or phases of a single cycle of a wave

One complete cycle of a wave has our stages or *phases*:

- Rising from zero to a maximum amplitude peak.
- Falling from that maximum amplitude peak back to and through zero.
- Falling from zero to a maximum negative amplitude trough.
- Rising from that maximum negative amplitude trough back to and through zero.
- Rinse and repeat — periodic.

# Circles and sine waves

The two most common forms of cycles or waves are:

**Circle.**Four quadrants, each comparable to one phase of a sine wave.**Sine wave.**The path a point on a circle takes if the circle is rolled.

# Phase — quadrants of a cycle vs. fraction of a cycle

There are two distinct ways to look at phase:

- The four phases of a single cycle of a wave.
- A specific fraction of a single cycle of a wave. A specific point or relative distance along the path of a wave in terms of a fraction of the complete path for a single cycle.

In this paper, and in quantum computing in general, that latter meaning is presumed.

# Phase angle

Generally, phase corresponds to an angle — *phase angle* — as in a fraction of a full circle.

# Phi for phase angle

The greek letter *phi* is commonly used to refer to a *phase angle*.

# Units for phase (phase angle)

There are three distinct units for measuring phase, as an angle:

**Radians.**The language of formal mathematics. Two pi radians in a circle. Each of the four phases of a cycle or the four quadrants of a circle correspond to pi over 2 radians.**Degrees.**Common, vernacular unit for measuring angles. Simple, direct numeric conversion factor — two pi radians equals 360 degrees. Pi over two radians corresponds to 90 degrees.**Decimal fraction.**Fraction of a full circle. From 0.0 to 1.0. 1.0 corresponds to two pi radians or 360 degrees. 0.5 corresponds to pi radians or 180 degrees. 0.25 corresponds to pi over two radians or 90 degrees.

Quantum computing generally uses both radians and decimal fractions for phase.

Quantum logic gates tend to be phrased in terms of angles in radians, pi, pi over two, and pi over four being common gates for rotation of qubits.

Exponentials in unitary matrices can be in either decimal fractions or radians. If you see exponentials prefixed by two pi, that usually indicates that phase is represented as a decimal fraction. If that two pi prefix is not present, phase angle is expected to be in radians, such as pi, pi over two, and pi over four. For example,

**exp(i phi)**— presume phi is an angle in radians.**exp(two pi i phi)**— presume phi is an angle as a decimal fraction.

*Quantum phase estimation* will usually produce a decimal fraction, or more technically correct, a binary-point fraction.

Some common values:

- 0.0 radians = 0 degrees = 0.0 decimal fraction.
- pi over four radians = 45 degrees = 0.125 decimal fraction.
- pi over two radians = 90 degrees = 0.25 decimal fraction.
- pi radians = 180 degrees = 0.5 decimal fraction.
- Three pi over two radians = 270 degrees = 0.75 decimal fraction.
- Two pi radians = 360 degrees = 1.0 decimal fraction.

# Gradations of phase vs. granularity

Granularity of phase and gradations of phase are approximately the same thing.

Both express how many divisions are made for a single full circle or cycle.

How many slices of a pie (pi?!).

# Theoretical gradations of phase vs. granularity

The only significant difference between granularity of phase and gradations of phase may be that gradations are more *theoretical* or *ideal* while granularity is more focused on the *practical* aspects of distinguishing two phase angles.

# Phase as a decimal fraction

Generally in quantum computing, it makes more sense to conceptualize operations on phase in terms of decimal fractions, such as 1.0, 0.5, 0.25, etc. After all, pi, pi over two, and pi over four are irrational numbers, which cannot be easily conceptualized from a numeric computational perspective.

# Why is two pi used everywhere when phase is used?

Just to highlight, as already mentioned, that two pi is the conversion factor from phase angle as a decimal fraction (0.0 to 1.0) to radians (zero to two pi).

The common case being:

**exp(two pi i phi)**— phi is presumed to be an angle as a decimal fraction.

# Euler’s formula

*Euler’s formula* converts *exp(i phi)* to and from *cos(phi) + i sin(phi)*.

Exponentials can be written either as true exponentials or in terms of sine and cosine.

In cases where phi is a multiple of pi, including 0, the sine term is zero (sin(0) == 0 and sin(pi) == 0). So, exp(i pi) == cos(pi) == -1.

If the phase angle is written as a decimal fraction, the two pi conversion factor must be propagated in Euler’s formula: exp (two pi i phi) == cos(two pi phi) + i sin(two pi phi).

Using Euler’s formula, some common special cases become apparent:

- Even multiples of pi, including 0.0. cos(0) + i sin(0) == 1.0.
- Odd multiples of pi, including pi. cos(pi) + i sin(pi) == -1.0.
- Even multiples of pi plus pi over two. cos(pi over two) + i sin(pi over two) == i.
- Odd multiples of pi plus pi over two. cos(pi plus pi over two) + i sin(pi plus pi over two) == -i.

# Range of phase

There are four distinct ways to look at the range of phase (or phase angle):

**A full circle or single full wave (one cycle).**Zero to two pi radians, 0 to 360 degrees, or 0.0 to 1.0 as a decimal fraction.**Half a circle.**The other half of the circle merely retraces the first half, back to where it started. Zero to pi and pi to two pi radians, 0 to 180 degrees and then 180 degrees to 360 degrees, and 0.0 to 0.5 and then 0.5 to 1.0 as a decimal fraction.**Two half circles which are mirror images, but with the sign flipped.**Zero to pi and zero to minus pi radians, 0 to 180 degrees and 0 to minus 180 degrees, and 0.0 to 0.5 and 0.0 to minus 0.5 as a decimal fraction.**Infinite circles or waves (cycles), but periodic based on the size of one cycle.**Four pi radians is the same as two pi radians, 720 degrees is the same as 360 degrees, and 2.0 is the same as 1.0 as a decimal fraction.

Whether the upper end of the range should be treated as a distinct value or mapped to zero — wraps around to the origin — is an interesting question. For all intents and purposes, two pi radians is equivalent to zero radians, 360 degrees is equivalent to 0 degrees, and 1.0 is equivalent to 0.0 as a decimal fraction. But, the upper end of the range is actually useful for expressing the length or magnitude of a full cycle.

# Phase is a continuous value

Although the 0 and 1 values of a qubit are clearly very discrete — there are two of them, a binary pair of values, phase at least superficially seems to be a *continuous value*, between zero and two pi radians or between 0.0 and 1.0 as a decimal fraction.

# Is phase an infinitely-valued continuous value?

Okay, phase appears to be a continuous value, but are there really an infinity of phase angles between zero and two pi?

Conceptually and theoretically, maybe the answer is yes, at least in the abstract, but for a real, physical system, infinity just doesn’t work or seem likely.

# Is phase a discrete continuous value?

It seems reasonable to presume that there is some limit as to how fine a granularity there can be between any two adjacent phase angles.

At some point, there is likely some Planck-type limit to the fine granularity of adjacent phase angles. There may or may not be some Planck-type limit, but there may also be some engineering limit implied by the limitations of the classical digital and analog electronics used to control real qubits.

But generally, phase appears to have at least some degree of continuous value, even if it ultimately is discrete down at the physics level.

# How can phase be discrete if two pi is irrational?

There are two pi radians in a circle or single cycle of a wave, so if phase is discrete at some level, any level, how can there be any discrete value for the smallest difference between two phase angles which divides two pi, an irrational number? It doesn’t seem possible.

Maybe there is some clever principle of physics which answers this question, but I haven’t encountered it.

The only obvious solution is approximation, with some implied limit on maximum number of gradations in a single cycle.

# What does a decimal phase fraction between 0.0 and 1.0 mean if two pi is irrational?

How exact, precise, or meaningful can phase expressed as a decimal fraction between 0.0 and 1.0 be if two pi is irrational? If a phase fraction of 0.5 corresponds to pi radians, what does that really mean, precisely? Or a fraction of 0.25, 0.125, 0.1, 0.2, etc.

If one wishes to convert to and from decimal phase fractions and radians, how many decimal (or binary) digits of precision are needed for approximating pi to give results which are consistent with both theory and the actual engineering reality of real quantum computers?

Technically, there needs to be some error bound or uncertainty for all of these numbers.

Is there some Planck-level of precision or uncertainty?

# Is phase multivalued?

Regardless of whether phase is a true continuous value or discrete, at a minimum it supports multiple values.

The open question is how many values are supported — the precision or granularity.

Or the cardinality of how many gradations there can be in a single cycle.

# Are phase angles bright lines or fuzzy and uncertain?

Separate from the question of actual precision or granularity of phase angles, there is the question of whether there is some degree of fuzziness or uncertainty between adjacent phase angles.

I imagine that there might be some degree of fuzziness and uncertainty.

Some of the fuzziness and uncertainty might be due to environmental noise or noisiness in the practical engineering implementation of qubits.

But ultimately there might be fuzziness or uncertainty which is an inescapable consequence of the quantum mechanical nature of phase. Some Planck-level constant for fuzziness or uncertainty.

# Are phase angles black and white or shades of gray?

Maybe the better question is how distinctive the adjacent shades of gray really are.

Assuming that phase does indeed have more than two binary values (besides zero and two pi), that implies shades of gray.

The question then is how many shades of gray.

And how distinct — or fuzzy — those shades of gray are.

# Is phase digital or analog?

A much more basic question is whether phase should be treated as an *analog* metric rather than a *digital* metric — is phase *continuous* or discrete?

Or more to the point, is it reasonable for algorithms or applications to treat phase as an analog or continuous value, or whether phase should be treated as a discrete digital value.

The current answer seems to be… both, in a fashion. Or, a hybrid or a little of both — less than fully continuous, but more than a simply binary discrete value.

Are operations on the Bloch sphere (so-called Clifford gates) really just analog operations, not strictly digital? Unclear.

Is a single, isolated qubit digital or analog? Again, unclear. Certainty the 0 and 1 basis states are binary or digital, but once you throw superposition and probability amplitudes into the mix, who’s to say whether the value of a qubit is strictly digital or in fact analog (continuous value).

Does entanglement give the value of one or more qubits a digital, binary (either/or) quality? Again, it’s not so clear.

# What is the resolution or precision of a phase angle?

It is probably common for the API interfaces for quantum circuits to use double precision floating point for all real numbers, but that begs the question of what resolution or precision is actually used down at the hardware interface level where a unitary matrix is converted to the analog electrical signals to control qubit operations.

I personally haven’t found any technical documentation which speaks to this issue — hence this entire paper.

In short, the answer is that *we just don’t know*, which is the root of the problem.

These comments apply regardless of whether phase is expressed in radians or as a decimal fraction.

# Aspects of phase in quantum computing

When contemplating the use of phase in quantum computing, here are the considerations which must be kept in mind:

**Minimum phase.**Greater than zero. Or zero if no phase.**Maximum phase.**Less than two pi radians or 1.0 as a decimal fraction.**Smallest increment or delta.**Between two adjacent phases.**Error or uncertainty.**In the quantum mechanical sense.**Measurement resolution.**Can’t directly measure phase, but can use phase estimation techniques — quantum phase estimation (QPE).

There are actually two minimums and two maximums, ignoring the points of the Bloch sphere which lie on the circle on the X-Z plane:

Two minimums:

- Smallest phase greater than zero.
- Smallest phase greater than pi radians or 0.5 as a decimal fraction.

And the two maximums:

- Greatest value less that two pi radians or 1.0 as a decimal fraction.
- Greatest value less than pi radians or 0.5 as a decimal fraction.

The minimums and maximums near pi can be problematic since pi is an irrational number, so they could be very difficult to distinguish from pi itself — or an approximation of pi.

The point is to be able to distinguish having a phase from having no phase.

# How close can phase come to 0.0 and pi and not be treated as not having any phase?

That’s part of the question about minimum and maximum values of phase — being able to distinguish from zero and pi radians.

# Phase granularity may be fine for smaller circuits

For quantum circuits using only relatively few qubits and relatively few gates, phase may work just fine, such as 4–8 qubits or maybe even 12–16 qubits and a comparable number of gates. Exactly where the breakpoint is would need to be determined for each distinct quantum computer.

But phase is unlikely or not certain or guaranteed to work well for more than 32 qubits and 32 gates. Again, the exact breakpoint would need to be determined.

The point of this paper is that care, even caution, needs to be exercised when relying on more than a few gradations of phase.

# Bloch sphere

This paper won’t delve into the full details of the Bloch sphere for visualizing the quantum state of a qubit, other than simply to give some context for visualizing precision and granularity of qubit phase angles.

Classical computing is based on the strictly binary nature of bits — either a zero or a one, one or the other, exclusively. Although the common description of quantum computing is that qubits permit a combination of zero and one at the same time, it’s a little more complicated than that, with a third feature known as *phase*.

You can think of the binary nature of classical bits as being one dimensional.

A simple combination of two bit values would be two-dimensional, but quantum bit values are actually three-dimensional (the so-called Bloch sphere) with *phase* being the third dimension.

In two dimensions, the combinations of a zero and a one (the two *basis vectors*) trace a circle in a two-dimensional plane. The radius of the circle is 1.0, a so-called *unit circle*, with all of the combinations of zero and one being all of the so-called *unit vectors* with origin (or tail) at the origin of the two axes of the plane and the head of the unit vectors on the circle. Each unique combination of zero and one is a distinct point on the circle.

Each combination of zero and one is specified by two *probability amplitudes*, one probability amplitude for zero and one probability amplitude for one. The sum of the squares of the two probability amplitudes will always be 1.0, which by definition is the length of a unit vector.

Incidentally, the square of the probability amplitude for zero or one is the *probability* that if measured the qubit value will measure as a zero or a one. By definition, the two probabilities must sum to 1.0 since a measured qubit value must by definition be either a zero or a one.

These two dimensions constitute the X-Z plane of the Bloch sphere.

But quantum mechanics is a bit more complicated than that, using all three spatial dimensions, the third dimension being *phase*.

Each probability amplitude is actually a *complex number*, with the *real part* of the complex number representing the two-dimensional character of a qubit value, and the *imaginary part* of the complex number representing the *phase* or rotation in the third dimension.

This third dimension constitutes the Y axis of the Bloch sphere, or the X-Y plane.

# Rotations of the Bloch sphere

The Bloch sphere can be rotated around all three axes, X, Y, and Z.

A unit vector or point on the surface of the Bloch sphere can be moved to any other unit vector or point on the surface of the Bloch sphere by some combination of rotations about the X, Y, and Z axes.

Two rotations are sufficient since absolute or relative positions can be specified using two angles — theta and phi. In some cases, a single rotation will be sufficient.

# Phase is rotation about the Z axis

Changes to phase of a qubit are achieved by rotations about the Z or X axis of the Bloch sphere.

The rotation about the Z axis corresponds to the *phi* angle.

Any rotation about the Y axis will leave phase unchanged.

# Phase is real in the range 0.0 to 1.0

As a decimal fraction, phase (phase angle) is a real number in the range 0.0 to 1.0, representing a rotation about the Z axis of the Bloch sphere.

# Theta and phi

The Greek symbol *theta* is commonly used to refer to rotation about the Y axis, which has the effect of changing the *probabilities* for the 0 and 1 states, but leaving the phase unchanged.

The Greek symbol *phi* is commonly used to refer to rotation about the Z axis, which has the effect of changing the *phase*, but leaving the probabilities for the 0 and 1 states unchanged.

# Phase is relative

Although each of the two probability amplitudes for a qubit state is a complex number with its own imaginary part — the phase, there is only one phase for the qubit state and it is relative — the *relative phase* between the *phase angle* of the 0 state and the *phase angle* of the 1 state.

# S and T gates should be reliable

The S and T quantum logic gates rotate the Bloch sphere about the Z axis by 90 degrees and 45 degrees, respectively (pi over two and pi over four radians, or 0.25 and 0.125 as a decimal fraction.) This is rather coarse granularity — four and eight gradations, respectively, so these gates should be reasonably reliable on most quantum computers.

Emphasis on the word *should*. Reality must be verified.

It’s only when granularity gets finer than this that issues might appear.

# R-phi gate (or PHASE gate, phase shift) may or may not be reliable

The *R-phi* quantum logic gate, sometimes called the *PHASE* (shift) gate, rotates the Bloch sphere about the Z axis by an arbitrary phase angle, expressed in radians. Whether this gate is reliable or problematic depends on whether the phase angle is a clean multiple of a low-granularity angle, such as two, four, or eight gradations. It is only when the number of gradations — and the granularity of the phase angle — get greater than eight that issues might begin to appear.

This paper is not asserting that issues ** will** appear when more than eight gradations are used, simply that there is no clear guarantee of reliability. Look to the vendor documentation for clarification. Or, as a worst case scenario, perform some diagnostic tests to confirm what granularities are reliable.

The S gate is the same as the R-phi gate with an argument of pi over two radians (90 degrees or 0.25 as a decimal fraction.)

The T gate is the same as the R-phi gate with an argument of pi over four radians (45 degrees or 0.125 as a decimal fraction.)

The lower right entry of the unitary matrix would contain *exp(i phi)*. So there are two precision questions: the precision of phi, the phase angle, in radians, and the precision of the calculation of the exponential.

Using Euler’s formula, *exp(i phi)* can also be expressed as *cos(phi) + i sin(phi)*. The same precision issues arise, but with sine and cosine rather than exp.

# Phase cannot be measured directly

Note that the phase of a qubit value cannot be measured directly — it *collapses* when the qubit is measured.

# Measuring phase — indirectly

Although the phase of a qubit cannot be directly measured, there are clever tricks to indirectly *infer* the value of the phase of a qubit, notably *quantum phase estimation* (*QPE*). This paper won’t delve into either this technique or others since the focus here is on resolution of phase — how many unique values it can have.

# Phase as a binary flag or for constructive and destructive interference

The concept of *interference* makes use of the phase of a qubit to perform clever tricks used in quantum computations. This paper won’t delve into the details of interference or how it is used, other than the narrow aspect of the *granularity* or *resolution* of phase — how many values of phase can be used in the quantum computations using a single qubit.

Using phase as a binary flag or for *constructive and destructive interference* is probably reasonably safe, and probably two or three bits of precision as well, but all bets are off beyond a few bits of precision — exactly where is indeterminate at this stage of the technology.

# Degree of granularity

Just to inspire thinking about the utility or value of various categories of fine granularity, here are some possible ranges:

- Binary or flag — two states of phase (actually four — pi over two and minus pi over two radians, plus the two zeroes of the Bloch sphere, 0.0 and pi radians)
- Two or three bits (4–8 states)
- 8–12
- 16
- 32
- 50–64
- 80–100
- 128–150
- 192–256
- 512
- 1024
- 2K
- 4K
- Thousands
- Millions
- Billions
- Trillions
- Quadrillions
- 10²⁰ to 10⁵⁰
- Beyond 10⁵⁰

Is there ultimately some Planck-level limit for granularity of phase? I just don’t know. I haven’t seen any mention of such a limit, but it seems reasonable to presume that such a limit might exist.

# Where is the “break” point for phase?

Where might the transition point or *break* point be between phase granularity which works reliably and phase granularity which begins to break down? Great question, but at present the answer is unknown — and can vary from machine to machine.

Some possibilities:

- Anything more than just a binary flag.
- Anything more than a handful, such as 3 to 5 gradations.
- 8 gradations.
- 12
- 16
- 24
- 32
- 50
- 64
- 100
- 128
- 256
- 1024
- 4K
- 16K
- 64K
- 256K
- 1M
- Millions
- Billions
- 10⁴⁰
- 10⁵⁰
- 10¹⁰⁰

I suspect it might be in the high dozens or low hundreds of gradations.

I suspect that thousands, millions, and billions of gradations are unlikely to work well.

I suspect that a few dozen gradations should work, at least for more advanced machines.

I wouldn’t be surprised if 100 or 128 or even 256 gradations worked, but I also wouldn’t be surprised if 100 or 128 or 256 gradations did not work reliably.

I’d be rather surprised if millions or billions of gradations worked well.

# Limitations due to theory, engineering, or portability

Phase could be limited or constrained in three areas:

**Theory.**Raw physics. Physical limitations, regardless of particular implementations.**Engineering of real machines.**Not all theory can readily, practically, or economically be turned into a real machine.**Portability.**Consistency between machines, vendors, and technologies and architectures.

I can’t speak with any authority about theoretical limitations or constraints on phase, although I imagine that they exist.

Every quantum hardware vendor will make their own engineering tradeoffs which might affect limitations or constraints on phase.

I expect that some vendor limits relate to the quantum mechanical aspects of the vendor’s technology, while other vendor limits relate to the classical digital and analog electronics which control the qubit hardware.

It might be that qubits have greater theoretical capabilities than can be directly controlled by the classical digital and analog electronics.

Even if an algorithm designer or application developer fully understands the limitations or constraints on phase for a particular vendor’s particular machine, there are then questions about how much of those limitations or constraints apply to the machines of other vendors or even other models of machines from the same vendor. Designing quantum algorithms and applications for portability is a real challenge.

# Theoretical limitations

Theoretical limitations could arise in two ways:

- Limitations of quantum mechanics in general.
- Specific physics of particular qubit designs.

Are there rules or limits which apply to all possible qubit designs? Possibly, but unclear.

What are the specific theoretical rules or limits which apply to the physics of particular qubit designs? Vendors should document those rules and limits for their qubits.

# Is there a Planck-type unit for phase?

I imagine that phase is not infinitely continuous between zero and two pi. Relatively continuous, yes, but not absolutely and infinitely continuous.

I imagine that phase has some discrete quantum character, such as some Planck-level discrete unit that represents the smallest possible difference between two discrete phase angles. But I haven not seen any such unit documented.

# Levels of translation

One of the overall issues with precision and granularity of phase — or any aspect of quantum computing, for that matter — is the significant number of levels of interfaces which must be transitioned to translate from a high-level algorithm and application at the software level to actual physics at the hardware level.

The levels of interfaces or transitions include:

- Abstract phase — e.g., pi as an abstraction vs. approximation of pi to so many digits.
- Representation in source programming language — e.g., Python.
- High-level API representation.
- Network interface representation.
- Software driver representation. Where exactly do the entries in unitary matrices get turned into physical hardware control?
- FPGA representation.
- Digital electronics representation.
- Analog electronics representation.
- Cryogenic electronics and photonics (e.g., microwaves or lasers) representation.
- Physical control of qubits implementation.
- Physical effect on qubits. The actual quantum mechanics.

What happens with phase at each of these levels is somewhat of a mystery. Where exactly do various limitations and constraints on phase angles come into play?

Much better vendor documentation and technical specifications would help a lot and are definitely needed.

# Precision of entries in unitary matrices

Unitary matrices are the method used to express the fine details of the operation to be performed by each quantum logic gate. Each entry of the matrix is a complex number.

The entries of unitary matrices are the essence of describing operations to be performed on qubits, such as rotations for phase angles.

But what exactly is the precision that is available in those entries?

Each entry is a complex number, consisting of a real part and an imaginary part which is also specified using a real number.

Generally, real numbers will be represented internally as floating-point numbers.

But there are a number of different floating-point number representations, each with a distinct number of bits or digits of precision and range of exponent:

- Single-precision floating point.
- Double-precision.
- Quad precision.

Generally, the high-level programming language (e.g., Python) doesn’t care what precision is used, but the question is what precision is needed by the various levels of interfaces which translate the entries of unitary matrices from high-level programming down to actual hardware control.

At present, the answer is unknown and undocumented.

A lot of modern high-level programming languages will default to double precision.

Is double precision sufficient? Or is it overkill? Again, the answer is unknown.

I suspect that double precision (roughly 15 decimal digits) is gross overkill for current hardware, but the question is how we should conceptualize this issue for future hardware.

And certainly down at the level of the software hardware drivers and FPGAs, 15 decimal digits is unlikely to be a close match for the capabilities for the hardware. Likely it is gross overkill, but that is still supposition on my part.

The real point of this paper is that such technical details should be clearly documented for each quantum computer and each service providing access to a quantum computer — and for classical quantum simulators as well.

# Precision of exponentials in unitary matrices

In addition to the raw precision of the entries of unitary matrices, there is the question of precision for the exponents for exponentials. Generally, a rotation will be specified by one or more entries in the unitary matrix of the form:

**exp(two pi i phi)**— if phi is a decimal fraction (0.0 to 1.0)**exp(i phi)**— if phi is in radians (0.0 to two pi)

The precision of the exponential and the precision of the exponent (phi) are two separate matters. Both need to be clearly documented for each quantum computer.

# Precision for exponentials in a quantum Fourier transform (QFT)

When implementing a quantum Fourier transform (QFT), phi, as a decimal fraction will be 1.0 over N, where N is 2^n. If n is fairly large, such as in Shor’s algorithm for factoring large semiprimes, even a very modest value of n = 50 means N = 2⁵⁰, which is roughly 10¹⁵, so that 1.0 over N (1 over 10¹⁵) is a very tiny number. And that’s the motivation for this paper — how small N (or how large n) can be and still produce valid results in a quantum computation.

# Precision of pi and sqrt(2) when used in unitary matrices

pi and the square root of 2 are irrational numbers, which means that they cannot be expressed exactly with a finite number of digits or bits of precision. That raises the question of exactly how many digits or bits of precision are needed to use pi or sqrt(2) or 1 over sqrt(2) in the entries of a unitary matrix.

Both need to be clearly documented for each quantum computer.

# Quantum vs. classical hardware issues

Besides theoretical limitations, practical aspects of designing and engineering hardware may cause limitations on use of phase.

There are two distinct areas of hardware limitations:

- Quantum aspects of a qubit.
- Classical control of qubit gate operations.

Between the two, it’s an open question which area has what impact on phase granularity limitations.

Classical hardware also has two major areas:

- Classical digital electronics.
- Classical analog electronics.

As much as possible is done in the digital domain, either in digital electronics or digital software if that’s possible.

*Field-programmable gate arrays* (FPGAs) are a much more flexible way to implement classical electronic hardware since they can be dynamically reconfigured rather than requiring physical changes to components and wiring. They focus primarily on digital electronics, but may perform some analog electronics functions as well. Either way, they are still classical hardware.

But at some stage even the most advanced modern digital electronics does not have enough precision to control all physical aspects of the hardware, especially when and where quantum effects come into play. This is where classical analog electronics comes into play, to be the bridge between the classical digital and quantum worlds.

In any case, each of these three areas has some impact on precision and granularity of phase angles.

# Uses of phase in quantum algorithms

There are many potential uses of phase in quantum algorithms, but they can be divided into two broad categories:

- Those which rely on phase merely as a binary flag. Such as constructive and destructive interference.
- Those which rely on some degree of granularity of phase.

This paper isn’t concerned with the former — there is no granularity issue at stake.

# Quantum algorithms which rely on granularity of phase

The major examples of quantum algorithms which rely on granularity of phase are:

- Quantum Fourier transform (QFT).
- Quantum phase estimation (QPE).
- Algorithms which use the technique of phase kickback.

# QFT and QPE are not currently viable at-scale anyway

Although *quantum Fourier transform (QFT)* and *quantum phase estimation (QPE)* are considered essential algorithmic building blocks for quantum computing, at least in the long-term, it is widely accepted that they are not viable at-scale in the near-term, being currently suitable only for only the tiniest of demonstration cases. This non-viability may be due more to coherence, gate errors, and circuit-depth requirements, so we don’t even get to the stage of testing the limits of phase angle granularity.

So, even if any phase angle limitations were eliminated, QFT and QPE remain unlikely to be viable, at-scale for the next few years. The advent of *quantum error correction (QEC)* and *logical qubits* may or should change that. But for now, we’re not there and not even close.

# Algorithms which use phase kickback

*Phase kickback* is a general technique which can be used in a very wide variety of algorithms. Whether phase kickback relies on granularity of phase will depend on the particular usage.

So we have two cases for phase kickback:

- Phase is used merely as a binary flag.
- Phase has some degree of granularity, more than a mere two-state flag.

The former is not likely to be problematic.

The latter may or may not be problematic depending on how many gradations of phase are used.

A T gate is not likely to be problematic (eight gradations, pi over 4 radiations or 0.125 as a decimal fraction), but that all depends on the particular hardware.

Granularity beyond a T gate could be problematic — or not — depending on the particular hardware. Vendors and service providers for quantum computers must clearly document any such limits.

# Extreme granularity of phase for quantum Fourier transform (QFT)

This informal paper won’t provide a deep description of *quantum Fourier transform (QFT)* — for more background, read the Wikipedia Quantum Fourier transform article.

When implementing a quantum Fourier transform (QFT), phi, phase angle as a decimal fraction will be 1.0 over N, where N is 2^n. Very small n should be okay, but n > 3 could become problematic.

More specifically, the entries of the unitary transform for a QFT have the form:

**exp(two pi i j k over 2^n)**

If n is fairly large and j and k are relatively small (relative to 2^n), such as in Shor’s algorithm for factoring large semiprimes, even a very modest value of n = 50 means N = 2⁵⁰, which is roughly 10¹⁵, so that 1.0 over N (1 over 10¹⁵) is a very tiny number, which could be very problematic for phase.

And that’s the motivation for this paper — how small N (or how large n) can be and still produce valid results in a quantum computation.

# No, banding won’t facilitate precision of phase in quantum Fourier transforms

A large quantum Fourier transform can quickly result in very small values of phase, even zero or very close to zero. *Banding* (also known as *approximate quantum Fourier transform (AQFT)*) is a technique to skip over all of the zero values of phase and even most of the very small values of phase which are so close to zero as to not having a significant effect on the computation of the quantum Fourier transform. Adding a significant number of zeros or very small values is unlikely to significantly impact the net result significantly, so banding simply skips over them — any matrix entries outside of a relatively narrow band.

In essence, a *banded QFT* is a *performance optimization*, which dramatically reduces the number of computation steps, but results in an *approximate result*.

*Approximate* does mean faster, but usually with a concomitant *loss of precision*.

Banding may be sufficient for some algorithms and applications, but a careful analysis is required to assess whether the loss of precision is significant to the particular algorithm or application.

And to be clear, banding is *not* intended to improve or increase the precision of the result, but simply to optimize or improve performance.

# Extreme granularity of phase for quantum phase estimation (QPE)

*Quantum phase estimation* (QPE) is essentially a specialized application of *quantum Fourier transform* (QFT), so the comments for QFT apply to QPE.

This informal paper won’t provide a deep description of *quantum phase estimation (QPE)* — for more background, read the Wikipedia Quantum phase estimation algorithm article.

Whether QPE is problematic depends on its precision, its granularity.

QPE probably won’t be problematic if only a relatively small number of gradations of phase are used.

But QPE may be problematic if a significant number of gradations are used for phase.

# When will quantum phase estimation (QPE) be viable?

Although quantum phase estimation (QPE) is not viable today, the open question is when or at what stage of evolution of the quantum computing sector will QPE in fact become technically viable? The short answer is that it is unknown, but not in the very near future. And by viable, it is presumed that more than a small number of bits of precision is supported, such as eight to sixteen or more bits or 256 to 64K or more gradations.

**18 months?**Not likely**2–3 years?**Unlikely.**5 years?**Possibly.**7 years?**A distinct possibility.**10 years?**One would hope so.

The firms which are developing quantum computers should annotate their product roadmaps as to when various levels of quantum phase estimation are likely to be supported? Levels in terms of the number of qubits of precision or granularity or number of gradations which can be distinguished with a reasonable degree of accuracy.

Until quantum phase estimation is technically viable, there won’t be any significant demand for fine granularity of phase angles.

# When will quantum Fourier transform (QFT) be viable?

Quantum phase estimation (QPE) is essentially a quantum Fourier transform (QFT), so the answer to the question of when or at what stage quantum Fourier transform (QFT) will be technically viable is essentially the same as the answer to the same question about quantum phase estimation (QPE).

Until quantum Fourier transform is technically viable, there won’t be any significant demand for fine granularity of phase angles. And by viable, it is presumed that more than a small number of bits of precision is supported, such as eight to sixteen or more bits or 256 to 64K or more gradations.

Again, developers of quantum computers should detail levels of support for quantum Fourier transforms in their product roadmaps, in terms of number of bits of precision or granularity to be supported for quantum Fourier transforms.

# How does phase granularity scale as an algorithm is scaled?

Scaling of algorithms is a great unknown. Scaling of phase (granularity) is a key one of those unknowns.

If one doubles or quadruples the number of qubits or size of input values, how does demand for granularity of phase scale?

Designers of algorithms and developers of applications need to pay attention to this issue to assure that even if qubit usage scales reasonably well, demand for phase granularity needs to be evaluated as well.

# Shor’s algorithm as worst-case example so far

To the best of my knowledge, *Shor’s algorithm* for factoring very large semiprime numbers is the worst-case algorithm so far in terms of overall complexity, raw qubit requirements, raw gate count, and size of quantum Fourier transform (QFT). The latter implying that Shor’s is the worst-case so far in terms of need for very fine granularity of phase.

As noted earlier, a quantum Fourier transform would have unitary matrix entries of the form:

**exp (two pi i j k over 2^n)**

For a strong encryption key, n would have values such as 1024, 2048, or even 4096.

2⁴⁰⁹⁶ is an extremely large number, so dividing even a modest-sized number by 2⁴⁰⁹⁶ is an exceedingly small number.

Personally, I’m very skeptical that such large or small numbers would be practical in any computer, classical or even quantum.

But if the limits of granularity or precision of phase angles are as limited as seems likely, Shor’s algorithm would place an impossible burden on the precision of phase angles.

Granted, the current wisdom is that *banding* (also known as *approximate quantum Fourier transform (AQFT)*) should be used to discard values which are outright zero or very close to zero, but that would have the unwelcome side effect of dramatically limiting precision, which is something that would not be acceptable in an algorithm such as Shor’s that is intended to produced exact rather than approximate results.

# Is Shor’s really the worst-case limit for quantum algorithms, or just the starting point for serious, heavy-duty quantum algorithms?

As quantum algorithm designers struggle with even very modest-sized algorithms and Shor’s algorithm is far beyond the size of algorithms realizable today, it’s rather difficult to contemplate algorithms much more complex than Shor’s, but that shouldn’t stop us from doing so.

But if the limits of granularity or precision of phase angles are as limited as seems likely, Shor’s algorithm and algorithms far beyond Shor’s algorithm would place an impossible burden on the precision of phase angles.

# Hardware vendors (and service providers) need to fully document any limitations on phase for their qubits

Granularity of phase must be fully documented for each quantum computer. Designers of algorithms and developers of applications need to know exactly what they are working worth — they need to know the rules of the road and where the lines are on the road.

I took a stab at proposing a framework for documenting the *Principles of Operation* for quantum computers, including limitations on granularity of phase:

*Framework for Principles of Operation for a Quantum Computer*- https://jackkrupansky.medium.com/framework-for-principles-of-operation-for-a-quantum-computer-652ead10bc48

# What does current vendor documentation say about granularity of phase?

As far as I have seen, current vendor documentation and technical specifications are completely silent (i.e., useless) with regard to the granularity of phase.

# Product roadmaps should detail the number of gradations of phase supported at each stage of the roadmap

Product roadmaps from hardware vendors should document in detail the number of gradations or granularity of phase supported at each stage of the product roadmap. The roadmap should clearly answer questions such as:

- When will even four bits (16 gradations) of precision be supported?
- Ditto for five bits (32 gradations)
- 6 bits (64 gradations)
- 8 bits (256 gradations)
- 10 bits (1024 gradations)
- 12 bits (4K gradations)
- 16 bits (64K gradations)
- 20 bits (one million gradations)
- 24 bits (24M gradations)
- 32 bits (4G gradations)
- And beyond.

# Product roadmaps should detail the number of bits of precision supported for quantum Fourier transform (QFT) and quantum phase estimation (QPE)

Product roadmaps from hardware vendors should document in detail the number of bits of precision supported for quantum Fourier transform (QFT) and quantum phase estimation (QPE) at each stage of the roadmap. The roadmap should clearly answer questions such as:

- When will even four bits of precision be supported?
- Ditto for five bits.
- 6 bits.
- 8 bits.
- 10 bits.
- 12 bits.
- 16 bits.
- 20 bits.
- 24 bits.
- 32 bits.
- And beyond.

# Providers of quantum simulators need to fully document the behavior of phase

Even classical quantum simulators need clear technical documentation of precision and granularity of phase, including the degree to which any limitations on phase can be configured.

Simulating ideal qubits is useful, but configuring the simulator to artificially constrain phase to match specified real quantum computers may be even more useful, so that a simulation run is much more likely to agree with a run on a real physical machine.

Designers of new quantum computers should also be able to tune the phase limitations of a classical quantum simulator to match proposed new quantum computer hardware, even before it is built.

# No, “Just try it and see what happens!” is not a reasonable or professional approach

Algorithm designers and application developers should work from documentation and specifications for the quantum computers they will be using. It’s inappropriate and outright unprofessional to throw up your hands and say “** Well, let’s just try it and see what happens!**” Good grief! We can, should, and

*must*do better,

*much*better.

The essential problem with relying on trial and error is that there is no assurance that the same results will be produced on all occasions, let alone on other machines from other vendors.

# Trial and error is not a plan

Same point. With a lot of immature technologies there is a great temptation to use trial and error as if it were a plan, when it isn’t.

# Vendor validation testing of phase limits — compare to theory

Theory is great and documentation and specifications are great, but there also needs to be *technical validation testing* to confirm that theory, documentation, and reality really are in sync.

# Publish reports for validation testing of phase limits

Every quantum computer — or service offering access to a quantum computer should come with a report documenting the validation testing for phase limits, either confirming theory or noting any discrepancies.

# Accumulated error after performing n x PHASE(1/n)

The basic question for the uncertainty of a phase rotation is if you pick a granularity, n, such as 16, 50, 64, 100, 256, 500, 1024, 4K, 16K, 64K, etc., and execute that many PHASE gates each with a phase rotation angle of 1 over n, do you really get back to zero. What is the residual error?

Presumably you can perform *quantum phase estimation (QPE)* to obtain an approximation of the residual error.

# Model categories of algorithm and application phase granularity as tee-shirt sizes — S, M, L, XL, XXL, XXXL

There may be roughly six categories of algorithm and application phase granularity requirements which can be distinguished using the classic tee-shirt size metaphor:

**S — Small.**Requires no more or little more than S and T gate phase granularity.**M — Medium.**Dozens of gradations of phase, such as 24 to 64.**L — Large.**Hundreds of gradations of phase, such as 256 to 1024.**XL — Extra Large.**Thousands of gradations of phase.**XXL — Extra-extra Large.**Millions or billions of gradations of phase.**XXXL — Extra-extra-extra Large.**Far beyond billions of gradations of phase.

At present, for the near-term, only the first two are probably feasible.

# What multiples of phase granularity are supported?

Vendors need to clearly document what multiples of phase granularity are supported, such as:

- Powers of 2?
- Multiples of 2?
- Multiples of 4? Since there are four quadrants in the Bloch sphere.
- Multiples of 3 or other odd numbers? 3, 6, 9, 12, 15? 5, 7, 11, 13, 23? What happens if the multiple isn’t divisible by 2 or 4 to get 0 at the midpoint and maximum magnitude at 90 and 270 degrees?

# Do probability amplitudes have the same characteristics, limitations, and issues as phase?

It’s hard to say whether *probability amplitudes* of qubit state have the same characteristics, limitations, and issues as phase angles. Possibly. Maybe. I would expect so since they’re all just rotations about the Bloch sphere. But I just don’t know for sure and haven’t been able to verify one way or the other. Vendors need to supply detailed technical guidance.

First there is theory — quantum mechanics.

Then there is the engineering of the physical machine.

Then there is the actual practical physics of the physical machine as actually built, as opposed to some idealized theory of the machine as designed.

Then there are the details of the implementation of all of the hardware and software interface layers.

# Still at laboratory curiosity stage, so all bets are off

Quantum computers and qubits are still a very active area of research and not even close to being ready for commercialization. As such, quantum computers remain *laboratory curiosities* and will remain so for years to come.

Therefore, trying to nail down specifics for phase is essentially problematic — and subject to change as research and engineering progress.

# Sector is too young for most people to run into phase granularity issues

Most people are struggling to get basic, simple quantum algorithms to work. Anything beyond an S or T gate is generally beyond most small projects.

But wait a few years, and things will change. People will have mastered toy algorithms and want to sink their teeth into real beef, and try using phase angles as a real power tool, with significantly more phase granularity than an S or T gate. But that’s not where we are today.

# Need for hardware and architecture advances

Regardless of where quantum computer hardware is today, there’s no question that there will be much research and many waves of incremental and quantum-leap advances in quantum computing hardware in the coming years.

Whatever research is already funded, much more is needed.

Where phase limitations will end up with all of this research remains to be seen.

The important thing is for vendors to clearly document current and projected limits on phase granularity.

# As hardware evolves, the rules may change

It is also important to note that as hardware evolves, the rules may change, sometimes incrementally, and sometimes in quantum leaps.

This means that there is technical risk in designing algorithms and applications which depend too heavily on imagined or apparent rules which can change at any time and without any notice.

# First things first, get the theory straight

There is too much hearsay and folklore about phase angles floating around. Folklore won’t cut it.

We need a sound scientific basis for working with phase angles. We need a sound basis in theory. But, the topic simply isn’t being discussed.

Maybe scientists have too many bigger fish to fry, so maybe we simply have to wait for all of the bigger fish to be fried before scientists find the time, energy, and focus to work out the details of the theory behind phase angles.

In any case, we need to get the theory straight before placing too many big bets on phase angles.

Alas, at present, my interest in seeing theory placed first may amount to little more than wishful thinking for the indefinite future. We can only hope that interest in theory will pick up in the coming years.

# What does the theory say about phase granularity?

Just to reiterate, as far as I can tell, the theory of qubits doesn’t say anything at all about what the granularity or precision of phase might be.

# What are the actual physics of phase granularity?

Same question, but focused on the actual physics of whatever physical phenomenon actually underlies phase. There’s nothing that I have been able to find.

# Impact of granularity and uncertainty on constructive and destructive interference

The concepts of *constructive and destructive interference* depend on the addition and subtraction of two phase angles of identical magnitude but either identical or opposite signs. This raises the question of the impact of granularity or precision of phase when two phase angles are *interfered*.

What is the impact? Unclear. Uncertain. And just plain unknown.

Maybe it will be a big deal, or maybe not. Again, it’s just plain unclear. But it is something to be considered for more advanced quantum algorithms a few years down the road.

# How will phase interact with quantum error correction (QEC)?

Will *quantum error correction (QEC)* have any impact on phase granularity or limits on phase in general? Hard to say.

Will a *logical qubit* support more gradations of phase, or fewer gradations, or the same?

Will there be a dramatic increase in phase precision, possibly exponential, based on the number of physical qubits per logical qubit?

Or will it be more of a least common denominator for all of the physical qubits which comprise a logical qubit?

The theoreticians owe us an answer.

And then it’s up to the engineers to build and deliver hardware which fulfills the promises of the theoreticians.

# How stable is physical phase?

Does the phase of a qubit have *jitter*?

Does or can phase *drift* over time?

Does or can phase *decohere* over time?

Is phase susceptible to *environmental interference*?

Great questions. The answers are… unknown.

# We need more information on implementation of phase angle rotations

Even when we finally get all of the theory of phase angles worked out, there is then the question of how the theory is implemented in real, physical hardware — and the software which controls the hardware. How the theory meets the road.

# Are trapped-ion qubits better for high-precision phase?

Trapped-ion qubits may be better for higher-precision phase.

I say this only because I recall seeing a paper from IonQ which mentioned a test with I believe it was 128 gradations of phase. I can’t remember the exact details and I haven’t been able to recall which paper it was in.

But I haven’t seen any comparable claims for superconducting transmon qubits.

# Timeframe

When discussing future capabilities of quantum computers it is useful to distinguish the timeframe:

- Now — currently available.
- Coming soon — over the next few months.
- Coming over the remainder of the year.
- Next year.
- 1 year — must wait a whole year.
- 2 years.
- 5 years.
- 7 years.
- 10 years.
- 15 years.
- 20 years.
- Ultimate, maximum capabilities.

# No specific granularity guidance I can offer — it’s all up in the air

After all of this, the bottom line is that there simply isn’t any specific guidance I can offer on granularity of phase and what exactly algorithms and applications can or can’t depend on.

I certainly don’t want to tell anyone to “Just try it and see what happens.”

All I can really say is that vendors of quantum computers have their work cut out for them:

- They need to get the theory straight.
- They need to deeply understand exactly what they are building.
- They need to fully characterize what they are building.
- They need to fully test and validate what they have built.
- They need to fully document what they have built.

# Conclusion

- We are still at the toy and experimentation stage of quantum computing — these hard issues are beyond current imagination.
- There are many unknowns which vendors need to clarify, such as any limitations or issues with phase of qubits.
- Algorithm designers should only rely on a few bits of precision for phase, for now.
- Algorithms depending on modest granularity of phase (dozens) should tread very carefully.
- Depending on fine granularity of phase (hundreds or thousands of gradations) is likely beyond the limits of current technologies over the next few to five years.
- Phase granularity in the millions, billions, and beyond should not be considered as practical for the indefinite future.
- Whether extremely fine granularity of phase is practical at all even in the long term remains to be seen.
- Portability of algorithms and applications is problematic when different quantum computers have different limits on phase.

For more of my writing: ** List of My Papers on Quantum Computing**.