simon algorithm

Author: dakk

TODO.md

@@ -107,6 +107,7 @@
 - [x] Qmatrix
 - [x] Hash function preimage attack notebook
 - [x] Move all examples to doc
+- [x] Simon periodicity
 - [ ] Improve documentation
 - [ ] First stable release
 
@@ -133,6 +134,10 @@
 - [ ] Builtin function: map
 - [ ] First beta release
 
+### Algorithms
+
+- [ ] Deutsch-Jozsa
+
 ### Language support
 
 - [ ] Datatype: Dict

docs/source/example_grover_hash.ipynb

@@ -32,7 +32,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Thanks to the fact that qlasskit function are standard python functions, we can call the `original_f` to perform some kind of analysis on the hash function. Since the input space is tiny (it is a toy hash function), we can detect if the hash function it's uniform (if it maps equally to the output space)."
+    "Thanks to the fact that qlasskit function are standard python functions, we can call the `original_f` to perform some kind of analysis on the hash function. Since the input space is tiny (it is a toy hash function), we can detect if the hash function is uniform (if it maps equally to the output space)."
    ]
   },
   {

qlasskit/algorithms/__init__.py

@@ -19,3 +19,4 @@
     ConstantOracleException,
 )
 from .grover import Grover  # noqa: F401, E402
+from .simon import Simon  # noqa: F401, E402

qlasskit/algorithms/simon.py

@@ -0,0 +1,63 @@
+# Copyright 2023 Davide Gessa
+
+# 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
+
+# http://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.
+
+from typing import List, Tuple, Union
+
+from ..qcircuit import QCircuit
+from ..qlassfun import QlassF
+from ..types import Qtype, interpret_as_qtype
+from .qalgorithm import QAlgorithm
+
+
+class Simon(QAlgorithm):
+    def __init__(
+        self,
+        f: QlassF,
+    ):
+        """
+        Args:
+            f (QlassF): our f(x)
+        """
+        if len(f.args) != 1:
+            raise Exception("f should receive exactly one parameter")
+
+        self.f: QlassF = f
+        self.search_space_size = len(f.args[0])
+        self._qcircuit = QCircuit(self.f.num_qubits)
+
+        # State preparation
+        self._qcircuit.barrier(label="s")
+        for i in range(self.search_space_size):
+            self._qcircuit.h(i)
+
+        # Prepare and add the f
+        self._qcircuit += self.f.circuit()
+
+        # State preparation out
+        self._qcircuit.barrier(label="s")
+        for i in range(self.search_space_size):
+            self._qcircuit.h(i)
+
+    # @override
+    @property
+    def output_qubits(self) -> List[int]:
+        """Returns the list of output qubits"""
+        len_a = len(self.f.args[0])
+        return list(range(len_a))
+
+    # @override
+    def decode_output(
+        self, istr: Union[str, int, List[bool]]
+    ) -> Union[bool, Tuple, Qtype]:
+        return interpret_as_qtype(istr, self.f.args[0].ttype, len(self.f.args[0]))

qlasskit/qcircuit/qcircuitwrapper.py

@@ -63,7 +63,9 @@ def encode_input(self, *qvals):
     def decode_output(self, istr):
         raise Exception("Abstract")
 
-    def decode_counts(self, counts: Dict[str, int], discard_lower: Optional[int] = None) -> Dict[Any, int]:
+    def decode_counts(
+        self, counts: Dict[str, int], discard_lower: Optional[int] = None
+    ) -> Dict[Any, int]:
         """Decode data from a circuit counts dict"""
         outcomes = [(self.decode_output(e), c) for (e, c) in counts.items()]
         int_counts: Dict[Any, int] = {}
@@ -72,10 +74,12 @@ def decode_counts(self, counts: Dict[str, int], discard_lower: Optional[int] = N
                 int_counts[e] += c
             else:
                 int_counts[e] = c
-                
+
         if discard_lower:
-            int_counts = dict(filter(lambda el: el[1] >= discard_lower, int_counts.items()))
-            
+            int_counts = dict(
+                filter(lambda el: el[1] >= discard_lower, int_counts.items())
+            )
+
         return int_counts
 
     def circuit(self):

qlasskit/types/__init__.py

@@ -103,18 +103,17 @@ def interpret_as_qtype(
     out: Union[str, int, List[bool]], qtype, out_len: Optional[int] = None
 ) -> Any:
     out = list(reversed(format_outcome(out, out_len)))
-    
+
     def _getsize(x):
         if hasattr(x, "BIT_SIZE"):
-            return x.BIT_SIZE             
+            return x.BIT_SIZE
         elif len(get_args(x)) > 0:
             size = 0
             for x in get_args(x):
-                size += _getsize(x)           
-            return size     
+                size += _getsize(x)
+            return size
         else:
             return 1
-        
 
     def _interpret(out, qtype, out_len):
         if hasattr(qtype, "from_bool"):

test/test_algo_simon.py

@@ -0,0 +1,39 @@
+# Copyright 2023 Davide Gessa
+
+# 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
+
+# http://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.
+
+import unittest
+
+from qlasskit import Qint2, Qint4, qlassf
+from qlasskit.algorithms import Simon
+
+from .utils import qiskit_measure_and_count
+
+
+class TestAlgoSimon(unittest.TestCase):
+    def test_simon(self):
+        f = """
+def hash(k: Qint4) -> Qint4:
+    return k >> 3
+"""
+        qf = qlassf(f, compiler="tweedledum")
+        algo = Simon(qf)
+
+        qc = algo.circuit().export("circuit", "qiskit")
+        counts = qiskit_measure_and_count(qc, shots=1024)
+        counts_readable = algo.decode_counts(counts)
+
+        for x in [0, 8]:
+            self.assertEqual(x in counts_readable, True)
+            self.assertEqual(counts_readable[x] > 480, True)
+        self.assertEqual(algo.output_qubits, [0, 1, 2, 3])