Add RSA Phase Estimate Bloq and Move ModExp to rsa/ subdirectory

dev_tools/qualtran_dev_tools/notebook_specs.py

@@ -83,7 +83,7 @@
 import qualtran.bloqs.data_loading.qrom_base
 import qualtran.bloqs.data_loading.select_swap_qrom
 import qualtran.bloqs.factoring.ecc
-import qualtran.bloqs.factoring.mod_exp
+import qualtran.bloqs.factoring.rsa
 import qualtran.bloqs.gf_arithmetic.gf2_add_k
 import qualtran.bloqs.gf_arithmetic.gf2_addition
 import qualtran.bloqs.gf_arithmetic.gf2_inverse
@@ -515,10 +515,12 @@
         ],
     ),
     NotebookSpecV2(
-        title='Modular Exponentiation',
-        module=qualtran.bloqs.factoring.mod_exp,
-        bloq_specs=[qualtran.bloqs.factoring.mod_exp._MODEXP_DOC],
-        directory=f'{SOURCE_DIR}/bloqs/factoring',
+        title='Factoring RSA',
+        module=qualtran.bloqs.factoring.rsa,
+        bloq_specs=[
+            qualtran.bloqs.factoring.rsa.rsa_phase_estimate._RSA_PE_BLOQ_DOC,
+            qualtran.bloqs.factoring.rsa.rsa_mod_exp._RSA_MODEXP_DOC,
+        ],
     ),
     NotebookSpecV2(
         title='Elliptic Curve Addition',

docs/bloqs/index.rst

@@ -83,7 +83,7 @@ Bloqs Library
     mod_arithmetic/mod_addition.ipynb
     mod_arithmetic/mod_subtraction.ipynb
     mod_arithmetic/mod_multiplication.ipynb
-    factoring/mod_exp.ipynb
+    factoring/rsa/rsa.ipynb
     factoring/ecc/ec_add.ipynb
     factoring/ecc/ecc.ipynb
 

qualtran/bloqs/factoring/__init__.py

@@ -1,4 +1,4 @@
-#  Copyright 2023 Google LLC
+#  Copyright 2024 Google LLC
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -11,5 +11,3 @@
 #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
-
-from .mod_exp import ModExp

qualtran/bloqs/factoring/ecc/_ecc_shims.py → qualtran/bloqs/factoring/_factoring_shims.py

@@ -19,11 +19,12 @@
 
 from qualtran import Bloq, CompositeBloq, DecomposeTypeError, QBit, Register, Side, Signature
 from qualtran.drawing import RarrowTextBox, Text, WireSymbol
+from qualtran.symbolics import SymbolicInt
 
 
 @frozen
 class MeasureQFT(Bloq):
-    n: int
+    n: 'SymbolicInt'
 
     @cached_property
     def signature(self) -> 'Signature':

qualtran/bloqs/factoring/ecc/ec_phase_estimate_r.py

@@ -33,7 +33,7 @@
 from qualtran.bloqs.basic_gates import PlusState
 from qualtran.resource_counting import BloqCountDictT, SympySymbolAllocator
 
-from ._ecc_shims import MeasureQFT
+from .._factoring_shims import MeasureQFT
 from .ec_add_r import ECAddR
 from .ec_point import ECPoint
 

qualtran/bloqs/factoring/rsa/__init__.py

@@ -0,0 +1,37 @@
+#  Copyright 2024 Google LLC
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+# isort:skip_file
+
+r"""Bloqs for breaking RSA cryptography systems via integer factorization.
+
+RSA cryptography is a form of public key cryptography based on the difficulty of
+factoring the product of two large prime numbers.
+
+Using RSA, the cryptographic scheme chooses two large prime numbers p, q, their product n,
+λ(n) = lcm(p - 1, q - 1) where λ is Carmichael's totient function, an integer e such that
+1 < e < λ(n), and finally d as d ≡ e^-1 (mod λ(n)). The public key consists of the modulus n and
+the public (or encryption) exponent e. The private key consists of the private (or decryption)
+exponent d, which must be kept secret. p, q, and λ(n) must also be kept secret because they can be
+used to calculate d.
+
+Using Shor's algorithm for factoring, we can find p and q (the factors of n) in polynomial time
+with a quantum algorithm.
+
+References:
+    [RSA (cryptosystem)](https://en.wikipedia.org/wiki/RSA_(cryptosystem)).
+"""
+
+from .rsa_phase_estimate import RSAPhaseEstimate
+from .rsa_mod_exp import ModExp

qualtran/bloqs/factoring/factoring-via-modexp.ipynb → qualtran/bloqs/factoring/rsa/factoring-via-modexp.ipynb

@@ -180,7 +180,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from qualtran.bloqs.factoring.mod_exp import ModExp\n",
+    "from qualtran.bloqs.factoring.rsa.rsa_mod_exp import ModExp\n",
     "from qualtran.drawing import show_bloq\n",
     "\n",
     "mod_exp = ModExp(base=g, mod=N, exp_bitsize=32, x_bitsize=32)\n",
@@ -205,6 +205,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "from qualtran import QUInt\n",
     "for e in range(20):\n",
     "    ref = (g ** e) % N\n",
     "    _, bloq_eval = mod_exp.call_classically(exponent=e)\n",
@@ -231,7 +232,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.9"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,