def ok2addaVpath(e, p, g, g2, rate=2):
mask = addaVpath(g, e, p)
if not gk.isedgesubset(bfu.undersample(g, rate), g2):
cleanVedges(g, e, p, mask)
return False
cleanVedges(g, e, p, mask)
return True
def prunepaths_1D(g2, path, conn):
c = []
g = cloneempty(g2)
for p in conn:
mask = addapath(g, path, p)
if gk.isedgesubset(bfu.increment(g), g2):
c.append(tuple(p))
delapath(g, path, p, mask)
return c
def g22g1(g2, capsize=None):
'''
computes all g1 that are in the equivalence class for g2
'''
if bfu.isSclique(g2):
print 'Superclique - any SCC with GCD = 1 fits'
return set([-1])
single_cache = {}
@memo # memoize the search
def nodesearch(g, g2, edges, s):
if edges:
if bfu.increment(g) == g2:
s.add(g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
return g
e = edges[0]
for n in g2:
if (n, e) in single_cache:
continue
if not edge_increment_ok(e[0], n, e[1], g, g2):
continue
mask = add2edges(g, e, n)
r = nodesearch(g, g2, edges[1:], s)
del2edges(g, e, n, mask)
elif bfu.increment(g) == g2:
s.add(g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements in eqclass')
return g
# find all directed g1's not conflicting with g2
n = len(g2)
edges = gk.edgelist(g2)
random.shuffle(edges)
g = cloneempty(g2)
for e in edges:
for n in g2:
mask = add2edges(g, e, n)
if not gk.isedgesubset(bfu.increment(g), g2):
single_cache[(n, e)] = False
del2edges(g, e, n, mask)
s = set()
try:
nodesearch(g, g2, edges, s)
except ValueError:
s.add(0)
return s
def call_u_conflicts2(G_star, H):
glist = [G_star]
while True:
g = increment_u(G_star, glist[-1])
if gk.isedgesubset(g, H):
return False, glist
if g in glist:
return True, glist
glist.append(g)
return True, glist
def call_u_conflicts_d(G_star, H, checkrate=0):
glist = [G_star]
while True:
g = dincrement_u(G_star, glist[-1])
if gk.isedgesubset(g, H):
return False
if g in glist:
return True
glist.append(g)
return True
def overshoot(G_star, H):
glist = [G_star]
while True:
g = increment_u(G_star, glist[-1])
if isSclique(g):
return False
if gk.isedgesubset(H, g):
return True
if g in glist:
return False
glist.append(g)
return False
def edge_backtrack2g1_directed(g2, capsize=None):
'''
computes all g1 that are in the equivalence class for g2
'''
if bfu.isSclique(g2):
print 'Superclique - any SCC with GCD = 1 fits'
return set([-1])
single_cache = {}
def edgeset(g):
return set(gk.edgelist(g))
@memo # memoize the search
def nodesearch(g, g2, edges, s):
if edges:
e = edges.pop()
ln = [n for n in g2]
for n in ln:
if (n, e) in single_cache:
continue
mask = add2edges(g, e, n)
if gk.isedgesubset(bfu.increment(g), g2):
r = nodesearch(g, g2, edges, s)
if r and edgeset(bfu.increment(r)) == edgeset(g2):
s.add(g2num(r))
if capsize and len(s) > capsize:
raise ValueError('Too many elements in eqclass')
del2edges(g, e, n, mask)
edges.append(e)
else:
return g
# find all directed g1's not conflicting with g2
n = len(g2)
edges = gk.edgelist(g2)
random.shuffle(edges)
g = cloneempty(g2)
for e in edges:
for n in g2:
mask = add2edges(g, e, n)
if not gk.isedgesubset(bfu.increment(g), g2):
single_cache[(n, e)] = False
del2edges(g, e, n, mask)
s = set()
try:
nodesearch(g, g2, edges, s)
except ValueError:
s.add(0)
return s
def call_u_conflicts(G_star, H, checkrate=0):
glist = [G_star]
while True:
# g = increment_u(G_star, glist[-1])
g = directed_inc(G_star, glist[-1])
if gk.isdedgesubset(g, H):
return False
g = bidirected_inc(g, glist[-1])
if gk.isedgesubset(g, H):
return False
if g in glist:
return True
glist.append(g)
return True
def nodesearch(g, g2, edges, s):
if edges:
e = edges.pop()
ln = [n for n in g2]
for n in ln:
if (n, e) in single_cache:
continue
mask = add2edges(g, e, n)
if gk.isedgesubset(bfu.increment(g), g2):
r = nodesearch(g, g2, edges, s)
if r and edgeset(bfu.increment(r)) == edgeset(g2):
s.add(g2num(r))
if capsize and len(s) > capsize:
raise ValueError('Too many elements in eqclass')
del2edges(g, e, n, mask)
edges.append(e)
else:
return g
def nodesearch(g, g2, edges, s):
if edges:
# key, checklist = edges.popitem()
key = random.choice(edges.keys())
checklist = edges.pop(key)
adder, remover = f[edge_function_idx(key)]
checks_ok = c[edge_function_idx(key)]
for n in checklist:
mask = adder(g, key, n)
if gk.isedgesubset(bfu.increment(g), g2):
r = nodesearch(g, g2, edges, s)
if r and bfu.increment(r) == g2:
s.add(g2num(r))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
remover(g, key, n, mask)
edges[key] = checklist
else:
return g
def ok2addanedge_sub(s, e, g, g2, rate=1):
mask = addanedge(g, (s, e))
value = gk.isedgesubset(bfu.undersample(g, rate), g2)
delanedge(g, (s, e), mask)
return value
def backtrack_more(g2, rate=1, capsize=None):
'''
computes all g1 that are in the equivalence class for g2
'''
if bfu.isSclique(g2):
print 'Superclique - any SCC with GCD = 1 fits'
return set([-1])
single_cache = {}
if rate == 1:
ln = [n for n in g2]
else:
ln = []
for x in itertools.combinations_with_replacement(g2.keys(), rate):
ln.extend(itertools.permutations(x, rate))
ln = set(ln)
@memo # memoize the search
def nodesearch(g, g2, edges, s):
if edges:
if bfu.undersample(g, rate) == g2:
s.add(g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
return g
e = edges[0]
for n in ln:
if (n, e) in single_cache:
continue
if not ok2addaVpath(e, n, g, g2, rate=rate):
continue
mask = addaVpath(g, e, n)
r = nodesearch(g, g2, edges[1:], s)
delaVpath(g, e, n, mask)
elif bfu.undersample(g, rate) == g2:
s.add(g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements in eqclass')
return g
# find all directed g1's not conflicting with g2
n = len(g2)
edges = gk.edgelist(g2)
random.shuffle(edges)
g = cloneempty(g2)
for e in edges:
for n in ln:
mask = addaVpath(g, e, n)
if not gk.isedgesubset(bfu.undersample(g, rate), g2):
single_cache[(n, e)] = False
delaVpath(g, e, n, mask)
s = set()
try:
nodesearch(g, g2, edges, s)
except ValueError:
s.add(0)
return s
