further merge conflict fixes

Author: positr0nium

tests/test_QAOAeTwoThrLin.py

@@ -17,69 +17,37 @@
 """
 
 
-from qrisp.qaoa import QAOAProblem
-from qrisp.qaoa.problems.eThrTwoLinInfrastr import eTwoThrLinclCostfct, eThrTwocostOp, init_state
-from qrisp.qaoa.mixers import RX_mixer 
 from qrisp import QuantumVariable
-import numpy as np 
+from qrisp.qaoa import QAOAProblem, RX_mixer, approximation_ratio, create_e3lin2_cl_cost_function, create_e3lin2_cost_operator
+import itertools
 
 
-def test_eTwoThrLinQAOA():
-    # first three are the indices (a_1,j ; a_2,j ; a3,j), last one is b_L
-    #clauses = [(1,3,4,5), (2,6,9,11), (1,5,8,33), (3,4,5,77), (2,4,6,7), (1,3,4,55),(1,3,6,49),(2,4,7,87),  (1,3,4,55),(1,3,6,43),(2,4,7,89), (1,3,4,57),(1,3,6,44),(2,4,7,8)]
-    for index in range(10):
-        clauses = []
-        for index2 in range(4):
-            index2a = np.random.randint(0,1)
-            if index2a % 2 == 0:
-                int1 = np.random.randint(3,5)
-                int2 = np.random.randint(0,3)
-                int3 = np.random.randint(5,7)
-                int4 = np.random.randint(30,39)
-                clauses.append((int1,int2,int3,int4))
-            else:
-                int1 = np.random.randint(1,4)
-                int2 = np.random.randint(0,1)
-                int3 = np.random.randint(4,7)
-                int4 = np.random.randint(31,40)
-                clauses.append((int1,int2,int3,int4))
+def test_eThrLinTwoQAOA():
 
-        #assign cost function
-        cl_cost_function=eTwoThrLinclCostfct(clauses)
-        print(clauses)
+    clauses = [[0,1,2,1],[1,2,3,0],[0,1,4,0],[0,2,4,1],[2,4,5,1],[1,3,5,1],[2,3,4,0]]
+    num_variables = 6
+    qarg = QuantumVariable(num_variables)
 
-        #assign qarg
-        qarg = QuantumVariable(7)
+    qaoa_e3lin2 = QAOAProblem(cost_operator=create_e3lin2_cost_operator(clauses),
+                                    mixer=RX_mixer,
+                                    cl_cost_function=create_e3lin2_cl_cost_function(clauses))
+    results = qaoa_e3lin2.run(qarg=qarg, depth=5)
 
-        # run the qaoa
-        QAOAinstance = QAOAProblem(cost_operator=eThrTwocostOp(clauses=clauses), mixer=RX_mixer, cl_cost_function=cl_cost_function)
-        QAOAinstance.set_init_function(init_function=init_state)
-        theNiceQAOA = QAOAinstance.run(qarg=qarg, depth=5, mes_kwargs = {"shots" : 100000})
+    cl_cost = create_e3lin2_cl_cost_function(clauses)
 
-        import itertools
-        def testCostFun(state):
-            obj = 0
-                #ljust do a minus 1 op if state is equiv to a given condition clause
-            for index in range(len(clauses)):
-                clause = clauses[index]
-                sum = 0
-                for index_aj in range(0,2):
-                    sum += int(state[clause[index_aj]])
-                if sum == clause[3] % 2:
-                    obj -= 1 
-            return obj
-        
-        
-        #maxfive = sorted(theNiceQAOA, key=theNiceQAOA.get, reverse=True)[:1]
-        for name in theNiceQAOA.keys():  # for name, age in dictionary.iteritems():  (for Python 2.x)
-            if testCostFun(name) < 0:
-                temp = False
-
-                for clause in clauses:
-                    sum = 0
-                    for index_aj in range(0,2):
-                        sum += int(name[clause[index_aj]])
-                    if sum == clause[3] % 2:
-                        temp  = True
-                assert temp 
+    # find optimal solution by brute force    
+    temp_binStrings = list(itertools.product([1,0], repeat=num_variables))
+    binStrings = ["".join(map(str, item)) for item in temp_binStrings]
+    
+    min = 0
+    min_index = 0
+    for index in range(len(binStrings)):
+        val = cl_cost({binStrings[index] : 1})
+        if val < min:
+            min = val
+            min_index = index
+
+    optimal_sol = binStrings[min_index]
 
+    # approximation ratio test
+    assert approximation_ratio(results, optimal_sol, cl_cost)>=0.5

tests/test_QAOAminSetCover.py

@@ -36,66 +36,8 @@ def test_QAOAminSetCover():
 
     cl_cost = create_min_set_cover_cl_cost_function(sets, universe)
 
-
-    """
-
-
-    # sets are given as list of lists
-    examplesets = [[0,1,2,3],[1,5,6,4],[0,2,6,3,4,5],[3,4,0,1],[1,2,3,0],[1]]
-    # full universe is given as a tuple
-    sol = (0,1,2,3,4,5,6)
- 
-
-    # assign operators
-    cost_fun = minSetCoverclCostfct(sets=examplesets,universe = sol)
-    mixerOp = RZ_mixer
-    costOp = minSetCoverCostOp(sets=examplesets, universe=sol)
-
-    #initialize variable
-    qarg = QuantumVariable(len(examplesets))
-
-    #+run qaoa
-    QAOAinstance = QAOAProblem(cost_operator=costOp ,mixer= mixerOp, cl_cost_function=cost_fun)
-    QAOAinstance.set_init_function(init_function=init_state)
-    InitTest = QAOAinstance.run(qarg=qarg, depth=5, mes_kwargs = {"shots" : 100000})
-
-    # create example cost_func
-    def testCostFun(state,universe):
-        obj = 0
-        #literally just do a minus 1 op if state is equiv to a given condition
-        intlist = [s for s in range(len(list(state))) if list(state)[s] == "1"]
-        sol_sets = [examplesets[index] for index in intlist]
-        res = ()
-        for seto in sol_sets:
-            res = tuple(set(res+ tuple(seto))) 
-        if res == universe:
-            obj += len(intlist)
-
-        return obj
-
-    # test if cost_func functions for all items . 
-    for state in InitTest.keys():
-        if testCostFun(state=state, universe = sol) > 0:
-            intlist = [s for s in range(len(list(state))) if list(state)[s] == "1"]
-            sol_sets = [examplesets[index] for index in intlist]
-            res = ()
-            for seto in sol_sets:
-                res = tuple(set(res+ tuple(seto))) 
-            assert sol == res
-
-    
-
-    #print the ideal solutions
-    #print("5 most likely Solutions") 
-    maxfive = sorted(InitTest, key=InitTest.get, reverse=True)[:5]
-    for name in InitTest.keys():  # for name, age in dictionary.iteritems():  (for Python 2.x)
-        if name in maxfive:
-            print(name)
-            print(testCostFun(name, universe=sol))  
-
-    #find ideal solution by brute force    
-    temp_binStrings = list(itertools.product([1,0], repeat=len(examplesets)))
-
+    # find optimal solution by brute force    
+    temp_binStrings = list(itertools.product([1,0], repeat=len(sets)))
     binStrings = ["".join(map(str, item))  for item in temp_binStrings]
 
     min = len(sets)