Implement decomposition for `BitonicSort` #1089

anurudhp · 2024-06-21T17:55:11Z

Decomposition for sorting lists whose size is a power of 2. Partially addresses #219

Described briefly in https://www.nature.com/articles/s41534-018-0071-5, circuit based on wiki.

anurudhp · 2024-06-21T17:55:27Z

@tanujkhattar @fdmalone ptal

qualtran/bloqs/arithmetic/comparison_test.py

qualtran/bloqs/arithmetic/sorting.ipynb

qualtran/bloqs/arithmetic/sorting.py

fdmalone · 2024-06-21T19:12:08Z

qualtran/bloqs/arithmetic/sorting_test.py

-    with pytest.raises(NotImplementedError):
-        bloq.decompose_bloq()
+    bloq = Comparator(2**4)
+    assert bloq.t_complexity().t == 88 - 4 - 7 * 4


why the -7 * 4?

I had some reason to justify this, but can't remember anymore. I think somewhere in the previous t_complexity it assumed CSwap was t=14, but the current impl is t=7

The paper assumes CSWAP is t=4 using 1 ancilla, right? We should probably open an issue to track that though. Textbook CSWAP should be t=7.

CSWAP to 1 Toffoli can be reduced as follows

and then the Toffoli can be implemented using 4 T either using a Relative phase toffoli or using an ancilla with AND gate.

qualtran/bloqs/arithmetic/sorting_test.py

qualtran/bloqs/arithmetic/sorting.py

qualtran/bloqs/arithmetic/sorting_test.py

fdmalone

So nice! I'm glad someone finally did this.

tanujkhattar

+1, great to have this implemented!

qualtran/bloqs/arithmetic/sorting.py

qualtran/bloqs/arithmetic/sorting.ipynb

tanujkhattar · 2024-06-21T19:31:23Z

qualtran/bloqs/arithmetic/sorting.py

+    """Given k numbers in [0, L), compare every pair that is `offset` apart.
+
+    Args:


Please more details to the docstring - do we compare and swap or we just store the result of the comparison somewhere? Are the RIGHT junk registers storing the result of the comparison? Or are they supposed to be completely ignored?

updated all docstrings.

tanujkhattar · 2024-06-21T19:32:52Z

qualtran/bloqs/arithmetic/sorting.py

    Args:
-        bitsize: Number of bits used to represent each integer.
+        L: Upper-bound (excluded) on the input integers.
+        k: Number of integers in each half


Please specify that k must be a power of 2. Also specify the complexity in terms of T / Toffoli costs, ancilla cost and circuit depth.

Also, would it be a lot more work if we want to support merging two lists of different sizes?

It isn't too difficult, but the edge cases need to be dealt with care. I wanted to get the power-of-2 case working first, will implement the general case in a follow up.

tanujkhattar · 2024-06-21T19:35:48Z

qualtran/bloqs/arithmetic/sorting.py

+    r"""Sort k numbers in the range {0, ..., L-1}.
+
+    Args:
+        L: Upper-bound (excluded) on the input integers.


Please specify that k must be a power of 2. Also specify the complexity in terms of T / Toffoli costs, ancilla cost and circuit depth.

added to docstring

tanujkhattar · 2024-06-21T19:39:21Z

qualtran/bloqs/arithmetic/sorting.py

+        return Signature(
+            [
+                Register("xs", BoundedQUInt(self.bitsize, self.L), shape=(self.k,)),
+                Register("junk", QBit(), shape=(self.num_comparisons,), side=Side.RIGHT),


Why do we have junk RIGHT registers everywhere ? Are we saving on any uncomputation? Can you also expand the docstring to explain this?

This is the comparator circuit from the reference:

I wrote the signature similar to the And bloq where the result bit is RIGHT.

I think its worth highlighting this in the docstring -- i.e. the junk stores the result of the comparisons. This would be necessary to make the sorting bloq reversible so you can apply the unitary in reverse and get back to the original sequence of unsorted elements if needed.

updated the docstring explaining this.

qualtran/bloqs/arithmetic/sorting_test.py

tanujkhattar · 2024-06-24T18:42:37Z

qualtran/bloqs/arithmetic/sorting.py

+    If each half has length $k$, then the merge network uses $k * (\log{k} + 1)$ comparisons
+    when $k$ is a power of 2.


Please also add information / $$..$$ formula to specify what the junk stores since it can be potentially useful depending upon the context.

Added a brief description (similar to the one in BitonicSort).

Did you also want a description of the order of the ancillas?

The order is not as important, but we should at least specify that the ancilla qubits store the results of intermediate comparisons.

qualtran/bloqs/arithmetic/sorting.py

tanujkhattar · 2024-06-24T18:43:55Z

qualtran/bloqs/arithmetic/sorting.py

+    The bitonic sorting network requires $\frac{k}{2} \frac{\log{k} (\log{k} + 1)}{2}$ total comparisons,
+    and has depth $\frac{\log{k} (\log{k} + 1)}{2}$, when $k$ is a power of 2. Each comparison generates
+    one ancilla qubit, so the total size of junk register equals the number of comparisons.


This is great!

qualtran/serialization/sympy.py

tanujkhattar

LGTM % some final comments

tanujkhattar · 2024-06-24T20:39:12Z

qualtran/bloqs/arithmetic/sorting.py

+    $$
+
+    The above expression is at most $k / 2$.
+    Each comparison generates one ancilla qubit, which are aggregated into the `junk` register.


Suggested change

Each comparison generates one ancilla qubit, which are aggregated into the `junk` register.

Each comparison generates one ancilla qubit which stores the result of the comparison. The ancillas

are aggregated into the `junk` register.

tanujkhattar · 2024-06-24T20:40:07Z

qualtran/bloqs/arithmetic/sorting.py

+        + \max((k\mod 2\delta) - \delta, 0)
+    $$
+
+    The above expression is at most $k / 2$.


There seems to be a break after "this requires, . The above expression".

We should finish the "this requires," line. Maybe something like

Suggested change

The above expression is at most $k / 2$.

number of comparisons. The above expression is at most $k / 2$.

oops, fixed

tanujkhattar · 2024-06-24T20:40:32Z

qualtran/bloqs/arithmetic/sorting.py

+
+    If each half has length $k$, then the merge network uses $k (1+\log{k})$ comparisons
+    when $k$ is a power of 2.
+    Each comparison generates one ancilla qubit, which are aggregated into the `junk` register.


ditto: Let's specify that the ancilla qubit stores the result of comparisons

anurudhp added 3 commits June 21, 2024 10:38

decomposition for GreaterThan

bf139b3

sorting: implement comparator

c6efeaa

implement bitonic sort

02b29f6

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/comparison_test.py Show resolved Hide resolved

anurudhp and others added 3 commits June 21, 2024 11:34

add classical simulation tests, fix bugs

2438f3e

more random tests and bug fixes

fa5c1d2

Merge branch 'main' into 2024-06-20-bitonic-sort

74d457b

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.ipynb Outdated Show resolved Hide resolved

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.py Show resolved Hide resolved

anurudhp added 2 commits June 21, 2024 11:59

fix mypy

23577b2

fix serialization bug

6fbc466

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting_test.py Show resolved Hide resolved

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.py Show resolved Hide resolved

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.py Show resolved Hide resolved

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.py Outdated Show resolved Hide resolved

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.py Outdated Show resolved Hide resolved

fdmalone reviewed Jun 21, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting_test.py Show resolved Hide resolved

fdmalone requested changes Jun 21, 2024

View reviewed changes

tanujkhattar requested changes Jun 21, 2024

View reviewed changes

anurudhp added 3 commits June 21, 2024 13:19

add all perm 4! test

676c790

more assertions

5bd8502

use bitsize instead of L

8e2a053

anurudhp mentioned this pull request Jun 21, 2024

BitonicSort: support non-power-of-two input lengths #1090

Open

2 tasks

anurudhp added 5 commits June 21, 2024 14:23

link issue in TODOs

67eb042

add to resolverdict

ff3380d

add tests for ParallelComparators, more docstring

ac18bc6

more docstring

13188bd

more docstrings and tests for merge

65e605c

anurudhp added 3 commits June 21, 2024 15:44

add BloqDocSpec for BitonicMerge and ParallelComparators

7040d61

add ancilla cost to docstring

776a3fa

allow decomposing when bitsize is symbolic

9d6a4f7

anurudhp requested review from fdmalone and tanujkhattar June 21, 2024 23:11

tanujkhattar self-assigned this Jun 24, 2024

tanujkhattar reviewed Jun 24, 2024

View reviewed changes

qualtran/bloqs/arithmetic/sorting.py Outdated Show resolved Hide resolved

tanujkhattar reviewed Jun 24, 2024

View reviewed changes

qualtran/serialization/sympy.py Outdated Show resolved Hide resolved

tanujkhattar reviewed Jun 24, 2024

View reviewed changes

qualtran/serialization/sympy.py Outdated Show resolved Hide resolved

tanujkhattar approved these changes Jun 24, 2024

View reviewed changes

fdmalone approved these changes Jun 24, 2024

View reviewed changes

update docstrings, fix latex

f579287

tanujkhattar reviewed Jun 24, 2024

View reviewed changes

tanujkhattar approved these changes Jun 24, 2024

View reviewed changes

anurudhp and others added 3 commits June 24, 2024 13:48

Merge branch 'main' into 2024-06-20-bitonic-sort

130d287

cleanup

9f6d200

docstring: explain compare ancilla

955912f

tanujkhattar merged commit cc4e3bc into quantumlib:main Jun 24, 2024

anurudhp deleted the 2024-06-20-bitonic-sort branch June 24, 2024 21:50

charlesyuan314 mentioned this pull request Jul 18, 2024

Make static type checking work better with symbolics #1156

Merged

		"""Given k numbers in [0, L), compare every pair that is `offset` apart.

		Args:

		If each half has length $k$, then the merge network uses $k * (\log{k} + 1)$ comparisons
		when $k$ is a power of 2.

	Each comparison generates one ancilla qubit, which are aggregated into the `junk` register.
	Each comparison generates one ancilla qubit which stores the result of the comparison. The ancillas
	are aggregated into the `junk` register.

	The above expression is at most $k / 2$.
	number of comparisons. The above expression is at most $k / 2$.

Implement decomposition for BitonicSort #1089

Implement decomposition for BitonicSort #1089

Uh oh!

Conversation

anurudhp commented Jun 21, 2024 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

anurudhp commented Jun 21, 2024

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

fdmalone left a comment

Choose a reason for hiding this comment

Uh oh!

tanujkhattar left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

tanujkhattar left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Implement decomposition for `BitonicSort` #1089

Implement decomposition for `BitonicSort` #1089

anurudhp commented Jun 21, 2024 •

edited

Loading