From 005fa983ced5f1bc855039e9391929cb82650c4a Mon Sep 17 00:00:00 2001 From: Fionn Malone Date: Thu, 5 Oct 2023 10:26:00 -0700 Subject: [PATCH 1/2] Add more arithmetic bloqs. * Square real * Scale int by real * Multiply two reals Fix bug with bitsize for sum of squares. --- dev_tools/autogenerate-bloqs-notebooks.py | 3 + qualtran/bloqs/arithmetic.ipynb | 150 ++++++++++++- qualtran/bloqs/arithmetic.py | 262 +++++++++++++++++++++- qualtran/bloqs/arithmetic_test.py | 74 +++++- 4 files changed, 466 insertions(+), 23 deletions(-) diff --git a/dev_tools/autogenerate-bloqs-notebooks.py b/dev_tools/autogenerate-bloqs-notebooks.py index d400b177e..2755c558d 100644 --- a/dev_tools/autogenerate-bloqs-notebooks.py +++ b/dev_tools/autogenerate-bloqs-notebooks.py @@ -112,6 +112,9 @@ BloqNbSpec(qualtran.bloqs.arithmetic_test._make_square), BloqNbSpec(qualtran.bloqs.arithmetic_test._make_sum_of_squares), BloqNbSpec(qualtran.bloqs.arithmetic_test._make_greater_than), + BloqNbSpec(qualtran.bloqs.arithmetic_test._make_scale_int_by_real), + BloqNbSpec(qualtran.bloqs.arithmetic_test._make_multiply_two_reals), + BloqNbSpec(qualtran.bloqs.arithmetic_test._make_square_real_number), ], directory=f'{SOURCE_DIR}/bloqs', ), diff --git a/qualtran/bloqs/arithmetic.ipynb b/qualtran/bloqs/arithmetic.ipynb index cfaf5806c..0d0dd3f43 100644 --- a/qualtran/bloqs/arithmetic.ipynb +++ b/qualtran/bloqs/arithmetic.ipynb @@ -71,7 +71,7 @@ }, "source": [ "## `Product`\n", - "Compute the product of an `n` and `m` bit integer.\n", + "Compute the product of an `n` and `m` bit binary number.\n", "\n", "Implements $U|a\\rangle|b\\rangle|0\\rangle -\\rightarrow\n", "|a\\rangle|b\\rangle|a\\times b\\rangle$ using $2nm-n$ Toffolis.\n", @@ -112,9 +112,9 @@ }, "source": [ "## `Square`\n", - "Square an n-bit number.\n", + "Square an n-bit binary number.\n", "\n", - "Implements $U|a\\rangle|0\\rangle \\rightarrow |a\\rangle|a^2\\rangle$ using $4n - 4 T$ gates.\n", + "Implements $U|a\\rangle|0\\rangle \\rightarrow |a\\rangle|a^2\\rangle$ using $n^2 - n$ Toffolis.\n", "\n", "#### Parameters\n", " - `bitsize`: Number of bits used to represent the integer to be squared. The result is stored in a register of size 2*bitsize. \n", @@ -150,19 +150,21 @@ }, "source": [ "## `SumOfSquares`\n", - "Compute the sum of squares of k n-bit numbers.\n", + "Compute the sum of squares of k n-bit binary numbers.\n", "\n", "Implements $U|a\\rangle|b\\rangle\\dots k\\rangle|0\\rangle \\rightarrow\n", " |a\\rangle|b\\rangle\\dots|k\\rangle|a^2+b^2+\\dots k^2\\rangle$ using\n", " $4 k n^2 T$ gates.\n", "\n", + "The number of bits required by the output register is 2*bitsize + ceil(log2(k)).\n", + "\n", "#### Parameters\n", " - `bitsize`: Number of bits used to represent each of the k integers.\n", " - `k`: The number of integers we want to square. \n", "\n", "#### Registers\n", " - `input`: k n-bit registers.\n", - " - `result`: 2 * bitsize + 1 sized output register. \n", + " - `result`: 2 * bitsize + ceil(log2(k)) sized output register. \n", "\n", "#### References\n", "[Fault-Tolerant Quantum Simulations of Chemistry in First Quantization](https://arxiv.org/abs/2105.12767) pg 80 give a Toffoli complexity for squaring.\n" @@ -223,6 +225,142 @@ "bloq = GreaterThan(bitsize=4)\n", "show_bloq(bloq)" ] + }, + { + "cell_type": "markdown", + "id": "1c63d263", + "metadata": { + "cq.autogen": "_make_scale_int_by_real.md" + }, + "source": [ + "## `ScaleIntByReal`\n", + "Scale an integer by fixed-point representation of a real number.\n", + "\n", + "i.e.\n", + "\n", + "$$\n", + " |r\\rangle|i\\rangle|0\\rangle \\rightarrow |r\\rangle|i\\rangle|r \\times i\\rangle\n", + "$$\n", + "\n", + "The real number is assumed to be in the range [0, 1).\n", + "\n", + "#### Parameters\n", + " - `r_bitsize`: Number of bits used to represent the real number.\n", + " - `i_bitsize`: Number of bits used to represent the integer. \n", + "\n", + "#### Registers\n", + " - `- real_in`: r_bitsize-sized input register.\n", + " - `- int_in`: i_bitsize-sized input register.\n", + " - `- result`: r_bitsize output register \n", + "\n", + "#### References\n", + "[Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization] (https://arxiv.org/pdf/2007.07391.pdf) pg 70.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4538d32b", + "metadata": { + "cq.autogen": "_make_scale_int_by_real.py" + }, + "outputs": [], + "source": [ + "from qualtran.bloqs.arithmetic import ScaleIntByReal\n", + "\n", + "bloq = ScaleIntByReal(r_bitsize=8, i_bitsize=12)\n", + "show_bloq(bloq)" + ] + }, + { + "cell_type": "markdown", + "id": "6247c0bd", + "metadata": { + "cq.autogen": "_make_multiply_two_reals.md" + }, + "source": [ + "## `MultiplyTwoReals`\n", + "Multiply two fixed-point representations of real numbers\n", + "\n", + "i.e.\n", + "\n", + "$$\n", + " |a\\rangle|b\\rangle|0\\rangle \\rightarrow |a\\rangle|b\\rangle|a \\times b\\rangle\n", + "$$\n", + "\n", + "The real numbers are assumed to be in the range [0, 1).\n", + "\n", + "#### Parameters\n", + " - `bitsize`: Number of bits used to represent the real number. \n", + "\n", + "#### Registers\n", + " - `- a`: bitsize-sized input register.\n", + " - `- b`: bitsize-sized input register.\n", + " - `- result`: bitsize output register \n", + "\n", + "#### References\n", + "[Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization] (https://arxiv.org/pdf/2007.07391.pdf) pg 71.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b8be106", + "metadata": { + "cq.autogen": "_make_multiply_two_reals.py" + }, + "outputs": [], + "source": [ + "from qualtran.bloqs.arithmetic import MultiplyTwoReals\n", + "\n", + "bloq = MultiplyTwoReals(bitsize=10)\n", + "show_bloq(bloq)" + ] + }, + { + "cell_type": "markdown", + "id": "7b0a73bb", + "metadata": { + "cq.autogen": "_make_square_real_number.md" + }, + "source": [ + "## `SquareRealNumber`\n", + "Square a fixed-point representation of a real number\n", + "\n", + "i.e.\n", + "\n", + "$$\n", + " |a\\rangle|0\\rangle \\rightarrow |a\\rangle|a^2\\rangle\n", + "$$\n", + "\n", + "The real numbers are assumed to be in the range [0, 1).\n", + "\n", + "#### Parameters\n", + " - `bitsize`: Number of bits used to represent the real number. \n", + "\n", + "#### Registers\n", + " - `- a`: bitsize-sized input register.\n", + " - `- b`: bitsize-sized input register.\n", + " - `- result`: bitsize output register \n", + "\n", + "#### References\n", + "[Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization ](https://arxiv.org/pdf/2007.07391.pdf) pg 74.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec6335d9", + "metadata": { + "cq.autogen": "_make_square_real_number.py" + }, + "outputs": [], + "source": [ + "from qualtran.bloqs.arithmetic import SquareRealNumber\n", + "\n", + "bloq = SquareRealNumber(bitsize=10)\n", + "show_bloq(bloq)" + ] } ], "metadata": { @@ -241,7 +379,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.9" + "version": "3.9.6" } }, "nbformat": 4, diff --git a/qualtran/bloqs/arithmetic.py b/qualtran/bloqs/arithmetic.py index 65ff27598..155561bab 100644 --- a/qualtran/bloqs/arithmetic.py +++ b/qualtran/bloqs/arithmetic.py @@ -12,10 +12,18 @@ # See the License for the specific language governing permissions and # limitations under the License. +from typing import Optional, Set, Tuple, TYPE_CHECKING + from attrs import frozen from cirq_ft import TComplexity -from qualtran import Bloq, Register, Signature +from qualtran import Bloq, Register, Side, Signature +from qualtran.bloqs.basic_gates import TGate +from qualtran.bloqs.util_bloqs import ArbitraryClifford + +if TYPE_CHECKING: + from qualtran.resource_counting import SympySymbolAllocator + from qualtran.simulation.classical_sim import ClassicalValT @frozen @@ -50,12 +58,58 @@ def t_complexity(self): num_t_gates = 4 * self.bitsize - 4 return TComplexity(t=num_t_gates, clifford=num_clifford) + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + num_clifford = (self.bitsize - 2) * 19 + 16 + num_t_gates = 4 * self.bitsize - 4 + return {(num_t_gates, TGate()), (num_clifford, ArbitraryClifford(n=1))} + + +@frozen +class OutOfPlaceAdder(Bloq): + r"""An n-bit addition gate. + + Implements $U|a\rangle|b\rangle 0\rangle \rightarrow |a\rangle|b\rangle|a+b\rangle$ + using $4n - 4 T$ gates. + + Args: + bitsize: Number of bits used to represent each integer. Must be large + enough to hold the result in the output register of a + b. + + Registers: + - a: A bitsize-sized input register (register a above). + - b: A bitsize-sized input/output register (register b above). + + References: + [Halving the cost of quantum addition](https://arxiv.org/abs/1709.06648) + """ + + bitsize: int + + @property + def signature(self): + return Signature.build(a=self.bitsize, b=self.bitsize, c=self.bitsize) + + def pretty_name(self) -> str: + return "c = a + b" + + def t_complexity(self): + # TODO: This is just copied from adder above, not sure if correct. + # see https://github.com/quantumlib/Qualtran/issues/375 + num_clifford = (self.bitsize - 2) * 19 + 16 + num_t_gates = 4 * self.bitsize - 4 + return TComplexity(t=num_t_gates, clifford=num_clifford) + + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + num_clifford = (self.bitsize - 2) * 19 + 16 + num_t_gates = 4 * self.bitsize - 4 + return {(num_t_gates, TGate()), (num_clifford, ArbitraryClifford(n=1))} + @frozen class Square(Bloq): - r"""Square an n-bit number. + r"""Square an n-bit binary number. - Implements $U|a\rangle|0\rangle \rightarrow |a\rangle|a^2\rangle$ using $4n - 4 T$ gates. + Implements $U|a\rangle|0\rangle \rightarrow |a\rangle|a^2\rangle$ using $n^2 - n$ Toffolis. Args: bitsize: Number of bits used to represent the integer to be squared. The @@ -74,7 +128,9 @@ class Square(Bloq): @property def signature(self): - return Signature.build(a=self.bitsize, result=2 * self.bitsize) + return Signature( + [Register("a", self.bitsize), Register("result", 2 * self.bitsize, side=Side.RIGHT)] + ) def pretty_name(self) -> str: return "a^2" @@ -86,22 +142,28 @@ def t_complexity(self): num_toff = self.bitsize * (self.bitsize - 1) return TComplexity(t=4 * num_toff) + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + num_toff = self.bitsize * (self.bitsize - 1) + return {(4 * num_toff, TGate())} + @frozen class SumOfSquares(Bloq): - r"""Compute the sum of squares of k n-bit numbers. + r"""Compute the sum of squares of k n-bit binary numbers. Implements $U|a\rangle|b\rangle\dots k\rangle|0\rangle \rightarrow |a\rangle|b\rangle\dots|k\rangle|a^2+b^2+\dots k^2\rangle$ using $4 k n^2 T$ gates. + The number of bits required by the output register is 2*bitsize + ceil(log2(k)). + Args: bitsize: Number of bits used to represent each of the k integers. k: The number of integers we want to square. Registers: input: k n-bit registers. - result: 2 * bitsize + 1 sized output register. + result: 2 * bitsize + ceil(log2(k)) sized output register. References: [Fault-Tolerant Quantum Simulations of Chemistry in First @@ -117,7 +179,9 @@ def signature(self): return Signature( [ Register("input", bitsize=self.bitsize, shape=(self.k,)), - Register("result", bitsize=2 * self.bitsize + 1), + Register( + "result", bitsize=2 * self.bitsize + (self.k - 1).bit_length(), side=Side.RIGHT + ), ] ) @@ -133,10 +197,16 @@ def t_complexity(self): num_toff -= 1 return TComplexity(t=4 * num_toff) + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + num_toff = self.k * self.bitsize**2 - self.bitsize + if self.k % 3 == 0: + num_toff -= 1 + return {(4 * num_toff, TGate())} + @frozen class Product(Bloq): - r"""Compute the product of an `n` and `m` bit integer. + r"""Compute the product of an `n` and `m` bit binary number. Implements $U|a\rangle|b\rangle|0\rangle -\rightarrow |a\rangle|b\rangle|a\times b\rangle$ using $2nm-n$ Toffolis. @@ -161,8 +231,12 @@ class Product(Bloq): @property def signature(self): - return Signature.build( - a=self.a_bitsize, b=self.b_bitsize, result=2 * max(self.a_bitsize, self.b_bitsize) + return Signature( + [ + Register("a", self.a_bitsize), + Register("b", self.b_bitsize), + Register("result", 2 * max(self.a_bitsize, self.b_bitsize), side=Side.RIGHT), + ] ) def pretty_name(self) -> str: @@ -175,6 +249,171 @@ def t_complexity(self): num_toff = 2 * self.a_bitsize * self.b_bitsize - max(self.a_bitsize, self.b_bitsize) return TComplexity(t=4 * num_toff) + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + num_toff = 2 * self.a_bitsize * self.b_bitsize - max(self.a_bitsize, self.b_bitsize) + return {(4 * num_toff, TGate())} + + +@frozen +class ScaleIntByReal(Bloq): + r"""Scale an integer by fixed-point representation of a real number. + + i.e. + + $$ + |r\rangle|i\rangle|0\rangle \rightarrow |r\rangle|i\rangle|r \times i\rangle + $$ + + The real number is assumed to be in the range [0, 1). + + Args: + r_bitsize: Number of bits used to represent the real number. + i_bitsize: Number of bits used to represent the integer. + + Registers: + - real_in: r_bitsize-sized input register. + - int_in: i_bitsize-sized input register. + - result: r_bitsize output register + + References: + [Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization] + (https://arxiv.org/pdf/2007.07391.pdf) pg 70. + """ + + r_bitsize: int + i_bitsize: int + + @property + def signature(self): + return Signature( + [ + Register("real_in", self.r_bitsize), + Register("int_in", self.i_bitsize), + Register("result", self.r_bitsize, side=Side.RIGHT), + ] + ) + + def pretty_name(self) -> str: + return "r*i" + + def t_complexity(self): + # Eq. D8, we are assuming dA and dB there are assumed as inputs and the + # user has ensured these are large enough for their desired precision. + num_toff = self.r_bitsize * (2 * self.i_bitsize - 1) - self.i_bitsize**2 + return TComplexity(t=4 * num_toff) + + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + # Eq. D8, we are assuming dA(r_bitsize) and dB(i_bitsize) are inputs and + # the user has ensured these are large enough for their desired + # precision. + num_toff = self.r_bitsize * (2 * self.i_bitsize - 1) - self.i_bitsize**2 + return {(4 * num_toff, TGate())} + + +@frozen +class MultiplyTwoReals(Bloq): + r"""Multiply two fixed-point representations of real numbers + + i.e. + + $$ + |a\rangle|b\rangle|0\rangle \rightarrow |a\rangle|b\rangle|a \times b\rangle + $$ + + The real numbers are assumed to be in the range [0, 1). + + Args: + bitsize: Number of bits used to represent the real number. + + Registers: + - a: bitsize-sized input register. + - b: bitsize-sized input register. + - result: bitsize output register + + References: + [Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization] + (https://arxiv.org/pdf/2007.07391.pdf) pg 71. + """ + + bitsize: int + + @property + def signature(self): + return Signature( + [ + Register("a", self.bitsize), + Register("b", self.bitsize), + Register("result", self.bitsize, side=Side.RIGHT), + ] + ) + + def pretty_name(self) -> str: + return "a*b" + + def t_complexity(self): + # Eq. D13, there it is suggested keeping both registers the same size is optimal. + num_toff = self.bitsize**2 - self.bitsize - 1 + return TComplexity(t=4 * num_toff) + + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + # Eq. D13, there it is suggested keeping both registers the same size is optimal. + num_toff = self.bitsize**2 - self.bitsize - 1 + return {(4 * num_toff, TGate())} + + +@frozen +class SquareRealNumber(Bloq): + r"""Square a fixed-point representation of a real number + + i.e. + + $$ + |a\rangle|0\rangle \rightarrow |a\rangle|a^2\rangle + $$ + + The real numbers are assumed to be in the range [0, 1). + + Args: + bitsize: Number of bits used to represent the real number. + + Registers: + - a: bitsize-sized input register. + - b: bitsize-sized input register. + - result: bitsize output register + + References: + [Compilation of Fault-Tolerant Quantum Heuristics for Combinatorial Optimization + ](https://arxiv.org/pdf/2007.07391.pdf) pg 74. + """ + + bitsize: int + + def __attrs_post_init__(self): + if self.bitsize < 3: + raise ValueError("bitsize must be at least 3 for SquareRealNumber bloq to make sense.") + + @property + def signature(self): + return Signature( + [ + Register("a", self.bitsize), + Register("b", self.bitsize), + Register("result", self.bitsize, side=Side.RIGHT), + ] + ) + + def pretty_name(self) -> str: + return "a^2" + + def t_complexity(self): + num_toff = self.bitsize**2 // 2 - 4 + return TComplexity(t=4 * num_toff) + + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + # Bottom of page 74 + num_toff = self.bitsize**2 // 2 - 4 + return {(4 * num_toff, TGate())} + @frozen class GreaterThan(Bloq): @@ -211,3 +450,6 @@ def t_complexity(self): # See: https://github.com/quantumlib/cirq-qubitization/issues/219 # See: https://github.com/quantumlib/cirq-qubitization/issues/217 return TComplexity(t=8 * self.bitsize) + + def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: + return {(8 * self.bitsize, TGate())} diff --git a/qualtran/bloqs/arithmetic_test.py b/qualtran/bloqs/arithmetic_test.py index 6afdaead6..ca3f7476d 100644 --- a/qualtran/bloqs/arithmetic_test.py +++ b/qualtran/bloqs/arithmetic_test.py @@ -13,7 +13,17 @@ # limitations under the License. from qualtran import BloqBuilder, Register -from qualtran.bloqs.arithmetic import Add, GreaterThan, Product, Square, SumOfSquares +from qualtran.bloqs.arithmetic import ( + Add, + GreaterThan, + MultiplyTwoReals, + OutOfPlaceAdder, + Product, + ScaleIntByReal, + Square, + SquareRealNumber, + SumOfSquares, +) from qualtran.testing import execute_notebook @@ -47,6 +57,24 @@ def _make_greater_than(): return GreaterThan(bitsize=4) +def _make_scale_int_by_real(): + from qualtran.bloqs.arithmetic import ScaleIntByReal + + return ScaleIntByReal(r_bitsize=8, i_bitsize=12) + + +def _make_multiply_two_reals(): + from qualtran.bloqs.arithmetic import MultiplyTwoReals + + return MultiplyTwoReals(bitsize=10) + + +def _make_square_real_number(): + from qualtran.bloqs.arithmetic import SquareRealNumber + + return SquareRealNumber(bitsize=10) + + def test_add(): bb = BloqBuilder() bitsize = 4 @@ -56,12 +84,21 @@ def test_add(): cbloq = bb.finalize(a=a, b=b) +def test_out_of_place_adder(): + bb = BloqBuilder() + bitsize = 4 + q0 = bb.add_register('a', bitsize) + q1 = bb.add_register('b', bitsize) + q2 = bb.add_register('c', bitsize) + a, b, c = bb.add(OutOfPlaceAdder(bitsize), a=q0, b=q1, c=q2) + cbloq = bb.finalize(a=a, b=b, c=c) + + def test_square(): bb = BloqBuilder() bitsize = 4 q0 = bb.add_register('a', bitsize) - q1 = bb.add_register('result', 2 * bitsize) - q0, q1 = bb.add(Square(bitsize), a=q0, result=q1) + q0, q1 = bb.add(Square(bitsize), a=q0) cbloq = bb.finalize(a=q0, result=q1) @@ -70,9 +107,9 @@ def test_sum_of_squares(): bitsize = 4 k = 3 inp = bb.add_register(Register("input", bitsize=bitsize, shape=(k,))) - out = bb.add_register(Register("result", bitsize=2 * bitsize + 1)) - inp, out = bb.add(SumOfSquares(bitsize, k), input=inp, result=out) + inp, out = bb.add(SumOfSquares(bitsize, k), input=inp) cbloq = bb.finalize(input=inp, result=out) + assert SumOfSquares(bitsize, k).signature[1].bitsize == 2 * bitsize + 2 def test_product(): @@ -81,8 +118,31 @@ def test_product(): mbits = 3 q0 = bb.add_register('a', bitsize) q1 = bb.add_register('b', mbits) - q2 = bb.add_register('result', 2 * max(bitsize, mbits)) - q0, q1, q2 = bb.add(Product(bitsize, mbits), a=q0, b=q1, result=q2) + q0, q1, q2 = bb.add(Product(bitsize, mbits), a=q0, b=q1) + cbloq = bb.finalize(a=q0, b=q1, result=q2) + + +def test_scale_int_by_real(): + bb = BloqBuilder() + q0 = bb.add_register('a', 15) + q1 = bb.add_register('b', 8) + q0, q1, q2 = bb.add(ScaleIntByReal(15, 8), real_in=q0, int_in=q1) + cbloq = bb.finalize(a=q0, b=q1, result=q2) + + +def test_multiply_two_reals(): + bb = BloqBuilder() + q0 = bb.add_register('a', 15) + q1 = bb.add_register('b', 15) + q0, q1, q2 = bb.add(MultiplyTwoReals(15), a=q0, b=q1) + cbloq = bb.finalize(a=q0, b=q1, result=q2) + + +def test_square_real_number(): + bb = BloqBuilder() + q0 = bb.add_register('a', 15) + q1 = bb.add_register('b', 15) + q0, q1, q2 = bb.add(SquareRealNumber(15), a=q0, b=q1) cbloq = bb.finalize(a=q0, b=q1, result=q2) From dd294f9f20b6f28e577d27555dd3f3646c09299a Mon Sep 17 00:00:00 2001 From: Fionn Malone Date: Fri, 6 Oct 2023 05:25:04 +0000 Subject: [PATCH 2/2] Correct addition clifford costs from Nour. --- qualtran/bloqs/arithmetic.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/qualtran/bloqs/arithmetic.py b/qualtran/bloqs/arithmetic.py index 155561bab..57ac5810a 100644 --- a/qualtran/bloqs/arithmetic.py +++ b/qualtran/bloqs/arithmetic.py @@ -93,16 +93,15 @@ def pretty_name(self) -> str: return "c = a + b" def t_complexity(self): - # TODO: This is just copied from adder above, not sure if correct. - # see https://github.com/quantumlib/Qualtran/issues/375 - num_clifford = (self.bitsize - 2) * 19 + 16 + # extra bitsize cliffords comes from CNOTs before adding: + # yield CNOT.on_each(zip(b, c)) + # yield Add(a, c) + num_clifford = (self.bitsize - 2) * 19 + 16 + self.bitsize num_t_gates = 4 * self.bitsize - 4 return TComplexity(t=num_t_gates, clifford=num_clifford) def bloq_counts(self, ssa: Optional['SympySymbolAllocator'] = None) -> Set[Tuple[int, Bloq]]: - num_clifford = (self.bitsize - 2) * 19 + 16 - num_t_gates = 4 * self.bitsize - 4 - return {(num_t_gates, TGate()), (num_clifford, ArbitraryClifford(n=1))} + return {(1, Add(self.bitsize)), (self.bitsize, ArbitraryClifford(n=2))} @frozen