optimize qlassf.truth_table, introduce cnotsim

Author: dakk

qlasskit/boolquant.py

@@ -17,6 +17,8 @@
 
 
 class QuantumBooleanGate(Function, Boolean):
+    # TODO: add an eval method to be able to simplify H(H(a)) => a
+
     def build(name: str):
         return type(name, (QuantumBooleanGate,), {})
 

qlasskit/qcircuit/__init__.py

@@ -22,3 +22,4 @@
 from .qcircuit import QCircuit  # noqa: F401, E402
 from .qcircuitenhanced import QCircuitEnhanced  # noqa: F401, E402
 from .qcircuitwrapper import QCircuitWrapper, reindex  # noqa: F401, E402
+from .cnotsim import CNotSim, GateNotSimulableException  # noqa: F401, E402

qlasskit/qcircuit/cnotsim.py

@@ -0,0 +1,73 @@
+# 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, Union
+
+from .gates import CCX, CX, MCX, MCtrl, X
+from .qcircuit import QCircuit
+
+
+class GateNotSimulableException(Exception):
+    def __init__(self, g):
+        super(GateNotSimulableException, self).__init__(
+            f"Gate not simulable by CNotSim: {g}"
+        )
+
+
+class CNotSim:
+    """A dummy simulator for X, CX, CCX, MCX circuits"""
+
+    def simulate(  # noqa: C901
+        self,
+        qc: QCircuit,
+        initialize: List[bool] = [],
+        to_measure: List[Union[int, str]] = [],
+    ) -> List[bool]:
+        """Simulate a quantum circuit qc
+
+        Args:
+            initialize (List[bool], optional): list of initializer for the qubits
+            to_measure (List[int], optional): list of qubits to measure; measure all
+                if None.
+        """
+        qubits = [False] * qc.num_qubits
+
+        for i, x in enumerate(initialize):
+            qubits[i] = x
+
+        for g, w, p in qc.gates:
+            if isinstance(g, X):
+                qubits[w[0]] = not qubits[w[0]]
+            elif isinstance(g, CX):
+                if qubits[w[0]]:
+                    qubits[w[1]] = not qubits[w[1]]
+            elif isinstance(g, CCX):
+                if qubits[w[0]] and qubits[w[1]]:
+                    qubits[w[2]] = not qubits[w[2]]
+            elif isinstance(g, MCX):
+                if all([qubits[x] for x in w[0:-1]]):
+                    qubits[w[-1]] = not qubits[w[-1]]
+            elif isinstance(g, MCtrl) and isinstance(g.gate, X):
+                if all([qubits[x] for x in w[0:-1]]):
+                    qubits[w[-1]] = not qubits[w[-1]]
+            else:
+                raise GateNotSimulableException(g)
+
+        if len(to_measure) == 0:
+            return qubits
+
+        measured = []
+        for q in to_measure:
+            measured.append(qubits[qc[q]])
+        return measured

qlasskit/qlassfun.py

@@ -23,6 +23,7 @@
 from .ast2ast import ast2ast
 from .ast2logic import Arg, Args, BoolExpList, LogicFun, flatten, translate_ast
 from .boolopt import BoolOptimizerProfile, bestWorkingOptimizer
+from .boolopt.bool_optimizer import merge_expressions
 from .boolquant import Q  # noqa: F403, F401
 from .compiler import SupportedCompiler, to_quantum
 from .qcircuit import QCircuitWrapper
@@ -134,6 +135,8 @@ def truth_table(self, max=None) -> List[List[bool]]:
                 f"Max truth table size reached: {bits + self.output_size} > {MAX_TRUTH_TABLE_SIZE}"
             )
 
+        exps = merge_expressions(self.expressions)
+
         for i in range(
             0, 2**bits, int(2**bits / max) if max and max < 2**bits else 1
         ):
@@ -142,7 +145,7 @@ def truth_table(self, max=None) -> List[List[bool]]:
             bin_arr = list(map(lambda c: c == "1", bin_str))
             known = list(zip(arg_bits, bin_arr))
 
-            for ename, exp in self.expressions:
+            for ename, exp in exps:
                 exp_sub = exp.subs(known)
 
                 known = list(filter(lambda x: x[0] != ename.name, known))

test/test_qlassf_int.py

@@ -392,11 +392,6 @@ def test_mul(self):
         qf = qlassf(f, to_compile=COMPILATION_ENABLED, compiler=self.compiler)
         compute_and_compare_results(self, qf)
 
-    # def test_mul2(self):
-    #     f = "def test(a: Qint4, b: Qint4) -> Qint8: return a * b"
-    #     qf = qlassf(f, to_compile=COMPILATION_ENABLED, compiler=self.compiler)
-    #     compute_and_compare_results(self, qf)
-
     def test_mul_and_sum(self):
         f = "def test(a: Qint2, b: Qint2, c: Qint2) -> Qint2: return a * b + c"
         qf = qlassf(f, to_compile=COMPILATION_ENABLED, compiler=self.compiler)
@@ -412,8 +407,7 @@ def test_mul_const(self):
         qf = qlassf(f, compiler=self.compiler, to_compile=COMPILATION_ENABLED)
         compute_and_compare_results(self, qf)
 
-    # def test_mul4(self):
-    #     f = "def test(a: Qint4, b: Qint4) -> Qint4: return a * b"
-    #     qf = qlassf(f, to_compile=COMPILATION_ENABLED, compiler=self.compiler)
-    #     print(qf.expressions)
-    #     compute_and_compare_results(self, qf)
+    def test_mul4(self):
+        f = "def test(a: Qint4, b: Qint4) -> Qint8: return a * b"
+        qf = qlassf(f, to_compile=COMPILATION_ENABLED, compiler=self.compiler)
+        compute_and_compare_results(self, qf)

test/utils.py

@@ -14,6 +14,7 @@
 
 import inspect
 import json
+import os
 import random
 import threading
 from typing import Tuple, get_args
@@ -23,6 +24,7 @@
 from sympy.logic.boolalg import gateinputcount
 
 from qlasskit import Qint, QlassF, Qtype, compiler, const_to_qtype
+from qlasskit.qcircuit import CNotSim, GateNotSimulableException
 
 COMPILATION_ENABLED = True
 
@@ -122,13 +124,19 @@ def compute_result_of_qcircuit(cls, qf, truth_line):
 
     cls.assertEqual(len(counts), 1)
 
-    max_qubits = (
-        qf.input_size
-        + len(qf.expressions)
-        + sum([gateinputcount(e[1]) for e in qf.expressions])
-    )
+    return res_str
+
+
+def compute_result_of_qcircuit_using_cnotsim(cls, qf, truth_line):
+    qc = qf.circuit()
+
+    qinit = [True if truth_line[i] else False for i in range(qf.input_size)]
 
-    cls.assertLessEqual(qf.gate().num_qubits, max_qubits)
+    res = CNotSim().simulate(qc, initialize=qinit)
+
+    res_str = ""
+    for qname in qf.truth_table_header()[-qf.output_size :]:
+        res_str += "1" if res[qc[qname]] else "0"
 
     return res_str
 
@@ -202,7 +210,7 @@ def compute_and_compare_results(cls, qf, test_original_f=True):
     elif COMPILATION_ENABLED:
         qc_truth = truth_table
 
-    circ_qi = qf.circuit().export("circuit", "qiskit")
+    # circ_qi = qf.circuit().export("circuit", "qiskit")
 
     # update_statistics(qf.circuit().num_qubits, qf.circuit().num_gates)
 
@@ -223,5 +231,22 @@ def compute_and_compare_results(cls, qf, test_original_f=True):
 
         # Calculate and compare the gate result
         if qc_truth and truth_line in qc_truth and COMPILATION_ENABLED:
-            res_qc = compute_result_of_qcircuit(cls, qf, truth_line)
-            cls.assertEqual(truth_str, res_qc)
+            max_qubits = (
+                qf.input_size
+                + len(qf.expressions)
+                + sum([gateinputcount(e[1]) for e in qf.expressions])
+            )
+            cls.assertLessEqual(qf.num_qubits, max_qubits)
+
+            if os.getenv("GITHUB_ACTIONS"):
+                res_qc = compute_result_of_qcircuit(cls, qf, truth_line)
+                cls.assertEqual(truth_str, res_qc)
+            else:
+                try:
+                    res_qc2 = compute_result_of_qcircuit_using_cnotsim(
+                        cls, qf, truth_line
+                    )
+                    cls.assertEqual(truth_str, res_qc2)
+                except GateNotSimulableException:
+                    res_qc = compute_result_of_qcircuit(cls, qf, truth_line)
+                    cls.assertEqual(truth_str, res_qc)