def local_clustering_binary_undirected(g, nodes=None):
'''
Returns the undirected local clustering coefficient of some `nodes`.
If `g` is directed, then it is converted to a simple undirected graph
(no parallel edges).
Parameters
----------
g : :class:`~nngt.Graph`
Graph to analyze.
nodes : list, optional (default: all nodes)
The list of nodes for which the clustering will be returned
Returns
-------
lc : :class:`numpy.ndarray`
The list of clustering coefficients, on per node.
References
----------
.. [gt-local-clustering] :gtdoc:`clustering.locall_clustering`
'''
# use undirected graph view, filter parallel edges
u = GraphView(g.graph, directed=False)
u = GraphView(u, efilt=label_parallel_edges(u).fa == 0)
# compute clustering
lc = gtc.local_clustering(u, weight=None, undirected=None).a
if nodes is None:
return lc
return lc[nodes]
def min_steiner_tree(g, obs_nodes, debug=False, verbose=False):
if g.num_vertices() == len(obs_nodes):
print('it\'s a minimum spanning tree problem')
gc, eweight, r2pred = build_closure(g,
obs_nodes,
debug=debug,
verbose=verbose)
# print('gc', gc)
tree_map = min_spanning_tree(gc, eweight, root=None)
tree = GraphView(gc, directed=False, efilt=tree_map)
tree_edges = set()
# print('tree', tree)
for e in tree.edges():
u, v = map(int, e)
recovered_edges = extract_edges_from_pred(u, v, r2pred[u])
assert recovered_edges, 'empty!'
for i, j in recovered_edges:
tree_edges.add(((i, j)))
tree_nodes = list(set(itertools.chain(*tree_edges)))
vfilt = g.new_vertex_property('bool')
vfilt.set_value(False)
for n in tree_nodes:
vfilt[n] = True
efilt = g.new_edge_property('bool')
for i, j in tree_edges:
efilt[g.edge(i, j)] = 1
return GraphView(g, efilt=efilt, vfilt=vfilt)
def test_fill_missing_time():
"""simple chain graph test
"""
g = Graph(directed=False)
g.add_vertex(4)
g.add_edge_list([(0, 1), (1, 2), (2, 3)])
t = GraphView(g, directed=True)
efilt = t.new_edge_property('bool')
efilt.a = True
efilt[t.edge(2, 3)] = False
t.set_edge_filter(efilt)
vfilt = t.new_vertex_property('bool')
vfilt.a = True
vfilt[3] = False
t.set_vertex_filter(vfilt)
root = 0
obs_nodes = {0, 2}
infection_times = [0, 1.5, 3, -1]
pt = fill_missing_time(g, t, root, obs_nodes, infection_times, debug=False)
for i in range(4):
assert pt[i] == infection_times[i]
def draw_community(gml_fn,
output,
layout_name=None,
layout_kwargs=dict(),
**draw_kwargs):
g = load_graph(gml_fn)
# Sampel of graph g
# g = GraphView(g, vfilt=lambda v: g.vertex_index[v]%2==0)
g.vp['wdeg'] = g.degree_property_map('total', weight=g.ep['weight'])
# g = GraphView(g, vfilt=lambda v: g.vp['wdeg'][v]>0)
# label for hub account only in each community
g.vp['clabel'] = g.new_vertex_property("string", val="")
for c in np.nditer(np.unique(g.vp['community'].a)):
cg = GraphView(g, vfilt=(g.vp['community'].a == c))
v_hub = find_vertex(cg, cg.vp['wdeg'], cg.vp['wdeg'].fa.max())[0]
cg.vp['clabel'][v_hub] = cg.vp['screenname'][v_hub]
v_size = prop_to_size(
g.vp['wdeg'],
mi=MIN_V_SIZE,
ma=MAX_V_SIZE,
log=V_SIZE_LOG,
power=V_SIZE_POWER)
e_width = prop_to_size(
g.ep['weight'],
mi=MIN_E_WIDTH,
ma=MAX_E_WIDTH,
log=E_WIDTH_LOG,
power=E_WIDTH_POWER)
if layout_name is not None:
try:
pos = globals()[layout_name](g, **layout_kwargs)
except KeyError as e:
logger.critical('No such layout function found!')
raise
graph_draw(
g,
pos,
output=output,
vprops=dict(
fill_color=g.vp['community'],
# color='grey',
size=v_size,
pen_width=0.01,
text=g.vp['clabel'],
text_position='centered',
font_size=8,),
eprops=dict(
pen_width=e_width,
end_marker="arrow",),
**draw_kwargs)
def fs_digraph_using_basic_properties(D, stats, options={'features': []}):
""""""
# at least one of these features needed to continue
if len([
f for f in ['degree', 'parallel_edges', 'fill']
if f in options['features']
]) == 0:
return
# feature: order
num_vertices = D.num_vertices()
log.debug('done order')
# feature: size
num_edges = D.num_edges()
log.debug('done size')
stats['n'] = num_vertices
stats['m'] = num_edges
# feature: mean_degree
if 'degree' in options['features']:
stats['mean_degree'] = float(2 * num_edges) / num_vertices
log.debug('done mean_degree')
# feature: fill_overall
if 'fill' in options['features']:
stats['fill_overall'] = float(num_edges) / (num_vertices *
num_vertices)
log.debug('done fill_overall')
if 'parallel_edges' in options['features'] or 'fill' in options['features']:
eprop = label_parallel_edges(D, mark_only=True)
PE = GraphView(D, efilt=eprop)
num_edges_PE = PE.num_edges()
stats['m_unique'] = num_edges - num_edges_PE
# feature: parallel_edges
if 'parallel_edges' in options['features']:
stats['parallel_edges'] = num_edges_PE
log.debug('done parallel_edges')
# feature: fill
if 'fill' in options['features']:
stats['fill'] = float(num_edges - num_edges_PE) / (num_vertices *
num_vertices)
log.debug('done fill')
def new_function(eptm, *args, **kwargs):
from .epithelium import Epithelium
from graph_tool import Graph, GraphView
local_graph = Graph(GraphView(eptm.graph,
vfilt=eptm.is_local_vert,
efilt=eptm.is_local_edge),
prune=True)
local_eptm = Epithelium(paramtree=eptm.paramtree, graph=local_graph)
# if local_eptm.at_boundary.fa.sum() > 0:
# local_eptm.rotate(np.pi)
# local_eptm.current_angle = np.pi
# print('rotated')
out = meth(local_eptm, *args, **kwargs)
# if not -1e-8 < local_eptm.current_angle < 1e-8:
# local_eptm.rotate(-local_eptm.current_angle)
# local_eptm.current_angle = 0.
# print( 'rotated back')
eptm.graph.set_vertex_filter(eptm.is_local_vert)
eptm.graph.set_edge_filter(eptm.is_local_edge)
for key, val in local_eptm.graph.vertex_properties.items():
eptm.graph.vertex_properties[key].fa = val.a
for key, val in local_eptm.graph.edge_properties.items():
eptm.graph.edge_properties[key].fa = val.a
eptm.graph.set_vertex_filter(None)
eptm.graph.set_edge_filter(None)
eptm.reset_topology()
return out
def get_steiner_tree(g, root, obs_nodes, debug=False, verbose=False):
gc, eweight, r2pred = build_closure(g, obs_nodes,
debug=debug, verbose=verbose)
tree_map = min_spanning_tree(gc, eweight, root=None)
tree = GraphView(gc, directed=False, efilt=tree_map)
tree_edges = set()
for e in tree.edges():
u, v = map(int, e)
for i, j in extract_edges_from_pred(g, u, v, r2pred[u]):
tree_edges.add((j, i))
# a bit involved...
und_tree = edges_to_directed_tree(g, root, tree_edges)
return build_minimum_tree(g, root, obs_nodes, extract_edges(und_tree))
def min_steiner_tree(g,
obs_nodes,
p=None,
return_type='tree',
debug=False,
verbose=False):
assert len(obs_nodes) > 0, 'no terminals'
if g.num_vertices() == len(obs_nodes):
print('it\'s a minimum spanning tree problem')
gc, eweight, r2pred = build_closure(g,
obs_nodes,
p=p,
debug=debug,
verbose=verbose)
# print('gc', gc)
tree_map = min_spanning_tree(gc, eweight, root=None)
tree = GraphView(gc, directed=False, efilt=tree_map)
tree_edges = set()
for e in tree.edges():
u, v = map(int, e)
recovered_edges = extract_edges_from_pred(u, v, r2pred[u])
assert recovered_edges, 'empty!'
for i, j in recovered_edges:
tree_edges.add((i, j))
tree_nodes = list(set(itertools.chain(*tree_edges)))
if return_type == 'nodes':
return tree_nodes
elif return_type == 'edges':
return list(map(edge2tuple, tree_edges))
elif return_type == 'tree':
vfilt = g.new_vertex_property('bool')
vfilt.set_value(False)
for n in tree_nodes:
vfilt[n] = True
efilt = g.new_edge_property('bool')
for i, j in tree_edges:
efilt[g.edge(i, j)] = 1
subg = GraphView(g, efilt=efilt, vfilt=vfilt, directed=False)
if p is not None:
weights = subg.new_edge_property('float')
for e in subg.edges():
weights[e] = p[e]
else:
weights = None
# remove cycles
tree_map = min_spanning_tree(subg, weights, root=None)
t = GraphView(g, directed=False, vfilt=vfilt, efilt=tree_map)
return t
def ratio_of_typed_subjects(D,
edge_labels=np.empty(0),
stats=dict(),
print_stats=False):
"""
(1) number of all different typed subjects
(2) ratio of typed subjects
"""
if edge_labels is None or edge_labels.size == 0:
edge_labels = np.array([D.ep.c0[p] for p in D.get_edges()])
# ae98476863dc6ec5 = http://www.w3.org/1999/02/22-rdf-syntax-ns#type
rdf_type = hash('ae98476863dc6ec5')
S_C_G = GraphView(D, efilt=edge_labels == rdf_type)
S_C_G = np.unique(S_C_G.get_edges()[:, 0])
if print_stats:
print("number of different typed subjects S^{C}_G: %s" % S_C_G.size)
S_G = GraphView(D, vfilt=D.get_out_degrees(D.get_vertices()))
if print_stats:
print("ratio of typed subjects r_T(G): %s" %
(float(S_C_G.size) / S_G.num_vertices()))
stats['typed_subjects'], stats['ratio_of_typed_subjects'] = S_C_G.size, (
float(S_C_G.size) / S_G.num_vertices())
return S_C_G
def f_pseudo_diameter( D, stats, options={ 'features': [] } ):
""""""
LC = label_largest_component(D)
LCD = GraphView( D, vfilt=LC )
if 'diameter' in options['features']:
if LCD.num_vertices() == 0 or LCD.num_vertices() == 1:
# if largest component does practically not exist, use the whole graph
dist, ends = pseudo_diameter(D)
else:
dist, ends = pseudo_diameter(LCD)
stats['pseudo_diameter']=dist
# D may be used in both cases
stats['pseudo_diameter_src_vertex']=D.vertex_properties['name'][ends[0]]
stats['pseudo_diameter_trg_vertex']=D.vertex_properties['name'][ends[1]]
log.debug( 'done pseudo_diameter' )
def get_steiner_tree(g, root, obs_nodes, debug=False, verbose=False):
gc, eweight, r2pred = build_closure(g,
obs_nodes,
debug=debug,
verbose=verbose)
tree_map = min_spanning_tree(gc, eweight, root=None)
tree = GraphView(gc, directed=False, efilt=tree_map)
tree_edges = set()
for e in tree.edges():
u, v = map(int, e)
for i, j in extract_edges_from_pred(g, u, v, r2pred[u]):
tree_edges.add((j, i))
# a bit involved...
und_tree = edges_to_directed_tree(g, root, tree_edges)
return build_minimum_tree(g, root, obs_nodes, extract_edges(und_tree))
def egonets(graph, direction):
egonets = dict()
for node in graph.vertices():
mask = graph.new_vertex_property("bool")
for u in node.out_neighbours():
mask[u] = True
mask[node] = True
label_node = graph.vertex_properties["name"][node]
egonets[label_node] = GraphView(graph, vfilt=mask)
return egonets
def egoNetwork(inGraph, node):
'''
Compute the ego-network subgraph of the -inGraph- where the ego is the -node-.
Precondition: inGraph is undirected
'''
neighbors = [int(n) for n in node.out_neighbours()]
neighborhood = inGraph.new_vertex_property("bool")
neighborhood.a[neighbors] = 1
neighborhood.a[int(node)] = 1
return GraphView(inGraph, vfilt=neighborhood)
def number_of_classes(D,
edge_labels=np.empty(0),
stats=dict(),
print_stats=False):
"""counts the number of different classes"""
if edge_labels is None or edge_labels.size == 0:
edge_labels = np.array([D.ep.c0[p] for p in D.get_edges()])
# ae98476863dc6ec5 = http://www.w3.org/1999/02/22-rdf-syntax-ns#type
rdf_type = hash('ae98476863dc6ec5')
C_G = GraphView(D, efilt=edge_labels == rdf_type)
C_G = np.unique(C_G.get_edges()[:, 1])
if print_stats:
print("number of different classes C_G: %s" % C_G.size)
stats['distinct_classes'] = C_G.size
return C_G
def produce_answer(entry, g, prune):
qc_fltr = g.new_vertex_property("bool")
qc_fltr = make_filter(g, entry.qc, qc_fltr)
qg = GraphView(g, qc_fltr)
qg = Graph(qg, prune=prune)
best_score = 0.0
answer = -1
for i, ac in enumerate(entry.ac):
ac_fltr = g.new_vertex_property("bool")
ac_fltr = None #make_filter(g, ac, ac_fltr)
ag = GraphView(g, ac_fltr)
ag = Graph(ag, prune=prune)
score = reason_over_paths(qg, ag)
if score > best_score:
best_score = score
answer = i
del ac_fltr
del qc_fltr
return answer
def observe_cascade(c,
source,
q,
method='uniform',
tree=None,
source_includable=False):
"""
given a cascade `c` and `source`,
return a list of observed nodes according to probability `q`
"""
all_infection = np.nonzero(c != -1)[0]
if not source_includable:
all_infection = list(set(all_infection) - {source})
num_obs = int(math.ceil(len(all_infection) * q))
if num_obs < 2:
num_obs = 2
if method == 'uniform':
return np.random.permutation(all_infection)[:num_obs]
elif method == 'late':
return np.argsort(c)[-num_obs:]
elif method == 'leaves':
assert tree is not None, 'to get the leaves, the cascade tree is required'
# extract_steiner_tree(tree, )
nodes_in_order = reverse_bfs(tree)
return nodes_in_order[:num_obs]
elif method == 'bfs-head':
assert tree is not None, 'the cascade tree is required'
vis = BFSNodeCollector()
bfs_search(GraphView(tree, directed=False), source, vis)
sampling_weights_by_order
vis.nodes_in_order
return vis.nodes_in_order[:num_obs] # head
elif method == 'bfs-tail':
assert tree is not None, 'the cascade tree is required'
vis = BFSNodeCollector()
bfs_search(GraphView(tree, directed=False), source, vis)
return vis.nodes_in_order[-num_obs:] # tail
else:
raise ValueError('unknown method {}'.format(method))
def is_order_respected(tree, root, obs_nodes, infection_times):
tree = GraphView(tree)
obs_set = set(obs_nodes)
vfilt = tree.new_vertex_property('bool')
vfilt.a = True
tree.set_vertex_filter(vfilt)
leaves = [o for o in obs_nodes if tree.vertex(o).out_degree() == 0]
vis = init_visitor(tree, root)
pbfs_search(tree, root, terminals=leaves, visitor=vis, count_threshold=-1)
for l in leaves:
edges = extract_edges_from_pred(tree, root, l, vis.pred)
edges = edges[::-1]
path = list(edges[0]) + [u for _, u in edges[1:]]
useful_nodes_on_path = [v for v in path if v in obs_set]
for i in range(len(useful_nodes_on_path)-1):
u, v = useful_nodes_on_path[i: i+2]
if infection_times[u] > infection_times[v]:
return False
return True
def global_clustering_binary_undirected(g):
'''
Returns the undirected global clustering coefficient.
This corresponds to the ratio of undirected triangles to the number of
undirected triads.
Parameters
----------
g : :class:`~nngt.Graph`
Graph to analyze.
References
----------
.. [gt-global-clustering] :gtdoc:`clustering.global_clustering`
'''
# use undirected graph view, filter parallel edges
u = GraphView(g.graph, directed=False)
u = GraphView(u, efilt=label_parallel_edges(u).fa == 0)
return gtc.global_clustering(u, weight=None)[0]
def solve(g):
if g.num_vertices() == 0:
W0 = self.pg.new_vertex_property("bool")
W1 = self.pg.new_vertex_property("bool")
return {0: W0, 1: W1}
else:
p = self.maxparity(g)
i = p % 2
U = self.vertices_with_priority(g, p)
A = self.attractor(U, i) # get i attractor of U in g
WW = solve(GraphView(g, vfilt=self.complement(A)))
#if WW[1-i].ma.all(): ## does not work
gg = GraphView(g, vfilt=WW[1 - i]) # just to check emptiness
if gg.num_vertices() == 0:
res = {}
res[i] = self.maskplus(g, WW[i], A)
res[1 - i] = WW[1 - i]
return res
else:
B = self.attractor(WW[1 - i], 1 - i)
gg = GraphView(g, vfilt=self.complement(B))
WW = solve(gg)
res = {}
res[i] = WW[i]
res[1 - i] = self.maskplus(g, WW[1 - i], B)
return res
def save(self, file_name, fmt="auto"):
""" overload Graph.save to make output dotfiles pretty.
This is entirely cosmetic. """
u = self
# add some properties to prettify dot output
if fmt is "dot" or fmt is "auto" and file_name.endswith(".dot"):
u = GraphView(self)
# add shape property according to vertex owners
shape = u.new_vertex_property("string")
for v in u.vertices():
if u.vp.owner[v] == 1:
shape[v] = "box"
else:
shape[v] = "diamond"
u.vp.shape = shape
# add label property according to priorities
#u.vertex_properties['label'] = u.vertex_properties['priority']
label = u.new_vertex_property("string")
for v in u.vertices():
prio = u.vertex_properties['priority'][v]
name = u.vertex_index[v]
label[v] = "%d (%d)" % (name, prio)
u.vp.label = label
Graph.save(u, file_name, fmt)
def is_tree(tree):
# is tree?
l, _ = label_components(GraphView(tree, directed=False))
if not np.all(np.array(l.a) == 0):
print('not connected')
print(np.array(l.a))
return False
if tree.num_edges() != (tree.num_vertices() - 1):
print('n. edges != n. nodes - 1')
return False
return True
def get(self, args):
from depth_first_searcher import dfs_search_with_limit
root = int(args["root"])
limit = int(args["limit"])
vertices = dfs_search_with_limit(graph, graph.vertex(root), limit)
v_filter = graph.new_vertex_property('bool')
for v in vertices:
v_filter[v] = True
subgraph = GraphView(graph, v_filter)
from graph_tool.stats import remove_parallel_edges
remove_parallel_edges(subgraph)
subgraph = self.set_properties(subgraph)
from graph_json_builder import create_json_graph
return create_json_graph(subgraph)
def repeated_predicate_lists(D,
edge_labels=np.empty(0),
stats=dict(),
print_stats=False,
return_collected=True):
""""""
if edge_labels is None or edge_labels.size == 0:
edge_labels = [D.ep.c0[p] for p in D.get_edges()]
# filter those vertices v | out-degree(v) > 0
S = GraphView(D, vfilt=D.get_out_degrees(D.get_vertices()))
# .. is defined as the ratio of repeated predicate lists from the total lists in the graph G
df = pd.DataFrame(data=list(zip(D.get_edges()[:, 0], edge_labels)),
index=np.arange(0,
D.get_edges().shape[0]),
columns=np.arange(0,
D.get_edges().shape[1]))
df = df.groupby(0)[1].apply(tuple).apply(hash).to_frame().reset_index()
if return_collected:
df = df.groupby(1).count()[0]
if print_stats:
print("(Eq.17) ratio of repeated predicate lists r_L(G): %f" %
(1 - (df.size / S.num_vertices())))
print(
"(Eq.18/19) predicate list degree deg_{PL}(G). max: %f, mean: %f"
% (df.max(), df.mean()))
stats['repeated_predicate_lists'] = 1 - (df.size / S.num_vertices())
stats['max_predicate_list_degree'], stats[
'mean_predicate_list_degree'] = df.max(), df.mean()
return df
def sample_graph_by_p(g, p):
"""
for IC model
graph_tool version of sampling a graph
mask the edge according to probability p and return the masked graph
g: the graph
p: float or np.array
"""
if isinstance(p, PropertyMap):
p = p.a
flags = (np.random.random(p.shape) <= p)
p = g.new_edge_property('bool')
p.set_2d_array(flags)
return GraphView(g, efilt=p)
def remove_filters(g):
"""
remove all filters and add filter with all entries on
so that we won't get null vertex_filter or edge_filter
"""
efilt = g.new_edge_property('bool')
efilt.a = True
vfilt = g.new_vertex_property('bool')
vfilt.a = True
# print('making GraphView started')
gv = GraphView(g, efilt=efilt, vfilt=vfilt, directed=g.is_directed())
# print('making GraphView done')
return gv
def filter_graph_by_edges(g, edges):
"""returns GraphView
"""
efilt = g.new_edge_property('bool')
efilt.set_value(False)
for i, j in edges:
efilt[g.edge(i, j)] = True
vfilt = g.new_vertex_property('bool')
vfilt.set_value(False)
for e in edges:
for u in e:
vfilt[u] = True
return GraphView(g, efilt=efilt, vfilt=vfilt)
def get_subgraph(self, vertices, genes=False):
r'''
Return the subgraph of self induced by the given vertices.
Args:
vertices: a set of vertex IDs (or a set of genes)
genes: a boolean with value `True` if `vertices` is a set of genes
and `False` if it is a set of vertex IDs.
Returns:
:math:`\Delta_{\text{vertices}}(G)`
'''
if genes:
vertices = self.verts_id(vertices)
filt = self.G.new_vertex_property('bool')
filt.a[vertices] = True
return GraphView(self.G, vfilt=filt)
def is_arborescence(tree):
# is tree?
l, _ = label_components(GraphView(tree, directed=False))
if not np.all(np.array(l.a) == 0):
print('not connected')
print(np.array(l.a))
return False
in_degs = np.array([v.in_degree() for v in tree.vertices()])
if in_degs.max() > 1:
print('in_degree.max() > 1')
return False
if np.sum(in_degs == 1) != (tree.num_vertices() - 1):
print('should be: only root has no parent')
return False
roots = get_roots(tree)
assert len(roots) == 1, '>1 roots'
return True
def is_tree(t):
# to undirected
t = GraphView(t, directed=False)
# num nodes = num edges+1
if t.num_vertices() != (t.num_edges() + 1):
return False
# all nodes have degree > 0
vs = list(map(int, t.vertices()))
degs = t.degree_property_map('out').a[vs]
if np.all(degs > 0) == 0:
return False
return True
def extract_tree(g, source, pred, terminals=None):
"""return a tree from source to terminals based on `pred`"""
edges = set()
if terminals:
visited = set()
for t in sorted(terminals):
c = t
while c != source and c not in visited:
visited.add(c)
if pred[c] != -1:
edges.add((pred[c], c))
c = pred[c]
else:
break
else:
for c, p in enumerate(pred.a):
if p != -1:
edges.add((c, p))
efilt = g.new_edge_property('bool')
for u, v in edges:
efilt[g.edge(g.vertex(u), g.vertex(v))] = 1
return GraphView(g, efilt=efilt)
def minimum_spanning_tree(self,
distance,
write=False,
write_property=None):
"""Compute the minimum spanning tree.
Parameters
----------
distance : str
Distance to minimize when computing the minimum spanning tree
(MST)
write : bool, optional
Flag indicating whether the MST should be returned as
a new graph
object or saved within a Boolean edge property being True whenever
a given edge belongs to the MST.
write_property : str, optional
Edge property name for marking edges beloning to the MST.
Returns
-------
tree : nx.Graph
The minimum spanning tree graph object
"""
mst_property = min_spanning_tree(self.graph,
weights=self.graph.ep[distance])
if write:
if write_property is None:
raise PathFinder.PathSearchException(
"The minimum spanning tree finder has the write option set "
"to True, the write property name must be specified")
self.graph.ep[write_property] = mst_property
else:
tree = GraphView(self.graph, efilt=mst_property)
return tree
def is_order_respected(tree, root, obs_nodes, infection_times):
tree = GraphView(tree)
obs_set = set(obs_nodes)
vfilt = tree.new_vertex_property('bool')
vfilt.a = True
tree.set_vertex_filter(vfilt)
leaves = [o for o in obs_nodes if tree.vertex(o).out_degree() == 0]
vis = init_visitor(tree, root)
pbfs_search(tree, root, terminals=leaves, visitor=vis, count_threshold=-1)
for l in leaves:
edges = extract_edges_from_pred(tree, root, l, vis.pred)
edges = edges[::-1]
path = list(edges[0]) + [u for _, u in edges[1:]]
useful_nodes_on_path = [v for v in path if v in obs_set]
for i in range(len(useful_nodes_on_path)-1):
u, v = useful_nodes_on_path[i: i+2]
if infection_times[u] > infection_times[v]:
return False
return True