From 705149c4d2f4e1187f571fe4ce6dac56df6be5d7 Mon Sep 17 00:00:00 2001 From: Fionn Malone Date: Fri, 4 Oct 2024 23:52:05 -0700 Subject: [PATCH] Update THC Prepare to use QROAMClean (#1378) --- .../block_encoding/lcu_block_encoding.py | 3 +- .../bloqs/chemistry/resource_estimation.ipynb | 100 +- qualtran/bloqs/chemistry/thc/prepare.py | 224 +-- qualtran/bloqs/chemistry/thc/prepare_test.py | 18 +- qualtran/bloqs/chemistry/thc/thc.ipynb | 10 +- .../trotter/grid_ham/trotter_costs.ipynb | 1588 ++++++++++++++++- 6 files changed, 1716 insertions(+), 227 deletions(-) diff --git a/qualtran/bloqs/block_encoding/lcu_block_encoding.py b/qualtran/bloqs/block_encoding/lcu_block_encoding.py index 308bb85ab..189290834 100644 --- a/qualtran/bloqs/block_encoding/lcu_block_encoding.py +++ b/qualtran/bloqs/block_encoding/lcu_block_encoding.py @@ -24,6 +24,7 @@ BloqDocSpec, CtrlSpec, Register, + Side, Signature, SoquetT, ) @@ -250,7 +251,7 @@ def selection_registers(self) -> Tuple[Register, ...]: @cached_property def junk_registers(self) -> Tuple[Register, ...]: - return self.prepare.junk_registers + return tuple(reg for reg in self.prepare.junk_registers if reg.side == Side.THRU) @cached_property def target_registers(self) -> Tuple[Register, ...]: diff --git a/qualtran/bloqs/chemistry/resource_estimation.ipynb b/qualtran/bloqs/chemistry/resource_estimation.ipynb index adf7a2c20..9218086ee 100644 --- a/qualtran/bloqs/chemistry/resource_estimation.ipynb +++ b/qualtran/bloqs/chemistry/resource_estimation.ipynb @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "2fb17f7f", "metadata": {}, "outputs": [], @@ -113,42 +113,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "b9991178", "metadata": {}, "outputs": [], "source": [ "from qualtran.bloqs.block_encoding import LCUBlockEncoding\n", - "from qualtran.bloqs.multiplexers.black_box_select import BlackBoxSelect\n", - "from qualtran.bloqs.state_preparation.black_box_prepare import BlackBoxPrepare\n", - "\n", "epsilon = 1e-4 # choosing this arbitrarily at this point. See: https://github.com/quantumlib/Qualtran/issues/985\n", "block_encoding_bloq = LCUBlockEncoding(\n", - " select=BlackBoxSelect(sel_thc), prepare=BlackBoxPrepare(prep_thc)\n", + " select=sel_thc, prepare=prep_thc\n", ")" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "55ce02c5", - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "from qualtran.drawing.musical_score import get_musical_score_data, draw_musical_score\n", - "msd = get_musical_score_data(block_encoding_bloq.decompose_bloq())\n", - "fig, ax = draw_musical_score(msd)\n", - "plt.tick_params(left=False, right=False, labelleft=False, labelbottom=False, bottom=False)\n", - "fig.set_size_inches(8, 4)" - ] - }, { "cell_type": "markdown", "id": "deb5c0fa", "metadata": {}, "source": [ - "This looks like our math expression above. Now given our block encoding block we can determine the resources required as follows" + "Now given our block encoding block we can determine the resources required as follows" ] }, { @@ -158,35 +140,22 @@ "metadata": {}, "outputs": [], "source": [ + "from qualtran import Bloq\n", + "from qualtran.symbolics import SymbolicInt\n", + "from qualtran.bloqs import block_encoding\n", "from qualtran.resource_counting import get_bloq_call_graph\n", "import attrs\n", "from qualtran.bloqs.bookkeeping import Partition, Split, Join, Allocate, Free\n", "from qualtran.bloqs.basic_gates import CSwap, TGate\n", "from qualtran.drawing import show_call_graph\n", + "from qualtran.resource_counting import QECGatesCost, get_cost_value\n", + "from qualtran.resource_counting.generalizers import generalize_cswap_approx\n", "\n", - "def keeper(bloq):\n", - " # intercept CSwaps which are lumped in with Toffolis in the reference papers\n", - " if isinstance(bloq, CSwap):\n", - " return True\n", - " return False\n", - "\n", - "def generalizer(bloq):\n", - " if isinstance(bloq, (Partition, Split, Join, Allocate, Free)):\n", - " return None\n", - " return bloq\n", - "\n", - "\n", - "def get_toffoli_counts(bloq):\n", - " _, sigma = get_bloq_call_graph(bloq, generalizer=generalizer, keep=keeper)\n", - " toffolis = 0\n", - " for k, v in sigma.items():\n", - " if isinstance(k, CSwap):\n", - " toffolis += v * k.bitsize\n", - " elif isinstance(k, TGate):\n", - " toffolis += v // 4\n", - " return toffolis\n", + "def get_toffoli_counts(bloq: Bloq) -> SymbolicInt:\n", + " return get_cost_value(bloq, QECGatesCost(), generalizer=generalize_cswap_approx).total_t_and_ccz_count(ts_per_rotation=0)['n_ccz']\n", "\n", "num_toff = get_toffoli_counts(block_encoding_bloq)\n", + "print(num_toff)\n", "# note the cost here is from openfermion, the reference number excludes the reflection\n", "print(f'qualtran = {num_toff} vs. ref = 10880, delta = {num_toff - 10880}')" ] @@ -219,6 +188,7 @@ "metadata": {}, "outputs": [], "source": [ + "import matplotlib.pyplot as plt\n", "plt.pie(toffoli_counts, labels=['SELECT', 'PREPARE', r'PREPARE$^{\\dagger}$'], autopct='%1.1f%%')" ] }, @@ -227,34 +197,12 @@ "id": "94fe7d78", "metadata": {}, "source": [ - "We see SELECT is the dominant cost and the inverse state preparation is significantly more expensive than its inverse. Let's have a look at the circuits to see where the costs are coming from." + "We see SELECT is the dominant cost and that state preparation is significantly more expensive than its inverse. Let's look at a breakdown of the costs" ] }, { "cell_type": "code", - "execution_count": null, - "id": "f671f121", - "metadata": {}, - "outputs": [], - "source": [ - "msd = get_musical_score_data(prep_thc.decompose_bloq())\n", - "fig, ax = draw_musical_score(msd)\n", - "fig.set_size_inches(12, 8)\n", - "ax.set_title('Prepare')\n", - "plt.tick_params(left=False, right=False, labelleft=False, labelbottom=False, bottom=False)" - ] - }, - { - "cell_type": "markdown", - "id": "cec920ff", - "metadata": {}, - "source": [ - "This figure should resemble Fig. 4 in the [THC paper](https://arxiv.org/abs/2011.03494). This circuit takes a familiar form, uniform state preparation followed by coherent alias sampling (QROM + swaps). Let's see a breakdown of these costs." - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "5efd66ae", "metadata": {}, "outputs": [], @@ -306,6 +254,7 @@ "metadata": {}, "outputs": [], "source": [ + "from qualtran.drawing import get_musical_score_data, draw_musical_score\n", "msd = get_musical_score_data(sel_thc.decompose_bloq())\n", "fig, ax = draw_musical_score(msd)\n", "fig.set_size_inches(12, 8)\n", @@ -356,7 +305,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "614bfb21", "metadata": {}, "outputs": [], @@ -414,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "349b70ab", "metadata": {}, "outputs": [], @@ -435,7 +384,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "2ef506ab", "metadata": {}, "outputs": [], @@ -462,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "e34dcb1c", "metadata": {}, "outputs": [], @@ -471,6 +420,8 @@ " SelectFirstQuantization,\n", " PrepareFirstQuantization,\n", ")\n", + "from qualtran.bloqs.state_preparation.black_box_prepare import BlackBoxPrepare\n", + "from qualtran.bloqs.multiplexers.black_box_select import BlackBoxSelect\n", "\n", "# keep the electron count small to make the diagrams nicer\n", "rs = 3.0\n", @@ -547,15 +498,16 @@ "metadata": {}, "outputs": [], "source": [ + "from qualtran.resource_counting.generalizers import ignore_split_join, ignore_alloc_free\n", "# let's just get the names of the relevant bloqs in select first\n", "fig, ax = plt.subplots(nrows=1, ncols=5)\n", "eta_vals = [10, 20, 40, 60, 80]\n", "for ieta, eta in enumerate(eta_vals):\n", " sel_fq = SelectFirstQuantization(num_bits_p, eta, eta, eta)\n", - " bloq_counts = sel_fq.bloq_counts(generalizer=generalizer)\n", + " bloq_counts = sel_fq.bloq_counts(generalizer=[ignore_split_join, ignore_alloc_free])\n", " # dictionary returned does not preserve any order so sort by the pretty names of the bloqs\n", " sorted_bloqs = sorted(\n", - " [bloq for bloq in sel_fq.bloq_counts(generalizer=generalizer).keys()],\n", + " [bloq for bloq in sel_fq.bloq_counts(generalizer=[ignore_split_join, ignore_alloc_free]).keys()],\n", " key=lambda x: str(x),\n", " )\n", " keys = [str(b) for b in sorted_bloqs]\n", @@ -582,7 +534,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "qualtran", "language": "python", "name": "python3" }, diff --git a/qualtran/bloqs/chemistry/thc/prepare.py b/qualtran/bloqs/chemistry/thc/prepare.py index e07978aef..f93891e72 100644 --- a/qualtran/bloqs/chemistry/thc/prepare.py +++ b/qualtran/bloqs/chemistry/thc/prepare.py @@ -15,7 +15,6 @@ from functools import cached_property from typing import Dict, Optional, Tuple, TYPE_CHECKING -import cirq import numpy as np from attrs import field, frozen from numpy.typing import NDArray @@ -28,8 +27,8 @@ QAny, QBit, Register, + Side, Signature, - Soquet, SoquetT, ) from qualtran._infra.data_types import BQUInt @@ -40,17 +39,19 @@ LessThanEqual, ToContiguousIndex, ) -from qualtran.bloqs.basic_gates import CSwap, Hadamard, Ry, Toffoli, XGate +from qualtran.bloqs.basic_gates import CSwap, CZ, Hadamard, Ry, Toffoli, XGate from qualtran.bloqs.basic_gates.on_each import OnEach -from qualtran.bloqs.data_loading.select_swap_qrom import SelectSwapQROM +from qualtran.bloqs.data_loading.qroam_clean import ( + get_optimal_log_block_size_clean_ancilla, + QROAMClean, +) from qualtran.bloqs.mcmt import MultiControlX from qualtran.bloqs.reflections.reflection_using_prepare import ReflectionUsingPrepare from qualtran.bloqs.state_preparation.prepare_base import PrepareOracle -from qualtran.cirq_interop import CirqGateAsBloq from qualtran.drawing import Text, WireSymbol from qualtran.linalg.lcu_util import preprocess_probabilities_for_reversible_sampling from qualtran.resource_counting.generalizers import ignore_cliffords, ignore_split_join -from qualtran.symbolics import SymbolicFloat +from qualtran.symbolics import SymbolicFloat, SymbolicInt if TYPE_CHECKING: from qualtran.resource_counting import BloqCountDictT, SympySymbolAllocator @@ -153,7 +154,6 @@ def build_composite_bloq( # 7. Control off of 5 and 6 to not prepare if these conditions are met (nu_eq_mp1, gt_mu_n), junk = bb.add(Toffoli(), ctrl=[nu_eq_mp1, gt_mu_n], target=junk) # 6. Reflect on comparitors, rotated qubit and |+>. - # ctrls = bb.join(np.array([rot, lte_nu_mp1, lte_mu_nu])) rot, lte_nu_mp1, lte_mu_nu, junk = bb.add( ReflectionUsingPrepare.reflection_around_zero(bitsizes=(1, 1, 1, 1), global_phase=1), reg0_=rot, @@ -161,7 +161,6 @@ def build_composite_bloq( reg2_=lte_mu_nu, reg3_=junk, ) - # (rot, lte_nu_mp1, lte_mu_nu) = bb.split(ctrls) # We now undo comparitors and rotations and repeat the steps nu, lte_nu_mp1 = bb.add(lt_gate, x=nu, target=lte_nu_mp1) mu, nu, lte_mu_nu = bb.add(lte_gate, x=mu, y=nu, target=lte_mu_nu) @@ -183,7 +182,6 @@ def build_composite_bloq( reg1_=nu, reg2_=rot, ) - # amp = trg[0] mu = bb.add(OnEach(num_bits_mu, Hadamard()), q=mu) nu = bb.add(OnEach(num_bits_mu, Hadamard()), q=nu) nu, lte_nu_mp1 = bb.add(lt_gate, x=nu, target=lte_nu_mp1) @@ -269,6 +267,7 @@ class PrepareTHC(PrepareOracle): keep: Tuple[int, ...] = field(repr=False) keep_bitsize: int sum_of_l1_coeffs: SymbolicFloat + log_block_size: SymbolicInt = 0 @classmethod def from_hamiltonian_coeffs( @@ -277,6 +276,7 @@ def from_hamiltonian_coeffs( eta: NDArray[np.float64], zeta: NDArray[np.float64], num_bits_state_prep: int = 8, + log_block_size: Optional[SymbolicInt] = None, ) -> 'PrepareTHC': """Factory method to build PrepareTHC from Hamiltonian coefficients. @@ -285,6 +285,7 @@ def from_hamiltonian_coeffs( eta: The THC leaf tensors. zeta: THC central tensor. num_bits_state_prep: The number of bits for the state prepared during alias sampling. + log_block_size: (log) Block size for qroam. Returns: Constructed PrepareTHC object. @@ -324,6 +325,11 @@ def from_hamiltonian_coeffs( zeta_normalized = norm_fac.dot(zeta).dot(norm_fac) # Eq. 11 & 12 lambda_t = np.sum(np.abs(t_l)) # Eq. 19 lambda_z = 0.5 * np.sum(np.abs(zeta_normalized)) # Eq. 20 + if log_block_size is None: + target_bitsizes = (1, 1, num_mu.bit_length(), num_mu.bit_length(), mu) + log_block_size = get_optimal_log_block_size_clean_ancilla( + len(alt_mu), sum(target_bitsizes) + ) return PrepareTHC( num_mu, 2 * num_spat, @@ -334,6 +340,7 @@ def from_hamiltonian_coeffs( keep=tuple(keep), keep_bitsize=mu, sum_of_l1_coeffs=lambda_t + lambda_z, + log_block_size=log_block_size, ) @property @@ -361,106 +368,120 @@ def selection_registers(self) -> Tuple[Register, ...]: @cached_property def junk_registers(self) -> Tuple[Register, ...]: data_size = self.num_spin_orb // 2 + self.num_mu * (self.num_mu + 1) // 2 - log_mu = self.num_mu.bit_length() - return ( - Register('theta', QBit()), + junk = ( Register('s', QAny(bitsize=(data_size - 1).bit_length())), - Register('alt_mn', QAny(bitsize=log_mu), shape=(2,)), - Register('alt_theta', QBit()), - Register('keep', QAny(bitsize=self.keep_bitsize)), Register('less_than', QBit()), Register('extra_ctrl', QBit()), ) + return junk + self.qroam_target_registers + self.qroam_extra_target_registers - def build_composite_bloq( - self, - bb: 'BloqBuilder', - mu: SoquetT, - nu: SoquetT, - plus_mn: SoquetT, - plus_a: SoquetT, - plus_b: SoquetT, - sigma: SoquetT, - rot: SoquetT, - succ: SoquetT, - nu_eq_mp1: SoquetT, - theta: SoquetT, - s: SoquetT, - alt_mn: NDArray[Soquet], # type: ignore[type-var] - alt_theta: SoquetT, - keep: SoquetT, - less_than: SoquetT, - extra_ctrl: SoquetT, - ) -> Dict[str, 'SoquetT']: + @cached_property + def qroam_target_registers(self) -> Tuple[Register, ...]: + """Target registers for QROAMClean.""" + return ( + Register('theta', QBit(), side=Side.RIGHT), + Register('alt_theta', QBit(), side=Side.RIGHT), + Register('alt_mu', QAny(bitsize=self.num_mu.bit_length()), side=Side.RIGHT), + Register('alt_nu', QAny(bitsize=self.num_mu.bit_length()), side=Side.RIGHT), + Register('keep', QAny(bitsize=self.keep_bitsize), side=Side.RIGHT), + ) + + @cached_property + def qroam_extra_target_registers(self) -> Tuple[Register, ...]: + """Extra registers required for QROAMClean.""" + return tuple( + Register( + name=f'junk_{reg.name}', + dtype=reg.dtype, + shape=reg.shape + (2**self.log_block_size - 1,), + side=Side.RIGHT, + ) + for reg in self.qroam_target_registers + ) + + def build_qrom_bloq(self) -> 'Bloq': + log_mu = self.num_mu.bit_length() + qroam = QROAMClean.build_from_data( + self.theta, + self.alt_theta, + self.alt_mu, + self.alt_nu, + self.keep, + target_bitsizes=(1, 1, log_mu, log_mu, self.keep_bitsize), + log_block_sizes=(self.log_block_size,), + ) + return qroam + + def add_qrom(self, bb: 'BloqBuilder', **soqs: 'SoquetT') -> Dict[str, 'SoquetT']: + qrom = self.build_qrom_bloq() + # The qroam_junk_regs won't be present initially when building the + # composite bloq as they're RIGHT registers. + qroam_out_soqs = bb.add_d(qrom, selection=soqs['s']) + out_soqs: Dict[str, 'SoquetT'] = {'s': qroam_out_soqs.pop('selection')} + # map output soqs to Prepare junk registers names + out_soqs |= { + reg.name: qroam_out_soqs.pop(f'target{i}_') + for (i, reg) in enumerate(self.qroam_target_registers) + } + out_soqs |= { + reg.name: qroam_out_soqs.pop(f'junk_target{i}_') + for (i, reg) in enumerate(self.qroam_extra_target_registers) + } + return soqs | out_soqs + + def build_composite_bloq(self, bb: 'BloqBuilder', **soqs: 'SoquetT') -> Dict[str, 'SoquetT']: # 1. Prepare THC uniform superposition over mu, nu. succ flags success. - mu, nu, succ, nu_eq_mp1, rot = bb.add( + soqs['mu'], soqs['nu'], soqs['succ'], soqs['nu_eq_mp1'], soqs['rot'] = bb.add( UniformSuperpositionTHC(num_mu=self.num_mu, num_spin_orb=self.num_spin_orb), - mu=mu, - nu=nu, - succ=succ, - nu_eq_mp1=nu_eq_mp1, - rot=rot, + mu=soqs['mu'], + nu=soqs['nu'], + succ=soqs['succ'], + nu_eq_mp1=soqs['nu_eq_mp1'], + rot=soqs['rot'], ) data_size = self.num_spin_orb // 2 + self.num_mu * (self.num_mu + 1) // 2 log_mu = self.num_mu.bit_length() log_d = (data_size - 1).bit_length() # 2. Make contiguous register from mu and nu and store in register `s`. - mu, nu, s = bb.add(ToContiguousIndex(log_mu, log_d), mu=mu, nu=nu, s=s) + soqs['mu'], soqs['nu'], soqs['s'] = bb.add( + ToContiguousIndex(log_mu, log_d), mu=soqs['mu'], nu=soqs['nu'], s=soqs['s'] + ) # 3. Load alt / keep values - qroam = SelectSwapQROM.build_from_data( - *(self.theta, self.alt_theta, self.alt_mu, self.alt_nu, self.keep), - target_bitsizes=(1, 1, log_mu, log_mu, self.keep_bitsize), - use_dirty_ancilla=False, + soqs |= self.add_qrom(bb, **soqs) + soqs['sigma'] = bb.add(OnEach(self.keep_bitsize, Hadamard()), q=soqs['sigma']) + lte_gate = LessThanEqual(self.keep_bitsize, self.keep_bitsize) + soqs['keep'], soqs['sigma'], soqs['less_than'] = bb.add( + lte_gate, x=soqs['keep'], y=soqs['sigma'], target=soqs['less_than'] ) - alt_mu, alt_nu = alt_mn - s, theta, alt_theta, alt_mu, alt_nu, keep = bb.add( - qroam, - selection=s, - target0_=theta, - target1_=alt_theta, - target2_=alt_mu, - target3_=alt_nu, - target4_=keep, + soqs['alt_theta'], soqs['less_than'] = bb.add( + CZ(), q1=soqs['alt_theta'], q2=soqs['less_than'] + ) + # off-control + soqs['less_than'] = bb.add(XGate(), q=soqs['less_than']) + soqs['less_than'], soqs['theta'] = bb.add(CZ(), q1=soqs['less_than'], q2=soqs['theta']) + soqs['less_than'] = bb.add(XGate(), q=soqs['less_than']) + soqs['less_than'], soqs['alt_mu'], soqs['mu'] = bb.add( + CSwap(bitsize=log_mu), ctrl=soqs['less_than'], x=soqs['alt_mu'], y=soqs['mu'] + ) + soqs['less_than'], soqs['alt_nu'], soqs['nu'] = bb.add( + CSwap(bitsize=log_mu), ctrl=soqs['less_than'], x=soqs['alt_nu'], y=soqs['nu'] + ) + soqs['keep'], soqs['sigma'], soqs['less_than'] = bb.add( + lte_gate, x=soqs['keep'], y=soqs['sigma'], target=soqs['less_than'] ) - sigma = bb.add(OnEach(self.keep_bitsize, Hadamard()), q=sigma) - lte_gate = LessThanEqual(self.keep_bitsize, self.keep_bitsize) - keep, sigma, less_than = bb.add(lte_gate, x=keep, y=sigma, target=less_than) - cz = CirqGateAsBloq(cirq.ControlledGate(cirq.Z)) - alt_theta, less_than = bb.add(cz, q=[alt_theta, less_than]) - cz = CirqGateAsBloq(cirq.ControlledGate(cirq.Z, control_values=(0,))) - # negative control on the less_than register - less_than, theta = bb.add(cz, q=[less_than, theta]) - less_than, alt_mu, mu = bb.add(CSwap(bitsize=log_mu), ctrl=less_than, x=alt_mu, y=mu) - less_than, alt_nu, nu = bb.add(CSwap(bitsize=log_mu), ctrl=less_than, x=alt_nu, y=nu) - keep, sigma, less_than = bb.add(lte_gate, x=keep, y=sigma, target=less_than) - # delete the QROM # Select expects three plus states so set them up here. - plus_a = bb.add(Hadamard(), q=plus_a) - plus_b = bb.add(Hadamard(), q=plus_b) - plus_mn = bb.add(Hadamard(), q=plus_mn) - (nu_eq_mp1, plus_a), extra_ctrl = bb.add( - MultiControlX(cvs=(0, 1)), controls=np.array([nu_eq_mp1, plus_a]), target=extra_ctrl + soqs['plus_a'] = bb.add(Hadamard(), q=soqs['plus_a']) + soqs['plus_b'] = bb.add(Hadamard(), q=soqs['plus_b']) + soqs['plus_mn'] = bb.add(Hadamard(), q=soqs['plus_mn']) + (soqs['nu_eq_mp1'], soqs['plus_a']), soqs['extra_ctrl'] = bb.add( + MultiControlX(cvs=(0, 1)), + controls=np.array([soqs['nu_eq_mp1'], soqs['plus_a']]), + target=soqs['extra_ctrl'], ) - extra_ctrl, mu, nu = bb.add(CSwap(bitsize=log_mu), ctrl=extra_ctrl, x=mu, y=nu) - out_regs = { - 'mu': mu, - 'nu': nu, - 'plus_mn': plus_mn, - 'plus_a': plus_a, - 'plus_b': plus_b, - 'sigma': sigma, - 'rot': rot, - 'succ': succ, - 'nu_eq_mp1': nu_eq_mp1, - 'theta': theta, - 's': s, - 'alt_mn': [alt_mu, alt_nu], - 'alt_theta': alt_theta, - 'keep': keep, - 'less_than': less_than, - 'extra_ctrl': extra_ctrl, - } - return out_regs + soqs['extra_ctrl'], soqs['mu'], soqs['nu'] = bb.add( + CSwap(bitsize=log_mu), ctrl=soqs['extra_ctrl'], x=soqs['mu'], y=soqs['nu'] + ) + return soqs def build_call_graph(self, ssa: 'SympySymbolAllocator') -> 'BloqCountDictT': cost_1 = (UniformSuperpositionTHC(self.num_mu, self.num_spin_orb), 1) @@ -468,17 +489,18 @@ def build_call_graph(self, ssa: 'SympySymbolAllocator') -> 'BloqCountDictT': data_size = self.num_spin_orb // 2 + self.num_mu * (self.num_mu + 1) // 2 nd = (data_size - 1).bit_length() cost_2 = (ToContiguousIndex(nmu, nd), 1) - qroam = SelectSwapQROM.build_from_data( - *(self.theta, self.alt_theta, self.alt_mu, self.alt_nu, self.keep), - target_bitsizes=(1, 1, nmu, nmu, self.keep_bitsize), - use_dirty_ancilla=False, - ) + qroam = self.build_qrom_bloq() cost_3 = (qroam, 1) cost_4 = (OnEach(self.keep_bitsize, Hadamard()), 1) cost_5 = (LessThanEqual(self.keep_bitsize, self.keep_bitsize), 2) cost_6 = (CSwap(nmu), 3) - cost_7 = (Toffoli(), 1) - return dict([cost_1, cost_2, cost_3, cost_4, cost_5, cost_6, cost_7]) + cost_7 = (MultiControlX(cvs=(0, 1)), 1) + cost_8 = (XGate(), 2) + cost_9 = (CZ(), 2) + cost_10 = (Hadamard(), 3) + return dict( + [cost_1, cost_2, cost_3, cost_4, cost_5, cost_6, cost_7, cost_8, cost_9, cost_10] + ) @bloq_example @@ -496,7 +518,9 @@ def _thc_prep() -> PrepareTHC: num_spat = 4 num_mu = 8 t_l, eta, zeta = build_random_test_integrals(num_mu, num_spat, seed=7) - thc_prep = PrepareTHC.from_hamiltonian_coeffs(t_l, eta, zeta, num_bits_state_prep=8) + thc_prep = PrepareTHC.from_hamiltonian_coeffs( + t_l, eta, zeta, num_bits_state_prep=8, log_block_size=2 + ) return thc_prep diff --git a/qualtran/bloqs/chemistry/thc/prepare_test.py b/qualtran/bloqs/chemistry/thc/prepare_test.py index f50f8c18d..8f3da8352 100644 --- a/qualtran/bloqs/chemistry/thc/prepare_test.py +++ b/qualtran/bloqs/chemistry/thc/prepare_test.py @@ -27,7 +27,9 @@ ) from qualtran.drawing.musical_score import get_musical_score_data, MusicalScoreData from qualtran.linalg.lcu_util import preprocess_probabilities_for_reversible_sampling +from qualtran.resource_counting import get_cost_value, QECGatesCost from qualtran.resource_counting.classify_bloqs import classify_t_count_by_bloq_type +from qualtran.resource_counting.generalizers import generalize_cswap_approx, ignore_split_join from qualtran.testing import execute_notebook @@ -112,11 +114,17 @@ def test_prepare_qrom_counts(): t_l, eta, zeta = build_random_test_integrals(num_mu, num_spat, seed=7) thc_prep = PrepareTHC.from_hamiltonian_coeffs(t_l, eta, zeta, num_bits_state_prep=8) binned_counts = classify_t_count_by_bloq_type(thc_prep) - assert binned_counts['data_loading'] == 304, binned_counts['data_loading'] - t_l, eta, zeta = build_random_test_integrals(num_mu, num_spat, seed=23) - thc_prep = PrepareTHC.from_hamiltonian_coeffs(t_l, eta, zeta, num_bits_state_prep=8) - binned_counts = classify_t_count_by_bloq_type(thc_prep) - assert binned_counts['data_loading'] == 296, binned_counts['data_loading'] + qroam = thc_prep.build_qrom_bloq() + + counts = get_cost_value( + qroam, QECGatesCost(), generalizer=generalize_cswap_approx + ).total_t_and_ccz_count() + assert binned_counts['data_loading'] == counts['n_ccz'] * 4, binned_counts['data_loading'] + + +def test_equivalent_bloq_counts(): + prepare = _thc_prep.make() + qlt_testing.assert_equivalent_bloq_counts(prepare, ignore_split_join) def test_musical_score(): diff --git a/qualtran/bloqs/chemistry/thc/thc.ipynb b/qualtran/bloqs/chemistry/thc/thc.ipynb index e5a8b65da..17e405ec4 100644 --- a/qualtran/bloqs/chemistry/thc/thc.ipynb +++ b/qualtran/bloqs/chemistry/thc/thc.ipynb @@ -327,7 +327,9 @@ "num_spat = 4\n", "num_mu = 8\n", "t_l, eta, zeta = build_random_test_integrals(num_mu, num_spat, seed=7)\n", - "thc_prep = PrepareTHC.from_hamiltonian_coeffs(t_l, eta, zeta, num_bits_state_prep=8)" + "thc_prep = PrepareTHC.from_hamiltonian_coeffs(\n", + " t_l, eta, zeta, num_bits_state_prep=8, log_block_size=2\n", + ")" ] }, { @@ -433,7 +435,7 @@ " print(f\"{k+':':20s} qualtran = {binned_counts[k]:5d} vs paper cost = {v:5d}.\")\n", "\n", "print(f\"Total cost = {sum(v for v in binned_counts.values())}\")\n", - "assert binned_counts['data_loading'] == 304" + "assert binned_counts['data_loading'] == 248" ] }, { @@ -441,7 +443,7 @@ "id": "807674de", "metadata": {}, "source": [ - "The main discrepancies arise from QROAM assumptions and the difference in comparator cost seen before. " + "The main discrepancies arise the differences in comparator cost seen before. The QROAM cost in qualtran is more accurate as it includes the constant factor of -2 Toffolis arising from uncontrolled QROM. " ] }, { @@ -618,7 +620,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/qualtran/bloqs/chemistry/trotter/grid_ham/trotter_costs.ipynb b/qualtran/bloqs/chemistry/trotter/grid_ham/trotter_costs.ipynb index 2ea95aba8..2472a3888 100644 --- a/qualtran/bloqs/chemistry/trotter/grid_ham/trotter_costs.ipynb +++ b/qualtran/bloqs/chemistry/trotter/grid_ham/trotter_costs.ipynb @@ -57,9 +57,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "delta = 0.25\n", + "unscaled grid points = [-30 -29 -28 -27 -26 -25 -24 -23 -22 -21 -20 -19 -18 -17 -16 -15 -14 -13\n", + " -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5\n", + " 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23\n", + " 24 25 26 27 28 29 30]\n", + "scaled grid points = [-7.5 -7.25 -7. -6.75 -6.5 -6.25 -6. -5.75 -5.5 -5.25 -5. -4.75\n", + " -4.5 -4.25 -4. -3.75 -3.5 -3.25 -3. -2.75 -2.5 -2.25 -2. -1.75\n", + " -1.5 -1.25 -1. -0.75 -0.5 -0.25 0. 0.25 0.5 0.75 1. 1.25\n", + " 1.5 1.75 2. 2.25 2.5 2.75 3. 3.25 3.5 3.75 4. 4.25\n", + " 4.5 4.75 5. 5.25 5.5 5.75 6. 6.25 6.5 6.75 7. 7.25\n", + " 7.5 ]\n" + ] + } + ], "source": [ "import numpy as np\n", "ng = 30\n", @@ -83,9 +101,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Coulomb potential on a grid.')" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt \n", "ij_pairs = np.triu_indices(len(x_int), k=1)\n", @@ -110,9 +149,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xmin = 1, xmax = 60\n" + ] + }, + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Coulomb potential on a.')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "rij_int = np.unique(np.array(np.sqrt((x_int[ij_pairs[0]] - x_int[ij_pairs[1]])**(2)), dtype=int))\n", "Vij_int = 1.0 / rij_int\n", @@ -234,9 +301,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(1e-06, 0.0001)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham.inverse_sqrt import get_inverse_square_root_poly_coeffs\n", "coeffs_one, coeffs_two = get_inverse_square_root_poly_coeffs()\n", @@ -271,7 +359,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -286,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -295,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -304,9 +392,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(1e-12, 1e-08)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plt.plot(xs_one, np.abs(1.0 / xs_one**0.5 - nr_one), marker='o', lw=0, label=\"range 1\")\n", "plt.plot(xs_two, np.abs(1.0 / xs_two**0.5 - nr_two), marker='x', lw=0, label=\"range 2\")\n", @@ -330,9 +439,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max error = 5.8675108801198306e-05 vs expected error = 3.0517578125e-05\n", + "max error after NR step = 2.5821014215665627e-09\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from typing import Union\n", "from numpy.typing import NDArray\n", @@ -441,9 +569,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "L = 16384\n", + "l = 00000000000100, range = [ 4, 5], length = 2 3\n", + "l = 00000000000110, range = [ 6, 7], length = 2 3\n", + "l = 00000000001000, range = [ 8, 11], length = 4 4\n", + "l = 00000000001100, range = [ 12, 15], length = 4 4\n", + "l = 00000000010000, range = [ 16, 23], length = 8 5\n", + "l = 00000000011000, range = [ 24, 31], length = 8 5\n", + "l = 00000000100000, range = [ 32, 47], length = 16 6\n", + "l = 00000000110000, range = [ 48, 63], length = 16 6\n", + "l = 00000001000000, range = [ 64, 95], length = 32 7\n", + "l = 00000001100000, range = [ 96, 127], length = 32 7\n", + "l = 00000010000000, range = [ 128, 191], length = 64 8\n", + "l = 00000011000000, range = [ 192, 255], length = 64 8\n", + "l = 00000100000000, range = [ 256, 383], length = 128 9\n", + "l = 00000110000000, range = [ 384, 511], length = 128 9\n", + "l = 00001000000000, range = [ 512, 767], length = 256 10\n", + "l = 00001100000000, range = [ 768, 1023], length = 256 10\n", + "l = 00010000000000, range = [ 1024, 1535], length = 512 11\n", + "l = 00011000000000, range = [ 1536, 2047], length = 512 11\n", + "l = 00100000000000, range = [ 2048, 3071], length = 1024 12\n", + "l = 00110000000000, range = [ 3072, 4095], length = 1024 12\n", + "l = 01000000000000, range = [ 4096, 6143], length = 2048 13\n", + "l = 01100000000000, range = [ 6144, 8191], length = 2048 13\n", + "l = 10000000000000, range = [ 8192, 12287], length = 4096 14\n", + "l = 11000000000000, range = [12288, 16383], length = 4096 14\n", + "number of distinct regions g = 28. Toffoli cost g - 2 = 26\n" + ] + } + ], "source": [ "nbits = 6\n", "nbits_rij_sq = 2 * nbits + 2\n", @@ -504,9 +665,189 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "my_graph\n", + "\n", + "\n", + "\n", + "system_G0\n", + "system[0, 0]\n", + "\n", + "\n", + "\n", + "KineticEnergy\n", + "\n", + "KineticEnergy\n", + "\n", + "system[0, 0]\n", + "\n", + "system[0, 1]\n", + "\n", + "system[0, 2]\n", + "\n", + "system[1, 0]\n", + "\n", + "system[1, 1]\n", + "\n", + "system[1, 2]\n", + "\n", + "\n", + "\n", + "system_G0:e->KineticEnergy:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G6\n", + "system[0, 1]\n", + "\n", + "\n", + "\n", + "system_G6:e->KineticEnergy:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G2\n", + "system[0, 2]\n", + "\n", + "\n", + "\n", + "system_G2:e->KineticEnergy:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G12\n", + "system[1, 0]\n", + "\n", + "\n", + "\n", + "system_G12:e->KineticEnergy:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G16\n", + "system[1, 1]\n", + "\n", + "\n", + "\n", + "system_G16:e->KineticEnergy:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G3\n", + "system[1, 2]\n", + "\n", + "\n", + "\n", + "system_G3:e->KineticEnergy:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G9\n", + "system[0, 0]\n", + "\n", + "\n", + "\n", + "KineticEnergy:e->system_G9:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G15\n", + "system[0, 1]\n", + "\n", + "\n", + "\n", + "KineticEnergy:e->system_G15:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G13\n", + "system[0, 2]\n", + "\n", + "\n", + "\n", + "KineticEnergy:e->system_G13:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G1\n", + "system[1, 0]\n", + "\n", + "\n", + "\n", + "KineticEnergy:e->system_G1:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G5\n", + "system[1, 1]\n", + "\n", + "\n", + "\n", + "KineticEnergy:e->system_G5:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G11\n", + "system[1, 2]\n", + "\n", + "\n", + "\n", + "KineticEnergy:e->system_G11:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham import KineticEnergy \n", "from qualtran.drawing import show_bloq\n", @@ -518,9 +859,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T-count: 808\n", + "Rotations: 28\n", + "Cliffords: 0\n", + "\n" + ] + } + ], "source": [ "print(ke_bloq.t_complexity())" ] @@ -541,9 +893,199 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "my_graph\n", + "\n", + "\n", + "\n", + "system\n", + "system[0, 0]\n", + "\n", + "\n", + "\n", + "PairPotential\n", + "\n", + "PairPotential\n", + "\n", + "system_i[0]\n", + "\n", + "system_i[1]\n", + "\n", + "system_i[2]\n", + "\n", + "system_j[0]\n", + "\n", + "system_j[1]\n", + "\n", + "system_j[2]\n", + "\n", + "\n", + "\n", + "system:e->PairPotential:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G6\n", + "system[0, 1]\n", + "\n", + "\n", + "\n", + "system_G6:e->PairPotential:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G2\n", + "system[0, 2]\n", + "\n", + "\n", + "\n", + "system_G2:e->PairPotential:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G9\n", + "system[1, 0]\n", + "\n", + "\n", + "\n", + "system_G9:e->PairPotential:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G13\n", + "system[1, 1]\n", + "\n", + "\n", + "\n", + "system_G13:e->PairPotential:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G3\n", + "system[1, 2]\n", + "\n", + "\n", + "\n", + "system_G3:e->PairPotential:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G7\n", + "system[0, 0]\n", + "\n", + "\n", + "\n", + "PairPotential:e->system_G7:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G15\n", + "system[0, 1]\n", + "\n", + "\n", + "\n", + "PairPotential:e->system_G15:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G11\n", + "system[0, 2]\n", + "\n", + "\n", + "\n", + "PairPotential:e->system_G11:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G1\n", + "system[1, 0]\n", + "\n", + "\n", + "\n", + "PairPotential:e->system_G1:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G5\n", + "system[1, 1]\n", + "\n", + "\n", + "\n", + "PairPotential:e->system_G5:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "system_G8\n", + "system[1, 2]\n", + "\n", + "\n", + "\n", + "PairPotential:e->system_G8:w\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T-count: 9176\n", + "Rotations: 24\n", + "Cliffords: 2646\n", + "\n" + ] + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham import PotentialEnergy\n", "from qualtran.drawing import show_bloq, show_call_graph\n", @@ -564,9 +1106,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "T-count: 9176\n", + "Rotations: 24\n", + "Cliffords: 2646\n", + "\n" + ] + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham import PairPotential\n", "from qualtran.bloqs.chemistry.trotter.grid_ham.inverse_sqrt import build_qrom_data_for_poly_fit\n", @@ -591,7 +1144,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -639,9 +1192,158 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "counts\n", + "\n", + "\n", + "\n", + "b0\n", + "\n", + "y ~ x^{-1/2}\n", + "x_sq_bitsize=14, poly_bitsize=15, out_bitsize=24\n", + "\n", + "\n", + "\n", + "b1\n", + "\n", + "Add\n", + "a_dtype=QInt(bit ..., b_dtype=QInt(bit ...\n", + "\n", + "\n", + "\n", + "b0->b1\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "b2\n", + "\n", + "a*b\n", + "bitsize=15\n", + "\n", + "\n", + "\n", + "b0->b2\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "b3\n", + "\n", + "And†\n", + "cv1=1, cv2=1, uncompute=True\n", + "\n", + "\n", + "\n", + "b1->b3\n", + "\n", + "\n", + "14\n", + "\n", + "\n", + "\n", + "b4\n", + "\n", + "And\n", + "cv1=1, cv2=1, uncompute=False\n", + "\n", + "\n", + "\n", + "b1->b4\n", + "\n", + "\n", + "14\n", + "\n", + "\n", + "\n", + "b5\n", + "\n", + "CNOT\n", + "\n", + "\n", + "\n", + "b1->b5\n", + "\n", + "\n", + "81\n", + "\n", + "\n", + "\n", + "b6\n", + "\n", + "Toffoli\n", + "\n", + "\n", + "\n", + "b2->b6\n", + "\n", + "\n", + "209\n", + "\n", + "\n", + "\n", + "b7\n", + "\n", + "ArbitraryClifford\n", + "n=2\n", + "\n", + "\n", + "\n", + "b3->b7\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b4->b7\n", + "\n", + "\n", + "9\n", + "\n", + "\n", + "\n", + "b8\n", + "\n", + "T\n", + "is_adjoint=False\n", + "\n", + "\n", + "\n", + "b4->b8\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b6->b8\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham.inverse_sqrt import PolynmomialEvaluationInverseSquareRoot \n", "poly_eval = PolynmomialEvaluationInverseSquareRoot(14, 15, 24)\n", @@ -651,9 +1353,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "qualtran cost = 2676 vs paper_cost = 2880 T gates\n" + ] + } + ], "source": [ "paper_cost = 4 * (3*15**2 + 45)\n", "print(f\"qualtran cost = {poly_eval.t_complexity().t} vs paper_cost = {paper_cost} T gates\")" @@ -661,9 +1371,200 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "counts\n", + "\n", + "\n", + "\n", + "b0\n", + "\n", + "y = x^{-1/2}\n", + "x_sq_bitsize=14, poly_bitsize=15, target_bitsize=24\n", + "\n", + "\n", + "\n", + "b1\n", + "\n", + "a^2\n", + "bitsize=15\n", + "\n", + "\n", + "\n", + "b0->b1\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b2\n", + "\n", + "r*i\n", + "r_bitsize=15, i_bitsize=14\n", + "\n", + "\n", + "\n", + "b0->b2\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b3\n", + "\n", + "Add\n", + "a_dtype=QInt(bit ..., b_dtype=QInt(bit ...\n", + "\n", + "\n", + "\n", + "b0->b3\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b4\n", + "\n", + "a*b\n", + "bitsize=24\n", + "\n", + "\n", + "\n", + "b0->b4\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "\n", + "b8\n", + "\n", + "Toffoli\n", + "\n", + "\n", + "\n", + "b1->b8\n", + "\n", + "\n", + "108\n", + "\n", + "\n", + "\n", + "b2->b8\n", + "\n", + "\n", + "209\n", + "\n", + "\n", + "\n", + "b5\n", + "\n", + "CNOT\n", + "\n", + "\n", + "\n", + "b3->b5\n", + "\n", + "\n", + "135\n", + "\n", + "\n", + "\n", + "b6\n", + "\n", + "And†\n", + "cv1=1, cv2=1, uncompute=True\n", + "\n", + "\n", + "\n", + "b3->b6\n", + "\n", + "\n", + "23\n", + "\n", + "\n", + "\n", + "b7\n", + "\n", + "And\n", + "cv1=1, cv2=1, uncompute=False\n", + "\n", + "\n", + "\n", + "b3->b7\n", + "\n", + "\n", + "23\n", + "\n", + "\n", + "\n", + "b4->b8\n", + "\n", + "\n", + "551\n", + "\n", + "\n", + "\n", + "b9\n", + "\n", + "ArbitraryClifford\n", + "n=2\n", + "\n", + "\n", + "\n", + "b6->b9\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b7->b9\n", + "\n", + "\n", + "9\n", + "\n", + "\n", + "\n", + "b10\n", + "\n", + "T\n", + "is_adjoint=False\n", + "\n", + "\n", + "\n", + "b7->b10\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b8->b10\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham.inverse_sqrt import NewtonRaphsonApproxInverseSquareRoot\n", "nr = NewtonRaphsonApproxInverseSquareRoot(14, 15, 24)\n", @@ -673,9 +1574,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "qualtran cost = 5768 vs paper cost = 5664 T gates\n" + ] + } + ], "source": [ "paper_cost = 4 * (2136 - 3*15**2 - 45)\n", "print(f\"qualtran cost = {nr.t_complexity().t} vs paper cost = {paper_cost} T gates\")" @@ -683,9 +1592,103 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "counts\n", + "\n", + "\n", + "\n", + "b0\n", + "\n", + "U_T(dt)\n", + "num_elec=4, num_grid=21\n", + "\n", + "\n", + "\n", + "b1\n", + "\n", + "e^{i*phi}\n", + "phi_bitsize=14\n", + "\n", + "\n", + "\n", + "b0->b1\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b2\n", + "\n", + "SOS\n", + "bitsize=6, k=3\n", + "\n", + "\n", + "\n", + "b0->b2\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b3\n", + "\n", + "Rz\n", + "angle=_phi0, eps=1e-11\n", + "\n", + "\n", + "\n", + "b1->b3\n", + "\n", + "\n", + "14\n", + "\n", + "\n", + "\n", + "b4\n", + "\n", + "Toffoli\n", + "\n", + "\n", + "\n", + "b2->b4\n", + "\n", + "\n", + "101\n", + "\n", + "\n", + "\n", + "b5\n", + "\n", + "T\n", + "is_adjoint=False\n", + "\n", + "\n", + "\n", + "b4->b5\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham import KineticEnergy \n", "ke = KineticEnergy(4, 21)\n", @@ -695,9 +1698,500 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "counts\n", + "\n", + "\n", + "\n", + "b0\n", + "\n", + "PotentialEnergy\n", + "num_elec=4, num_grid=21, poly_bitsize=15, label='V'\n", + "\n", + "\n", + "\n", + "b1\n", + "\n", + "PairPotential\n", + "bitsize=6, qrom_data=((0, 327 ..., poly_bitsize=15, inv_sqrt_bitsize=24, label='V'\n", + "\n", + "\n", + "\n", + "b0->b1\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "b2\n", + "\n", + "Cast\n", + "inp_dtype=BQUInt(b ..., out_dtype=QUInt(bi ..., shape=()\n", + "\n", + "\n", + "\n", + "b1->b2\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b3\n", + "\n", + "c = a + b\n", + "bitsize=6, is_adjoint=False\n", + "\n", + "\n", + "\n", + "b1->b3\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "b4\n", + "\n", + "y = x^{-1/2}\n", + "x_sq_bitsize=16, poly_bitsize=15, target_bitsize=24\n", + "\n", + "\n", + "\n", + "b1->b4\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b5\n", + "\n", + "e^{i*phi}\n", + "phi_bitsize=24\n", + "\n", + "\n", + "\n", + "b1->b5\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b6\n", + "\n", + "y ~ x^{-1/2}\n", + "x_sq_bitsize=16, poly_bitsize=15, out_bitsize=15\n", + "\n", + "\n", + "\n", + "b1->b6\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b7\n", + "\n", + "Cast\n", + "inp_dtype=QUInt(bi ..., out_dtype=BQUInt(b ..., shape=()\n", + "\n", + "\n", + "\n", + "b1->b7\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b8\n", + "\n", + "c = a + b\n", + "bitsize=6, is_adjoint=True\n", + "\n", + "\n", + "\n", + "b1->b8\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "b9\n", + "\n", + "QROM\n", + "data_or_shape=(array([ ..., selection_bitsizes=(16,), target_bitsizes=(15, 15, ..., target_shapes=((), (), ..., num_controls=0\n", + "\n", + "\n", + "\n", + "b1->b9\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b10\n", + "\n", + "SOS\n", + "bitsize=7, k=3\n", + "\n", + "\n", + "\n", + "b1->b10\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b21\n", + "\n", + "And\n", + "cv1=1, cv2=1, uncompute=False\n", + "\n", + "\n", + "\n", + "b3->b21\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "b22\n", + "\n", + "CNOT\n", + "\n", + "\n", + "\n", + "b3->b22\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "\n", + "b11\n", + "\n", + "a^2\n", + "bitsize=15\n", + "\n", + "\n", + "\n", + "b4->b11\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b12\n", + "\n", + "a*b\n", + "bitsize=24\n", + "\n", + "\n", + "\n", + "b4->b12\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "\n", + "b13\n", + "\n", + "r*i\n", + "r_bitsize=15, i_bitsize=16\n", + "\n", + "\n", + "\n", + "b4->b13\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b14\n", + "\n", + "Add\n", + "a_dtype=QInt(bit ..., b_dtype=QInt(bit ...\n", + "\n", + "\n", + "\n", + "b4->b14\n", + "\n", + "\n", + "1\n", + "\n", + "\n", + "\n", + "b15\n", + "\n", + "Rz\n", + "angle=_phi0, eps=1e-11\n", + "\n", + "\n", + "\n", + "b5->b15\n", + "\n", + "\n", + "24\n", + "\n", + "\n", + "\n", + "b16\n", + "\n", + "Add\n", + "a_dtype=QInt(bit ..., b_dtype=QInt(bit ...\n", + "\n", + "\n", + "\n", + "b6->b16\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "b17\n", + "\n", + "a*b\n", + "bitsize=15\n", + "\n", + "\n", + "\n", + "b6->b17\n", + "\n", + "\n", + "3\n", + "\n", + "\n", + "\n", + "b20\n", + "\n", + "And†\n", + "cv1=1, cv2=1, uncompute=True\n", + "\n", + "\n", + "\n", + "b8->b20\n", + "\n", + "\n", + "6\n", + "\n", + "\n", + "\n", + "b8->b22\n", + "\n", + "\n", + "30\n", + "\n", + "\n", + "\n", + "b18\n", + "\n", + "XGate\n", + "\n", + "\n", + "\n", + "b9->b18\n", + "\n", + "\n", + "2\n", + "\n", + "\n", + "\n", + "b19\n", + "\n", + "And\n", + "cv1=1, cv2=0, uncompute=False\n", + "\n", + "\n", + "\n", + "b9->b19\n", + "\n", + "\n", + "26\n", + "\n", + "\n", + "\n", + "b9->b20\n", + "\n", + "\n", + "26\n", + "\n", + "\n", + "\n", + "b9->b22\n", + "\n", + "\n", + "617\n", + "\n", + "\n", + "\n", + "b23\n", + "\n", + "Toffoli\n", + "\n", + "\n", + "\n", + "b10->b23\n", + "\n", + "\n", + "139\n", + "\n", + "\n", + "\n", + "b11->b23\n", + "\n", + "\n", + "108\n", + "\n", + "\n", + "\n", + "b12->b23\n", + "\n", + "\n", + "551\n", + "\n", + "\n", + "\n", + "b13->b23\n", + "\n", + "\n", + "209\n", + "\n", + "\n", + "\n", + "b14->b20\n", + "\n", + "\n", + "23\n", + "\n", + "\n", + "\n", + "b14->b21\n", + "\n", + "\n", + "23\n", + "\n", + "\n", + "\n", + "b14->b22\n", + "\n", + "\n", + "135\n", + "\n", + "\n", + "\n", + "b16->b20\n", + "\n", + "\n", + "14\n", + "\n", + "\n", + "\n", + "b16->b21\n", + "\n", + "\n", + "14\n", + "\n", + "\n", + "\n", + "b16->b22\n", + "\n", + "\n", + "81\n", + "\n", + "\n", + "\n", + "b17->b23\n", + "\n", + "\n", + "209\n", + "\n", + "\n", + "\n", + "b24\n", + "\n", + "ArbitraryClifford\n", + "n=2\n", + "\n", + "\n", + "\n", + "b19->b24\n", + "\n", + "\n", + "11\n", + "\n", + "\n", + "\n", + "b25\n", + "\n", + "T\n", + "is_adjoint=False\n", + "\n", + "\n", + "\n", + "b19->b25\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b20->b24\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b21->b24\n", + "\n", + "\n", + "9\n", + "\n", + "\n", + "\n", + "b21->b25\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "\n", + "b23->b25\n", + "\n", + "\n", + "4\n", + "\n", + "\n", + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham import PotentialEnergy \n", "pe = PotentialEnergy(4, 21)\n", @@ -714,9 +2208,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "qualtran_cost = 7928 vs paper_cost = 9052\n" + ] + } + ], "source": [ "from qualtran.bloqs.chemistry.trotter.grid_ham import PairPotential\n", "nbits = 6\n", @@ -760,7 +2262,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "qualtran", "language": "python", "name": "python3" }, @@ -774,9 +2276,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.5" + "version": "3.11.9" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }