sync

util/SAT2QUBO.py

@@ -4,9 +4,10 @@ import numpy as np
 from . import kSAT
 from tqdm import tqdm
 import math
+import random
 
-__VERTEX_WEIGHT__ = -1
-__EDGE_WEIGHT__ = 2
+__VERTEX_WEIGHT__ = -2#-1
+__EDGE_WEIGHT__ = 2#2
 
 def WMISdictQUBO(kSATInstance):
     quboInstance = {}
@@ -32,6 +33,37 @@ def WMISdictQUBO(kSATInstance):
     
     return quboInstance
 
+def WMISdictQUBO_2(kSATInstance):
+    quboInstance = {}
+    
+    for clauseIndex in range(kSATInstance.getNumberOfClauses()):
+        clause = kSATInstance.getClause(clauseIndex)
+        
+        # build triangles
+        for varIndexInClause in range(len(clause)):
+            lit = clause[varIndexInClause]
+            var = abs(lit)
+            
+            aux = "z{}_{}".format(clauseIndex, var)
+            var_node = "x{}".format(var)
+            
+            if lit < 0:
+                quboInstance[(aux, aux)] = __VERTEX_WEIGHT__
+                quboInstance[(var_node, aux)] = __EDGE_WEIGHT__
+            else:
+                quboInstance[(var_node, aux)] = __VERTEX_WEIGHT__
+            
+            
+            
+            for i in range(varIndexInClause + 1, len(clause)):
+                var2 = abs(clause[i])
+                
+                aux2 = "z{}_{}".format(clauseIndex, var2)
+                
+                quboInstance[(aux, aux2)] = __EDGE_WEIGHT__
+    
+    return quboInstance
+
 # only 3sat
 def primitiveQUBO(sat):
     quboInstance = {}
@@ -47,10 +79,10 @@ def primitiveQUBO(sat):
         lit1 = "c{}_l{}".format(clauseIndex, clause[0])
         lit2 = "c{}_l{}".format(clauseIndex, clause[1])
         lit3 = "c{}_l{}".format(clauseIndex, clause[2])
-        aux1 = "a{}_{}".format(clauseIndex, 1)
-        aux2 = "a{}_{}".format(clauseIndex, 2)
-        aux3 = "a{}_{}".format(clauseIndex, 3)
-        aux4 = "a{}_{}".format(clauseIndex, 4)
+        aux1 = "z{}_{}".format(clauseIndex, 1)
+        aux2 = "z{}_{}".format(clauseIndex, 2)
+        aux3 = "z{}_{}".format(clauseIndex, 3)
+        aux4 = "z{}_{}".format(clauseIndex, 4)
         
         quboInstance[(lit1, lit1)] = 1;
         quboInstance[(lit2, lit2)] = 1;
@@ -91,7 +123,15 @@ def primitiveQUBO(sat):
             longestChain = len(nodes)
             
         if lit > 0 and -1 * lit in chains:
-            quboInstance[(chains[lit][0], chains[-1*lit][0])] = 2
+            len_smaller_chain = min(len(chains[lit]), len(chains[-lit]))
+            
+            indices = random.sample(list(range(len_smaller_chain)),
+                                    round(len_smaller_chain / 2))
+            
+            for index in indices:
+                quboInstance[(chains[lit][index], chains[-1*lit][index])] = 10
+            
+            #quboInstance[(chains[lit][0], chains[-1*lit][0])] = 2
             
     print("longest chain = {}".format(longestChain))
     
@@ -101,6 +141,574 @@ def primitiveQUBO(sat):
             nodes.pop(0)
     
     return quboInstance
+
+# only 3sat
+def primitiveQUBO_2(sat):
+    quboInstance = {}
+    
+    chains = {}
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sat.getClause(clauseIndex)
+        
+        lit1 = clause[0]
+        lit2 = clause[1]
+        lit3 = clause[2]
+        
+        var1 = abs(lit1)
+        var2 = abs(lit2)
+        var3 = abs(lit3)
+        
+        sign1 = 1 if lit1 > 0 else -1
+        sign2 = 1 if lit2 > 0 else -1
+        sign3 = 1 if lit3 > 0 else -1
+        
+        node_var1 = "x{}".format(var1)
+        node_var2 = "x{}".format(var2)
+        node_var3 = "x{}".format(var3)
+        
+        node_aux1 = "a{}_{}".format(clauseIndex, 1)
+        node_aux2 = "a{}_{}".format(clauseIndex, 2)
+        node_aux3 = "a{}_{}".format(clauseIndex, 3)
+        node_aux4 = "a{}_{}".format(clauseIndex, 4)
+        
+        
+        quboInstance[(node_var1, node_var1)] = 1 * sign1
+        quboInstance[(node_var2, node_var2)] = 1 * sign2
+        quboInstance[(node_var3, node_var3)] = 1 * sign3
+        quboInstance[(node_aux1, node_aux1)] = -2
+        quboInstance[(node_aux2, node_aux2)] = 1
+        quboInstance[(node_aux3, node_aux3)] = -2
+        quboInstance[(node_aux4, node_aux4)] = -2
+        
+        quboInstance[(node_var1, node_var2)] = 1 * sign1 * sign2
+        quboInstance[(node_var1, node_aux1)] = -2 * sign1
+        quboInstance[(node_var2, node_aux1)] = -2 * sign2
+        quboInstance[(node_aux1, node_aux2)] = -2
+        quboInstance[(node_aux2, node_var3)] = 1 * sign3
+        
+        quboInstance[(node_var3, node_aux3)] = -2 * sign3
+        quboInstance[(node_aux2, node_aux3)] = -2
+        quboInstance[(node_var3, node_aux4)] = -2
+    
+    return quboInstance
+
+# only 3sat
+def primitiveQUBO_3(sat):
+    quboInstance = {}
+    
+    chains = {}
+    
+    lits = {}
+    vars = {}
+    
+    n_clauses = sat.getNumberOfClauses()
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sat.getClause(clauseIndex)
+        
+        lit1 = clause[0]
+        lit2 = clause[1]
+        lit3 = clause[2]
+        
+        lits[lit1] = True
+        lits[lit2] = True
+        lits[lit3] = True
+        
+        var1 = abs(lit1)
+        var2 = abs(lit2)
+        var3 = abs(lit3)
+        
+        vars[var1] = True
+        vars[var2] = True
+        vars[var3] = True
+        
+        node_lit1 = "x{}".format(lit1)
+        node_lit2 = "x{}".format(lit2)
+        node_lit3 = "x{}".format(lit3)
+        
+        node_aux1 = "z{}_{}".format(clauseIndex, 1)
+        node_aux2 = "z{}_{}".format(clauseIndex, 2)
+        node_aux3 = "z{}_{}".format(clauseIndex, 3)
+        node_aux4 = "z{}_{}".format(clauseIndex, 4)
+        
+        
+        quboInstance[(node_lit1, node_lit1)] = 1
+        quboInstance[(node_lit2, node_lit2)] = 1
+        quboInstance[(node_lit3, node_lit3)] = 1
+        quboInstance[(node_aux1, node_aux1)] = -2
+        quboInstance[(node_aux2, node_aux2)] = 1
+        quboInstance[(node_aux3, node_aux3)] = -2
+        quboInstance[(node_aux4, node_aux4)] = -2
+        
+        quboInstance[(node_lit1, node_lit2)] = 1
+        quboInstance[(node_lit1, node_aux1)] = -2
+        quboInstance[(node_lit2, node_aux1)] = -2
+        
+        quboInstance[(node_aux1, node_aux2)] = -2
+        
+        quboInstance[(node_aux2, node_lit3)] = 1
+        quboInstance[(node_lit3, node_aux3)] = -2
+        quboInstance[(node_aux2, node_aux3)] = -2
+        
+        quboInstance[(node_aux3, node_aux4)] = -2
+    
+    for var in vars.keys():
+        if var in lits and -var in lits:
+            node_var = "x{}".format(var)
+            node_nvar = "x{}".format(-var)
+            
+            print((node_var, node_nvar))
+            quboInstance[(node_var, node_nvar)] = 2
+            
+    return quboInstance
+
+def primitiveQUBO_4(sat):
+    quboInstance = {}
+    
+    
+    clauses_per_lit = {}
+    
+    lits = {}
+    vars = {}
+    
+    n_clauses = sat.getNumberOfClauses()
+    
+    master_z = "zm"
+    
+    #quboInstance[(master_z, master_z)] = -2
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sat.getClause(clauseIndex)
+        
+        lit1 = clause[0]
+        lit2 = clause[1]
+        lit3 = clause[2]
+        
+        lits[lit1] = True
+        lits[lit2] = True
+        lits[lit3] = True
+        
+        sign1 = 1 if lit1 > 0 else -1
+        sign2 = 1 if lit2 > 0 else -1
+        sign3 = 1 if lit3 > 0 else -1
+        
+        for lit in clause:
+            if lit in clauses_per_lit:
+                clauses_per_lit[lit] += 1
+            else:
+                clauses_per_lit[lit] = 1
+        
+        var1 = abs(lit1)
+        var2 = abs(lit2)
+        var3 = abs(lit3)
+        
+        vars[var1] = True
+        vars[var2] = True
+        vars[var3] = True
+        
+        node_lit1 = "x{}".format(lit1)
+        node_lit2 = "x{}".format(lit2)
+        node_lit3 = "x{}".format(lit3)
+        
+        node_aux = "z{}".format(clauseIndex)
+        
+        #quboInstance[(node_aux, node_aux)] = -2
+        #quboInstance[(node_aux, master_z)] = -2
+        
+        #quboInstance[(node_lit1, node_lit1)] = +1 #* sign3
+        #quboInstance[(node_lit2, node_lit2)] = +1 #* sign3
+        #quboInstance[(node_lit3, node_lit3)] = +1 #* sign3
+        
+        quboInstance[(node_lit1, node_aux)] = -2 #* sign1
+        quboInstance[(node_lit2, node_aux)] = -2 #* sign2
+        quboInstance[(node_lit3, node_aux)] = -2 #* sign3
+    
+    for lit in lits.keys():
+        node_lit = "x{}".format(lit)
+        
+        #quboInstance[(node_lit, node_lit)] = 2 * clauses_per_lit[lit]
+        
+    for var in vars.keys():
+        if var in lits and -var in lits:
+            node_var = "x{}".format(var)
+            node_nvar = "x{}".format(-var)
+            
+            max_clauses = max(clauses_per_lit[var], clauses_per_lit[-var])
+            num_clauses = clauses_per_lit[var] + clauses_per_lit[-var]
+             
+            print((node_var, node_nvar))
+            quboInstance[(node_var, node_nvar)] = 2 * num_clauses
+            #quboInstance[(node_var, node_nvar)] = 2# * num_clauses
+            
+    return quboInstance
+
+def primitiveQUBO_5(sat):
+    quboInstance = {}
+    
+    
+    clauses_per_lit = {}
+    
+    lits = {}
+    vars = {}
+    
+    n_clauses = sat.getNumberOfClauses()
+    
+    master_z = "zm"
+    
+    #quboInstance[(master_z, master_z)] = -2
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sat.getClause(clauseIndex)
+        
+        lit1 = clause[0]
+        lit2 = clause[1]
+        lit3 = clause[2]
+        
+        lits[lit1] = True
+        lits[lit2] = True
+        lits[lit3] = True
+        
+        for lit in clause:
+            if lit in clauses_per_lit:
+                clauses_per_lit[lit] += 1
+            else:
+                clauses_per_lit[lit] = 1
+        
+        var1 = abs(lit1)
+        var2 = abs(lit2)
+        var3 = abs(lit3)
+        
+        vars[var1] = True
+        vars[var2] = True
+        vars[var3] = True
+        
+        node_lit1 = "x{}".format(lit1)
+        node_lit2 = "x{}".format(lit2)
+        node_lit3 = "x{}".format(lit3)
+        
+        node_aux1 = "z{}_1".format(clauseIndex)
+        node_aux2 = "z{}_2".format(clauseIndex)
+        
+        quboInstance[(node_lit1, node_aux1)] = -2
+        quboInstance[(node_lit2, node_aux1)] = -2
+        quboInstance[(node_lit1, node_lit2)] = +2
+        
+        quboInstance[(node_aux1, node_lit3)] = +2
+        quboInstance[(node_lit3, node_aux2)] = -2
+        
+
+        
+    for var in vars.keys():
+        if var in lits and -var in lits:
+            node_var = "x{}".format(var)
+            node_nvar = "x{}".format(-var)
+            
+            max_clauses = max(clauses_per_lit[var], clauses_per_lit[-var])
+            num_clauses = clauses_per_lit[var] + clauses_per_lit[-var]
+             
+            #print((node_var, node_nvar))
+            quboInstance[(node_var, node_nvar)] = 2 * max_clauses
+            
+    return quboInstance
+
+def primitiveQUBO_6(sat):
+    quboInstance = {}
+    
+    
+    clauses_per_lit = {}
+    
+    lits = {}
+    vars = {}
+    
+    n_clauses = sat.getNumberOfClauses()
+    
+    master_z = "zm"
+    
+    #quboInstance[(master_z, master_z)] = -2
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sat.getClause(clauseIndex)
+        
+        lit1 = clause[0]
+        lit2 = clause[1]
+        lit3 = clause[2]
+        
+        lits[lit1] = True
+        lits[lit2] = True
+        lits[lit3] = True
+        
+        for lit in clause:
+            if lit in clauses_per_lit:
+                clauses_per_lit[lit] += 1
+            else:
+                clauses_per_lit[lit] = 1
+        
+        var1 = abs(lit1)
+        var2 = abs(lit2)
+        var3 = abs(lit3)
+        
+        vars[var1] = True
+        vars[var2] = True
+        vars[var3] = True
+        
+        node_lit1 = "x{}".format(lit1)
+        node_lit2 = "x{}".format(lit2)
+        node_lit3 = "x{}".format(lit3)
+        
+        node_aux1 = "z{}_1".format(clauseIndex)
+        node_aux2 = "z{}_2".format(clauseIndex)
+        node_aux3 = "z{}_3".format(clauseIndex)
+        node_aux4 = "z{}_4".format(clauseIndex)
+        
+        quboInstance[(node_lit1, node_aux1)] = -2
+        quboInstance[(node_lit2, node_aux2)] = -2
+        quboInstance[(node_aux1, node_aux2)] = +2
+        
+        quboInstance[(node_aux1, node_aux3)] = -2
+        quboInstance[(node_aux2, node_aux3)] = -2
+        
+        quboInstance[(node_aux1, node_aux1)] = +2
+        quboInstance[(node_aux2, node_aux2)] = +2
+        
+        quboInstance[(node_aux3, node_lit3)] = +2
+        quboInstance[(node_lit3, node_aux4)] = -2
+        
+
+        
+    for var in vars.keys():
+        if var in lits and -var in lits:
+            node_var = "x{}".format(var)
+            node_nvar = "x{}".format(-var)
+            
+            max_clauses = max(clauses_per_lit[var], clauses_per_lit[-var])
+            num_clauses = clauses_per_lit[var] + clauses_per_lit[-var]
+             
+            #print((node_var, node_nvar))
+            quboInstance[(node_var, node_nvar)] = 2 * max_clauses
+            
+    return quboInstance
+
+def primitiveQUBO_7(sat):
+    quboInstance = {}
+    
+    
+    clauses_per_lit = {}
+    
+    lits = {}
+    vars = {}
+    
+    n_clauses = sat.getNumberOfClauses()
+    
+    master_z = "zm"
+    
+    #quboInstance[(master_z, master_z)] = -2
+    direct_cupplers = {}
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sat.getClause(clauseIndex)
+        
+        lit1 = clause[0]
+        lit2 = clause[1]
+        lit3 = clause[2]
+        
+        lits[lit1] = True
+        lits[lit2] = True
+        lits[lit3] = True
+        
+        for lit in clause:
+            if lit in clauses_per_lit:
+                clauses_per_lit[lit] += 1
+            else:
+                clauses_per_lit[lit] = 1
+        
+        var1 = abs(lit1)
+        var2 = abs(lit2)
+        var3 = abs(lit3)
+        
+        vars[var1] = True
+        vars[var2] = True
+        vars[var3] = True
+        
+        node_lit1 = "x{}".format(lit1)
+        node_lit2 = "x{}".format(lit2)
+        node_lit3 = "x{}".format(lit3)
+        
+        node_aux1 = "z{}_1".format(clauseIndex)
+        node_aux2 = "z{}_2".format(clauseIndex)
+        
+        quboInstance[(node_lit1, node_aux1)] = -2
+        quboInstance[(node_lit2, node_aux1)] = -2
+        quboInstance[(node_lit1, node_lit2)] = +2
+        
+        quboInstance[(node_aux1, node_lit3)] = +2
+        quboInstance[(node_lit3, node_aux2)] = -2
+        
+        
+        
+        if (node_lit1, node_lit2) in direct_cupplers:
+            direct_cupplers[(node_lit1, node_lit2)] += 1
+        else:
+            direct_cupplers[(node_lit1, node_lit2)] = 1
+        
+
+        
+    for var in vars.keys():
+        if var in lits and -var in lits:
+            node_var = "x{}".format(var)
+            node_nvar = "x{}".format(-var)
+            
+            max_clauses = max(clauses_per_lit[var], clauses_per_lit[-var])
+            num_clauses = clauses_per_lit[var] + clauses_per_lit[-var]
+             
+            print((node_var, node_nvar))
+            quboInstance[(node_var, node_nvar)] = 2 * max_clauses
+
+            
+    for coupler, count in direct_cupplers.items():        
+        quboInstance[coupler] = count * 2
+        
+            
+    return quboInstance
+
+def primitiveQUBO_8(sat):
+    quboInstance = {}
+    
+    
+    clauses_per_lit = {}
+    
+    lits = {}
+    vars = {}
+    
+    n_clauses = sat.getNumberOfClauses()
+
+    direct_cupplers = {}
+    
+    for clauseIndex in range(sat.getNumberOfClauses()):
+        clause = sorted(sat.getClause(clauseIndex))
+        
+        if clause[2] < 0:
+            __add_3not_or_clause(quboInstance, clause, clauseIndex)
+        elif clause[1] < 0:
+            __add_2not_or_clause(quboInstance, clause, clauseIndex)
+        elif clause[0] < 0:
+            __add_1not_or_clause(quboInstance, clause, clauseIndex, direct_cupplers)
+        else:
+            __add_3_or_clause(quboInstance, clause, clauseIndex, direct_cupplers)
+
+            
+    for coupler, count in direct_cupplers.items():        
+        quboInstance[coupler] = count * 2
+        
+            
+    return quboInstance
+
+def __add_3not_or_clause(quboInstance, clause, clause_index):
+    var1 = abs(clause[0])
+    var2 = abs(clause[1])
+    var3 = abs(clause[2])
+    
+    
+    node_var1 = "x{}".format(var1)
+    node_var2 = "x{}".format(var2)
+    node_var3 = "x{}".format(var3)
+    
+    node_aux1 = "z{}_1".format(clause_index)
+    node_aux2 = "z{}_2".format(clause_index)
+    node_aux3 = "z{}_3".format(clause_index)
+    
+    quboInstance[(node_var1, node_aux1)] = +2
+    quboInstance[(node_var2, node_aux2)] = +2
+    quboInstance[(node_aux1, node_aux2)] = +2
+    
+    quboInstance[(node_aux1, node_aux1)] = -2
+    quboInstance[(node_aux2, node_aux2)] = -2
+    
+    quboInstance[(node_var1, node_aux3)] = -2
+    quboInstance[(node_var2, node_aux3)] = -2
+    quboInstance[(node_var3, node_aux3)] = +2
+    quboInstance[(node_aux3, node_aux3)] = +2
+    
+def __add_2not_or_clause(quboInstance, clause, clause_index):
+    var1 = abs(clause[0])
+    var2 = abs(clause[1])
+    var3 = abs(clause[2])
+    
+    
+    node_var1 = "x{}".format(var1)
+    node_var2 = "x{}".format(var2)
+    node_var3 = "x{}".format(var3)
+    
+    node_aux1 = "z{}_1".format(clause_index)
+    node_aux2 = "z{}_2".format(clause_index)
+    node_aux3 = "z{}_3".format(clause_index)
+    node_aux4 = "z{}_4".format(clause_index)
+    node_aux5 = "z{}_5".format(clause_index)
+    
+    quboInstance[(node_var1, node_aux1)] = +2
+    quboInstance[(node_var2, node_aux2)] = +2
+    quboInstance[(node_aux1, node_aux2)] = +2
+    
+    quboInstance[(node_aux1, node_aux3)] = -2
+    quboInstance[(node_aux2, node_aux3)] = -2
+    quboInstance[(node_aux3, node_aux3)] = +2
+    
+    quboInstance[(node_aux3, node_aux4)] = -2
+    quboInstance[(node_var3, node_aux5)] = -2
+    quboInstance[(node_aux4, node_aux5)] = +2
+
+def __add_1not_or_clause(quboInstance, clause, clause_index, direct_cupplers):
+    var1 = abs(clause[1])
+    var2 = abs(clause[2])
+    var3 = abs(clause[0])
+    
+    
+    node_var1 = "x{}".format(var1)
+    node_var2 = "x{}".format(var2)
+    node_var3 = "x{}".format(var3)
+    
+    node_aux1 = "z{}_1".format(clause_index)
+    node_aux2 = "z{}_2".format(clause_index)
+    
+    quboInstance[(node_var1, node_var2)] = +2
+    quboInstance[(node_var1, node_aux1)] = -2
+    quboInstance[(node_var2, node_aux1)] = -2
+    
+    quboInstance[(node_aux1, node_aux2)] = +2
+    quboInstance[(node_var3, node_aux2)] = +2
+    
+    quboInstance[(node_aux2, node_aux2)] = -2
+    
+    if (node_var1, node_var2) in direct_cupplers:
+        direct_cupplers[(node_var1, node_var2)] += 1
+    else:
+        direct_cupplers[(node_var1, node_var2)] = 1
+        
+def __add_3_or_clause(quboInstance, clause, clause_index, direct_cupplers):
+    var1 = abs(clause[0])
+    var2 = abs(clause[1])
+    var3 = abs(clause[2])
+    
+    
+    node_var1 = "x{}".format(var1)
+    node_var2 = "x{}".format(var2)
+    node_var3 = "x{}".format(var3)
+    
+    node_aux1 = "z{}_1".format(clause_index)
+    node_aux2 = "z{}_2".format(clause_index)
+    
+    quboInstance[(node_var1, node_var2)] = +2
+    quboInstance[(node_var1, node_aux1)] = -2
+    quboInstance[(node_var2, node_aux1)] = -2
+    
+    quboInstance[(node_aux1, node_var3)] = +2
+    quboInstance[(node_var3, node_aux2)] = -2
+    
+    if (node_var1, node_var2) in direct_cupplers:
+        direct_cupplers[(node_var1, node_var2)] += 1
+    else:
+        direct_cupplers[(node_var1, node_var2)] = 1
+
     
 class QuboWriter:
     def __init__(self, qubo):

util/graph.py

@@ -25,3 +25,15 @@ def create_qpu_solver_nxgraph(solver):
     graph.add_edges_from(solver.edges)
     
     return graph
+
+def split_ising(ising):
+    h = {}
+    J = {}
+    
+    for coupler, energy in ising.items():
+        if coupler[0] == coupler[1]:
+            h[coupler[0]] = energy
+        else:
+            J[coupler] = energy
+    
+    return h, J

util/queries.py

@@ -59,6 +59,56 @@ class Instance_scope_query:
         
         return sat, document["_id"]
 
+class Qubo_ising_scope_query_raw:
+    def __init__(self, database, collection):
+        self.__database = database
+        self.__collection = collection
+        self.__query = None
+        self.__qubo_ids = []
+        self.__qubo_id_iterator = None
+    
+    def query(self, scope):
+        self.__query = self.__database["experiment_scopes"].aggregate([
+            {
+                "$match": {"_id": scope}
+            },
+            {
+                "$unwind": "$instances"
+            },
+            {
+                "$lookup":
+                {
+                    "from": self.__collection,
+                    "localField": "instances",
+                    "foreignField": "instance",
+                    "as": "qubo"
+                }
+            },
+            {
+                "$unwind": "$qubo"
+            },
+            {
+                "$project": {"qubo_id": "$qubo._id"}
+            }
+        ])
+        
+        self.__qubo_ids = []
+        for doc in self.__query:
+            self.__qubo_ids.append(doc["qubo_id"])
+        
+        self.__qubo_id_iterator = iter(self.__qubo_ids)
+            
+    def __len__(self):
+        return self.query.count_documents({})
+            
+    def __iter__(self):
+        return self
+    
+    def __next__(self):
+        qubo_filter = {"_id": self.__qubo_id_iterator.__next__()}
+        
+        return self.__database[self.__collection].find_one(qubo_filter)
+
 class WMIS_scope_query_raw:
     
     def __init__(self, database):
@@ -115,12 +165,27 @@ class WMIS_scope_query (WMIS_scope_query_raw):
         doc = super(WMIS_scope_query, self).__next__()
         
         
+        return read_raw_qubo(doc["qubo"]), doc["_id"]
+    
+class Ising_scope_query (Qubo_ising_scope_query_raw):
+    
+    def __next__(self):
+        doc = super(Ising_scope_query, self).__next__()
+        
+        return read_raw_ising(doc["qubo"]), doc["_id"]
+
+class Qubo_scope_query (Qubo_ising_scope_query_raw):
+    
+    def __next__(self):
+        doc = super(Qubo_scope_query, self).__next__()
+        
         return read_raw_qubo(doc["qubo"]), doc["_id"]
     
 class WMIS_solver_input_scope_query_raw:
     
-    def __init__(self, database):
+    def __init__(self, database, ising_qubo_collection):
         self.__database = database
+        self.__ising_qubo_collection = ising_qubo_collection
         self.__query = None
         self.__ids = []
         self.__id_iterator = None;
@@ -139,7 +204,7 @@ class WMIS_solver_input_scope_query_raw:
             {
                 "$lookup":
                 {
-                    "from": "wmis_qubos",
+                    "from": self.__ising_qubo_collection,
                     "localField": "instance_id",  
                     "foreignField": "instance",
                     "as": "wmis_qubo"
@@ -230,7 +295,9 @@ class WMIS_solver_input_scope_query_raw:
         doc["instance_id"] = ids["instance_id"]
         
         qubo_filter = {"_id": ids["wmis_qubo_id"]}
-        doc["wmis_qubo"] = self.__database["wmis_qubos"].find_one(qubo_filter)
+        
+        ising_qubo_collection = self.__database[self.__ising_qubo_collection]
+        doc["wmis_qubo"] = ising_qubo_collection.find_one(qubo_filter)
         
         embeddings_filter = {"_id": ids["embeddings_id"]}
         doc["embeddings"] = self.__database["embeddings"].find_one(embeddings_filter)
@@ -257,6 +324,26 @@ class WMIS_solver_input_scope_query (WMIS_solver_input_scope_query_raw):
             
         return data
     
+class Ising_solver_input_scope_query (WMIS_solver_input_scope_query_raw):
+    
+    def __next__(self):
+        doc = super(Ising_solver_input_scope_query, self).__next__()
+        
+        data = {}
+        
+        data["instance_id"] = doc["instance_id"]
+        
+        data["qubo_id"] = doc["wmis_qubo"]["_id"]
+        data["qubo"] = read_raw_ising(doc["wmis_qubo"]["qubo"])
+        
+        data["embeddings_id"] = doc["embeddings"]["_id"]
+        
+        data["embeddings"] = []
+        for raw_emb in doc["embeddings"]["embeddings"]:
+            data["embeddings"].append(read_raw_ising_embedding(raw_emb))
+            
+        return data
+    
 class WMIS_result_scope_query_raw:
     def __init__(self, database):
         self.__database = database
@@ -395,6 +482,19 @@ def read_raw_qubo(raw_qubo):
         
     return qubo
 
+def read_raw_ising(raw_ising):
+    ising = {}
+    
+    for entry in raw_ising:
+        energy = entry[1]
+        raw_coupler = entry[0]
+        node1 = raw_coupler[0]
+        node2 = raw_coupler[1]
+        
+        ising[(node1, node2)] = energy
+    
+    return ising
+
 def read_raw_embedding(raw_embedding):
     emb = {}
     
@@ -406,6 +506,17 @@ def read_raw_embedding(raw_embedding):
         
     return emb
 
+def read_raw_ising_embedding(raw_embedding):
+    emb = {}
+    
+    if "embedding" in raw_embedding:
+        raw_embedding = raw_embedding["embedding"]
+        
+    for entry in raw_embedding:
+        emb[entry[0]] = entry[1]
+        
+    return emb
+
 def read_raw_wmis_sample_set(raw_sample_set):
     sample_set_data = raw_sample_set.copy()
     
@@ -416,6 +527,16 @@ def read_raw_wmis_sample_set(raw_sample_set):
         
     return dimod.SampleSet.from_serializable(sample_set_data)
 
+def read_raw_primitive_ising_sample_set(raw_sample_set):
+    sample_set_data = raw_sample_set.copy()
+    
+    sample_set_data["variable_labels"] = []
+    
+    for label in raw_sample_set["variable_labels"]:
+        sample_set_data["variable_labels"].append("".join(label))
+        
+    return dimod.SampleSet.from_serializable(sample_set_data)
+
 def get_instance_by_id(collection, id):
     doc = collection.find_one({"_id": bson.ObjectId(id)})
     
@@ -425,4 +546,21 @@ def get_instance_by_id(collection, id):
             sat.addClause(clause);
         
     return sat
+
+def extract_primitive_ising_model(sample):
+    variable_bindings = {}
+    
+    for node, energy in sample.items():
+        if node[0] == "x":
+            var = int(node[1:])
+            variable_bindings[var] = True if energy > 0 else False
+            
+    model = [True for i in range(len(variable_bindings))]
+    
+    for var, binding in variable_bindings.items():
+        model[var - 1] = binding
+        
+    return model
+    
+    
     

util/script.py

@@ -186,7 +186,43 @@ def create_wmis_qubos_for_scope(db, scope):
     for instance, instance_id in instances:
         qubo = SAT2QUBO.WMISdictQUBO(instance)
         
-        write_qubo_to_pool_db(db["wmis_qubos"], qubo, instance_id)
+        write_qubo_to_pool_db(db["wmis_qubos_2"], qubo, instance_id)
+        
+def create_wmis_2_qubos_for_scope(db, scope):
+    instances = queries.Instance_scope_query(db)
+    instances.query(scope)
+    
+    for instance, instance_id in instances:
+        qubo = SAT2QUBO.WMISdictQUBO_2(instance)
+        
+        write_qubo_to_pool_db(db["wmis_2_qubos"], qubo, instance_id)
+
+def create_primitive_isings_for_scope_2(db, scope):
+    instances = queries.Instance_scope_query(db)
+    instances.query(scope)
+    
+    for instance, instance_id in instances:
+        ising = SAT2QUBO.primitiveQUBO_2(instance)
+        
+        write_qubo_to_pool_db(db["primitive_isings_2"], ising, instance_id)
+        
+def create_primitive_qubo_for_scope_5(db, scope):
+    instances = queries.Instance_scope_query(db)
+    instances.query(scope)
+    
+    for instance, instance_id in tqdm(instances):
+        ising = SAT2QUBO.primitiveQUBO_5(instance)
+        
+        write_qubo_to_pool_db(db["primitive_isings_5"], ising, instance_id)
+        
+def create_primitive_qubo_for_scope_8(db, scope):
+    instances = queries.Instance_scope_query(db)
+    instances.query(scope)
+    
+    for instance, instance_id in tqdm(instances):
+        ising = SAT2QUBO.primitiveQUBO_8(instance)
+        
+        write_qubo_to_pool_db(db["primitive_isings_8"], ising, instance_id)
     
 def __qubo_to_JSON(qubo):
     quboJSON = []
@@ -305,6 +341,53 @@ def find_wmis_embeddings_for_scope(db, scope, solver_graph):
                                                    total_count,
                                                    percentage))
     print("{} new embeddigns found".format(new_embeddings_found))
+    
+def find_embeddings_for_scope(db, solver_graph, qubo_ising_query):
+    solver_graph_id = write_solver_graph_to_pool_db(db["solver_graphs"], 
+                                                    solver_graph)
+    
+    new_embeddings_found = 0
+    already_found = 0
+    total_count = 0
+    for qubo, qubo_id in tqdm(qubo_ising_query):
+        total_count += 1
+        
+        max_no_improvement = 10
+        for i in range(5):
+            if __embedding_entry_exists(db["embeddings"], qubo_id, solver_graph_id):
+                if i == 0:
+                    already_found += 1
+                break;
+            else: 
+                nx_qubo = graph.qubo_to_nx_graph(qubo)
+                
+                seed = random.randint(0, sys.maxsize)
+                
+                emb = minorminer.find_embedding(nx_qubo.edges(),
+                                                solver_graph.edges(),
+                                                return_overlap=True,
+                                                max_no_improvement=max_no_improvement,
+                                                random_seed=seed)
+                
+                if emb[1] == 1:
+                    write_wmis_embedding_to_pool_db(db["embeddings"],
+                                                    qubo_id,
+                                                    solver_graph_id,
+                                                    seed,
+                                                    emb[0])
+                    new_embeddings_found += 1
+                    
+            max_no_improvement *= 1.5
+    
+    percentage = 0
+    
+    if total_count > 0:
+        percentage = round(((new_embeddings_found + already_found) / total_count) * 100)
+    
+    print("found {} of {} embeddigns ({}%)".format(new_embeddings_found + already_found,
+                                                   total_count,
+                                                   percentage))
+    print("{} new embeddigns found".format(new_embeddings_found))
 
 def save_sample_set(collection, result, solver_input, emb_list_index, run):
     doc = {}