Article GLIB_002, MML version 4.99.1005

:: GLIB_002:th 1
theorem
for b1 being finite set
      st 1 < card b1
   holds ex b2, b3 being set st
      b2 in b1 & b3 in b1 & b2 <> b3;

:: GLIB_002:attrnot 1 => GLIB_002:attr 1
definition
  let a1 be [Graph-like] GraphStruct;
  attr a1 is connected means
    for b1, b2 being Element of the_Vertices_of a1 holds
    ex b3 being Walk of a1 st
       b3 is_Walk_from b1,b2;
end;

:: GLIB_002:dfs 1
definiens
  let a1 be [Graph-like] GraphStruct;
To prove
     a1 is connected
it is sufficient to prove
  thus for b1, b2 being Element of the_Vertices_of a1 holds
    ex b3 being Walk of a1 st
       b3 is_Walk_from b1,b2;

:: GLIB_002:def 1
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is connected
   iff
      for b2, b3 being Element of the_Vertices_of b1 holds
      ex b4 being Walk of b1 st
         b4 is_Walk_from b2,b3;

:: GLIB_002:attrnot 2 => GLIB_002:attr 2
definition
  let a1 be [Graph-like] GraphStruct;
  attr a1 is acyclic means
    for b1 being Walk of a1 holds
       b1 is not Cycle-like(a1);
end;

:: GLIB_002:dfs 2
definiens
  let a1 be [Graph-like] GraphStruct;
To prove
     a1 is acyclic
it is sufficient to prove
  thus for b1 being Walk of a1 holds
       b1 is not Cycle-like(a1);

:: GLIB_002:def 2
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is acyclic
   iff
      for b2 being Walk of b1 holds
         b2 is not Cycle-like(b1);

:: GLIB_002:attrnot 3 => GLIB_002:attr 3
definition
  let a1 be [Graph-like] GraphStruct;
  attr a1 is Tree-like means
    a1 is acyclic & a1 is connected;
end;

:: GLIB_002:dfs 3
definiens
  let a1 be [Graph-like] GraphStruct;
To prove
     a1 is Tree-like
it is sufficient to prove
  thus a1 is acyclic & a1 is connected;

:: GLIB_002:def 3
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is Tree-like
   iff
      b1 is acyclic & b1 is connected;

:: GLIB_002:condreg 1
registration
  cluster [Graph-like] trivial -> connected (GraphStruct);
end;

:: GLIB_002:condreg 2
registration
  cluster [Graph-like] loopless trivial -> Tree-like (GraphStruct);
end;

:: GLIB_002:condreg 3
registration
  cluster [Graph-like] acyclic -> simple (GraphStruct);
end;

:: GLIB_002:condreg 4
registration
  cluster [Graph-like] Tree-like -> connected acyclic (GraphStruct);
end;

:: GLIB_002:condreg 5
registration
  cluster [Graph-like] connected acyclic -> Tree-like (GraphStruct);
end;

:: GLIB_002:condreg 6
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  cluster -> Tree-like (inducedSubgraph of a1,{a2},{});
end;

:: GLIB_002:prednot 1 => GLIB_002:pred 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  pred A1 is_DTree_rooted_at A2 means
    a1 is Tree-like &
     (for b1 being Element of the_Vertices_of a1 holds
        ex b2 being directed Walk of a1 st
           b2 is_Walk_from a2,b1);
end;

:: GLIB_002:dfs 4
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
To prove
     a1 is_DTree_rooted_at a2
it is sufficient to prove
  thus a1 is Tree-like &
     (for b1 being Element of the_Vertices_of a1 holds
        ex b2 being directed Walk of a1 st
           b2 is_Walk_from a2,b1);

:: GLIB_002:def 4
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
      b1 is_DTree_rooted_at b2
   iff
      b1 is Tree-like &
       (for b3 being Element of the_Vertices_of b1 holds
          ex b4 being directed Walk of b1 st
             b4 is_Walk_from b2,b3);

:: GLIB_002:exreg 1
registration
  cluster Relation-like Function-like finite [Graph-like] finite trivial Tree-like GraphStruct;
end;

:: GLIB_002:exreg 2
registration
  cluster Relation-like Function-like finite [Graph-like] finite non trivial Tree-like GraphStruct;
end;

:: GLIB_002:exreg 3
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] finite trivial Tree-like Subgraph of a1;
end;

:: GLIB_002:condreg 7
registration
  let a1 be [Graph-like] acyclic GraphStruct;
  cluster -> acyclic (Subgraph of a1);
end;

:: GLIB_002:funcnot 1 => GLIB_002:func 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  func A1 .reachableFrom A2 -> non empty Element of bool the_Vertices_of a1 means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Walk of a1 st
             b2 is_Walk_from a2,b1;
end;

:: GLIB_002:def 5
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being non empty Element of bool the_Vertices_of b1 holds
      b3 = b1 .reachableFrom b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5 being Walk of b1 st
               b5 is_Walk_from b2,b4;

:: GLIB_002:funcnot 2 => GLIB_002:func 2
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  func A1 .reachableDFrom A2 -> non empty Element of bool the_Vertices_of a1 means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being directed Walk of a1 st
             b2 is_Walk_from a2,b1;
end;

:: GLIB_002:def 6
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being non empty Element of bool the_Vertices_of b1 holds
      b3 = b1 .reachableDFrom b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5 being directed Walk of b1 st
               b5 is_Walk_from b2,b4;

:: GLIB_002:attrnot 4 => GLIB_002:attr 4
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Subgraph of a1;
  attr a2 is Component-like means
    a2 is connected &
     (for b1 being connected Subgraph of a1 holds
        not a2 c< b1);
end;

:: GLIB_002:dfs 7
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Subgraph of a1;
To prove
     a2 is Component-like
it is sufficient to prove
  thus a2 is connected &
     (for b1 being connected Subgraph of a1 holds
        not a2 c< b1);

:: GLIB_002:def 7
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1 holds
      b2 is Component-like(b1)
   iff
      b2 is connected &
       (for b3 being connected Subgraph of b1 holds
          not b2 c< b3);

:: GLIB_002:condreg 8
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Component-like -> connected (Subgraph of a1);
end;

:: GLIB_002:condreg 9
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  cluster -> Component-like (inducedSubgraph of a1,a1 .reachableFrom a2,a1 .edgesBetween (a1 .reachableFrom a2));
end;

:: GLIB_002:exreg 4
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] Component-like Subgraph of a1;
end;

:: GLIB_002:modenot 1
definition
  let a1 be [Graph-like] GraphStruct;
  mode Component of a1 is Component-like Subgraph of a1;
end;

:: GLIB_002:funcnot 3 => GLIB_002:func 3
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .componentSet() -> non empty Element of bool bool the_Vertices_of a1 means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Element of the_Vertices_of a1 st
             b1 = a1 .reachableFrom b2;
end;

:: GLIB_002:def 8
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool bool the_Vertices_of b1 holds
      b2 = b1 .componentSet()
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being Element of the_Vertices_of b1 st
               b3 = b1 .reachableFrom b4;

:: GLIB_002:condreg 10
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of a1 .componentSet();
  cluster -> Component-like (inducedSubgraph of a1,a2,a1 .edgesBetween a2);
end;

:: GLIB_002:funcnot 4 => GLIB_002:func 4
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .numComponents() -> cardinal set equals
    Card (a1 .componentSet());
end;

:: GLIB_002:def 9
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .numComponents() = Card (b1 .componentSet());

:: GLIB_002:funcnot 5 => GLIB_002:func 5
definition
  let a1 be [Graph-like] finite GraphStruct;
  redefine func a1 .numComponents() -> non empty Element of NAT;
end;

:: GLIB_002:attrnot 5 => GLIB_002:attr 5
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  attr a2 is cut-vertex means
    for b1 being inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2}) holds
       a1 .numComponents() in b1 .numComponents();
end;

:: GLIB_002:dfs 10
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
To prove
     a2 is cut-vertex
it is sufficient to prove
  thus for b1 being inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2}) holds
       a1 .numComponents() in b1 .numComponents();

:: GLIB_002:def 10
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
      b2 is cut-vertex(b1)
   iff
      for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2}) holds
         b1 .numComponents() in b3 .numComponents();

:: GLIB_002:attrnot 6 => GLIB_002:attr 5
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  attr a2 is cut-vertex means
    for b1 being inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2}) holds
       a1 .numComponents() < b1 .numComponents();
end;

:: GLIB_002:dfs 11
definiens
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be Element of the_Vertices_of a1;
To prove
     a2 is cut-vertex
it is sufficient to prove
  thus for b1 being inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2}) holds
       a1 .numComponents() < b1 .numComponents();

:: GLIB_002:def 11
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Element of the_Vertices_of b1 holds
      b2 is cut-vertex(b1)
   iff
      for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2}) holds
         b1 .numComponents() < b3 .numComponents();

:: GLIB_002:exreg 5
registration
  let a1 be [Graph-like] finite non trivial connected GraphStruct;
  cluster non cut-vertex Element of the_Vertices_of a1;
end;

:: GLIB_002:exreg 6
registration
  let a1 be [Graph-like] finite non trivial Tree-like GraphStruct;
  cluster endvertex Element of the_Vertices_of a1;
end;

:: GLIB_002:condreg 11
registration
  let a1 be [Graph-like] finite non trivial Tree-like GraphStruct;
  let a2 be endvertex Element of the_Vertices_of a1;
  cluster -> Tree-like (inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2}));
end;

:: GLIB_002:attrnot 7 => GLIB_002:attr 6
definition
  let a1 be Graph-yielding ManySortedSet of NAT;
  attr a1 is connected means
    for b1 being natural set holds
       a1 . b1 is connected;
end;

:: GLIB_002:dfs 12
definiens
  let a1 be Graph-yielding ManySortedSet of NAT;
To prove
     a1 is connected
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is connected;

:: GLIB_002:def 12
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is connected
   iff
      for b2 being natural set holds
         b1 . b2 is connected;

:: GLIB_002:attrnot 8 => GLIB_002:attr 7
definition
  let a1 be Graph-yielding ManySortedSet of NAT;
  attr a1 is acyclic means
    for b1 being natural set holds
       a1 . b1 is acyclic;
end;

:: GLIB_002:dfs 13
definiens
  let a1 be Graph-yielding ManySortedSet of NAT;
To prove
     a1 is acyclic
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is acyclic;

:: GLIB_002:def 13
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is acyclic
   iff
      for b2 being natural set holds
         b1 . b2 is acyclic;

:: GLIB_002:attrnot 9 => GLIB_002:attr 8
definition
  let a1 be Graph-yielding ManySortedSet of NAT;
  attr a1 is Tree-like means
    for b1 being natural set holds
       a1 . b1 is Tree-like;
end;

:: GLIB_002:dfs 14
definiens
  let a1 be Graph-yielding ManySortedSet of NAT;
To prove
     a1 is Tree-like
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is Tree-like;

:: GLIB_002:def 14
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is Tree-like
   iff
      for b2 being natural set holds
         b1 . b2 is Tree-like;

:: GLIB_002:condreg 12
registration
  cluster Graph-yielding trivial -> connected (ManySortedSet of NAT);
end;

:: GLIB_002:condreg 13
registration
  cluster Graph-yielding loopless trivial -> Tree-like (ManySortedSet of NAT);
end;

:: GLIB_002:condreg 14
registration
  cluster Graph-yielding acyclic -> simple (ManySortedSet of NAT);
end;

:: GLIB_002:condreg 15
registration
  cluster Graph-yielding Tree-like -> connected acyclic (ManySortedSet of NAT);
end;

:: GLIB_002:condreg 16
registration
  cluster Graph-yielding connected acyclic -> Tree-like (ManySortedSet of NAT);
end;

:: GLIB_002:exreg 7
registration
  cluster Relation-like Function-like Graph-yielding halting finite Tree-like ManySortedSet of NAT;
end;

:: GLIB_002:funcreg 1
registration
  let a1 be Graph-yielding connected ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] connected;
end;

:: GLIB_002:funcreg 2
registration
  let a1 be Graph-yielding acyclic ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] acyclic;
end;

:: GLIB_002:funcreg 3
registration
  let a1 be Graph-yielding Tree-like ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] Tree-like;
end;

:: GLIB_002:th 2
theorem
for b1 being [Graph-like] non trivial connected GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b2 is not isolated(b1);

:: GLIB_002:th 3
theorem
for b1 being [Graph-like] non trivial GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2})
      st b3 is connected &
         (ex b4 being set st
            b4 in b2 .edgesInOut() & not b4 Joins b2,b2,b1)
   holds b1 is connected;

:: GLIB_002:th 4
theorem
for b1 being [Graph-like] non trivial connected GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2})
      st b2 is endvertex(b1)
   holds b3 is connected;

:: GLIB_002:th 5
theorem
for b1 being [Graph-like] connected GraphStruct
for b2 being Walk of b1
for b3 being set
for b4 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ {b3}
      st b2 is Cycle-like(b1) & b3 in b2 .edges()
   holds b4 is connected;

:: GLIB_002:th 6
theorem
for b1 being [Graph-like] GraphStruct
      st ex b2 being Element of the_Vertices_of b1 st
           for b3 being Element of the_Vertices_of b1 holds
              ex b4 being Walk of b1 st
                 b4 is_Walk_from b2,b3
   holds b1 is connected;

:: GLIB_002:th 7
theorem
for b1 being [Graph-like] trivial GraphStruct holds
   b1 is connected;

:: GLIB_002:th 8
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2 & b1 is connected
   holds b2 is connected;

:: GLIB_002:th 9
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b2 in b1 .reachableFrom b2;

:: GLIB_002:th 10
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
for b5 being Element of the_Vertices_of b1
      st b2 in b1 .reachableFrom b5 & b3 Joins b2,b4,b1
   holds b4 in b1 .reachableFrom b5;

:: GLIB_002:th 11
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b1 .edgesBetween (b1 .reachableFrom b2) = b1 .edgesInOut (b1 .reachableFrom b2);

:: GLIB_002:th 12
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
      st b2 in b1 .reachableFrom b3
   holds b1 .reachableFrom b2 = b1 .reachableFrom b3;

:: GLIB_002:th 13
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being Walk of b1
      st b2 in b3 .vertices()
   holds b3 .vertices() c= b1 .reachableFrom b2;

:: GLIB_002:th 14
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
      st b3 = b4
   holds b2 .reachableFrom b4 c= b1 .reachableFrom b3;

:: GLIB_002:th 15
theorem
for b1 being [Graph-like] GraphStruct
      st ex b2 being Element of the_Vertices_of b1 st
           b1 .reachableFrom b2 = the_Vertices_of b1
   holds b1 is connected;

:: GLIB_002:th 16
theorem
for b1 being [Graph-like] GraphStruct
   st b1 is connected
for b2 being Element of the_Vertices_of b1 holds
   b1 .reachableFrom b2 = the_Vertices_of b1;

:: GLIB_002:th 17
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
      st b1 == b2 & b3 = b4
   holds b1 .reachableFrom b3 = b2 .reachableFrom b4;

:: GLIB_002:th 18
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b2 in b1 .reachableDFrom b2;

:: GLIB_002:th 19
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
for b5 being Element of the_Vertices_of b1
      st b2 in b1 .reachableDFrom b5 & b3 DJoins b2,b4,b1
   holds b4 in b1 .reachableDFrom b5;

:: GLIB_002:th 20
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b1 .reachableDFrom b2 c= b1 .reachableFrom b2;

:: GLIB_002:th 21
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
      st b3 = b4
   holds b2 .reachableDFrom b4 c= b1 .reachableDFrom b3;

:: GLIB_002:th 22
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
      st b1 == b2 & b3 = b4
   holds b1 .reachableDFrom b3 = b2 .reachableDFrom b4;

:: GLIB_002:th 23
theorem
for b1 being [Graph-like] GraphStruct
for b2 being connected Subgraph of b1
      st b2 is spanning(b1)
   holds b1 is connected;

:: GLIB_002:th 24
theorem
for b1 being [Graph-like] GraphStruct holds
   union (b1 .componentSet()) = the_Vertices_of b1;

:: GLIB_002:th 25
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is connected
   iff
      b1 .componentSet() = {the_Vertices_of b1};

:: GLIB_002:th 26
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2
   holds b1 .componentSet() = b2 .componentSet();

:: GLIB_002:th 27
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
      st b2 in b1 .componentSet()
   holds b2 is non empty Element of bool the_Vertices_of b1;

:: GLIB_002:th 28
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is connected
   iff
      b1 .numComponents() = 1;

:: GLIB_002:th 29
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2
   holds b1 .numComponents() = b2 .numComponents();

:: GLIB_002:th 30
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is Component-like Subgraph of b1
   iff
      b1 is connected;

:: GLIB_002:th 31
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Component-like Subgraph of b1 holds
   the_Edges_of b2 = b1 .edgesBetween the_Vertices_of b2;

:: GLIB_002:th 32
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Component-like Subgraph of b1 holds
   the_Vertices_of b2 = the_Vertices_of b3
iff
   b2 == b3;

:: GLIB_002:th 33
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Component-like Subgraph of b1
for b3 being Element of the_Vertices_of b1 holds
      b3 in the_Vertices_of b2
   iff
      the_Vertices_of b2 = b1 .reachableFrom b3;

:: GLIB_002:th 34
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Component-like Subgraph of b1
for b4 being set
      st b4 in the_Vertices_of b2 & b4 in the_Vertices_of b3
   holds b2 == b3;

:: GLIB_002:th 35
theorem
for b1 being [Graph-like] connected GraphStruct
for b2 being Element of the_Vertices_of b1 holds
      b2 is not cut-vertex(b1)
   iff
      for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2}) holds
         b3 .numComponents() c= b1 .numComponents();

:: GLIB_002:th 36
theorem
for b1 being [Graph-like] connected GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2})
      st b2 is not cut-vertex(b1)
   holds b3 is connected;

:: GLIB_002:th 37
theorem
for b1 being [Graph-like] finite non trivial connected GraphStruct holds
   ex b2, b3 being Element of the_Vertices_of b1 st
      b2 <> b3 & b2 is not cut-vertex(b1) & b3 is not cut-vertex(b1);

:: GLIB_002:th 38
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
      st b2 is cut-vertex(b1)
   holds b1 is not trivial;

:: GLIB_002:th 39
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
      st b1 == b2 & b3 = b4 & b3 is cut-vertex(b1)
   holds b4 is cut-vertex(b2);

:: GLIB_002:th 40
theorem
for b1 being [Graph-like] finite connected GraphStruct holds
   b1 .order() <= b1 .size() + 1;

:: GLIB_002:th 41
theorem
for b1 being [Graph-like] acyclic GraphStruct holds
   b1 is simple;

:: GLIB_002:th 42
theorem
for b1 being [Graph-like] acyclic GraphStruct
for b2 being Path-like Walk of b1
for b3 being set
      st not b3 in b2 .edges() & b3 in b2 .last() .edgesInOut()
   holds b2 .addEdge b3 is Path-like(b1);

:: GLIB_002:th 43
theorem
for b1 being [Graph-like] finite non trivial acyclic GraphStruct
      st the_Edges_of b1 <> {}
   holds ex b2, b3 being Element of the_Vertices_of b1 st
      b2 <> b3 & b2 is endvertex(b1) & b3 is endvertex(b1) & b3 in b1 .reachableFrom b2;

:: GLIB_002:th 44
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2 & b1 is acyclic
   holds b2 is acyclic;

:: GLIB_002:th 45
theorem
for b1 being [Graph-like] finite non trivial Tree-like GraphStruct holds
   ex b2, b3 being Element of the_Vertices_of b1 st
      b2 <> b3 & b2 is endvertex(b1) & b3 is endvertex(b1);

:: GLIB_002:th 46
theorem
for b1 being [Graph-like] finite GraphStruct holds
      b1 is Tree-like
   iff
      b1 is acyclic & b1 .order() = b1 .size() + 1;

:: GLIB_002:th 47
theorem
for b1 being [Graph-like] finite GraphStruct holds
      b1 is Tree-like
   iff
      b1 is connected & b1 .order() = b1 .size() + 1;

:: GLIB_002:th 48
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2 & b1 is Tree-like
   holds b2 is Tree-like;

:: GLIB_002:th 49
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
      st b1 is_DTree_rooted_at b2
   holds b2 is Element of the_Vertices_of b1;

:: GLIB_002:th 50
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
      st b1 == b2 & b1 is_DTree_rooted_at b3
   holds b2 is_DTree_rooted_at b3;