:: GLIB_002 semantic presentation

registration
let X be finite set ;
cluster bool a1 -> finite ;
coherence
bool X is finite
by FINSET_1:24;
end;

theorem Th1: :: GLIB_002:1
for X being finite set st 1 < card X holds
ex x1, x2 being set st
( x1 in X & x2 in X & x1 <> x2 )
proof end;

definition
let G be _Graph;
attr a1 is connected means :Def1: :: GLIB_002:def 1
for u, v being Vertex of G ex W being Walk of G st W is_Walk_from u,v;
end;

:: deftheorem Def1 defines connected GLIB_002:def 1 :
for G being _Graph holds
( G is connected iff for u, v being Vertex of G ex W being Walk of G st W is_Walk_from u,v );

definition
let G be _Graph;
attr a1 is acyclic means :Def2: :: GLIB_002:def 2
for W being Walk of G holds not W is Cycle-like;
end;

:: deftheorem Def2 defines acyclic GLIB_002:def 2 :
for G being _Graph holds
( G is acyclic iff for W being Walk of G holds not W is Cycle-like );

definition
let G be _Graph;
attr a1 is Tree-like means :Def3: :: GLIB_002:def 3
( G is acyclic & G is connected );
end;

:: deftheorem Def3 defines Tree-like GLIB_002:def 3 :
for G being _Graph holds
( G is Tree-like iff ( G is acyclic & G is connected ) );

registration
cluster trivial -> connected GraphStruct ;
coherence
for b1 being _Graph st b1 is trivial holds
b1 is connected
proof end;
end;

registration
cluster loopless trivial -> Tree-like GraphStruct ;
coherence
for b1 being _Graph st b1 is trivial & b1 is loopless holds
b1 is Tree-like
proof end;
end;

registration
cluster acyclic -> simple GraphStruct ;
coherence
for b1 being _Graph st b1 is acyclic holds
b1 is simple
proof end;
end;

registration
cluster Tree-like -> simple connected acyclic GraphStruct ;
coherence
for b1 being _Graph st b1 is Tree-like holds
( b1 is acyclic & b1 is connected )
by ;
end;

registration
cluster connected acyclic -> simple connected acyclic Tree-like GraphStruct ;
coherence
for b1 being _Graph st b1 is acyclic & b1 is connected holds
b1 is Tree-like
by ;
end;

registration
let G be _Graph;
let v be Vertex of G;
cluster -> Tree-like inducedSubgraph of a1,{a2}, {} ;
coherence
for b1 being inducedSubgraph of G,{v}, {} holds b1 is Tree-like
;
end;

definition
let G be _Graph;
let v be set ;
pred c1 is_DTree_rooted_at c2 means :Def4: :: GLIB_002:def 4
( G is Tree-like & ( for x being Vertex of G ex W being DWalk of G st W is_Walk_from v,x ) );
end;

:: deftheorem Def4 defines is_DTree_rooted_at GLIB_002:def 4 :
for G being _Graph
for v being set holds
( G is_DTree_rooted_at v iff ( G is Tree-like & ( for x being Vertex of G ex W being DWalk of G st W is_Walk_from v,x ) ) );

registration
cluster finite trivial simple connected acyclic Tree-like GraphStruct ;
existence
ex b1 being _Graph st
( b1 is trivial & b1 is finite & b1 is Tree-like )
proof end;
cluster finite non trivial simple connected acyclic Tree-like GraphStruct ;
existence
ex b1 being _Graph st
( not b1 is trivial & b1 is finite & b1 is Tree-like )
proof end;
end;

registration
let G be _Graph;
cluster finite trivial simple connected acyclic Tree-like Subgraph of a1;
existence
ex b1 being Subgraph of G st
( b1 is trivial & b1 is finite & b1 is Tree-like )
proof end;
end;

registration
let G be acyclic _Graph;
cluster -> acyclic Subgraph of a1;
coherence
for b1 being Subgraph of G holds b1 is acyclic
proof end;
end;

definition
let G be _Graph;
let v be Vertex of G;
func c1 .reachableFrom c2 -> non empty Subset of (the_Vertices_of a1) means :Def5: :: GLIB_002:def 5
for x being set holds
( x in it iff ex W being Walk of G st W is_Walk_from v,x );
existence
ex b1 being non empty Subset of (the_Vertices_of G) st
for x being set holds
( x in b1 iff ex W being Walk of G st W is_Walk_from v,x )
proof end;
uniqueness
for b1, b2 being non empty Subset of (the_Vertices_of G) st ( for x being set holds
( x in b1 iff ex W being Walk of G st W is_Walk_from v,x ) ) & ( for x being set holds
( x in b2 iff ex W being Walk of G st W is_Walk_from v,x ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def5 defines .reachableFrom GLIB_002:def 5 :
for G being _Graph
for v being Vertex of G
for b3 being non empty Subset of (the_Vertices_of G) holds
( b3 = G .reachableFrom v iff for x being set holds
( x in b3 iff ex W being Walk of G st W is_Walk_from v,x ) );

definition
let G be _Graph;
let v be Vertex of G;
func c1 .reachableDFrom c2 -> non empty Subset of (the_Vertices_of a1) means :Def6: :: GLIB_002:def 6
for x being set holds
( x in it iff ex W being DWalk of G st W is_Walk_from v,x );
existence
ex b1 being non empty Subset of (the_Vertices_of G) st
for x being set holds
( x in b1 iff ex W being DWalk of G st W is_Walk_from v,x )
proof end;
uniqueness
for b1, b2 being non empty Subset of (the_Vertices_of G) st ( for x being set holds
( x in b1 iff ex W being DWalk of G st W is_Walk_from v,x ) ) & ( for x being set holds
( x in b2 iff ex W being DWalk of G st W is_Walk_from v,x ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def6 defines .reachableDFrom GLIB_002:def 6 :
for G being _Graph
for v being Vertex of G
for b3 being non empty Subset of (the_Vertices_of G) holds
( b3 = G .reachableDFrom v iff for x being set holds
( x in b3 iff ex W being DWalk of G st W is_Walk_from v,x ) );

Lemma91: for G being _Graph
for v being Vertex of G holds v in G .reachableFrom v
proof end;

Lemma92: for G being _Graph
for v1 being Vertex of G
for e, x, y being set st x in G .reachableFrom v1 & e Joins x,y,G holds
y in G .reachableFrom v1
proof end;

Lemma95: for G being _Graph
for v1, v2 being Vertex of G st v1 in G .reachableFrom v2 holds
G .reachableFrom v1 = G .reachableFrom v2
proof end;

Lemma98: for G being _Graph
for W being Walk of G
for v being Vertex of G st v in W .vertices() holds
W .vertices() c= G .reachableFrom v
proof end;

definition
let G1 be _Graph;
let G2 be Subgraph of G1;
attr a2 is Component-like means :Def7: :: GLIB_002:def 7
( G2 is connected & ( for G3 being connected Subgraph of G1 holds not G2 c< G3 ) );
end;

:: deftheorem Def7 defines Component-like GLIB_002:def 7 :
for G1 being _Graph
for G2 being Subgraph of G1 holds
( G2 is Component-like iff ( G2 is connected & ( for G3 being connected Subgraph of G1 holds not G2 c< G3 ) ) );

registration
let G be _Graph;
cluster Component-like -> connected Subgraph of a1;
coherence
for b1 being Subgraph of G st b1 is Component-like holds
b1 is connected
by ;
end;

registration
let G be _Graph;
let v be Vertex of G;
cluster -> connected Component-like inducedSubgraph of a1,a1 .reachableFrom a2,a1 .edgesBetween (a1 .reachableFrom a2);
coherence
for b1 being inducedSubgraph of G,(G .reachableFrom v) holds b1 is Component-like
proof end;
end;

registration
let G be _Graph;
cluster connected Component-like Subgraph of a1;
existence
ex b1 being Subgraph of G st b1 is Component-like
proof end;
end;

definition
let G be _Graph;
mode Component of a1 is Component-like Subgraph of a1;
end;

definition
let G be _Graph;
func c1 .componentSet() -> non empty Subset-Family of (the_Vertices_of a1) means :Def8: :: GLIB_002:def 8
for x being set holds
( x in it iff ex v being Vertex of G st x = G .reachableFrom v );
existence
ex b1 being non empty Subset-Family of (the_Vertices_of G) st
for x being set holds
( x in b1 iff ex v being Vertex of G st x = G .reachableFrom v )
proof end;
uniqueness
for b1, b2 being non empty Subset-Family of (the_Vertices_of G) st ( for x being set holds
( x in b1 iff ex v being Vertex of G st x = G .reachableFrom v ) ) & ( for x being set holds
( x in b2 iff ex v being Vertex of G st x = G .reachableFrom v ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def8 defines .componentSet() GLIB_002:def 8 :
for G being _Graph
for b2 being non empty Subset-Family of (the_Vertices_of G) holds
( b2 = G .componentSet() iff for x being set holds
( x in b2 iff ex v being Vertex of G st x = G .reachableFrom v ) );

registration
let G be _Graph;
let X be Element of G .componentSet() ;
cluster -> connected Component-like inducedSubgraph of a1,a2,a1 .edgesBetween a2;
coherence
for b1 being inducedSubgraph of G,X holds b1 is Component-like
proof end;
end;

definition
let G be _Graph;
func c1 .numComponents() -> Cardinal equals :: GLIB_002:def 9
Card (G .componentSet() );
coherence
Card (G .componentSet() ) is Cardinal
;
end;

:: deftheorem Def9 defines .numComponents() GLIB_002:def 9 :
for G being _Graph holds G .numComponents() = Card (G .componentSet() );

definition
let G be finite _Graph;
redefine func .numComponents() as c1 .numComponents() -> non empty Element of NAT ;
coherence
G .numComponents() is non empty Element of NAT
proof end;
end;

definition
let G be _Graph;
let v be Vertex of G;
attr a2 is cut-vertex means :Def10: :: GLIB_002:def 10
for G2 being removeVertex of G,v holds G .numComponents() <` G2 .numComponents() ;
end;

:: deftheorem Def10 defines cut-vertex GLIB_002:def 10 :
for G being _Graph
for v being Vertex of G holds
( v is cut-vertex iff for G2 being removeVertex of G,v holds G .numComponents() <` G2 .numComponents() );

definition
let G be finite _Graph;
let v be Vertex of G;
redefine attr a2 is cut-vertex means :Def11: :: GLIB_002:def 11
for G2 being removeVertex of G,v holds G .numComponents() < G2 .numComponents() ;
compatibility
( v is cut-vertex iff for G2 being removeVertex of G,v holds G .numComponents() < G2 .numComponents() )
proof end;
end;

:: deftheorem Def11 defines cut-vertex GLIB_002:def 11 :
for G being finite _Graph
for v being Vertex of G holds
( v is cut-vertex iff for G2 being removeVertex of G,v holds G .numComponents() < G2 .numComponents() );

Lemma109: for G1 being non trivial connected _Graph
for v being Vertex of G1
for G2 being removeVertex of G1,v st v is endvertex holds
G2 is connected
proof end;

Lemma124: for G being _Graph st ex v1 being Vertex of G st
for v2 being Vertex of G ex W being Walk of G st W is_Walk_from v1,v2 holds
G is connected
proof end;

Lemma125: for G being _Graph st ex v being Vertex of G st G .reachableFrom v = the_Vertices_of G holds
G is connected
proof end;

Lemma126: for G being _Graph st G is connected holds
for v being Vertex of G holds G .reachableFrom v = the_Vertices_of G
proof end;

Lemma127: for G1, G2 being _Graph
for v1 being Vertex of G1
for v2 being Vertex of G2 st G1 == G2 & v1 = v2 holds
G1 .reachableFrom v1 = G2 .reachableFrom v2
proof end;

Lemma128: for G1 being _Graph
for G2 being connected Subgraph of G1 st G2 is spanning holds
G1 is connected
proof end;

Lemma131: for G being _Graph holds
( G is connected iff G .componentSet() = {(the_Vertices_of G)} )
proof end;

Lemma132: for G1, G2 being _Graph st G1 == G2 holds
G1 .componentSet() = G2 .componentSet()
proof end;

Lemma133: for G being _Graph
for x being set st x in G .componentSet() holds
x is non empty Subset of (the_Vertices_of G)
proof end;

Lemma134: for G being _Graph
for C being Component of G holds the_Edges_of C = G .edgesBetween (the_Vertices_of C)
proof end;

Lemma139: for G being _Graph
for C1, C2 being Component of G holds
( the_Vertices_of C1 = the_Vertices_of C2 iff C1 == C2 )
proof end;

Lemma142: for G being _Graph
for C being Component of G
for v being Vertex of G holds
( v in the_Vertices_of C iff the_Vertices_of C = G .reachableFrom v )
proof end;

Lemma146: for G being _Graph
for C1, C2 being Component of G
for v being set st v in the_Vertices_of C1 & v in the_Vertices_of C2 holds
C1 == C2
proof end;

Lemma147: for G being _Graph holds
( G is connected iff G .numComponents() = 1 )
proof end;

Lemma149: for G1, G2 being _Graph st G1 == G2 holds
G1 .numComponents() = G2 .numComponents()
by ;

Lemma150: for G being connected _Graph
for v being Vertex of G holds
( not v is cut-vertex iff for G2 being removeVertex of G,v holds G2 .numComponents() <=` G .numComponents() )
proof end;

Lemma151: for G being connected _Graph
for v being Vertex of G
for G2 being removeVertex of G,v st not v is cut-vertex holds
G2 is connected
proof end;

Lemma152: for G being finite non trivial connected _Graph ex v1, v2 being Vertex of G st
( v1 <> v2 & not v1 is cut-vertex & not v2 is cut-vertex )
proof end;

registration
let G be finite non trivial connected _Graph;
cluster non cut-vertex Element of the_Vertices_of a1;
existence
not for b1 being Vertex of G holds b1 is cut-vertex
proof end;
end;

Lemma274: for G being acyclic _Graph
for W being Path of G
for e being set st not e in W .edges() & e in (W .last() ) .edgesInOut() holds
W .addEdge e is Path-like
proof end;

Lemma277: for G being finite non trivial acyclic _Graph st the_Edges_of G <> {} holds
ex v1, v2 being Vertex of G st
( v1 <> v2 & v1 is endvertex & v2 is endvertex & v2 in G .reachableFrom v1 )
proof end;

Lemma281: for G being finite non trivial Tree-like _Graph ex v1, v2 being Vertex of G st
( v1 <> v2 & v1 is endvertex & v2 is endvertex )
proof end;

registration
let G be finite non trivial Tree-like _Graph;
cluster endvertex Element of the_Vertices_of a1;
existence
ex b1 being Vertex of G st b1 is endvertex
proof end;
end;

registration
let G be finite non trivial Tree-like _Graph;
let v be endvertex Vertex of G;
cluster -> acyclic Tree-like inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2});
coherence
for b1 being removeVertex of G,v holds b1 is Tree-like
proof end;
end;

definition
let GSq be GraphSeq;
attr a1 is connected means :Def12: :: GLIB_002:def 12
for n being Nat holds GSq . n is connected;
attr a1 is acyclic means :Def13: :: GLIB_002:def 13
for n being Nat holds GSq . n is acyclic;
attr a1 is Tree-like means :Def14: :: GLIB_002:def 14
for n being Nat holds GSq . n is Tree-like;
end;

:: deftheorem Def12 defines connected GLIB_002:def 12 :
for GSq being GraphSeq holds
( GSq is connected iff for n being Nat holds GSq . n is connected );

:: deftheorem Def13 defines acyclic GLIB_002:def 13 :
for GSq being GraphSeq holds
( GSq is acyclic iff for n being Nat holds GSq . n is acyclic );

:: deftheorem Def14 defines Tree-like GLIB_002:def 14 :
for GSq being GraphSeq holds
( GSq is Tree-like iff for n being Nat holds GSq . n is Tree-like );

registration
cluster trivial -> connected ManySortedSet of NAT ;
coherence
for b1 being GraphSeq st b1 is trivial holds
b1 is connected
proof end;
cluster loopless trivial -> Tree-like ManySortedSet of NAT ;
coherence
for b1 being GraphSeq st b1 is trivial & b1 is loopless holds
b1 is Tree-like
proof end;
cluster acyclic -> simple ManySortedSet of NAT ;
coherence
for b1 being GraphSeq st b1 is acyclic holds
b1 is simple
proof end;
cluster Tree-like -> connected acyclic ManySortedSet of NAT ;
coherence
for b1 being GraphSeq st b1 is Tree-like holds
( b1 is acyclic & b1 is connected )
proof end;
cluster connected acyclic -> Tree-like ManySortedSet of NAT ;
coherence
for b1 being GraphSeq st b1 is acyclic & b1 is connected holds
b1 is Tree-like
proof end;
end;

registration
cluster halting finite simple connected acyclic Tree-like ManySortedSet of NAT ;
existence
ex b1 being GraphSeq st
( b1 is halting & b1 is finite & b1 is Tree-like )
proof end;
end;

registration
let GSq be connected GraphSeq;
let n be Nat;
cluster a1 . a2 -> connected _Graph;
coherence
GSq . n is connected _Graph
by ;
end;

registration
let GSq be acyclic GraphSeq;
let n be Nat;
cluster a1 . a2 -> simple acyclic _Graph;
coherence
GSq . n is acyclic _Graph
by Th1;
end;

registration
let GSq be Tree-like GraphSeq;
let n be Nat;
cluster a1 . a2 -> simple connected acyclic Tree-like _Graph;
coherence
GSq . n is Tree-like _Graph
;
end;

theorem Th2: :: GLIB_002:2
for G being non trivial connected _Graph
for v being Vertex of G holds not v is isolated
proof end;

theorem Th3: :: GLIB_002:3
for G1 being non trivial _Graph
for v being Vertex of G1
for G2 being removeVertex of G1,v st G2 is connected & ex e being set st
( e in v .edgesInOut() & not e Joins v,v,G1 ) holds
G1 is connected
proof end;

theorem Th4: :: GLIB_002:4
for G1 being non trivial connected _Graph
for v being Vertex of G1
for G2 being removeVertex of G1,v st v is endvertex holds
G2 is connected by ;

theorem Th5: :: GLIB_002:5
for G1 being connected _Graph
for W being Walk of G1
for e being set
for G2 being removeEdge of G1,e st W is Cycle-like & e in W .edges() holds
G2 is connected
proof end;

theorem Th6: :: GLIB_002:6
for G being _Graph st ex v1 being Vertex of G st
for v2 being Vertex of G ex W being Walk of G st W is_Walk_from v1,v2 holds
G is connected by ;

theorem Th7: :: GLIB_002:7
for G being trivial _Graph holds G is connected ;

theorem Th8: :: GLIB_002:8
for G1, G2 being _Graph st G1 == G2 & G1 is connected holds
G2 is connected
proof end;

theorem Th9: :: GLIB_002:9
for G being _Graph
for v being Vertex of G holds v in G .reachableFrom v by ;

theorem Th10: :: GLIB_002:10
for G being _Graph
for x, e, y being set
for v1 being Vertex of G st x in G .reachableFrom v1 & e Joins x,y,G holds
y in G .reachableFrom v1 by ;

theorem Th11: :: GLIB_002:11
for G being _Graph
for v being Vertex of G holds G .edgesBetween (G .reachableFrom v) = G .edgesInOut (G .reachableFrom v)
proof end;

theorem Th12: :: GLIB_002:12
for G being _Graph
for v1, v2 being Vertex of G st v1 in G .reachableFrom v2 holds
G .reachableFrom v1 = G .reachableFrom v2 by ;

theorem Th13: :: GLIB_002:13
for G being _Graph
for v being Vertex of G
for W being Walk of G st v in W .vertices() holds
W .vertices() c= G .reachableFrom v by ;

theorem Th14: :: GLIB_002:14
for G1 being _Graph
for G2 being Subgraph of G1
for v1 being Vertex of G1
for v2 being Vertex of G2 st v1 = v2 holds
G2 .reachableFrom v2 c= G1 .reachableFrom v1
proof end;

theorem Th15: :: GLIB_002:15
for G being _Graph st ex v being Vertex of G st G .reachableFrom v = the_Vertices_of G holds
G is connected by ;

theorem Th16: :: GLIB_002:16
for G being _Graph st G is connected holds
for v being Vertex of G holds G .reachableFrom v = the_Vertices_of G by ;

theorem Th17: :: GLIB_002:17
for G1, G2 being _Graph
for v1 being Vertex of G1
for v2 being Vertex of G2 st G1 == G2 & v1 = v2 holds
G1 .reachableFrom v1 = G2 .reachableFrom v2 by ;

theorem Th18: :: GLIB_002:18
for G being _Graph
for v being Vertex of G holds v in G .reachableDFrom v
proof end;

theorem Th19: :: GLIB_002:19
for G being _Graph
for x, e, y being set
for v1 being Vertex of G st x in G .reachableDFrom v1 & e DJoins x,y,G holds
y in G .reachableDFrom v1
proof end;

theorem Th20: :: GLIB_002:20
for G being _Graph
for v being Vertex of G holds G .reachableDFrom v c= G .reachableFrom v
proof end;

theorem Th21: :: GLIB_002:21
for G1 being _Graph
for G2 being Subgraph of G1
for v1 being Vertex of G1
for v2 being Vertex of G2 st v1 = v2 holds
G2 .reachableDFrom v2 c= G1 .reachableDFrom v1
proof end;

theorem Th22: :: GLIB_002:22
for G1, G2 being _Graph
for v1 being Vertex of G1
for v2 being Vertex of G2 st G1 == G2 & v1 = v2 holds
G1 .reachableDFrom v1 = G2 .reachableDFrom v2
proof end;

theorem Th23: :: GLIB_002:23
for G1 being _Graph
for G2 being connected Subgraph of G1 st G2 is spanning holds
G1 is connected by ;

theorem Th24: :: GLIB_002:24
for G being _Graph holds union (G .componentSet() ) = the_Vertices_of G
proof end;

theorem Th25: :: GLIB_002:25
for G being _Graph holds
( G is connected iff G .componentSet() = {(the_Vertices_of G)} ) by ;

theorem Th26: :: GLIB_002:26
for G1, G2 being _Graph st G1 == G2 holds
G1 .componentSet() = G2 .componentSet() by ;

theorem Th27: :: GLIB_002:27
for G being _Graph
for x being set st x in G .componentSet() holds
x is non empty Subset of (the_Vertices_of G) by ;

theorem Th28: :: GLIB_002:28
for G being _Graph holds
( G is connected iff G .numComponents() = 1 ) by ;

theorem Th29: :: GLIB_002:29
for G1, G2 being _Graph st G1 == G2 holds
G1 .numComponents() = G2 .numComponents() by ;

theorem Th30: :: GLIB_002:30
for G being _Graph holds
( G is Component of G iff G is connected )
proof end;

theorem Th31: :: GLIB_002:31
for G being _Graph
for C being Component of G holds the_Edges_of C = G .edgesBetween (the_Vertices_of C) by ;

theorem Th32: :: GLIB_002:32
for G being _Graph
for C1, C2 being Component of G holds
( the_Vertices_of C1 = the_Vertices_of C2 iff C1 == C2 ) by ;

theorem Th33: :: GLIB_002:33
for G being _Graph
for C being Component of G
for v being Vertex of G holds
( v in the_Vertices_of C iff the_Vertices_of C = G .reachableFrom v ) by ;

theorem Th34: :: GLIB_002:34
for G being _Graph
for C1, C2 being Component of G
for v being set st v in the_Vertices_of C1 & v in the_Vertices_of C2 holds
C1 == C2 by ;

theorem Th35: :: GLIB_002:35
for G being connected _Graph
for v being Vertex of G holds
( not v is cut-vertex iff for G2 being removeVertex of G,v holds G2 .numComponents() <=` G .numComponents() ) by ;

theorem Th36: :: GLIB_002:36
for G being connected _Graph
for v being Vertex of G
for G2 being removeVertex of G,v st not v is cut-vertex holds
G2 is connected by ;

theorem Th37: :: GLIB_002:37
for G being finite non trivial connected _Graph ex v1, v2 being Vertex of G st
( v1 <> v2 & not v1 is cut-vertex & not v2 is cut-vertex ) by ;

theorem Th38: :: GLIB_002:38
for G being _Graph
for v being Vertex of G st v is cut-vertex holds
not G is trivial
proof end;

theorem Th39: :: GLIB_002:39
for G1, G2 being _Graph
for v1 being Vertex of G1
for v2 being Vertex of G2 st G1 == G2 & v1 = v2 & v1 is cut-vertex holds
v2 is cut-vertex
proof end;

theorem Th40: :: GLIB_002:40
for G being finite connected _Graph holds G .order() <= (G .size() ) + 1
proof end;

theorem Th41: :: GLIB_002:41
for G being acyclic _Graph holds G is simple ;

theorem Th42: :: GLIB_002:42
for G being acyclic _Graph
for W being Path of G
for e being set st not e in W .edges() & e in (W .last() ) .edgesInOut() holds
W .addEdge e is Path-like by ;

theorem Th43: :: GLIB_002:43
for G being finite non trivial acyclic _Graph st the_Edges_of G <> {} holds
ex v1, v2 being Vertex of G st
( v1 <> v2 & v1 is endvertex & v2 is endvertex & v2 in G .reachableFrom v1 ) by ;

theorem Th44: :: GLIB_002:44
for G1, G2 being _Graph st G1 == G2 & G1 is acyclic holds
G2 is acyclic
proof end;

theorem Th45: :: GLIB_002:45
for G being finite non trivial Tree-like _Graph ex v1, v2 being Vertex of G st
( v1 <> v2 & v1 is endvertex & v2 is endvertex ) by ;

theorem Th46: :: GLIB_002:46
for G being finite _Graph holds
( G is Tree-like iff ( G is acyclic & G .order() = (G .size() ) + 1 ) )
proof end;

theorem Th47: :: GLIB_002:47
for G being finite _Graph holds
( G is Tree-like iff ( G is connected & G .order() = (G .size() ) + 1 ) )
proof end;

theorem Th48: :: GLIB_002:48
for G1, G2 being _Graph st G1 == G2 & G1 is Tree-like holds
G2 is Tree-like
proof end;

theorem Th49: :: GLIB_002:49
for G being _Graph
for x being set st G is_DTree_rooted_at x holds
x is Vertex of G
proof end;

theorem Th50: :: GLIB_002:50
for G1, G2 being _Graph
for x being set st G1 == G2 & G1 is_DTree_rooted_at x holds
G2 is_DTree_rooted_at x
proof end;