added maxkcut (#28)

* added maxkcut

Author: fgfuchs

qaoa/initialstates/__init__.py

@@ -2,3 +2,6 @@
 from .plus_initialstate import Plus
 from .dicke_initialstate import Dicke
 from .statevector_initialstate import StateVector
+from .maxkcut_feasible_initialstate import MaxKCutFeasible
+from .tensor_initialstate import Tensor
+from .lessthank_initialstate import LessThanK

qaoa/initialstates/dicke1_2_initialstate.py

@@ -0,0 +1,33 @@
+import numpy as np
+from qiskit import QuantumCircuit, QuantumRegister
+from qiskit.circuit.library import XXPlusYYGate, PauliEvolutionGate
+
+from qiskit.quantum_info import SparsePauliOp
+
+from .base_initialstate import InitialState
+
+
+class Dicke1_2(InitialState):
+    """
+    Returs equal superposition Dicke 1 and Dicke 2 states. Hard Coded
+    """
+
+    def __init__(self) -> None:
+        self.k = 6
+        self.N_qubits = 3
+
+    def create_circuit(self) -> None:
+        q = QuantumRegister(self.N_qubits)
+        circuit = QuantumCircuit(q)
+        X = SparsePauliOp("X")
+        Y = SparsePauliOp("Y")
+        operator = Y ^ Y ^ Y
+        circuit.x(0)
+        # qc.ry(np.pi/2,2)
+        circuit.append(PauliEvolutionGate(operator, time=np.pi / 4), q)
+        circuit.append(XXPlusYYGate(np.arcsin(2 * np.sqrt(2) / 3), np.pi / 2), [0, 1])
+        circuit.append(XXPlusYYGate(-np.pi / 2, np.pi / 2), [0, 2])
+        circuit.x(1)
+        circuit.cz(q[1], q[2])
+        circuit.x(1)
+        self.circuit = circuit

qaoa/initialstates/lessthank_initialstate.py

@@ -0,0 +1,91 @@
+import numpy as np
+from qiskit import QuantumCircuit, QuantumRegister
+from qiskit.circuit.library import XXPlusYYGate
+
+from .base_initialstate import InitialState  # type: ignore
+
+
+class LessThanK(InitialState):
+    def __init__(self, k: int) -> None:
+        if not LessThanK.is_power_of_two_or_between_2_and_8(k):
+            raise ValueError("k must be a power of two or between 2 and 8")
+        self.k = k
+        self.N_qubits = int(np.ceil(np.log2(self.k)))
+
+    def create_circuit(self) -> None:
+        if self.k == 3:
+            self.circuit = self.k3()
+        elif self.k == 5:
+            self.circuit = self.k5()
+        elif self.k == 6:
+            self.circuit = self.k6()
+        elif self.k == 7:
+            self.circuit = self.k7()
+        else:
+            self.circuit = self.power_of_two()
+
+    def is_power_of_two_or_between_2_and_8(k):
+        # Check if k is between 2 and 8
+        if 2 <= k <= 8:
+            return True
+
+        # Check if k is a power of two
+        # A number is a power of two if it has exactly one bit set, i.e., k & (k - 1) == 0 and k > 0
+        if k > 0 and (k & (k - 1)) == 0:
+            return True
+
+        return False
+
+    def power_of_two(self) -> QuantumCircuit:
+        q = QuantumRegister(self.N_qubits)
+        circuit = QuantumCircuit(q)
+        circuit.h(q)
+        return circuit
+
+    def k3(self) -> QuantumCircuit:
+        q = QuantumRegister(self.N_qubits)
+        circuit = QuantumCircuit(q)
+        theta = np.arccos(1 / np.sqrt(3)) * 2
+        phi = np.pi / 2
+        beta = -np.pi / 2
+        circuit.ry(theta, 1)
+        gate = XXPlusYYGate(phi, beta)
+        circuit.append(gate, [0, 1])
+        return circuit
+
+    def k5(self) -> QuantumCircuit:
+        q = QuantumRegister(self.N_qubits)
+        circuit = QuantumCircuit(q)
+        theta = np.arcsin(1 / np.sqrt(5)) * 2
+        circuit.ry(theta, 0)
+        circuit.ch(0, [1, 2], ctrl_state=0)
+        return circuit
+
+    def k6(self) -> QuantumCircuit:
+        q = QuantumRegister(self.N_qubits)
+        circuit = QuantumCircuit(q)
+        theta = np.pi / 2
+        phi = np.arccos(1 / np.sqrt(3)) * 2
+        gamma = np.pi / 2
+        beta = -np.pi / 2
+        circuit.ry(theta, 2)
+        circuit.ry(phi, 1)
+        gate = XXPlusYYGate(gamma, beta)
+        circuit.append(gate, [0, 1])
+        return circuit
+
+    def k7(self) -> QuantumCircuit:
+        q = QuantumRegister(self.N_qubits)
+        circuit = QuantumCircuit(q)
+        delta = np.arcsin(1 / np.sqrt(7)) * 2
+        theta = np.pi / 2
+        phi = np.arccos(1 / np.sqrt(3)) * 2
+        gamma = np.pi / 2
+        beta = -np.pi / 2
+        circuit.ry(delta, 0)
+        circuit.cx(0, 1)
+        circuit.cry(theta, 0, 2, ctrl_state=0)
+        circuit.cry(phi, 0, 1, ctrl_state=0)
+        gate = XXPlusYYGate(gamma, beta)
+        circuit.append(gate, [0, 1])
+        return circuit

qaoa/initialstates/maxkcut_feasible_initialstate.py

@@ -0,0 +1,77 @@
+import numpy as np
+
+
+from .base_initialstate import InitialState
+from .dicke_initialstate import Dicke
+from .dicke1_2_initialstate import Dicke1_2
+from .lessthank_initialstate import LessThanK
+from .tensor_initialstate import Tensor
+
+
+class MaxKCutFeasible(InitialState):
+    def __init__(
+        self, k_cuts: int, problem_encoding: str, color_encoding: str = "LessThanK"
+    ) -> None:
+        self.k_cuts = k_cuts
+        self.problem_encoding = problem_encoding
+        self.color_encoding = color_encoding
+
+        if not problem_encoding in ["onehot", "binary"]:
+            raise ValueError('case must be in ["onehot", "binary"]')
+        if problem_encoding == "binary":
+            if k_cuts == 6 and (color_encoding not in ["Dicke1_2", "LessThanK"]):
+                raise ValueError('color_encoding must be in ["LessThanK", "Dicke1_2"]')
+            self.color_encoding = color_encoding
+
+        if self.k_cuts == 3:
+            self.infeasible = ["11"]
+        elif self.k_cuts == 5:
+            if self.color_encoding == "max_balanced":
+                self.infeasible = ["100", "111", "101"]
+            else:
+                self.infeasible = ["101", "110", "111"]
+        elif self.k_cuts == 6:
+            if self.color_encoding in ["Dicke1_2", "max_balanced"]:
+                self.infeasible = ["000", "111"]
+            else:
+                self.infeasible = ["110", "111"]
+        elif self.k_cuts == 7:
+            self.infeasible = ["111"]
+
+    def create_circuit(self) -> None:
+        if self.problem_encoding == "binary":
+            self.k_bits = int(np.ceil(np.log2(self.k_cuts)))
+            self.num_V = self.N_qubits / self.k_bits
+
+            if not self.num_V.is_integer():
+                raise ValueError(
+                    "Total qubits="
+                    + str(self.N_qubits)
+                    + " is not a multiple of "
+                    + str(self.k_bits)
+                )
+            if self.k_cuts == 6 and self.color_encoding == "Dicke1_2":
+                circ_one_node = Dicke1_2()
+            else:
+                circ_one_node = LessThanK(self.k_cuts)
+
+        elif self.problem_encoding == "onehot":
+            self.num_V = self.N_qubits / self.k_cuts
+
+            if not self.num_V.is_integer():
+                raise ValueError(
+                    "Total qubits="
+                    + str(self.N_qubits)
+                    + " is not a multiple of "
+                    + str(self.k_cuts)
+                )
+            self.num_V = int(self.num_V)
+
+            circ_one_node = Dicke(1)
+            circ_one_node.setNumQubits(self.k_cuts)
+
+        self.num_V = int(self.num_V)
+        self.tensor = Tensor(circ_one_node, self.num_V)
+
+        self.tensor.create_circuit()
+        self.circuit = self.tensor.circuit

qaoa/initialstates/tensor_initialstate.py

@@ -0,0 +1,25 @@
+import numpy as np
+from copy import deepcopy
+
+from qiskit import QuantumRegister, QuantumCircuit
+
+from .base_initialstate import InitialState
+
+
+class Tensor(InitialState):
+    def __init__(self, subcircuit: InitialState, num: int) -> None:
+        """
+        Args:
+            subcircuit (InitialState): the circuit that is to be tensorised
+            #subN_qubits (int): number of qubits of the subpart
+        """
+        self.num = num
+        self.subcircuit = subcircuit
+        self.N_qubits = self.num * self.subcircuit.N_qubits
+
+    def create_circuit(self) -> None:
+        self.subcircuit.create_circuit()
+        self.circuit = self.subcircuit.circuit
+        for v in range(self.num - 1):
+            self.subcircuit.create_circuit()  # self.subcircuit.circuit.qregs)
+            self.circuit.tensor(self.subcircuit.circuit, inplace=True)

qaoa/mixers/__init__.py

@@ -2,3 +2,6 @@
 from .xy_mixer import XY
 from .x_mixer import X
 from .grover_mixer import Grover
+from .xy_tensor import XYTensor
+from .maxkcut_grover_mixer import MaxKCutGrover
+from .maxkcut_lx_mixer import MaxKCutLX

qaoa/mixers/grover_mixer.py

@@ -1,7 +1,7 @@
 from qiskit.circuit import Parameter
 from qiskit.circuit.library import PhaseGate
 
-from qaoa.mixers.base_mixer import Mixer
+from .base_mixer import Mixer
 from qaoa.initialstates.base_initialstate import InitialState
 
 

qaoa/mixers/maxkcut_grover_mixer.py

@@ -0,0 +1,92 @@
+import numpy as np
+
+from qaoa.mixers import Mixer, Grover
+from qaoa.initialstates import Dicke, Plus
+
+from qaoa.initialstates.dicke1_2_initialstate import Dicke1_2
+from qaoa.initialstates.lessthank_initialstate import LessThanK
+from qaoa.initialstates.tensor_initialstate import Tensor
+
+
+class MaxKCutGrover(Mixer):
+    def __init__(
+        self, k_cuts: int, problem_encoding: str, color_encoding: str, tensorized: bool
+    ) -> None:
+        if (k_cuts < 2) or (k_cuts > 8):
+            raise ValueError(
+                "k_cuts must be 2 or more, and is not implemented for k_cuts > 8"
+            )
+        if not problem_encoding in ["onehot", "binary"]:
+            raise ValueError('case must be in ["onehot", "binary"]')
+        self.k_cuts = k_cuts
+        self.problem_encoding = problem_encoding
+        self.color_encoding = color_encoding
+        self.tensorized = tensorized
+
+        if (self.problem_encoding == "binary") and self.is_power_of_two():
+            print(
+                "k_cuts is a power of two. You might want to use the X-mixer instead."
+            )
+
+        # for k=6, max_balanced == Dicke1_2
+        if k_cuts == 6 and (
+            color_encoding not in ["max_balanced", "Dicke1_2", "LessThanK"]
+        ):
+            raise ValueError(
+                'color_encoding must be in ["LessThanK", "Dicke1_2", max_balanced]'
+            )
+
+    def is_power_of_two(self) -> bool:
+        """
+        Return True if self.k_cuts is a power of two, False otherwise.
+        """
+        if self.k_cuts > 0 and (self.k_cuts & (self.k_cuts - 1)) == 0:
+            return True
+        return False
+
+    def set_numV(self, k):
+        num_V = self.N_qubits / k
+
+        if not num_V.is_integer():
+            raise ValueError(
+                "Total qubits=" + str(self.N_qubits) + " is not a multiple of " + str(k)
+            )
+
+        self.num_V = int(num_V)
+
+    def create_circuit(self) -> None:
+        if self.problem_encoding == "binary":
+            self.k_bits = int(np.ceil(np.log2(self.k_cuts)))
+            self.set_numV(self.k_bits)
+
+            if self.is_power_of_two():
+                circ_one_node = Plus()
+                circ_one_node.N_qubits = self.k_bits
+            elif self.k_cuts == 6 and self.color_encoding in [
+                "max_balanced",
+                "Dicke1_2",
+            ]:
+                circ_one_node = Dicke1_2()
+            else:
+                circ_one_node = LessThanK(self.k_cuts)
+
+        elif self.problem_encoding == "onehot":
+            self.set_numV(self.k_cuts)
+
+            circ_one_node = Dicke(1)
+            circ_one_node.setNumQubits(self.k_cuts)
+
+        if self.tensorized:
+            gm = Grover(circ_one_node)
+
+            tensor_gm = Tensor(gm, self.num_V)
+
+            tensor_gm.create_circuit()
+            self.circuit = tensor_gm.circuit
+        else:
+            tensor_feas = Tensor(circ_one_node, self.num_V)
+
+            gm = Grover(tensor_feas)
+
+            gm.create_circuit()
+            self.circuit = gm.circuit