Adding hypergraph states

mypy.ini

@@ -4,6 +4,12 @@
 plugins = numpy.typing.mypy_plugin
 warn_return_any = True
 warn_unused_configs = True
+ignore_missing_imports = True
+strict_optional = False
+no_implicit_optional = True
+warn_redundant_casts = True
+warn_unused_ignores = True
+
 
 # Per-module options:
 

quantum_perceptron/tests/test_utils.py

@@ -1,42 +1,47 @@
 import pytest
 import numpy as np
 
-from quantum_perceptron.utils.data_utils import (
+from quantum_perceptron.utils import (
     get_vector_from_int,
-    get_num_bits,
-    get_possible_state_strings
+    get_bin_int,
+    get_possible_state_strings,
+    get_ones_counts_to_states
 )
 
 
-@pytest.mark.parametrize("data, expected_result", [
-    (12, 4),
-    (8, 4),
-    (7, 3),
-    (0, 1),
-    (-5, False),
+@pytest.mark.parametrize("data, num_qubits, expected_result", [
+    (12, 4, '1100'),
+    (12, 5, '01100'),
+    (1, 1, '1'),
+    (2, None, '10'),
+    (-5, 2, False)
 ])
-def test_get_num_bits(data, expected_result):
+def test_get_bin_int(data, num_qubits, expected_result):
     if isinstance(expected_result, bool) and not expected_result:
         with pytest.raises(ValueError):
-            get_num_bits(data)
+            get_bin_int(data, num_qubits)
     else:
-        assert expected_result == get_num_bits(data)
+        np.array_equal(
+            expected_result,
+            get_bin_int(data, num_qubits)
+        )
 
 
-@pytest.mark.parametrize("data, expected_result", [
-    (12, np.array([-1, -1, 1, 1])),
-    (1, np.array([1, 1, 1, -1])),
-    (0, np.array([1, 1, 1, 1])),
-    (-5, False)
+@pytest.mark.parametrize("data, num_qubits, expected_result", [
+    (12, 4, np.array([-1, -1, 1, 1])),
+    (12, 5, np.array([1, -1, -1, 1, 1])),
+    (1, 1, np.array([-1])),
+    (12, 3, False),
+    (-5, 2, False)
 ])
-def test_get_vector_from_int(data, expected_result):
+def test_get_vector_from_int(data, num_qubits, expected_result):
     if isinstance(expected_result, bool) and not expected_result:
         with pytest.raises(ValueError):
-            get_vector_from_int(data)
+            get_vector_from_int(data, num_qubits)
     else:
         np.array_equal(
             expected_result,
-            get_vector_from_int(data)
+            get_vector_from_int(data, num_qubits)
         )
 
 
@@ -56,3 +61,22 @@ def test_get_possible_state_strings(num_bits, expected_result):
             expected_result,
             get_possible_state_strings(num_bits)
         )
+
+
+@pytest.mark.parametrize("states, expected_result", [
+    (np.array(['0', '1']), {0: [0], 1: [1]}),
+    (np.array(['00', '01', '10', '11']), {0: [0], 1: [1, 2], 2: [3]}),
+    (np.array(['000', '001', '010', '011', '100', '101', '110', '111']), {
+        0: [0],
+        1: [1, 2, 4],
+        2: [3, 5, 6],
+        3: [7]
+    }),
+    (np.array([]), False)
+])
+def test_get_ones_counts_to_states(states, expected_result):
+    if isinstance(expected_result, bool) and not expected_result:
+        with pytest.raises(ValueError):
+            get_ones_counts_to_states(states)
+    else:
+        assert expected_result == get_ones_counts_to_states(states)

quantum_perceptron/utils/__init__.py

@@ -0,0 +1 @@
+from quantum_perceptron.utils.data_utils import *

quantum_perceptron/utils/data_utils.py

@@ -1,4 +1,5 @@
 import numpy as np
+from typing import Dict, List, Optional
 
 
 def assert_negative(data: int):
@@ -9,23 +10,25 @@ def assert_negative(data: int):
         raise ValueError("Currently we do not support negative data values.")
 
 
-def get_bin_int(data: int) -> str:
+def get_bin_int(data: int, num_qubits: Optional[int] = None) -> str:
     """
     Get binary representation of integer.
     """
     assert_negative(data)
+    if num_qubits:
+        return bin(data)[2:].zfill(num_qubits)
     return bin(data)[2:]
 
 
-def get_num_bits(data: int) -> int:
+def assert_bits(data: int, num_bits: int):
     """
-    Get number of bits in an integer.
+    General method to prevent invalid number of bits.
     """
-    assert_negative(data)
-    return len(get_bin_int(data))
+    if len(get_bin_int(data)) > num_bits:
+        raise ValueError("data has more bits than num_bits")
 
 
-def get_vector_from_int(data: int) -> np.ndarray:
+def get_vector_from_int(data: int, num_qubits: int) -> np.ndarray:
     """
     This method returns the vector where each element is (-1)^b_i where b_i is
     the bit value at index i.
@@ -33,13 +36,14 @@ def get_vector_from_int(data: int) -> np.ndarray:
     Args:
       data: `int` representing data value
         (correspponding toinput or weight vector)
+      num_qubits: `int` representing number of qubits.
 
     Returns: Vector in  form of `np.ndarray`.
     """
     assert_negative(data)
+    assert_bits(data, num_qubits)
 
-    bin_data = get_bin_int(data)
-    num_qubits = get_num_bits(data)
+    bin_data = get_bin_int(data, num_qubits)
     data_vector = np.empty(num_qubits)
 
     for i, bit in enumerate(bin_data):
@@ -72,3 +76,27 @@ def get_possible_state_strings(num_bits: int) -> np.ndarray:
         states[i] = state_template.format(i)
 
     return states
+
+
+def get_ones_counts_to_states(states: np.ndarray) -> Dict[int, List[int]]:
+    """
+    Get the mapping from number of 1's to the states which has that many number
+    of 1 bits.
+
+    Args:
+      states: `np.ndarray` containing the bit strings of the states.
+
+    Returns: `dict` containing the mappings from count of 1's to the list
+      of states.
+    """
+    if len(states) == 0:
+        raise ValueError("The states array is empty")
+
+    ones_count: Dict[int, List[int]] = dict()
+    for i in range(len(states)):
+        ct = states[i].count('1')
+        if ct not in ones_count:
+            ones_count[ct] = []
+        ones_count[ct].append(i)
+
+    return ones_count

quantum_perceptron/utils/quantum_utils.py

@@ -0,0 +1,80 @@
+import numpy as np
+from typing import List, Dict
+from qiskit import QuantumCircuit
+from quantum_perceptron.utils.data_utils import (
+    get_possible_state_strings,
+    get_ones_counts_to_states
+)
+
+
+def append_hypergraph_state(
+        circuit: QuantumCircuit,
+        data_vector: np.ndarray,
+        states: np.ndarray,
+        ones_count: Dict[int, List[int]]) -> QuantumCircuit:
+    """
+    Append the computed hypergraph state to the circuit.
+
+    Args:
+      circuit: `QuantumCircuit` object corresponding to the perceptron.
+      data_vector: `np.ndarray` containing the data vector containing -1s & 1s.
+      states: `list` of `str` containing the bit strings for states.
+      ones_count: `dict` containing mapping of the count of ones with
+        index of states
+
+    Returns: `QuantumCircuit` object denoting the circuit containing
+      hypergraph states.
+    """
+    num_qubits = int(np.log2(len(data_vector)))
+    is_sign_inverted = [1] * len(data_vector)
+
+    # Flipping all signs if all zero state has coef -1.
+    if data_vector[0] == -1:
+        for i in range(len(data_vector)):
+            data_vector[i] *= -1
+
+    for ct in range(1, num_qubits + 1):
+        for i in ones_count.get(ct, []):
+            if data_vector[i] == is_sign_inverted[i]:
+                state = states[i]
+                ones_idx = [j for j, x in enumerate(state) if x == '1']
+                if ct == 1:
+                    circuit.z(ones_idx[0])
+                elif ct == 2:
+                    circuit.cz(ones_idx[0], ones_idx[1])
+                else:
+                    circuit.mcrz(
+                        -np.pi,
+                        [circuit.qubits[j] for j in ones_idx[1:]],
+                        circuit.qubits[ones_idx[0]]
+                    )
+                for j, state in enumerate(states):
+                    is_one = np.array([bit == '1' for bit in state])
+                    if np.all(is_one[ones_idx]):
+                        is_sign_inverted[j] *= -1
+    return circuit
+
+
+def create_hypergraph_state(circuit: QuantumCircuit,
+                            data_vector: np.ndarray) -> QuantumCircuit:
+    """
+    Creating hypergraph state for specific data vector corresponding to
+    the provided data (input or weight value).
+    It is as per https://arxiv.org/abs/1811.02266.
+
+    Args:
+      circuit: `QuantumCircuit` object corresponding to the perceptron.
+      data_vector: `np.ndarray` containing the data vector containing -1s & 1s.
+
+    Returns: `QuantumCircuit` object denoting the circuit containing
+      hypergraph states.
+    """
+    num_qubits = int(np.log2(len(data_vector)))
+    states = get_possible_state_strings(num_qubits)
+    ones_count = get_ones_counts_to_states(states)
+    return append_hypergraph_state(
+        circuit,
+        data_vector,
+        states,
+        ones_count
+    )