def prunepaths_1D(g2, path, conn):
c = []
g = cloneempty(g2)
for p in conn:
mask = addapath(g,path,p)
if isedgesubset(bfu.increment(g), g2): c.append(tuple(p))
delapath(g,path,p,mask)
return c
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 isedgesubsetD(bfu.increment(g), g2):
r = nodesearch(g,g2,edges,s)
if r and edgeset(bfu.increment(r))==edgeset(g2):
s.add(bfu.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, order, inlist, s, cds, pool, pc):
if order:
if bfu.increment(g) == g2:
s.add(bfu.g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
s.update(supergraphs_in_eq(g, g2))
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): 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.increment(g) == g2:
s.add(bfu.g2num(g))
if capsize and len(s) > capsize:
raise ValueError('Too many elements')
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 isedgesubset(bfu.increment(g), g2):
r = nodesearch(g,g2,edges,s)
if r and bfu.increment(r)==g2:
s.add(bfu.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 g22g1(g2, capsize=None):
'''
computes all g1 that are in the equivalence class for g2
'''
if ecj.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(bfu.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(bfu.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 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 checker(n,ee):
g = bfu.ringmore(n,ee)
g2 = bfu.increment(g)
d = checkable(g2)
t = [len(d[x]) for x in d]
r = []
n = len(g2)
ee= len(gk.edgelist(g2))
for i in range(1,len(t)):
r.append(sum(np.log10(t[:i])) - ee*np.log10(n))
return r
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(bfu.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(bfu.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(bfu.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 checkerDS(n,ee):
g = bfu.ringmore(n,ee)
g2 = bfu.increment(g)
gg = checkable(g2)
d,p,idx = conformanceDS(g2,gg,gg.keys())
t = [len(x) for x in p]
r = []
n = len(g2)
ee= len(gk.edgelist(g2))
for i in range(1,len(t)):
r.append(sum(np.log10(t[:i])) - ee*np.log10(n))
return r
def nodesearch(g, g2, order, inlist, s, cds, pool, pc):
if order:
if bfu.increment(g) == g2:
s.add(bfu.g2num(g))
if capsize and len(s)>capsize:
raise ValueError('Too many elements')
s.update(supergraphs_in_eq(g, g2))
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): 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.increment(g)==g2:
s.add(bfu.g2num(g))
if capsize and len(s)>capsize:
raise ValueError('Too many elements')
return g
def nodesearch(g, g2, edges, s):
if edges:
if bfu.increment(g) == g2:
s.add(bfu.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(bfu.g2num(g))
if capsize and len(s)>capsize:
raise ValueError('Too many elements in eqclass')
return g
def edge_backtrack2g1_directed(g2, capsize=None):
'''
computes all g1 that are in the equivalence class for g2
'''
if ecj.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 isedgesubsetD(bfu.increment(g), g2):
r = nodesearch(g, g2, edges, s)
if r and edgeset(bfu.increment(r)) == edgeset(g2):
s.add(bfu.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 isedgesubsetD(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 edge_backtrack2g1_directed(g2, capsize=None):
'''
computes all g1 that are in the equivalence class for g2
'''
if ecj.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 isedgesubsetD(bfu.increment(g), g2):
r = nodesearch(g,g2,edges,s)
if r and edgeset(bfu.increment(r))==edgeset(g2):
s.add(bfu.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 isedgesubsetD(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
