Article GLIB_001, MML version 4.99.1005

:: GLIB_001:th 1
theorem
for b1, b2 being odd Element of NAT holds
   b1 < b2
iff
   b1 + 2 <= b2;

:: GLIB_001:th 2
theorem
for b1 being set
for b2 being Element of NAT
   st b1 c= Seg b2
for b3, b4 being Element of NAT
      st b3 in dom Sgm b1 & b4 = (Sgm b1) . b3
   holds b3 <= b4;

:: GLIB_001:th 3
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
   len Seq b3 <= len b2;

:: GLIB_001:th 4
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2
for b4 being Element of NAT
      st b4 in dom Seq b3
   holds ex b5 being Element of NAT st
      b5 in dom b2 & b4 <= b5 & (Seq b3) . b4 = b2 . b5;

:: GLIB_001:th 5
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
   len Seq b3 = card b3;

:: GLIB_001:th 6
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
   dom Seq b3 = dom Sgm proj1 b3;

:: GLIB_001:modenot 1 => GLIB_001:mode 1
definition
  let a1 be [Graph-like] GraphStruct;
  mode VertexSeq of A1 -> FinSequence of the_Vertices_of a1 means
    for b1 being Element of NAT
          st 1 <= b1 & b1 < len it
       holds ex b2 being set st
          b2 Joins it . b1,it . (b1 + 1),a1;
end;

:: GLIB_001:dfs 1
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be FinSequence of the_Vertices_of a1;
To prove
     a2 is VertexSeq of a1
it is sufficient to prove
  thus for b1 being Element of NAT
          st 1 <= b1 & b1 < len a2
       holds ex b2 being set st
          b2 Joins a2 . b1,a2 . (b1 + 1),a1;

:: GLIB_001:def 1
theorem
for b1 being [Graph-like] GraphStruct
for b2 being FinSequence of the_Vertices_of b1 holds
      b2 is VertexSeq of b1
   iff
      for b3 being Element of NAT
            st 1 <= b3 & b3 < len b2
         holds ex b4 being set st
            b4 Joins b2 . b3,b2 . (b3 + 1),b1;

:: GLIB_001:modenot 2 => GLIB_001:mode 2
definition
  let a1 be [Graph-like] GraphStruct;
  mode EdgeSeq of A1 -> FinSequence of the_Edges_of a1 means
    ex b1 being FinSequence of the_Vertices_of a1 st
       len b1 = (len it) + 1 &
        (for b2 being Element of NAT
              st 1 <= b2 & b2 <= len it
           holds it . b2 Joins b1 . b2,b1 . (b2 + 1),a1);
end;

:: GLIB_001:dfs 2
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be FinSequence of the_Edges_of a1;
To prove
     a2 is EdgeSeq of a1
it is sufficient to prove
  thus ex b1 being FinSequence of the_Vertices_of a1 st
       len b1 = (len a2) + 1 &
        (for b2 being Element of NAT
              st 1 <= b2 & b2 <= len a2
           holds a2 . b2 Joins b1 . b2,b1 . (b2 + 1),a1);

:: GLIB_001:def 2
theorem
for b1 being [Graph-like] GraphStruct
for b2 being FinSequence of the_Edges_of b1 holds
      b2 is EdgeSeq of b1
   iff
      ex b3 being FinSequence of the_Vertices_of b1 st
         len b3 = (len b2) + 1 &
          (for b4 being Element of NAT
                st 1 <= b4 & b4 <= len b2
             holds b2 . b4 Joins b3 . b4,b3 . (b4 + 1),b1);

:: GLIB_001:modenot 3 => GLIB_001:mode 3
definition
  let a1 be [Graph-like] GraphStruct;
  mode Walk of A1 -> FinSequence of (the_Vertices_of a1) \/ the_Edges_of a1 means
    len it is odd &
     it . 1 in the_Vertices_of a1 &
     (for b1 being odd Element of NAT
           st b1 < len it
        holds it . (b1 + 1) Joins it . b1,it . (b1 + 2),a1);
end;

:: GLIB_001:dfs 3
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be FinSequence of (the_Vertices_of a1) \/ the_Edges_of a1;
To prove
     a2 is Walk of a1
it is sufficient to prove
  thus len a2 is odd &
     a2 . 1 in the_Vertices_of a1 &
     (for b1 being odd Element of NAT
           st b1 < len a2
        holds a2 . (b1 + 1) Joins a2 . b1,a2 . (b1 + 2),a1);

:: GLIB_001:def 3
theorem
for b1 being [Graph-like] GraphStruct
for b2 being FinSequence of (the_Vertices_of b1) \/ the_Edges_of b1 holds
      b2 is Walk of b1
   iff
      len b2 is odd &
       b2 . 1 in the_Vertices_of b1 &
       (for b3 being odd Element of NAT
             st b3 < len b2
          holds b2 . (b3 + 1) Joins b2 . b3,b2 . (b3 + 2),b1);

:: GLIB_001:funcreg 1
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  cluster Card a2 -> non empty cardinal odd;
end;

:: GLIB_001:funcnot 1 => GLIB_001:func 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  func A1 .walkOf A2 -> Walk of a1 equals
    <*a2*>;
end;

:: GLIB_001:def 4
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b1 .walkOf b2 = <*b2*>;

:: GLIB_001:funcnot 2 => GLIB_001:func 2
definition
  let a1 be [Graph-like] GraphStruct;
  let a2, a3, a4 be set;
  func A1 .walkOf(A2,A4,A3) -> Walk of a1 equals
    <*a2,a4,a3*>
    if a4 Joins a2,a3,a1
    otherwise a1 .walkOf choose the_Vertices_of a1;
end;

:: GLIB_001:def 5
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
(b4 Joins b2,b3,b1 implies b1 .walkOf(b2,b4,b3) = <*b2,b4,b3*>) &
 (b4 Joins b2,b3,b1 or b1 .walkOf(b2,b4,b3) = b1 .walkOf choose the_Vertices_of b1);

:: GLIB_001:funcnot 3 => GLIB_001:func 3
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .first() -> Element of the_Vertices_of a1 equals
    a2 . 1;
end;

:: GLIB_001:def 6
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .first() = b2 . 1;

:: GLIB_001:funcnot 4 => GLIB_001:func 4
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .last() -> Element of the_Vertices_of a1 equals
    a2 . len a2;
end;

:: GLIB_001:def 7
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .last() = b2 . len b2;

:: GLIB_001:funcnot 5 => GLIB_001:func 5
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3 be natural set;
  func A2 .vertexAt A3 -> Element of the_Vertices_of a1 equals
    a2 . a3
    if a3 is odd & a3 <= len a2
    otherwise a2 .first();
end;

:: GLIB_001:def 8
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being natural set holds
   (b3 is odd & b3 <= len b2 implies b2 .vertexAt b3 = b2 . b3) &
    (b3 is odd & b3 <= len b2 or b2 .vertexAt b3 = b2 .first());

:: GLIB_001:funcnot 6 => GLIB_001:func 6
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .reverse() -> Walk of a1 equals
    Rev a2;
end;

:: GLIB_001:def 9
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .reverse() = Rev b2;

:: GLIB_001:funcnot 7 => GLIB_001:func 7
definition
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Walk of a1;
  func A2 .append A3 -> Walk of a1 equals
    a2 ^' a3
    if a2 .last() = a3 .first()
    otherwise a2;
end;

:: GLIB_001:def 10
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1 holds
(b2 .last() = b3 .first() implies b2 .append b3 = b2 ^' b3) &
 (b2 .last() = b3 .first() or b2 .append b3 = b2);

:: GLIB_001:funcnot 8 => GLIB_001:func 8
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3, a4 be natural set;
  func A2 .cut(A3,A4) -> Walk of a1 equals
    (a3,a4)-cut a2
    if a3 is odd & a4 is odd & a3 <= a4 & a4 <= len a2
    otherwise a2;
end;

:: GLIB_001:def 11
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being natural set holds
(b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 implies b2 .cut(b3,b4) = (b3,b4)-cut b2) &
 (b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 or b2 .cut(b3,b4) = b2);

:: GLIB_001:funcnot 9 => GLIB_001:func 9
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3, a4 be Element of NAT;
  func A2 .remove(A3,A4) -> Walk of a1 equals
    (a2 .cut(1,a3)) .append (a2 .cut(a4,len a2))
    if a3 is odd & a4 is odd & a3 <= a4 & a4 <= len a2 & a2 . a3 = a2 . a4
    otherwise a2;
end;

:: GLIB_001:def 12
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
(b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4 implies b2 .remove(b3,b4) = (b2 .cut(1,b3)) .append (b2 .cut(b4,len b2))) &
 (b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4 or b2 .remove(b3,b4) = b2);

:: GLIB_001:funcnot 10 => GLIB_001:func 10
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3 be set;
  func A2 .addEdge A3 -> Walk of a1 equals
    a2 .append (a1 .walkOf(a2 .last(),a3,a2 .last() .adj a3));
end;

:: GLIB_001:def 13
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
   b2 .addEdge b3 = b2 .append (b1 .walkOf(b2 .last(),b3,b2 .last() .adj b3));

:: GLIB_001:funcnot 11 => GLIB_001:func 11
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .vertexSeq() -> VertexSeq of a1 means
    (len a2) + 1 = 2 * len it &
     (for b1 being natural set
           st 1 <= b1 & b1 <= len it
        holds it . b1 = a2 . ((2 * b1) - 1));
end;

:: GLIB_001:def 14
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being VertexSeq of b1 holds
      b3 = b2 .vertexSeq()
   iff
      (len b2) + 1 = 2 * len b3 &
       (for b4 being natural set
             st 1 <= b4 & b4 <= len b3
          holds b3 . b4 = b2 . ((2 * b4) - 1));

:: GLIB_001:funcnot 12 => GLIB_001:func 12
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .edgeSeq() -> EdgeSeq of a1 means
    len a2 = (2 * len it) + 1 &
     (for b1 being natural set
           st 1 <= b1 & b1 <= len it
        holds it . b1 = a2 . (2 * b1));
end;

:: GLIB_001:def 15
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being EdgeSeq of b1 holds
      b3 = b2 .edgeSeq()
   iff
      len b2 = (2 * len b3) + 1 &
       (for b4 being natural set
             st 1 <= b4 & b4 <= len b3
          holds b3 . b4 = b2 . (2 * b4));

:: GLIB_001:funcnot 13 => GLIB_001:func 13
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .vertices() -> finite Element of bool the_Vertices_of a1 equals
    rng (a2 .vertexSeq());
end;

:: GLIB_001:def 16
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .vertices() = rng (b2 .vertexSeq());

:: GLIB_001:funcnot 14 => GLIB_001:func 14
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .edges() -> finite Element of bool the_Edges_of a1 equals
    rng (a2 .edgeSeq());
end;

:: GLIB_001:def 17
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .edges() = rng (b2 .edgeSeq());

:: GLIB_001:funcnot 15 => GLIB_001:func 15
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  func A2 .length() -> Element of NAT equals
    len (a2 .edgeSeq());
end;

:: GLIB_001:def 18
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .length() = len (b2 .edgeSeq());

:: GLIB_001:funcnot 16 => GLIB_001:func 16
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3 be set;
  func A2 .find A3 -> odd Element of NAT means
    it <= len a2 &
     a2 . it = a3 &
     (for b1 being natural odd set
           st b1 <= len a2 & a2 . b1 = a3
        holds it <= b1)
    if a3 in a2 .vertices()
    otherwise it = len a2;
end;

:: GLIB_001:def 19
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
for b4 being odd Element of NAT holds
   (b3 in b2 .vertices() implies    (b4 = b2 .find b3
    iff
       b4 <= len b2 &
        b2 . b4 = b3 &
        (for b5 being natural odd set
              st b5 <= len b2 & b2 . b5 = b3
           holds b4 <= b5))) &
    (b3 in b2 .vertices() or    (b4 = b2 .find b3
    iff
       b4 = len b2));

:: GLIB_001:funcnot 17 => GLIB_001:func 17
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3 be Element of NAT;
  func A2 .find A3 -> odd Element of NAT means
    it <= len a2 &
     a2 . it = a2 . a3 &
     (for b1 being natural odd set
           st b1 <= len a2 & a2 . b1 = a2 . a3
        holds it <= b1)
    if a3 is odd & a3 <= len a2
    otherwise it = len a2;
end;

:: GLIB_001:def 20
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
for b4 being odd Element of NAT holds
   (b3 is odd & b3 <= len b2 implies    (b4 = b2 .find b3
    iff
       b4 <= len b2 &
        b2 . b4 = b2 . b3 &
        (for b5 being natural odd set
              st b5 <= len b2 & b2 . b5 = b2 . b3
           holds b4 <= b5))) &
    (b3 is odd & b3 <= len b2 or    (b4 = b2 .find b3
    iff
       b4 = len b2));

:: GLIB_001:funcnot 18 => GLIB_001:func 18
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3 be set;
  func A2 .rfind A3 -> odd Element of NAT means
    it <= len a2 &
     a2 . it = a3 &
     (for b1 being odd Element of NAT
           st b1 <= len a2 & a2 . b1 = a3
        holds b1 <= it)
    if a3 in a2 .vertices()
    otherwise it = len a2;
end;

:: GLIB_001:def 21
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
for b4 being odd Element of NAT holds
   (b3 in b2 .vertices() implies    (b4 = b2 .rfind b3
    iff
       b4 <= len b2 &
        b2 . b4 = b3 &
        (for b5 being odd Element of NAT
              st b5 <= len b2 & b2 . b5 = b3
           holds b5 <= b4))) &
    (b3 in b2 .vertices() or    (b4 = b2 .rfind b3
    iff
       b4 = len b2));

:: GLIB_001:funcnot 19 => GLIB_001:func 19
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3 be Element of NAT;
  func A2 .rfind A3 -> odd Element of NAT means
    it <= len a2 &
     a2 . it = a2 . a3 &
     (for b1 being odd Element of NAT
           st b1 <= len a2 & a2 . b1 = a2 . a3
        holds b1 <= it)
    if a3 is odd & a3 <= len a2
    otherwise it = len a2;
end;

:: GLIB_001:def 22
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
for b4 being odd Element of NAT holds
   (b3 is odd & b3 <= len b2 implies    (b4 = b2 .rfind b3
    iff
       b4 <= len b2 &
        b2 . b4 = b2 . b3 &
        (for b5 being odd Element of NAT
              st b5 <= len b2 & b2 . b5 = b2 . b3
           holds b5 <= b4))) &
    (b3 is odd & b3 <= len b2 or    (b4 = b2 .rfind b3
    iff
       b4 = len b2));

:: GLIB_001:prednot 1 => GLIB_001:pred 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be set;
  let a4 be Walk of a1;
  pred A4 is_Walk_from A2,A3 means
    a4 .first() = a2 & a4 .last() = a3;
end;

:: GLIB_001:dfs 23
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be set;
  let a4 be Walk of a1;
To prove
     a4 is_Walk_from a2,a3
it is sufficient to prove
  thus a4 .first() = a2 & a4 .last() = a3;

:: GLIB_001:def 23
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4 being Walk of b1 holds
      b4 is_Walk_from b2,b3
   iff
      b4 .first() = b2 & b4 .last() = b3;

:: GLIB_001:attrnot 1 => GLIB_001:attr 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is closed means
    a2 .first() = a2 .last();
end;

:: GLIB_001:dfs 24
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is closed
it is sufficient to prove
  thus a2 .first() = a2 .last();

:: GLIB_001:def 24
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is closed(b1)
   iff
      b2 .first() = b2 .last();

:: GLIB_001:attrnot 2 => GLIB_001:attr 2
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is directed means
    for b1 being odd Element of NAT
          st b1 < len a2
       holds (the_Source_of a1) . (a2 . (b1 + 1)) = a2 . b1;
end;

:: GLIB_001:dfs 25
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is directed
it is sufficient to prove
  thus for b1 being odd Element of NAT
          st b1 < len a2
       holds (the_Source_of a1) . (a2 . (b1 + 1)) = a2 . b1;

:: GLIB_001:def 25
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is directed(b1)
   iff
      for b3 being odd Element of NAT
            st b3 < len b2
         holds (the_Source_of b1) . (b2 . (b3 + 1)) = b2 . b3;

:: GLIB_001:attrnot 3 => GLIB_001:attr 3
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is trivial means
    a2 .length() = 0;
end;

:: GLIB_001:dfs 26
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is trivial
it is sufficient to prove
  thus a2 .length() = 0;

:: GLIB_001:def 26
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is trivial(b1)
   iff
      b2 .length() = 0;

:: GLIB_001:attrnot 4 => GLIB_001:attr 4
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is Trail-like means
    a2 .edgeSeq() is one-to-one;
end;

:: GLIB_001:dfs 27
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is Trail-like
it is sufficient to prove
  thus a2 .edgeSeq() is one-to-one;

:: GLIB_001:def 27
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Trail-like(b1)
   iff
      b2 .edgeSeq() is one-to-one;

:: GLIB_001:attrnot 5 => GLIB_001:attr 1
notation
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  antonym open for closed;
end;

:: GLIB_001:attrnot 6 => GLIB_001:attr 5
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is Path-like means
    a2 is Trail-like(a1) &
     (for b1, b2 being odd Element of NAT
           st b1 < b2 & b2 <= len a2 & a2 . b1 = a2 . b2
        holds b1 = 1 & b2 = len a2);
end;

:: GLIB_001:dfs 28
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is Path-like
it is sufficient to prove
  thus a2 is Trail-like(a1) &
     (for b1, b2 being odd Element of NAT
           st b1 < b2 & b2 <= len a2 & a2 . b1 = a2 . b2
        holds b1 = 1 & b2 = len a2);

:: GLIB_001:def 28
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Path-like(b1)
   iff
      b2 is Trail-like(b1) &
       (for b3, b4 being odd Element of NAT
             st b3 < b4 & b4 <= len b2 & b2 . b3 = b2 . b4
          holds b3 = 1 & b4 = len b2);

:: GLIB_001:attrnot 7 => GLIB_001:attr 6
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is vertex-distinct means
    for b1, b2 being odd Element of NAT
          st b1 <= len a2 & b2 <= len a2 & a2 . b1 = a2 . b2
       holds b1 = b2;
end;

:: GLIB_001:dfs 29
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is vertex-distinct
it is sufficient to prove
  thus for b1, b2 being odd Element of NAT
          st b1 <= len a2 & b2 <= len a2 & a2 . b1 = a2 . b2
       holds b1 = b2;

:: GLIB_001:def 29
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is vertex-distinct(b1)
   iff
      for b3, b4 being odd Element of NAT
            st b3 <= len b2 & b4 <= len b2 & b2 . b3 = b2 . b4
         holds b3 = b4;

:: GLIB_001:attrnot 8 => GLIB_001:attr 7
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is Circuit-like means
    a2 is closed(a1) & a2 is Trail-like(a1) & a2 is not trivial(a1);
end;

:: GLIB_001:dfs 30
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is Circuit-like
it is sufficient to prove
  thus a2 is closed(a1) & a2 is Trail-like(a1) & a2 is not trivial(a1);

:: GLIB_001:def 30
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Circuit-like(b1)
   iff
      b2 is closed(b1) & b2 is Trail-like(b1) & b2 is not trivial(b1);

:: GLIB_001:attrnot 9 => GLIB_001:attr 8
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is Cycle-like means
    a2 is closed(a1) & a2 is Path-like(a1) & a2 is not trivial(a1);
end;

:: GLIB_001:dfs 31
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is Cycle-like
it is sufficient to prove
  thus a2 is closed(a1) & a2 is Path-like(a1) & a2 is not trivial(a1);

:: GLIB_001:def 31
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Cycle-like(b1)
   iff
      b2 is closed(b1) & b2 is Path-like(b1) & b2 is not trivial(b1);

:: GLIB_001:condreg 1
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Path-like -> Trail-like (Walk of a1);
end;

:: GLIB_001:condreg 2
registration
  let a1 be [Graph-like] GraphStruct;
  cluster trivial -> Path-like (Walk of a1);
end;

:: GLIB_001:condreg 3
registration
  let a1 be [Graph-like] GraphStruct;
  cluster trivial -> vertex-distinct (Walk of a1);
end;

:: GLIB_001:condreg 4
registration
  let a1 be [Graph-like] GraphStruct;
  cluster vertex-distinct -> Path-like (Walk of a1);
end;

:: GLIB_001:condreg 5
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Circuit-like -> closed non trivial Trail-like (Walk of a1);
end;

:: GLIB_001:condreg 6
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Cycle-like -> closed non trivial Path-like (Walk of a1);
end;

:: GLIB_001:exreg 1
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like finite FinSequence-like closed directed trivial Walk of a1;
end;

:: GLIB_001:exreg 2
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like finite FinSequence-like vertex-distinct Walk of a1;
end;

:: GLIB_001:modenot 4
definition
  let a1 be [Graph-like] GraphStruct;
  mode Trail of a1 is Trail-like Walk of a1;
end;

:: GLIB_001:modenot 5
definition
  let a1 be [Graph-like] GraphStruct;
  mode Path of a1 is Path-like Walk of a1;
end;

:: GLIB_001:modenot 6
definition
  let a1 be [Graph-like] GraphStruct;
  mode DWalk of a1 is directed Walk of a1;
end;

:: GLIB_001:modenot 7
definition
  let a1 be [Graph-like] GraphStruct;
  mode DTrail of a1 is directed Trail-like Walk of a1;
end;

:: GLIB_001:modenot 8
definition
  let a1 be [Graph-like] GraphStruct;
  mode DPath of a1 is directed Path-like Walk of a1;
end;

:: GLIB_001:funcreg 2
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  cluster a1 .walkOf a2 -> closed directed trivial;
end;

:: GLIB_001:funcreg 3
registration
  let a1 be [Graph-like] GraphStruct;
  let a2, a3, a4 be set;
  cluster a1 .walkOf(a2,a3,a4) -> Path-like;
end;

:: GLIB_001:funcreg 4
registration
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be set;
  cluster a1 .walkOf(a2,a3,a2) -> closed;
end;

:: GLIB_001:funcreg 5
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be closed Walk of a1;
  cluster a2 .reverse() -> closed;
end;

:: GLIB_001:funcreg 6
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be trivial Walk of a1;
  cluster a2 .reverse() -> trivial;
end;

:: GLIB_001:funcreg 7
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Trail-like Walk of a1;
  cluster a2 .reverse() -> Trail-like;
end;

:: GLIB_001:funcreg 8
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Path-like Walk of a1;
  cluster a2 .reverse() -> Path-like;
end;

:: GLIB_001:funcreg 9
registration
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be closed Walk of a1;
  cluster a2 .append a3 -> closed;
end;

:: GLIB_001:funcreg 10
registration
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be directed Walk of a1;
  cluster a2 .append a3 -> directed;
end;

:: GLIB_001:funcreg 11
registration
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be trivial Walk of a1;
  cluster a2 .append a3 -> trivial;
end;

:: GLIB_001:funcreg 12
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be directed Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .cut(a3,a4) -> directed;
end;

:: GLIB_001:funcreg 13
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be trivial Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .cut(a3,a4) -> trivial;
end;

:: GLIB_001:funcreg 14
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Trail-like Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .cut(a3,a4) -> Trail-like;
end;

:: GLIB_001:funcreg 15
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Path-like Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .cut(a3,a4) -> Path-like;
end;

:: GLIB_001:funcreg 16
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be vertex-distinct Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .cut(a3,a4) -> vertex-distinct;
end;

:: GLIB_001:funcreg 17
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be closed Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .remove(a3,a4) -> closed;
end;

:: GLIB_001:funcreg 18
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be directed Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .remove(a3,a4) -> directed;
end;

:: GLIB_001:funcreg 19
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be trivial Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .remove(a3,a4) -> trivial;
end;

:: GLIB_001:funcreg 20
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Trail-like Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .remove(a3,a4) -> Trail-like;
end;

:: GLIB_001:funcreg 21
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Path-like Walk of a1;
  let a3, a4 be Element of NAT;
  cluster a2 .remove(a3,a4) -> Path-like;
end;

:: GLIB_001:modenot 9 => GLIB_001:mode 4
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  mode Subwalk of A2 -> Walk of a1 means
    it is_Walk_from a2 .first(),a2 .last() &
     (ex b1 being Element of bool (a2 .edgeSeq()) st
        it .edgeSeq() = Seq b1);
end;

:: GLIB_001:dfs 32
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Walk of a1;
To prove
     a3 is Subwalk of a2
it is sufficient to prove
  thus a3 is_Walk_from a2 .first(),a2 .last() &
     (ex b1 being Element of bool (a2 .edgeSeq()) st
        a3 .edgeSeq() = Seq b1);

:: GLIB_001:def 32
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1 holds
   b3 is Subwalk of b2
iff
   b3 is_Walk_from b2 .first(),b2 .last() &
    (ex b4 being Element of bool (b2 .edgeSeq()) st
       b3 .edgeSeq() = Seq b4);

:: GLIB_001:funcnot 20 => GLIB_001:func 20
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  let a3, a4 be Element of NAT;
  redefine func a2 .remove(a3,a4) -> Subwalk of a2;
end;

:: GLIB_001:exreg 3
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  cluster Relation-like Function-like finite FinSequence-like Trail-like Path-like Subwalk of a2;
end;

:: GLIB_001:modenot 10
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  mode Trail of a2 is Trail-like Subwalk of a2;
end;

:: GLIB_001:modenot 11
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  mode Path of a2 is Path-like Subwalk of a2;
end;

:: GLIB_001:exreg 4
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be directed Walk of a1;
  cluster Relation-like Function-like finite FinSequence-like directed Trail-like Path-like Subwalk of a2;
end;

:: GLIB_001:modenot 12
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be directed Walk of a1;
  mode DWalk of a2 is directed Subwalk of a2;
end;

:: GLIB_001:modenot 13
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be directed Walk of a1;
  mode DTrail of a2 is directed Trail-like Subwalk of a2;
end;

:: GLIB_001:modenot 14
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be directed Walk of a1;
  mode DPath of a2 is directed Path-like Subwalk of a2;
end;

:: GLIB_001:funcnot 21 => GLIB_001:func 21
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .allWalks() -> non empty Element of bool (((the_Vertices_of a1) \/ the_Edges_of a1) *) equals
    {b1 where b1 is Walk of a1: TRUE};
end;

:: GLIB_001:def 33
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .allWalks() = {b2 where b2 is Walk of b1: TRUE};

:: GLIB_001:funcnot 22 => GLIB_001:func 22
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .allTrails() -> non empty Element of bool (a1 .allWalks()) equals
    {b1 where b1 is Trail-like Walk of a1: TRUE};
end;

:: GLIB_001:def 34
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .allTrails() = {b2 where b2 is Trail-like Walk of b1: TRUE};

:: GLIB_001:funcnot 23 => GLIB_001:func 23
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .allPaths() -> non empty Element of bool (a1 .allTrails()) equals
    {b1 where b1 is Path-like Walk of a1: TRUE};
end;

:: GLIB_001:def 35
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .allPaths() = {b2 where b2 is Path-like Walk of b1: TRUE};

:: GLIB_001:funcnot 24 => GLIB_001:func 24
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .allDWalks() -> non empty Element of bool (a1 .allWalks()) equals
    {b1 where b1 is directed Walk of a1: TRUE};
end;

:: GLIB_001:def 36
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .allDWalks() = {b2 where b2 is directed Walk of b1: TRUE};

:: GLIB_001:funcnot 25 => GLIB_001:func 25
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .allDTrails() -> non empty Element of bool (a1 .allTrails()) equals
    {b1 where b1 is directed Trail-like Walk of a1: TRUE};
end;

:: GLIB_001:def 37
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .allDTrails() = {b2 where b2 is directed Trail-like Walk of b1: TRUE};

:: GLIB_001:funcnot 26 => GLIB_001:func 26
definition
  let a1 be [Graph-like] GraphStruct;
  func A1 .allDPaths() -> non empty Element of bool (a1 .allDTrails()) equals
    {b1 where b1 is directed Path-like Walk of a1: TRUE};
end;

:: GLIB_001:def 38
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 .allDPaths() = {b2 where b2 is directed Path-like Walk of b1: TRUE};

:: GLIB_001:funcreg 22
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster a1 .allTrails() -> non empty finite;
end;

:: GLIB_001:modenot 15 => GLIB_001:mode 5
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty Element of bool (a1 .allWalks());
  redefine mode Element of a2 -> Walk of a1;
end;

:: GLIB_001:modenot 16 => GLIB_001:mode 6
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty Element of bool (a1 .allTrails());
  redefine mode Element of a2 -> Trail-like Walk of a1;
end;

:: GLIB_001:modenot 17 => GLIB_001:mode 7
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty Element of bool (a1 .allPaths());
  redefine mode Element of a2 -> Path-like Walk of a1;
end;

:: GLIB_001:modenot 18 => GLIB_001:mode 8
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty Element of bool (a1 .allDWalks());
  redefine mode Element of a2 -> directed Walk of a1;
end;

:: GLIB_001:modenot 19 => GLIB_001:mode 9
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty Element of bool (a1 .allDTrails());
  redefine mode Element of a2 -> directed Trail-like Walk of a1;
end;

:: GLIB_001:modenot 20 => GLIB_001:mode 10
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty Element of bool (a1 .allDPaths());
  redefine mode Element of a2 -> directed Path-like Walk of a1;
end;

:: GLIB_001:th 8
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds b2 . b3 in the_Vertices_of b1;

:: GLIB_001:th 9
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being even Element of NAT
      st b3 in dom b2
   holds b2 . b3 in the_Edges_of b1;

:: GLIB_001:th 10
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being even Element of NAT
      st b3 in dom b2
   holds ex b4 being odd Element of NAT st
      b4 = b3 - 1 &
       b3 - 1 in dom b2 &
       b3 + 1 in dom b2 &
       b2 . b3 Joins b2 . b4,b2 . (b3 + 1),b1;

:: GLIB_001:th 11
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 < len b2
   holds b2 . (b3 + 1) in (b2 .vertexAt b3) .edgesInOut();

:: GLIB_001:th 12
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st 1 < b3 & b3 <= len b2
   holds b2 . (b3 - 1) in (b2 .vertexAt b3) .edgesInOut();

:: GLIB_001:th 13
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 < len b2
   holds b3 in dom b2 & b3 + 1 in dom b2 & b3 + 2 in dom b2;

:: GLIB_001:th 14
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   len (b1 .walkOf b2) = 1 & (b1 .walkOf b2) . 1 = b2 & (b1 .walkOf b2) .first() = b2 & (b1 .walkOf b2) .last() = b2 & b1 .walkOf b2 is_Walk_from b2,b2;

:: GLIB_001:th 15
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
      st b2 Joins b3,b4,b1
   holds len (b1 .walkOf(b3,b2,b4)) = 3;

:: GLIB_001:th 16
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
      st b2 Joins b3,b4,b1
   holds (b1 .walkOf(b3,b2,b4)) .first() = b3 & (b1 .walkOf(b3,b2,b4)) .last() = b4 & b1 .walkOf(b3,b2,b4) is_Walk_from b3,b4;

:: GLIB_001:th 17
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .first() = b4 .first() & b3 .last() = b4 .last();

:: GLIB_001:th 18
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set holds
   b2 is_Walk_from b3,b4
iff
   b2 . 1 = b3 & b2 . len b2 = b4;

:: GLIB_001:th 19
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b2 is_Walk_from b3,b4
   holds b3 is Element of the_Vertices_of b1 & b4 is Element of the_Vertices_of b1;

:: GLIB_001:th 20
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4 being set
for b5 being Walk of b1
for b6 being Walk of b2
      st b5 = b6
   holds    b5 is_Walk_from b3,b4
   iff
      b6 is_Walk_from b3,b4;

:: GLIB_001:th 21
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
   st b3 = b4
for b5 being Element of NAT holds
   b3 .vertexAt b5 = b4 .vertexAt b5;

:: GLIB_001:th 22
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   len b2 = len (b2 .reverse()) & dom b2 = dom (b2 .reverse()) & rng b2 = rng (b2 .reverse());

:: GLIB_001:th 23
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .first() = b2 .reverse() .last() & b2 .last() = b2 .reverse() .first();

:: GLIB_001:th 24
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set holds
   b2 is_Walk_from b3,b4
iff
   b2 .reverse() is_Walk_from b4,b3;

:: GLIB_001:th 25
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
      st b3 in dom b2
   holds b2 . b3 = b2 .reverse() . (((len b2) - b3) + 1) &
    ((len b2) - b3) + 1 in dom (b2 .reverse());

:: GLIB_001:th 26
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
      st b3 in dom (b2 .reverse())
   holds b2 .reverse() . b3 = b2 . (((len b2) - b3) + 1) &
    ((len b2) - b3) + 1 in dom b2;

:: GLIB_001:th 27
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .reverse() .reverse() = b2;

:: GLIB_001:th 28
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .reverse() = b4 .reverse();

:: GLIB_001:th 29
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (len (b2 .append b3)) + 1 = (len b2) + len b3;

:: GLIB_001:th 30
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds len b2 <= len (b2 .append b3) & len b3 <= len (b2 .append b3);

:: GLIB_001:th 31
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (b2 .append b3) .first() = b2 .first() & (b2 .append b3) .last() = b3 .last() & b2 .append b3 is_Walk_from b2 .first(),b3 .last();

:: GLIB_001:th 32
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4, b5, b6 being set
      st b2 is_Walk_from b4,b5 & b3 is_Walk_from b5,b6
   holds b2 .append b3 is_Walk_from b4,b6;

:: GLIB_001:th 33
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4 being Element of NAT
      st b4 in dom b2
   holds (b2 .append b3) . b4 = b2 . b4 & b4 in dom (b2 .append b3);

:: GLIB_001:th 34
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
   st b2 .last() = b3 .first()
for b4 being Element of NAT
      st b4 < len b3
   holds (b2 .append b3) . ((len b2) + b4) = b3 . (b4 + 1) &
    (len b2) + b4 in dom (b2 .append b3);

:: GLIB_001:th 35
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4 being Element of NAT
      st b4 in dom (b2 .append b3) & not b4 in dom b2
   holds ex b5 being Element of NAT st
      b5 < len b3 & b4 = (len b2) + b5;

:: GLIB_001:th 36
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4 being Walk of b1
for b5, b6 being Walk of b2
      st b3 = b5 & b4 = b6
   holds b3 .append b4 = b5 .append b6;

:: GLIB_001:th 37
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2
   holds (len (b2 .cut(b3,b4))) + b3 = b4 + 1 &
    (for b5 being Element of NAT
          st b5 < len (b2 .cut(b3,b4))
       holds (b2 .cut(b3,b4)) . (b5 + 1) = b2 . (b3 + b5) &
        b3 + b5 in dom b2);

:: GLIB_001:th 38
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2
   holds (b2 .cut(b3,b4)) .first() = b2 . b3 & (b2 .cut(b3,b4)) .last() = b2 . b4 & b2 .cut(b3,b4) is_Walk_from b2 . b3,b2 . b4;

:: GLIB_001:th 39
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5 being odd Element of NAT
      st b3 <= b4 & b4 <= b5 & b5 <= len b2
   holds (b2 .cut(b3,b4)) .append (b2 .cut(b4,b5)) = b2 .cut(b3,b5);

:: GLIB_001:th 40
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .cut(1,len b2) = b2;

:: GLIB_001:th 41
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 < len b2
   holds b1 .walkOf(b2 . b3,b2 . (b3 + 1),b2 . (b3 + 2)) = b2 .cut(b3,b3 + 2);

:: GLIB_001:th 42
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 < len b2
   holds (b2 .cut(b3,b4)) .addEdge (b2 . (b4 + 1)) = b2 .cut(b3,b4 + 2);

:: GLIB_001:th 43
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds b2 .cut(b3,b3) = <*b2 .vertexAt b3*>;

:: GLIB_001:th 44
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT
      st b3 is odd & b3 <= b4
   holds (b2 .cut(1,b4)) .cut(1,b3) = b2 .cut(1,b3);

:: GLIB_001:th 45
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4, b5 being odd Element of NAT
      st b4 <= b5 & b5 <= len b2 & b2 .last() = b3 .first()
   holds (b2 .append b3) .cut(b4,b5) = b2 .cut(b4,b5);

:: GLIB_001:th 46
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds len (b2 .cut(1,b3)) = b3;

:: GLIB_001:th 47
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
for b4 being Element of NAT
      st b4 in dom (b2 .cut(1,b3)) & b3 <= len b2
   holds (b2 .cut(1,b3)) . b4 = b2 . b4;

:: GLIB_001:th 48
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
for b5 being Element of NAT
      st b3 <= b4 & b4 <= len b2 & b5 in dom (b2 .cut(b3,b4))
   holds (b2 .cut(b3,b4)) . b5 = b2 . ((b3 + b5) - 1) &
    (b3 + b5) - 1 in dom b2;

:: GLIB_001:th 49
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
for b5, b6 being Element of NAT
      st b3 = b4
   holds b3 .cut(b5,b6) = b4 .cut(b5,b6);

:: GLIB_001:th 50
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
   holds (len (b2 .remove(b3,b4))) + b4 = (len b2) + b3;

:: GLIB_001:th 51
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
for b5, b6 being Element of NAT
      st b2 is_Walk_from b3,b4
   holds b2 .remove(b5,b6) is_Walk_from b3,b4;

:: GLIB_001:th 52
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
len (b2 .remove(b3,b4)) <= len b2;

:: GLIB_001:th 53
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
   b2 .remove(b3,b3) = b2;

:: GLIB_001:th 54
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
   holds (b2 .cut(1,b3)) .last() = (b2 .cut(b4,len b2)) .first();

:: GLIB_001:th 55
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
   st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
for b5 being Element of NAT
      st b5 in Seg b3
   holds (b2 .remove(b3,b4)) . b5 = b2 . b5;

:: GLIB_001:th 56
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
   st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
for b5 being Element of NAT
      st b3 <= b5 & b5 <= len (b2 .remove(b3,b4))
   holds (b2 .remove(b3,b4)) . b5 = b2 . ((b5 - b3) + b4) &
    (b5 - b3) + b4 is Element of NAT &
    (b5 - b3) + b4 <= len b2;

:: GLIB_001:th 57
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
   holds len (b2 .remove(b3,b4)) = ((len b2) + b3) - b4;

:: GLIB_001:th 58
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
      st b2 . b3 = b2 .last()
   holds b2 .remove(b3,len b2) = b2 .cut(1,b3);

:: GLIB_001:th 59
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
      st b2 .first() = b2 . b3
   holds b2 .remove(1,b3) = b2 .cut(b3,len b2);

:: GLIB_001:th 60
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
(b2 .remove(b3,b4)) .first() = b2 .first() & (b2 .remove(b3,b4)) .last() = b2 .last();

:: GLIB_001:th 61
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
for b5 being Element of NAT
      st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4 & b5 in dom (b2 .remove(b3,b4)) & not b5 in Seg b3
   holds b3 <= b5 & b5 <= len (b2 .remove(b3,b4));

:: GLIB_001:th 62
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
for b5, b6 being Element of NAT
      st b3 = b4
   holds b3 .remove(b5,b6) = b4 .remove(b5,b6);

:: GLIB_001:th 63
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds b2 .addEdge b3 = b2 ^ <*b3,b4*>;

:: GLIB_001:th 64
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds (b2 .addEdge b3) .first() = b2 .first() & (b2 .addEdge b3) .last() = b4 & b2 .addEdge b3 is_Walk_from b2 .first(),b4;

:: GLIB_001:th 65
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds len (b2 .addEdge b3) = (len b2) + 2;

:: GLIB_001:th 66
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds (b2 .addEdge b3) . ((len b2) + 1) = b3 &
    (b2 .addEdge b3) . ((len b2) + 2) = b4 &
    (for b5 being Element of NAT
          st b5 in dom b2
       holds (b2 .addEdge b3) . b5 = b2 . b5);

:: GLIB_001:th 67
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5, b6 being set
      st b2 is_Walk_from b3,b4 & b5 Joins b4,b6,b1
   holds b2 .addEdge b5 is_Walk_from b3,b6;

:: GLIB_001:th 68
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   1 <= len (b2 .vertexSeq());

:: GLIB_001:th 69
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds (2 * ((b3 + 1) div 2)) - 1 = b3 &
    1 <= (b3 + 1) div 2 &
    (b3 + 1) div 2 <= len (b2 .vertexSeq());

:: GLIB_001:th 70
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   (b1 .walkOf b2) .vertexSeq() = <*b2*>;

:: GLIB_001:th 71
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
      st b2 Joins b3,b4,b1
   holds (b1 .walkOf(b3,b2,b4)) .vertexSeq() = <*b3,b4*>;

:: GLIB_001:th 72
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .first() = b2 .vertexSeq() . 1 &
    b2 .last() = b2 .vertexSeq() . len (b2 .vertexSeq());

:: GLIB_001:th 73
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds b2 .vertexAt b3 = b2 .vertexSeq() . ((b3 + 1) div 2);

:: GLIB_001:th 74
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
      b3 in dom (b2 .vertexSeq())
   iff
      (2 * b3) - 1 in dom b2;

:: GLIB_001:th 75
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
   (b2 .cut(1,b3)) .vertexSeq() c= b2 .vertexSeq();

:: GLIB_001:th 76
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds (b2 .addEdge b3) .vertexSeq() = b2 .vertexSeq() ^ <*b4*>;

:: GLIB_001:th 77
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .vertexSeq() = b4 .vertexSeq();

:: GLIB_001:th 78
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being even Element of NAT
      st 1 <= b3 & b3 <= len b2
   holds b3 div 2 in dom (b2 .edgeSeq()) &
    b2 . b3 = b2 .edgeSeq() . (b3 div 2);

:: GLIB_001:th 79
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
      b3 in dom (b2 .edgeSeq())
   iff
      2 * b3 in dom b2;

:: GLIB_001:th 80
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
      st b3 in dom (b2 .edgeSeq())
   holds b2 .edgeSeq() . b3 in the_Edges_of b1;

:: GLIB_001:th 81
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   ex b3 being even Element of NAT st
      b3 = (len b2) - 1 & len (b2 .edgeSeq()) = b3 div 2;

:: GLIB_001:th 82
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
   (b2 .cut(1,b3)) .edgeSeq() c= b2 .edgeSeq();

:: GLIB_001:th 83
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds (b2 .addEdge b3) .edgeSeq() = b2 .edgeSeq() ^ <*b3*>;

:: GLIB_001:th 84
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
   b2 Joins b3,b4,b1
iff
   (b1 .walkOf(b3,b2,b4)) .edgeSeq() = <*b2*>;

:: GLIB_001:th 85
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .reverse() .edgeSeq() = Rev (b2 .edgeSeq());

:: GLIB_001:th 86
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (b2 .append b3) .edgeSeq() = b2 .edgeSeq() ^ (b3 .edgeSeq());

:: GLIB_001:th 87
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .edgeSeq() = b4 .edgeSeq();

:: GLIB_001:th 88
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
      b3 in b2 .vertices()
   iff
      ex b4 being odd Element of NAT st
         b4 <= len b2 & b2 . b4 = b3;

:: GLIB_001:th 89
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .first() in b2 .vertices() & b2 .last() in b2 .vertices();

:: GLIB_001:th 90
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds b2 .vertexAt b3 in b2 .vertices();

:: GLIB_001:th 91
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   (b1 .walkOf b2) .vertices() = {b2};

:: GLIB_001:th 92
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
      st b2 Joins b3,b4,b1
   holds (b1 .walkOf(b3,b2,b4)) .vertices() = {b3,b4};

:: GLIB_001:th 93
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .vertices() = b2 .reverse() .vertices();

:: GLIB_001:th 94
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (b2 .append b3) .vertices() = b2 .vertices() \/ (b3 .vertices());

:: GLIB_001:th 95
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2
   holds (b2 .cut(b3,b4)) .vertices() c= b2 .vertices();

:: GLIB_001:th 96
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds (b2 .addEdge b3) .vertices() = b2 .vertices() \/ {b4};

:: GLIB_001:th 97
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1 & not b4 in b2 .vertices()
   holds card ((b2 .addEdge b3) .vertices()) = (card (b2 .vertices())) + 1;

:: GLIB_001:th 98
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 in b2 .vertices() & b4 in b2 .vertices()
   holds ex b5 being Walk of b1 st
      b5 is_Walk_from b3,b4;

:: GLIB_001:th 99
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .vertices() = b4 .vertices();

:: GLIB_001:th 100
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
      b3 in b2 .edges()
   iff
      ex b4 being even Element of NAT st
         1 <= b4 & b4 <= len b2 & b2 . b4 = b3;

:: GLIB_001:th 101
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
      b3 in b2 .edges()
   iff
      ex b4 being odd Element of NAT st
         b4 < len b2 & b2 . (b4 + 1) = b3;

:: GLIB_001:th 102
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   rng b2 = b2 .vertices() \/ (b2 .edges());

:: GLIB_001:th 103
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (b2 .append b3) .edges() = b2 .edges() \/ (b3 .edges());

:: GLIB_001:th 104
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
      st b3 in b2 .edges()
   holds ex b4, b5 being Element of the_Vertices_of b1 st
      ex b6 being odd Element of NAT st
         b6 + 2 <= len b2 & b4 = b2 . b6 & b3 = b2 . (b6 + 1) & b5 = b2 . (b6 + 2) & b3 Joins b4,b5,b1;

:: GLIB_001:th 105
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
      b3 in b2 .edges()
   iff
      ex b4 being Element of NAT st
         b4 in dom (b2 .edgeSeq()) & b2 .edgeSeq() . b4 = b3;

:: GLIB_001:th 106
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5 being set
      st b3 in b2 .edges() & b3 Joins b4,b5,b1
   holds b4 in b2 .vertices() & b5 in b2 .vertices();

:: GLIB_001:th 107
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
(b2 .cut(b3,b4)) .edges() c= b2 .edges();

:: GLIB_001:th 108
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .edges() = b2 .reverse() .edges();

:: GLIB_001:th 109
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
   b2 Joins b3,b4,b1
iff
   (b1 .walkOf(b3,b2,b4)) .edges() = {b2};

:: GLIB_001:th 110
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 .edges() c= b1 .edgesBetween (b2 .vertices());

:: GLIB_001:th 111
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .edges() = b4 .edges();

:: GLIB_001:th 112
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds (b2 .addEdge b3) .edges() = b2 .edges() \/ {b3};

:: GLIB_001:th 113
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   len b2 = (2 * (b2 .length())) + 1;

:: GLIB_001:th 114
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1 holds
   len b2 = len b3
iff
   b2 .length() = b3 .length();

:: GLIB_001:th 115
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .length() = b4 .length();

:: GLIB_001:th 116
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds b2 .find (b2 . b3) <= b3 & b3 <= b2 .rfind (b2 . b3);

:: GLIB_001:th 117
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
for b5 being set
      st b3 = b4
   holds b3 .find b5 = b4 .find b5 & b3 .rfind b5 = b4 .rfind b5;

:: GLIB_001:th 118
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
      st b3 <= len b2
   holds b2 .find b3 <= b3 & b3 <= b2 .rfind b3;

:: GLIB_001:th 119
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is closed(b1)
   iff
      b2 . 1 = b2 . len b2;

:: GLIB_001:th 120
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is closed(b1)
   iff
      ex b3 being set st
         b2 is_Walk_from b3,b3;

:: GLIB_001:th 121
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is closed(b1)
   iff
      b2 .reverse() is closed(b1);

:: GLIB_001:th 122
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4 & b3 is closed(b1)
   holds b4 is closed(b2);

:: GLIB_001:th 123
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is directed(b1)
   iff
      for b3 being odd Element of NAT
            st b3 < len b2
         holds b2 . (b3 + 1) DJoins b2 . b3,b2 . (b3 + 2),b1;

:: GLIB_001:th 124
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5, b6 being set
      st b2 is directed(b1) & b2 is_Walk_from b3,b4 & b5 DJoins b4,b6,b1
   holds b2 .addEdge b5 is directed(b1) & b2 .addEdge b5 is_Walk_from b3,b6;

:: GLIB_001:th 125
theorem
for b1 being [Graph-like] GraphStruct
for b2 being directed Walk of b1
for b3, b4 being Element of NAT holds
b2 .cut(b3,b4) is directed(b1);

:: GLIB_001:th 126
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is not trivial(b1)
   iff
      3 <= len b2;

:: GLIB_001:th 127
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is not trivial(b1)
   iff
      len b2 <> 1;

:: GLIB_001:th 128
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 .first() <> b2 .last()
   holds b2 is not trivial(b1);

:: GLIB_001:th 129
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is trivial(b1)
   iff
      ex b3 being Element of the_Vertices_of b1 st
         b2 = b1 .walkOf b3;

:: GLIB_001:th 130
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is trivial(b1)
   iff
      b2 .reverse() is trivial(b1);

:: GLIB_001:th 131
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 is trivial(b1)
   holds b3 .append b2 = b3;

:: GLIB_001:th 132
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
      st b3 <= b4 & b4 <= len b2
   holds    b2 .cut(b3,b4) is trivial(b1)
   iff
      b3 = b4;

:: GLIB_001:th 133
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1
   holds b2 .addEdge b3 is not trivial(b1);

:: GLIB_001:th 134
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is not trivial(b1)
   holds ex b3 being odd Element of NAT st
      b3 = (len b2) - 2 &
       (b2 .cut(1,b3)) .addEdge (b2 . (b3 + 1)) = b2;

:: GLIB_001:th 135
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 is not trivial(b1) & b2 .edges() c= b3 .edges()
   holds b2 .vertices() c= b3 .vertices();

:: GLIB_001:th 136
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
   st b2 is not trivial(b1)
for b3 being Element of the_Vertices_of b1
      st b3 in b2 .vertices()
   holds b3 is not isolated(b1);

:: GLIB_001:th 137
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is trivial(b1)
   iff
      b2 .edges() = {};

:: GLIB_001:th 138
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4 & b3 is trivial(b1)
   holds b4 is trivial(b2);

:: GLIB_001:th 139
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Trail-like(b1)
   iff
      for b3, b4 being even Element of NAT
            st 1 <= b3 & b3 < b4 & b4 <= len b2
         holds b2 . b3 <> b2 . b4;

:: GLIB_001:th 140
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st len b2 <= 3
   holds b2 is Trail-like(b1);

:: GLIB_001:th 141
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Trail-like(b1)
   iff
      b2 .reverse() is Trail-like(b1);

:: GLIB_001:th 142
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
for b3, b4 being Element of NAT holds
b2 .cut(b3,b4) is Trail-like(b1);

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

:: GLIB_001:th 144
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
for b3 being Element of the_Vertices_of b1
      st b3 in b2 .vertices() & b3 is endvertex(b1) & b3 <> b2 .first()
   holds b3 = b2 .last();

:: GLIB_001:th 145
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Trail-like Walk of b1 holds
   len (b2 .edgeSeq()) <= b1 .size();

:: GLIB_001:th 146
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st len b2 <= 3
   holds b2 is Path-like(b1);

:: GLIB_001:th 147
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st for b3, b4 being odd Element of NAT
              st b3 <= len b2 & b4 <= len b2 & b2 . b3 = b2 . b4
           holds b3 = b4
   holds b2 is Path-like(b1);

:: GLIB_001:th 148
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is open(b1)
for b3, b4 being odd Element of NAT
      st b3 < b4 & b4 <= len b2
   holds b2 . b3 <> b2 . b4;

:: GLIB_001:th 149
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Path-like(b1)
   iff
      b2 .reverse() is Path-like(b1);

:: GLIB_001:th 150
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being Element of NAT holds
b2 .cut(b3,b4) is Path-like(b1);

:: GLIB_001:th 151
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1 &
         not b3 in b2 .edges() &
         (b2 is not trivial(b1) implies b2 is open(b1)) &
         (for b5 being odd Element of NAT
               st 1 < b5 & b5 <= len b2
            holds b2 . b5 <> b4)
   holds b2 .addEdge b3 is Path-like(b1);

:: GLIB_001:th 152
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1 & not b4 in b2 .vertices() & (b2 is not trivial(b1) implies b2 is open(b1))
   holds b2 .addEdge b3 is Path-like(b1);

:: GLIB_001:th 153
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st for b3 being odd Element of NAT
              st b3 <= len b2
           holds b2 .find (b2 . b3) = b2 .rfind (b2 . b3)
   holds b2 is Path-like(b1);

:: GLIB_001:th 154
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st for b3 being odd Element of NAT
              st b3 <= len b2
           holds b2 .rfind b3 = b3
   holds b2 is Path-like(b1);

:: GLIB_001:th 155
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Path-like Walk of b1 holds
   len (b2 .vertexSeq()) <= b1 .order() + 1;

:: GLIB_001:th 156
theorem
for b1 being [Graph-like] GraphStruct
for b2 being vertex-distinct Walk of b1
for b3, b4 being set
      st b3 Joins b2 .last(),b4,b1 & not b4 in b2 .vertices()
   holds b2 .addEdge b3 is vertex-distinct(b1);

:: GLIB_001:th 157
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
      st b2 Joins b3,b3,b1
   holds b1 .walkOf(b3,b2,b3) is Cycle-like(b1);

:: GLIB_001:th 158
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5 being set
      st b3 Joins b4,b5,b1 & b3 in b2 .edges() & b2 is Cycle-like(b1)
   holds ex b6 being Walk of b1 st
      b6 is_Walk_from b4,b5 & not b3 in b6 .edges();

:: GLIB_001:th 159
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   b2 is Subwalk of b2;

:: GLIB_001:th 160
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Subwalk of b2
for b4 being Subwalk of b3 holds
   b4 is Subwalk of b2;

:: GLIB_001:th 161
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4, b5 being set
      st b2 is Subwalk of b3
   holds    b2 is_Walk_from b4,b5
   iff
      b3 is_Walk_from b4,b5;

:: GLIB_001:th 162
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 is Subwalk of b3
   holds b2 .first() = b3 .first() & b2 .last() = b3 .last();

:: GLIB_001:th 163
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 is Subwalk of b3
   holds len b2 <= len b3;

:: GLIB_001:th 164
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
      st b2 is Subwalk of b3
   holds b2 .edges() c= b3 .edges() & b2 .vertices() c= b3 .vertices();

:: GLIB_001:th 165
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
   st b2 is Subwalk of b3
for b4 being odd Element of NAT
      st b4 <= len b2
   holds ex b5 being odd Element of NAT st
      b4 <= b5 & b5 <= len b3 & b2 . b4 = b3 . b5;

:: GLIB_001:th 166
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
   st b2 is Subwalk of b3
for b4 being even Element of NAT
      st 1 <= b4 & b4 <= len b2
   holds ex b5 being even Element of NAT st
      b4 <= b5 & b5 <= len b3 & b2 . b4 = b3 . b5;

:: GLIB_001:th 167
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
      st b2 is not trivial(b1)
   holds ex b3 being Path-like Subwalk of b2 st
      b3 is not trivial(b1);

:: GLIB_001:th 168
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b2 holds
   b3 is Walk of b1;

:: GLIB_001:th 169
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
      st b3 is trivial(b1) & b3 .first() in the_Vertices_of b2
   holds b3 is Walk of b2;

:: GLIB_001:th 170
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
      st b3 is not trivial(b1) & b3 .edges() c= the_Edges_of b2
   holds b3 is Walk of b2;

:: GLIB_001:th 171
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
      st b3 .vertices() c= the_Vertices_of b2 & b3 .edges() c= the_Edges_of b2
   holds b3 is Walk of b2;

:: GLIB_001:th 172
theorem
for b1 being [Graph-like] non trivial GraphStruct
for b2 being Walk of b1
for b3 being Element of the_Vertices_of b1
for b4 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b3},b1 .edgesBetween ((the_Vertices_of b1) \ {b3})
      st not b3 in b2 .vertices()
   holds b2 is Walk of b4;

:: GLIB_001:th 173
theorem
for b1 being [Graph-like] 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 not b3 in b2 .edges()
   holds b2 is Walk of b4;

:: GLIB_001:th 174
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3, b4, b5 being set
      st b5 Joins b3,b4,b2
   holds b1 .walkOf(b3,b5,b4) = b2 .walkOf(b3,b5,b4);

:: GLIB_001:th 175
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
for b4 being Walk of b2
for b5 being set
      st b3 = b4 & b5 in b4 .last() .edgesInOut()
   holds b3 .addEdge b5 = b4 .addEdge b5;

:: GLIB_001:th 176
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b2 holds
   (b3 is closed(b2) implies b3 is closed Walk of b1) & (b3 is directed(b2) implies b3 is directed Walk of b1) & (b3 is trivial(b2) implies b3 is trivial Walk of b1) & (b3 is Trail-like(b2) implies b3 is Trail-like Walk of b1) & (b3 is Path-like(b2) implies b3 is Path-like Walk of b1) & (b3 is vertex-distinct(b2) implies b3 is vertex-distinct Walk of b1);

:: GLIB_001:th 177
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds (b3 is closed(b1) implies b4 is closed(b2)) & (b4 is closed(b2) implies b3 is closed(b1)) & (b3 is directed(b1) implies b4 is directed(b2)) & (b4 is directed(b2) implies b3 is directed(b1)) & (b3 is trivial(b1) implies b4 is trivial(b2)) & (b4 is trivial(b2) implies b3 is trivial(b1)) & (b3 is Trail-like(b1) implies b4 is Trail-like(b2)) & (b4 is Trail-like(b2) implies b3 is Trail-like(b1)) & (b3 is Path-like(b1) implies b4 is Path-like(b2)) & (b4 is Path-like(b2) implies b3 is Path-like(b1)) & (b3 is vertex-distinct(b1) implies b4 is vertex-distinct(b2)) & (b4 is vertex-distinct(b2) implies b3 is vertex-distinct(b1));

:: GLIB_001:th 178
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
      st b1 == b2 & b3 is VertexSeq of b1
   holds b3 is VertexSeq of b2;

:: GLIB_001:th 179
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
      st b1 == b2 & b3 is EdgeSeq of b1
   holds b3 is EdgeSeq of b2;

:: GLIB_001:th 180
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
      st b1 == b2 & b3 is Walk of b1
   holds b3 is Walk of b2;

:: GLIB_001:th 181
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4, b5 being set
      st b1 == b2
   holds b1 .walkOf(b3,b4,b5) = b2 .walkOf(b3,b4,b5);

:: GLIB_001:th 182
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b1 == b2 & b3 = b4
   holds (b3 is closed(b1) implies b4 is closed(b2)) & (b4 is closed(b2) implies b3 is closed(b1)) & (b3 is directed(b1) implies b4 is directed(b2)) & (b4 is directed(b2) implies b3 is directed(b1)) & (b3 is trivial(b1) implies b4 is trivial(b2)) & (b4 is trivial(b2) implies b3 is trivial(b1)) & (b3 is Trail-like(b1) implies b4 is Trail-like(b2)) & (b4 is Trail-like(b2) implies b3 is Trail-like(b1)) & (b3 is Path-like(b1) implies b4 is Path-like(b2)) & (b4 is Path-like(b2) implies b3 is Path-like(b1)) & (b3 is vertex-distinct(b1) implies b4 is vertex-distinct(b2)) & (b4 is vertex-distinct(b2) implies b3 is vertex-distinct(b1));