def simple_loops(g, u):
"""
iterator over the list of simple loops of graph g at the undersample rate u
"""
gx = graph2nx(num2CG(g2num(undersample(g, u)), len(g)))
for l in networkx.simple_cycles(gx):
yield l
def forms_loop(G_star, loop):
glist = [G_star]
while True:
g = increment_u(G_star, glist[-1])
if (g2num(gk.digonly(g)) & loop) == loop:
return True
if g in glist:
return False
glist.append(g)
return False
def nodesearch0(g, g2, order, inlist, s, cds):
if order:
key = order.pop(0)
tocheck = cds[len(inlist) - 1][inlist[0]]
adder, remover, masker = f[edge_function_idx(key)]
checks_ok = c[edge_function_idx(key)]
if len(tocheck) > 1:
for n in tocheck:
if not checks_ok(key, n, g, g2):
continue
mask = masker(g, key, n)
if not np.prod(mask):
mask = adder(g, key, n)
r = nodesearch0(g, g2, order, [n] + inlist, s, cds)
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)
else:
r = nodesearch0(g, g2, order, [n] + inlist, s, cds)
if r and bfu.increment(r) == g2:
s.add(g2num(r))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
elif tocheck:
(n,) = tocheck
mask = adder(g, key, n)
r = nodesearch0(g, g2, order, [n] + inlist, s, cds)
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)
order.insert(0, key)
else:
return g
def nodesearch(g, g2, order, inlist, s, cds, pool, pc):
if order:
if bfu.undersample(g, rate) == g2:
s.add(g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
s.update(supergraphs_in_eq(g, g2, rate=rate))
return g
key = order[0]
if pc:
tocheck = [x for x in pc if x in cds[len(inlist) - 1][inlist[0]]]
else:
tocheck = cds[len(inlist) - 1][inlist[0]]
if len(order) > 1:
kk = order[1]
pc = predictive_check(g, g2, pool[len(inlist)],
c[edge_function_idx(kk)], kk)
else:
pc = set()
adder, remover, masker = f[edge_function_idx(key)]
checks_ok = c[edge_function_idx(key)]
for n in tocheck:
if not checks_ok(key, n, g, g2, rate=rate):
continue
masked = np.prod(masker(g, key, n))
if masked:
nodesearch(g, g2, order[1:], [n] + inlist, s, cds, pool, pc)
else:
mask = adder(g, key, n)
nodesearch(g, g2, order[1:], [n] + inlist, s, cds, pool, pc)
remover(g, key, n, mask)
elif bfu.undersample(g, rate) == g2:
s.add(g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
return g
def compat(G):
n = len(G)
num = g2num(G)
# sample all the graph for gStar
star_l = all_undersamples(G)
hits = {}
# brute force all graphs
for i in range(0, 2 ** (n**2)):
tmpG = num2CG(i, n)
tmp_l = all_undersamples(tmpG)
c = compatible(tmp_l, star_l)
if len(sum(c)) > 0:
hits[i] = c
return hits
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
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
def addnodes(g, g2, edges):
if edges:
masks = []
for e in edges:
if ok2addanedge(e[0], e[1], g, g2, rate=rate):
masks.append(True)
else:
masks.append(False)
nedges = [edges[i] for i in range(len(edges)) if masks[i]]
n = len(nedges)
if n:
for i in range(n):
mask = addanedge(g, nedges[i])
s.add(g2num(g))
addnodes(g, g2, nedges[:i] + nedges[i + 1:])
delanedge(g, nedges[i], mask)
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 addnodes(g, g2, edges):
if edges:
masks = []
for e in edges:
if ok2addanedge_(e[0], e[1], g, g2, rate=rate):
masks.append(True)
else:
masks.append(False)
nedges = [edges[i] for i in range(len(edges)) if masks[i]]
n = len(nedges)
if n:
for i in range(n):
mask = addanedge(g, nedges[i])
if bfu.undersample(g, rate) == g2:
s.add(g2num(g))
addnodes(g, g2, nedges[:i] + nedges[i + 1:])
delanedge(g, nedges[i], mask)
return s
else:
return noop
else:
return noop
def gsig(g):
'''
turns input graph g into a hash string using edges
'''
return g2num(g)
