def is_triangle_free(G):
"""Returns True if *G* is triangle-free, and False otherwise.
A graph is *triangle-free* if it contains no induced subgraph isomorphic to
the complete graph on 3 vertices.
Parameters
----------
G : NetworkX graph
An undirected graph.
Returns
-------
boolean
True if G is triangle-free, False otherwise.
Examples
--------
>>> G = gp.complete_graph(4)
>>> gp.is_triangle_free(G)
False
>>> G = gp.cycle_graph(5)
>> gp.is_triangle_free(G)
True
"""
# define a triangle graph, also known as the complete graph K_3
triangle = gp.complete_graph(3)
# enumerate over all possible combinations of 3 vertices contained in G
for S in set(itertools.combinations(G.nodes(), 3)):
H = G.subgraph(list(S))
if gp.is_isomorphic(H, triangle):
return False
# if the above loop completes, the graph is triangle free
return True
def test_contracting_two_nodes(self):
G = gp.complete_graph(3)
gp.contract_nodes(G, [0, 1])
assert G.has_node(0) == True
assert G.has_node(2) == True
assert G.has_node(1) == False
assert G.has_edge(0, 2) == True
assert G.has_edge(0, 1) == False
assert G.has_edge(1, 2) == False
def test_contracting_single_node_does_not_change_graph(self):
G = gp.complete_graph(3)
gp.contract_nodes(G, 0)
assert G.has_node(0) == True
assert G.has_node(2) == True
assert G.has_node(1) == True
assert G.has_edge(0, 2) == True
assert G.has_edge(0, 1) == True
assert G.has_edge(1, 2) == True
def graph_property_check(G, property):
if property == "is_planar":
return gp.check_planarity(G)[0]
elif property == "is_regular":
return gp.min_degree(G) == gp.max_degree(G)
elif property == "is_cubic":
return gp.min_degree(G) == 3 and gp.max_degree(G) == 3
elif property == "is_not_K_n":
return gp.is_isomorphic(G, gp.complete_graph(gp.number_of_nodes(G))) == False
elif property == "is_triangle_free":
return set(gp.triangles(G).values()) == {0}
else:
return getattr(gp, property)(G)
def test_elimination_sequence_of_complete_graph(self):
G = gp.complete_graph(5)
assert gp.elimination_sequence(G) == [4, 3, 2, 1, 0]
def test_common_neighbors_of_pair_of_nodes_in_K3_is_third_node(self):
G = gp.complete_graph(3)
assert gp.common_neighbors(G, [0, 1]) == [2]
def test_chromatic_number_of_complete_graph_is_order():
for i in range(1, 11):
G = gp.complete_graph(i)
assert (gp.chromatic_number(G, method='ram-rama') == G.order())
assert (gp.chromatic_number(G, method='ilp') == G.order())
def test_sub_2_domination_number_of_complete_graph(self):
for i in range(1, 10):
G = gp.complete_graph(i)
n = G.order()
val = n / (1 + (0.5 * (n - 1)))
assert gp.sub_k_domination_number(G, 2) == ceil(val)
def test_annihilation_number_of_complete_graph_is_half_of_nodes(self):
for i in range(2, 11):
G = gp.complete_graph(i)
assert gp.annihilation_number(G) == floor(G.order() / 2)
def test_K4_is_not_triangle_free(self):
G = gp.complete_graph(4)
assert gp.is_triangle_free(G) == False
def test_common_neighbors_of_single_node_in_K3_is_other_two_nodes(self):
G = gp.complete_graph(3)
assert gp.common_neighbors(G, [0]) == [1, 2]
def test_power_domination_number_of_complete_graph_is_1(self):
for i in range(1, 11):
G = gp.complete_graph(i)
assert gp.power_domination_number(G) == 1
def test_2_independence_number_of_complete_graph_is_2():
for i in range(2, 11):
G = gp.complete_graph(i)
assert gp.k_independence_number(G, 2) == 2
def test_residue_of_complete_graph_is_1(self):
for i in range(1, 11):
G = gp.complete_graph(i)
assert gp.residue(G) == 1
def test_2_residue_of_complete_graph_is_three_halves(self):
for i in range(3, 13):
G = gp.complete_graph(i)
assert gp.k_residue(G, 2) == 1.5
def test_K5_is_complete_graph(self):
G = gp.complete_graph(5)
assert gp.is_complete_graph(G) == True
def test_K4_is_claw_free(self):
G = gp.complete_graph(4)
assert gp.is_claw_free(G) == True
def test_bull_is_not_bull_free(self):
G = gp.complete_graph(3)
G.add_edge(1, 3)
G.add_edge(2, 4)
assert gp.is_bull_free(G) == False
def test_independence_number_of_complete_graph_is_1():
for i in range(1, 13):
G = gp.complete_graph(i)
assert gp.independence_number(G, method="bf") == 1
assert gp.independence_number(G, method="ilp") == 1
def test_process_of_compete_graph(self):
G = gp.complete_graph(4)
hh = gp.HavelHakimi(gp.degree_sequence(G))
p = [[3, 3, 3, 3], [2, 2, 2], [1, 1], [0]]
assert hh.get_process() == p
def test_vertex_cover_number_of_K4_is_3():
G = gp.complete_graph(4)
assert gp.vertex_cover_number(G) == 3
def test_elimination_sequence_of_complete_graph(self):
G = gp.complete_graph(4)
hh = gp.HavelHakimi(gp.degree_sequence(G))
e = [3, 2, 1, 0]
assert hh.get_elimination_sequence() == e
def test_initial_sequence(self):
G = gp.complete_graph(4)
hh = gp.HavelHakimi(gp.degree_sequence(G))
assert hh.get_initial_sequence() == [3, 3, 3, 3]
def test_depth_of_complete_graph_is_order_minus_1(self):
for i in range(2, 12):
G = gp.complete_graph(i)
hh = gp.HavelHakimi(gp.degree_sequence(G))
assert hh.depth() == G.order() - 1
def test_slater_of_complete_graph_is_1(self):
for i in range(1, 10):
G = gp.complete_graph(i)
assert gp.slater(G) == 1
class TestTopologicalIndices:
@pytest.mark.parametrize(
"graph, expected_value",
((gp.path_graph(2), 1**-0.5), (gp.cycle_graph(3), 1.5),
(gp.cycle_graph(4), 2), (gp.cycle_graph(5), 2.5)),
)
def test_randic_index(self, graph, expected_value):
"""Ensure randic_index returns the expected value for a given graph"""
assert gp.randic_index(graph) == expected_value
@pytest.mark.parametrize(
"graph, k, expected_value",
(
(gp.path_graph(2), -0.5, 1**-0.5),
(gp.cycle_graph(3), -0.5, 1.5),
(gp.cycle_graph(4), -0.5, 2),
(gp.cycle_graph(5), -0.5, 2.5),
),
)
def test_generalized_randic_index(self, graph, k, expected_value):
"""Ensure randic_index returns the expected value for a given graph"""
assert gp.generalized_randic_index(graph, k) == expected_value
@pytest.mark.parametrize("graph, expected_value",
((gp.path_graph(2), 1), (gp.cycle_graph(3), 1.5),
(gp.complete_graph(4), 2)))
def test_augmented_randic_index(self, graph, expected_value):
"""Ensure augmented_randic_index returns the expected value for a given graph"""
assert gp.augmented_randic_index(graph) == expected_value
@pytest.mark.parametrize("graph, expected_value",
((gp.path_graph(2), 1), (gp.cycle_graph(3), 1.5),
(gp.complete_graph(4), 2)))
def test_harmonic_index(self, graph, expected_value):
"""Ensure augmented_randic_index returns the expected value for a given graph"""
assert gp.harmonic_index(graph) == expected_value
@pytest.mark.parametrize(
"graph, expected_value",
((gp.path_graph(2), 0), (gp.cycle_graph(3), 3 * math.sqrt(2) / 2),
(gp.complete_graph(4), 4.0)),
)
def test_atom_bond_connectivity_index(self, graph, expected_value):
"""Ensure augmented_randic_index returns the expected value for a given graph"""
assert gp.atom_bond_connectivity_index(graph) == expected_value
@pytest.mark.parametrize(
"graph, expected_value",
((gp.path_graph(2), 1 / math.sqrt(2)), (gp.cycle_graph(3), 1.5),
(gp.complete_graph(4), 6 / math.sqrt(6))),
)
def test_sum_connectivity_index(self, graph, expected_value):
"""Ensure augmented_randic_index returns the expected value for a given graph"""
assert gp.sum_connectivity_index(graph) == expected_value
@pytest.mark.parametrize("graph, expected_value",
((gp.path_graph(2), 2.0),
(gp.cycle_graph(3), 12.0),
(gp.complete_graph(4), 36.0)))
def test_first_zagreb_index(self, graph, expected_value):
"""Ensure augmented_randic_index returns the expected value for a given graph"""
assert gp.first_zagreb_index(graph) == expected_value
@pytest.mark.parametrize("graph, expected_value",
((gp.path_graph(2), 1.0),
(gp.cycle_graph(3), 12.0),
(gp.complete_graph(4), 54.0)))
def test_second_zagreb_index(self, graph, expected_value):
"""Ensure augmented_randic_index returns the expected value for a given graph"""
assert gp.second_zagreb_index(graph) == expected_value
def test_sub_total_domination_number_of_complete_graph_is_2(self):
for i in range(2, 10):
G = gp.complete_graph(i)
assert gp.sub_total_domination_number(G) == 2
def test_irregularity_complete_graph(self):
for i in range(2, 10):
G = gp.complete_graph(i)
assert gp.irregularity(G) == 1.0
def test_clique_number_of_complete_graph_is_order(self):
for i in range(1, 11):
G = gp.complete_graph(i)
assert gp.clique_number(G) == G.order()
def test_chromatic_number_of_complete_graph_is_order():
for i in range(1, 11):
G = gp.complete_graph(i)
assert gp.chromatic_number(G, method="ram-rama") == G.order()
assert gp.chromatic_number(G, method="ilp") == G.order()
