oqft.com

Building a QFT Comparison Table for a Paper With One Shell Loop and OQFT

Fri, 13 Nov 2026 00:00:00 +0000

A paper or a design review usually wants one table: circuit size against depth and gate count, for a few register sizes and error targets. oqft stats prints all of it, one size at a time. A short shell loop turns that into a CSV file you can drop into a spreadsheet or a LaTeX table.

echo "qubits,eps,qft_depth,oqft_depth,qft_gates,oqft_gates"
for n in 64 256 1024; do
  for eps in 0.1 0.01; do
    oqft stats -n "$n" --eps "$eps" | awk -v n="$n" -v e="$eps" '
      /^Total gates/ {qg = $3}
      /^Depth/       {qd = $2}
      /^OQFT/        {gsub(",", ""); print n "," e "," qd "," $NF "," qg "," $6}'
  done
done > qft-table.csv

The awk part picks three lines out of each report: the textbook total from “Total gates”, the textbook depth from “Depth”, and both OQFT figures from the line that starts with “OQFT”. The commas inside that line are stripped so they don’t split the CSV.

Choosing an Error Target for a 2048-Qubit OQFT, Each Tenfold Tightening Costs 24 to 32 Layers

Fri, 13 Nov 2026 00:00:00 +0000

OQFT asks for one number besides the register size: the error target, --eps. It’s the average squared error you’re willing to accept over all inputs. Pick it too loose and Shor’s algorithm misses more often. Pick it too tight and you pay in depth. This case study puts numbers on that trade for a 2,048-qubit register, the size a 2048-bit RSA key calls for.

We ran oqft stats -n 2048 at four targets, from 0.1 down to 0.0001, and recorded the block width OQFT chose for each.

How Block Width Sets the Error of an Optimistic QFT, Measured on 16 Qubits

Fri, 13 Nov 2026 00:00:00 +0000

The block width is the one knob inside an optimistic QFT. Narrow blocks make a shallow circuit that fails often. Wide blocks fail rarely but cost more depth. OQFT normally picks the width for you from the error target, but on a register small enough to simulate you can force it with --block-width and watch what happens.

We took a 16-qubit register, forced every width from 2 to 8, and ran 300 random inputs through the simulator for each, with the same seed every time so the run can be repeated. For each input oqft check measured the squared error against the exact QFT, and flagged any above 0.1.

How OQFT Was Tested, Matrices, Random Inputs and the Wraparound Edge

Fri, 13 Nov 2026 00:00:00 +0000

A circuit generator can produce something that looks fine, loads fine, and computes the wrong thing. The only way to know is to run the circuit and compare. OQFT does that at three levels, and every number below comes from the recorded runs in the repository.

Whole Matrices, Up to 10 Qubits

For registers up to 10 qubits, the tests build the full matrix of each circuit, all 1,024 by 1,024 entries at the top end, and compare every entry with the exact Fourier transform written out by formula. The textbook QFT matches at every size from 1 to 10. The approximate QFT is checked the same way, to confirm its error stays inside a bound that tightens as it keeps more rotations.

Loading OQFT Circuits Into Qiskit, the Same CX Count After Transpiling but Less Than a Third of the Depth

Fri, 13 Nov 2026 00:00:00 +0000

OQFT writes OpenQASM 3 with three gates from the standard library, h, cp and swap. Anything that reads OpenQASM 3 can take it. Qiskit is the toolkit most people will try first, so this example loads OQFT’s output there, checks it, and runs it through Qiskit’s transpiler.

You need Python with qiskit and qiskit_qasm3_import, and oqft on your PATH.

pip install qiskit qiskit_qasm3_import

Optimistic Quantum Circuits Explained, Why a QFT That Is Almost Always Right Is Enough

Fri, 13 Nov 2026 00:00:00 +0000

Ask a circuit designer for a quantum Fourier transform and they’ll want it right on every input. That’s the normal bar. A circuit is a fixed piece of hardware, and you can’t look inside a quantum state to see which input you got and take a different path. So it has to work for all of them.

The trouble is that “all of them” is expensive. In 2025 a group of researchers from MIT, UC Berkeley and Google asked a different question: what if the circuit only has to be right on almost every input? They called that kind of circuit optimistic, and showed the QFT gets much cheaper under the looser rule.

OQFT Cuts QFT Depth From 4096 to 198 on a 2048-Qubit Register

Fri, 13 Nov 2026 00:00:00 +0000

The quantum Fourier transform sits in the middle of Shor’s algorithm. Build it the textbook way on 2,048 qubits, the size you’d need for a 2048-bit RSA key, and you get about 2.1 million gates stacked 4,096 layers deep. Most of those gates are tiny rotations that barely change anything. The rest still have to wait their turn.

OQFT 0.3 builds the other version. The optimistic QFT on the same 2,048 qubits takes 198 layers and about 104,000 gates, and it needs no qubits beyond the register itself. It’s right on almost every input. On a small, known slice of inputs it’s badly wrong, and that’s the deal.

OQFT Depth Crossover, the Optimistic QFT Beats the Textbook Circuit From 68 Qubits On

Fri, 13 Nov 2026 00:00:00 +0000

The optimistic QFT is built for big registers. Everyone working with it knows that. The less obvious question is where “big” starts, because below some size the textbook circuit is simply shallower, and a compiler that swaps in OQFT everywhere would make small circuits worse.

So we ran oqft stats at an error target of 0.01 for every register size from 32 to 80 qubits, plus a few larger ones, and wrote down depth and gate count for both circuits. Depth counts every gate as one layer, with gates on separate qubits sharing a layer.

What OQFT Stands For, the Optimistic Quantum Fourier Transform

Fri, 13 Nov 2026 00:00:00 +0000

OQFT is four letters and one idea. The last three, QFT, are the quantum Fourier transform, one of the most used building blocks in quantum computing. The O is the new part: optimistic.

The QFT got its name from the Fourier transform, the 200-year-old tool that breaks a signal into the waves it’s made of. Joseph Fourier worked it out while studying how heat spreads through metal. Phones, audio files and radio links all lean on its fast digital version. The quantum version does the same job on the amplitudes of a quantum state, and it’s what lets Shor’s algorithm find the hidden period that cracks a large number into its factors.

About

Mon, 01 Jan 0001 00:00:00 +0000

oqft.com is the home of OQFT, an open source toolkit for the optimistic quantum Fourier transform. It builds the circuit for any register size, writes it out as OpenQASM 3, counts its gates and depth, and checks it on a classical simulator against the exact transform.

The Name

OQFT stands for Optimistic Quantum Fourier Transform. The quantum Fourier transform, QFT for short, is the step in Shor’s factoring algorithm, and in quantum phase estimation, that turns a hidden repeating pattern into a number you can measure. “Optimistic” is the word the researchers who designed the fast version chose for circuits that are accurate on almost every input but give up on a small, predictable slice of them. The O in front is that trade.

Contact

Mon, 01 Jan 0001 00:00:00 +0000

oqft.com would like to hear from:

People building quantum compilers and toolchains who’d use an optimistic QFT as a building block.
Researchers who want a gate, an export format or a check that OQFT doesn’t have yet.
Anyone who found a bug. A circuit that doesn’t load, a count that looks off, an error you didn’t expect.

Write to info@oqft.com.

Bug reports are also welcome on GitHub. It helps to include what oqft version prints, the exact command you ran and what it printed.

Download OQFT

Mon, 01 Jan 0001 00:00:00 +0000

The oqft command is one file with nothing else to install. Each archive below holds it with its license files. The links always point to the latest release.

System	Download
Linux, x86-64	oqft_linux_amd64.tar.gz
Linux, ARM64	oqft_linux_arm64.tar.gz
macOS, Apple silicon	oqft_darwin_arm64.tar.gz
macOS, Intel	oqft_darwin_amd64.tar.gz
Windows, x86-64	oqft_windows_amd64.zip

Checksums are in SHA256SUMS. Every release is listed on GitHub.

Install

On Linux or macOS:

tar -xzf oqft_linux_amd64.tar.gz
sudo mv oqft /usr/local/bin/
oqft version

The binaries are static, so they run on any Linux distribution. The macOS binaries aren’t signed by Apple, so macOS may block the first run. Allow it in System Settings under Privacy & Security, or run xattr -d com.apple.quarantine oqft. On Windows, unzip the archive and put oqft.exe in a folder on your PATH.

Quick Start

Mon, 01 Jan 0001 00:00:00 +0000

This page gets OQFT running and walks through its three commands: gen writes a circuit, stats counts it, and check tests it against the exact transform.

Install

Download the archive for your system from the download page, unpack it and put oqft on your PATH. Then:

oqft version

Write a Circuit

oqft gen prints a circuit as OpenQASM 3. The textbook QFT on four qubits:

oqft gen -n 4

The optimistic QFT on 128 qubits, with an error target of 0.01, saved to a file:

Reference

Mon, 01 Jan 0001 00:00:00 +0000

Everything oqft does, in one page. The quick start has worked examples.

Commands

Command	What it does
`oqft gen`	Writes a circuit as OpenQASM 3 to standard output
`oqft stats`	Compares gate counts and depth of the textbook and approximate QFT, and the optimistic QFT when `--eps` is given
`oqft check`	Measures each input’s error against the exact QFT on a simulator
`oqft version`	Prints the version
`oqft help`	Lists the commands

oqft gen

oqft gen --type qft|aqft|oqft -n N [--cutoff K] [--eps E]

Option	Meaning	Default
`-n`	Number of qubits. Required
`--type`	`qft` textbook, `aqft` approximate, `oqft` optimistic	`qft`
`--cutoff`	For `aqft`: the largest distance between two qubits that keeps its rotation	2
`--eps`	For `oqft`: the error target, between 0 and 1	0.01

oqft stats

oqft stats -n N [--cutoff K] [--eps E]

Prints counts of each gate, total gates, two-qubit gates and depth. With --eps it adds a line for the optimistic QFT at that error target.