Article GRAPH_2, MML version 4.99.1005

:: GRAPH_2:th 1
theorem
for b1, b2, b3 being natural set holds
   b1 + 1 <= b2 & b2 <= b3
iff
   ex b4 being Element of NAT st
      b1 <= b4 & b4 < b3 & b2 = b4 + 1;

:: GRAPH_2:th 2
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
for b3 being Element of NAT
      st b1 = b2 | Seg b3
   holds len b1 <= len b2 &
    (for b4 being Element of NAT
          st 1 <= b4 & b4 <= len b1
       holds b2 . b4 = b1 . b4);

:: GRAPH_2:th 3
theorem
for b1, b2 being set
for b3 being Element of NAT
      st b1 c= Seg b3 & b2 c= dom Sgm b1
   holds (Sgm b1) * Sgm b2 = Sgm proj2 ((Sgm b1) | b2);

:: GRAPH_2:th 4
theorem
for b1, b2 being Element of NAT holds
Card {b3 where b3 is Element of NAT: b1 <= b3 & b3 <= b1 + b2} = b2 + 1;

:: GRAPH_2:th 5
theorem
for b1, b2, b3 being Element of NAT
      st 1 <= b3 & b3 <= b1
   holds (Sgm {b4 where b4 is Element of NAT: b2 + 1 <= b4 & b4 <= b2 + b1}) . b3 = b2 + b3;

:: GRAPH_2:funcnot 1 => GRAPH_2:func 1
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  let a2, a3 be natural set;
  func (A2,A3)-cut A1 -> Relation-like Function-like FinSequence-like set means
    (len it) + a2 = a3 + 1 &
     (for b1 being natural set
           st b1 < len it
        holds it . (b1 + 1) = a1 . (a2 + b1))
    if 1 <= a2 & a2 <= a3 & a3 <= len a1
    otherwise it = {};
end;

:: GRAPH_2:def 1
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3 being natural set
for b4 being Relation-like Function-like FinSequence-like set holds
   (1 <= b2 & b2 <= b3 & b3 <= len b1 implies    (b4 = (b2,b3)-cut b1
    iff
       (len b4) + b2 = b3 + 1 &
        (for b5 being natural set
              st b5 < len b4
           holds b4 . (b5 + 1) = b1 . (b2 + b5)))) &
    (1 <= b2 & b2 <= b3 & b3 <= len b1 or    (b4 = (b2,b3)-cut b1
    iff
       b4 = {}));

:: GRAPH_2:th 6
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being Element of NAT
      st 1 <= b2 & b2 <= len b1
   holds (b2,b2)-cut b1 = <*b1 . b2*>;

:: GRAPH_2:th 7
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
   (1,len b1)-cut b1 = b1;

:: GRAPH_2:th 8
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3, b4 being Element of NAT
      st b2 <= b3 & b3 <= b4 & b4 <= len b1
   holds ((b2 + 1,b3)-cut b1) ^ ((b3 + 1,b4)-cut b1) = (b2 + 1,b4)-cut b1;

:: GRAPH_2:th 9
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being Element of NAT
      st b2 <= len b1
   holds ((1,b2)-cut b1) ^ ((b2 + 1,len b1)-cut b1) = b1;

:: GRAPH_2:th 10
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3 being Element of NAT
      st b2 <= b3 & b3 <= len b1
   holds (((1,b2)-cut b1) ^ ((b2 + 1,b3)-cut b1)) ^ ((b3 + 1,len b1)-cut b1) = b1;

:: GRAPH_2:th 11
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3 being Element of NAT holds
proj2 ((b2,b3)-cut b1) c= proj2 b1;

:: GRAPH_2:funcnot 2 => GRAPH_2:func 2
definition
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3, a4 be natural set;
  redefine func (a3,a4)-cut a2 -> FinSequence of a1;
end;

:: GRAPH_2:th 12
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3 being Element of NAT
      st 1 <= b2 & b2 <= b3 & b3 <= len b1
   holds ((b2,b3)-cut b1) . 1 = b1 . b2 &
    ((b2,b3)-cut b1) . len ((b2,b3)-cut b1) = b1 . b3;

:: GRAPH_2:funcnot 3 => GRAPH_2:func 3
definition
  let a1, a2 be Relation-like Function-like FinSequence-like set;
  func A1 ^' A2 -> Relation-like Function-like FinSequence-like set equals
    a1 ^ ((2,len a2)-cut a2);
end;

:: GRAPH_2:def 2
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set holds
b1 ^' b2 = b1 ^ ((2,len b2)-cut b2);

:: GRAPH_2:th 13
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
      st b1 <> {}
   holds (len (b2 ^' b1)) + 1 = (len b2) + len b1;

:: GRAPH_2:th 14
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
for b3 being Element of NAT
      st 1 <= b3 & b3 <= len b1
   holds (b1 ^' b2) . b3 = b1 . b3;

:: GRAPH_2:th 15
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
for b3 being Element of NAT
      st 1 <= b3 & b3 < len b1
   holds (b2 ^' b1) . ((len b2) + b3) = b1 . (b3 + 1);

:: GRAPH_2:th 16
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
      st 1 < len b1
   holds (b2 ^' b1) . len (b2 ^' b1) = b1 . len b1;

:: GRAPH_2:th 17
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set holds
proj2 (b1 ^' b2) c= (proj2 b1) \/ proj2 b2;

:: GRAPH_2:funcnot 4 => GRAPH_2:func 4
definition
  let a1 be set;
  let a2, a3 be FinSequence of a1;
  redefine func a2 ^' a3 -> FinSequence of a1;
end;

:: GRAPH_2:th 18
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
      st b1 <> {} & b2 <> {} & b1 . len b1 = b2 . 1
   holds proj2 (b1 ^' b2) = (proj2 b1) \/ proj2 b2;

:: GRAPH_2:attrnot 1 => GRAPH_2:attr 1
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  attr a1 is TwoValued means
    card proj2 a1 = 2;
end;

:: GRAPH_2:dfs 3
definiens
  let a1 be Relation-like Function-like FinSequence-like set;
To prove
     a1 is TwoValued
it is sufficient to prove
  thus card proj2 a1 = 2;

:: GRAPH_2:def 3
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
      b1 is TwoValued
   iff
      card proj2 b1 = 2;

:: GRAPH_2:th 19
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
      b1 is TwoValued
   iff
      1 < len b1 &
       (ex b2, b3 being set st
          b2 <> b3 & proj2 b1 = {b2,b3});

:: GRAPH_2:attrnot 2 => GRAPH_2:attr 2
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  attr a1 is Alternating means
    for b1 being natural set
          st 1 <= b1 & b1 + 1 <= len a1
       holds a1 . b1 <> a1 . (b1 + 1);
end;

:: GRAPH_2:dfs 4
definiens
  let a1 be Relation-like Function-like FinSequence-like set;
To prove
     a1 is Alternating
it is sufficient to prove
  thus for b1 being natural set
          st 1 <= b1 & b1 + 1 <= len a1
       holds a1 . b1 <> a1 . (b1 + 1);

:: GRAPH_2:def 4
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
      b1 is Alternating
   iff
      for b2 being natural set
            st 1 <= b2 & b2 + 1 <= len b1
         holds b1 . b2 <> b1 . (b2 + 1);

:: GRAPH_2:exreg 1
registration
  cluster Relation-like Function-like finite FinSequence-like TwoValued Alternating set;
end;

:: GRAPH_2:th 20
theorem
for b1, b2 being Relation-like Function-like FinSequence-like TwoValued Alternating set
      st len b1 = len b2 & proj2 b1 = proj2 b2 & b1 . 1 = b2 . 1
   holds b1 = b2;

:: GRAPH_2:th 21
theorem
for b1, b2 being Relation-like Function-like FinSequence-like TwoValued Alternating set
   st b1 <> b2 & len b1 = len b2 & proj2 b1 = proj2 b2
for b3 being Element of NAT
      st 1 <= b3 & b3 <= len b1
   holds b1 . b3 <> b2 . b3;

:: GRAPH_2:th 22
theorem
for b1, b2 being Relation-like Function-like FinSequence-like TwoValued Alternating set
   st b1 <> b2 & len b1 = len b2 & proj2 b1 = proj2 b2
for b3 being Relation-like Function-like FinSequence-like TwoValued Alternating set
      st len b3 = len b1 & proj2 b3 = proj2 b1 & b3 <> b1
   holds b3 = b2;

:: GRAPH_2:th 23
theorem
for b1, b2 being set
for b3 being Element of NAT
      st b1 <> b2 & 1 < b3
   holds ex b4 being Relation-like Function-like FinSequence-like TwoValued Alternating set st
      proj2 b4 = {b1,b2} & len b4 = b3 & b4 . 1 = b1;

:: GRAPH_2:condreg 1
registration
  let a1 be set;
  let a2 be FinSequence of a1;
  cluster -> FinSubsequence-like (Element of bool a2);
end;

:: GRAPH_2:th 26
theorem
for b1 being Relation-like Function-like FinSubsequence-like set
for b2, b3, b4, b5, b6 being Relation-like Function-like FinSequence-like set
      st proj2 b2 c= proj1 b1 & proj2 b3 c= proj1 b1 & b4 = b2 * b1 & b5 = b3 * b1 & b6 = (b2 ^ b3) * b1
   holds b6 = b4 ^ b5;

:: GRAPH_2:th 27
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
   proj1 b3 c= dom b2 & proj2 b3 c= proj2 b2;

:: GRAPH_2:th 28
theorem
for b1 being set
for b2 being FinSequence of b1 holds
   b2 is Element of bool b2;

:: GRAPH_2:th 29
theorem
for b1, b2 being set
for b3 being FinSequence of b1
for b4 being Element of bool b3 holds
   b4 | b2 is Element of bool b3;

:: GRAPH_2:th 30
theorem
for b1 being set
for b2, b3, b4 being FinSequence of b1
for b5, b6 being Element of bool b2
for b7 being Element of bool b3
      st Seq b5 = b3 &
         Seq b7 = b4 &
         b6 = b5 | proj2 ((Sgm proj1 b5) | proj1 b7)
   holds Seq b6 = b4;

:: GRAPH_2:funcreg 1
registration
  let a1 be Graph-like MultiGraphStruct;
  cluster the Vertices of a1 -> non empty;
end;

:: GRAPH_2:th 31
theorem
for b1 being Graph-like MultiGraphStruct
for b2, b3 being Element of the Vertices of b1
for b4 being set
      st b4 joins b2,b3
   holds b4 joins b3,b2;

:: GRAPH_2:th 32
theorem
for b1 being Graph-like MultiGraphStruct
for b2, b3, b4, b5 being Element of the Vertices of b1
for b6 being set
      st b6 joins b2,b3 & b6 joins b4,b5 & (b2 = b4 implies b3 <> b5)
   holds b2 = b5 & b3 = b4;

:: GRAPH_2:exreg 2
registration
  let a1 be Graph-like MultiGraphStruct;
  cluster Relation-like Function-like empty finite FinSequence-like Chain of a1;
end;

:: GRAPH_2:funcnot 5 => GRAPH_2:func 5
definition
  let a1 be Graph-like MultiGraphStruct;
  let a2 be set;
  func A1 -VSet A2 -> set equals
    {b1 where b1 is Element of the Vertices of a1: ex b2 being Element of the Edges of a1 st
       b2 in a2 &
        (b1 = (the Source of a1) . b2 or b1 = (the Target of a1) . b2)};
end;

:: GRAPH_2:def 6
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being set holds
   b1 -VSet b2 = {b3 where b3 is Element of the Vertices of b1: ex b4 being Element of the Edges of b1 st
      b4 in b2 &
       (b3 = (the Source of b1) . b4 or b3 = (the Target of b1) . b4)};

:: GRAPH_2:prednot 1 => GRAPH_2:pred 1
definition
  let a1 be Graph-like MultiGraphStruct;
  let a2 be FinSequence of the Vertices of a1;
  let a3 be Relation-like Function-like FinSequence-like set;
  pred A2 is_vertex_seq_of A3 means
    len a2 = (len a3) + 1 &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 <= len a3
        holds a3 . b1 joins a2 /. b1,a2 /. (b1 + 1));
end;

:: GRAPH_2:dfs 6
definiens
  let a1 be Graph-like MultiGraphStruct;
  let a2 be FinSequence of the Vertices of a1;
  let a3 be Relation-like Function-like FinSequence-like set;
To prove
     a2 is_vertex_seq_of a3
it is sufficient to prove
  thus len a2 = (len a3) + 1 &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 <= len a3
        holds a3 . b1 joins a2 /. b1,a2 /. (b1 + 1));

:: GRAPH_2:def 7
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Relation-like Function-like FinSequence-like set holds
      b2 is_vertex_seq_of b3
   iff
      len b2 = (len b3) + 1 &
       (for b4 being Element of NAT
             st 1 <= b4 & b4 <= len b3
          holds b3 . b4 joins b2 /. b4,b2 /. (b4 + 1));

:: GRAPH_2:th 34
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
      st b3 <> {} & b2 is_vertex_seq_of b3
   holds b1 -VSet proj2 b3 = proj2 b2;

:: GRAPH_2:th 35
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being Element of the Vertices of b1 holds
   <*b2*> is_vertex_seq_of {};

:: GRAPH_2:th 36
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being Chain of b1 holds
   ex b3 being FinSequence of the Vertices of b1 st
      b3 is_vertex_seq_of b2;

:: GRAPH_2:th 37
theorem
for b1 being Graph-like MultiGraphStruct
for b2, b3 being FinSequence of the Vertices of b1
for b4 being Chain of b1
      st b4 <> {} & b2 is_vertex_seq_of b4 & b3 is_vertex_seq_of b4 & b2 <> b3
   holds b2 . 1 <> b3 . 1 &
    (for b5 being FinSequence of the Vertices of b1
          st b5 is_vertex_seq_of b4 & b5 <> b2
       holds b5 = b3);

:: GRAPH_2:prednot 2 => GRAPH_2:pred 2
definition
  let a1 be Graph-like MultiGraphStruct;
  let a2 be Relation-like Function-like FinSequence-like set;
  pred A2 alternates_vertices_in A1 means
    1 <= len a2 &
     Card (a1 -VSet proj2 a2) = 2 &
     (for b1 being Element of NAT
           st b1 in dom a2
        holds (the Source of a1) . (a2 . b1) <> (the Target of a1) . (a2 . b1));
end;

:: GRAPH_2:dfs 7
definiens
  let a1 be Graph-like MultiGraphStruct;
  let a2 be Relation-like Function-like FinSequence-like set;
To prove
     a2 alternates_vertices_in a1
it is sufficient to prove
  thus 1 <= len a2 &
     Card (a1 -VSet proj2 a2) = 2 &
     (for b1 being Element of NAT
           st b1 in dom a2
        holds (the Source of a1) . (a2 . b1) <> (the Target of a1) . (a2 . b1));

:: GRAPH_2:def 8
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being Relation-like Function-like FinSequence-like set holds
      b2 alternates_vertices_in b1
   iff
      1 <= len b2 &
       Card (b1 -VSet proj2 b2) = 2 &
       (for b3 being Element of NAT
             st b3 in dom b2
          holds (the Source of b1) . (b2 . b3) <> (the Target of b1) . (b2 . b3));

:: GRAPH_2:th 38
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
   st b3 alternates_vertices_in b1 & b2 is_vertex_seq_of b3
for b4 being Element of NAT
      st b4 in dom b3
   holds b2 . b4 <> b2 . (b4 + 1);

:: GRAPH_2:th 39
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
      st b3 alternates_vertices_in b1 & b2 is_vertex_seq_of b3
   holds proj2 b2 = {(the Source of b1) . (b3 . 1),(the Target of b1) . (b3 . 1)};

:: GRAPH_2:th 40
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
      st b3 alternates_vertices_in b1 & b2 is_vertex_seq_of b3
   holds b2 is Relation-like Function-like FinSequence-like TwoValued Alternating set;

:: GRAPH_2:th 41
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being Chain of b1
      st b2 alternates_vertices_in b1
   holds ex b3, b4 being FinSequence of the Vertices of b1 st
      b3 <> b4 &
       b3 is_vertex_seq_of b2 &
       b4 is_vertex_seq_of b2 &
       (for b5 being FinSequence of the Vertices of b1
             st b5 is_vertex_seq_of b2 & b5 <> b3
          holds b5 = b4);

:: GRAPH_2:th 42
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
      st b2 is_vertex_seq_of b3
   holds    (Card the Vertices of b1 = 1 or b3 <> {} & not b3 alternates_vertices_in b1)
   iff
      for b4 being FinSequence of the Vertices of b1
            st b4 is_vertex_seq_of b3
         holds b4 = b2;

:: GRAPH_2:funcnot 6 => GRAPH_2:func 6
definition
  let a1 be Graph-like MultiGraphStruct;
  let a2 be Chain of a1;
  assume (Card the Vertices of a1 = 1 or a2 <> {} & not a2 alternates_vertices_in a1);
  func vertex-seq A2 -> FinSequence of the Vertices of a1 means
    it is_vertex_seq_of a2;
end;

:: GRAPH_2:def 9
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being Chain of b1
   st (Card the Vertices of b1 = 1 or b2 <> {} & not b2 alternates_vertices_in b1)
for b3 being FinSequence of the Vertices of b1 holds
      b3 = vertex-seq b2
   iff
      b3 is_vertex_seq_of b2;

:: GRAPH_2:th 43
theorem
for b1 being Element of NAT
for b2 being Graph-like MultiGraphStruct
for b3, b4 being FinSequence of the Vertices of b2
for b5, b6 being Chain of b2
      st b3 is_vertex_seq_of b5 & b6 = b5 | Seg b1 & b4 = b3 | Seg (b1 + 1)
   holds b4 is_vertex_seq_of b6;

:: GRAPH_2:th 44
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2, b3 being Element of NAT
for b4 being Graph-like MultiGraphStruct
for b5 being Chain of b4
      st 1 <= b2 & b2 <= b3 & b3 <= len b5 & b1 = (b2,b3)-cut b5
   holds b1 is Chain of b4;

:: GRAPH_2:th 45
theorem
for b1, b2 being Element of NAT
for b3 being Graph-like MultiGraphStruct
for b4, b5 being FinSequence of the Vertices of b3
for b6, b7 being Chain of b3
      st 1 <= b1 & b1 <= b2 & b2 <= len b6 & b7 = (b1,b2)-cut b6 & b4 is_vertex_seq_of b6 & b5 = (b1,b2 + 1)-cut b4
   holds b5 is_vertex_seq_of b7;

:: GRAPH_2:th 46
theorem
for b1 being Graph-like MultiGraphStruct
for b2, b3 being FinSequence of the Vertices of b1
for b4, b5 being Chain of b1
      st b2 is_vertex_seq_of b4 & b3 is_vertex_seq_of b5 & b2 . len b2 = b3 . 1
   holds b4 ^ b5 is Chain of b1;

:: GRAPH_2:th 47
theorem
for b1 being Graph-like MultiGraphStruct
for b2, b3, b4 being FinSequence of the Vertices of b1
for b5, b6, b7 being Chain of b1
      st b2 is_vertex_seq_of b5 & b3 is_vertex_seq_of b6 & b2 . len b2 = b3 . 1 & b7 = b5 ^ b6 & b4 = b2 ^' b3
   holds b4 is_vertex_seq_of b7;

:: GRAPH_2:attrnot 3 => GRAPH_2:attr 3
definition
  let a1 be Graph-like MultiGraphStruct;
  let a2 be Chain of a1;
  attr a2 is simple means
    ex b1 being FinSequence of the Vertices of a1 st
       b1 is_vertex_seq_of a2 &
        (for b2, b3 being Element of NAT
              st 1 <= b2 & b2 < b3 & b3 <= len b1 & b1 . b2 = b1 . b3
           holds b2 = 1 & b3 = len b1);
end;

:: GRAPH_2:dfs 9
definiens
  let a1 be Graph-like MultiGraphStruct;
  let a2 be Chain of a1;
To prove
     a2 is simple
it is sufficient to prove
  thus ex b1 being FinSequence of the Vertices of a1 st
       b1 is_vertex_seq_of a2 &
        (for b2, b3 being Element of NAT
              st 1 <= b2 & b2 < b3 & b3 <= len b1 & b1 . b2 = b1 . b3
           holds b2 = 1 & b3 = len b1);

:: GRAPH_2:def 10
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being Chain of b1 holds
      b2 is simple(b1)
   iff
      ex b3 being FinSequence of the Vertices of b1 st
         b3 is_vertex_seq_of b2 &
          (for b4, b5 being Element of NAT
                st 1 <= b4 & b4 < b5 & b5 <= len b3 & b3 . b4 = b3 . b5
             holds b4 = 1 & b5 = len b3);

:: GRAPH_2:exreg 3
registration
  let a1 be Graph-like MultiGraphStruct;
  cluster Relation-like Function-like finite FinSequence-like simple Chain of a1;
end;

:: GRAPH_2:th 49
theorem
for b1 being Element of NAT
for b2 being Graph-like MultiGraphStruct
for b3 being simple Chain of b2 holds
   b3 | Seg b1 is simple Chain of b2;

:: GRAPH_2:th 50
theorem
for b1 being Graph-like MultiGraphStruct
for b2, b3 being FinSequence of the Vertices of b1
for b4 being simple Chain of b1
      st 2 < len b4 & b2 is_vertex_seq_of b4 & b3 is_vertex_seq_of b4
   holds b2 = b3;

:: GRAPH_2:th 51
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being simple Chain of b1
   st b2 is_vertex_seq_of b3
for b4, b5 being Element of NAT
      st 1 <= b4 & b4 < b5 & b5 <= len b2 & b2 . b4 = b2 . b5
   holds b4 = 1 & b5 = len b2;

:: GRAPH_2:th 52
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
      st b3 is not simple Chain of b1 & b2 is_vertex_seq_of b3
   holds ex b4 being Element of bool b3 st
      ex b5 being Element of bool b2 st
         ex b6 being Chain of b1 st
            ex b7 being FinSequence of the Vertices of b1 st
               len b6 < len b3 & b7 is_vertex_seq_of b6 & len b7 < len b2 & b2 . 1 = b7 . 1 & b2 . len b2 = b7 . len b7 & Seq b4 = b6 & Seq b5 = b7;

:: GRAPH_2:th 53
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being FinSequence of the Vertices of b1
for b3 being Chain of b1
      st b2 is_vertex_seq_of b3
   holds ex b4 being Element of bool b3 st
      ex b5 being Element of bool b2 st
         ex b6 being simple Chain of b1 st
            ex b7 being FinSequence of the Vertices of b1 st
               Seq b4 = b6 & Seq b5 = b7 & b7 is_vertex_seq_of b6 & b2 . 1 = b7 . 1 & b2 . len b2 = b7 . len b7;

:: GRAPH_2:condreg 2
registration
  let a1 be Graph-like MultiGraphStruct;
  cluster empty -> one-to-one (Chain of a1);
end;

:: GRAPH_2:th 54
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being Element of NAT
for b3 being Graph-like MultiGraphStruct
      st b1 is one-to-one Chain of b3
   holds b1 | Seg b2 is one-to-one Chain of b3;

:: GRAPH_2:exreg 4
registration
  let a1 be Graph-like MultiGraphStruct;
  cluster Relation-like Function-like one-to-one finite FinSequence-like simple Chain of a1;
end;

:: GRAPH_2:th 55
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being simple Chain of b1
      st 2 < len b2
   holds b2 is one-to-one Chain of b1;

:: GRAPH_2:th 56
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being simple Chain of b1 holds
      b2 is one-to-one Chain of b1
   iff
      (len b2 <> 0 & len b2 <> 1 implies b2 . 1 <> b2 . 2);

:: GRAPH_2:condreg 3
registration
  let a1 be Graph-like MultiGraphStruct;
  cluster empty -> oriented (Chain of a1);
end;

:: GRAPH_2:funcnot 7 => GRAPH_2:func 7
definition
  let a1 be Graph-like MultiGraphStruct;
  let a2 be oriented Chain of a1;
  assume a2 <> {};
  func vertex-seq A2 -> FinSequence of the Vertices of a1 means
    it is_vertex_seq_of a2 &
     it . 1 = (the Source of a1) . (a2 . 1);
end;

:: GRAPH_2:def 11
theorem
for b1 being Graph-like MultiGraphStruct
for b2 being oriented Chain of b1
   st b2 <> {}
for b3 being FinSequence of the Vertices of b1 holds
      b3 = vertex-seq b2
   iff
      b3 is_vertex_seq_of b2 &
       b3 . 1 = (the Source of b1) . (b2 . 1);

:: GRAPH_2:th 57
theorem
for b1 being non empty set
for b2 being non empty FinSequence of b1
for b3 being FinSequence of b1 holds
   (b2 ^' b3) /. 1 = b2 /. 1;

:: GRAPH_2:th 58
theorem
for b1 being non empty set
for b2 being FinSequence of b1
for b3 being non trivial FinSequence of b1 holds
   (b2 ^' b3) /. len (b2 ^' b3) = b3 /. len b3;

:: GRAPH_2:th 59
theorem
for b1 being Relation-like Function-like FinSequence-like set holds
   b1 ^' {} = b1;

:: GRAPH_2:th 60
theorem
for b1 being set
for b2 being Relation-like Function-like FinSequence-like set holds
   b2 ^' <*b1*> = b2;

:: GRAPH_2:th 61
theorem
for b1 being non empty set
for b2 being Element of NAT
for b3, b4 being FinSequence of b1
      st 1 <= b2 & b2 <= len b3
   holds (b3 ^' b4) /. b2 = b3 /. b2;

:: GRAPH_2:th 62
theorem
for b1 being non empty set
for b2 being Element of NAT
for b3, b4 being FinSequence of b1
      st 1 <= b2 & b2 < len b4
   holds (b3 ^' b4) /. ((len b3) + b2) = b4 /. (b2 + 1);

:: GRAPH_2:funcnot 8 => GRAPH_2:func 8
definition
  let a1 be FinSequence of INT;
  let a2, a3 be Element of NAT;
  assume 1 <= a2 & a2 <= a3 & a3 <= len a1;
  func min_at(A1,A2,A3) -> Element of NAT means
    ex b1 being non empty finite Element of bool INT st
       b1 = proj2 ((a2,a3)-cut a1) &
        it + 1 = ((lower_bound b1) .. ((a2,a3)-cut a1)) + a2;
end;

:: GRAPH_2:def 12
theorem
for b1 being FinSequence of INT
for b2, b3 being Element of NAT
   st 1 <= b2 & b2 <= b3 & b3 <= len b1
for b4 being Element of NAT holds
      b4 = min_at(b1,b2,b3)
   iff
      ex b5 being non empty finite Element of bool INT st
         b5 = proj2 ((b2,b3)-cut b1) &
          b4 + 1 = ((lower_bound b5) .. ((b2,b3)-cut b1)) + b2;

:: GRAPH_2:th 63
theorem
for b1 being FinSequence of INT
for b2, b3, b4 being Element of NAT
      st 1 <= b2 & b2 <= b3 & b3 <= len b1
   holds    b4 = min_at(b1,b2,b3)
   iff
      b2 <= b4 &
       b4 <= b3 &
       (for b5 being Element of NAT
             st b2 <= b5 & b5 <= b3
          holds b1 . b4 <= b1 . b5) &
       (for b5 being Element of NAT
             st b2 <= b5 & b5 < b4
          holds b1 . b4 < b1 . b5);

:: GRAPH_2:th 64
theorem
for b1 being FinSequence of INT
for b2 being Element of NAT
      st 1 <= b2 & b2 <= len b1
   holds min_at(b1,b2,b2) = b2;

:: GRAPH_2:prednot 3 => GRAPH_2:pred 3
definition
  let a1 be FinSequence of INT;
  let a2, a3 be Element of NAT;
  pred A1 is_non_decreasing_on A2,A3 means
    for b1, b2 being Element of NAT
          st a2 <= b1 & b1 <= b2 & b2 <= a3
       holds a1 . b1 <= a1 . b2;
end;

:: GRAPH_2:dfs 12
definiens
  let a1 be FinSequence of INT;
  let a2, a3 be Element of NAT;
To prove
     a1 is_non_decreasing_on a2,a3
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st a2 <= b1 & b1 <= b2 & b2 <= a3
       holds a1 . b1 <= a1 . b2;

:: GRAPH_2:def 13
theorem
for b1 being FinSequence of INT
for b2, b3 being Element of NAT holds
   b1 is_non_decreasing_on b2,b3
iff
   for b4, b5 being Element of NAT
         st b2 <= b4 & b4 <= b5 & b5 <= b3
      holds b1 . b4 <= b1 . b5;

:: GRAPH_2:prednot 4 => GRAPH_2:pred 4
definition
  let a1 be FinSequence of INT;
  let a2 be Element of NAT;
  pred A1 is_split_at A2 means
    for b1, b2 being Element of NAT
          st 1 <= b1 & b1 <= a2 & a2 < b2 & b2 <= len a1
       holds a1 . b1 <= a1 . b2;
end;

:: GRAPH_2:dfs 13
definiens
  let a1 be FinSequence of INT;
  let a2 be Element of NAT;
To prove
     a1 is_split_at a2
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st 1 <= b1 & b1 <= a2 & a2 < b2 & b2 <= len a1
       holds a1 . b1 <= a1 . b2;

:: GRAPH_2:def 14
theorem
for b1 being FinSequence of INT
for b2 being Element of NAT holds
      b1 is_split_at b2
   iff
      for b3, b4 being Element of NAT
            st 1 <= b3 & b3 <= b2 & b2 < b4 & b4 <= len b1
         holds b1 . b3 <= b1 . b4;

:: GRAPH_2:th 65
theorem
for b1, b2 being FinSequence of INT
for b3, b4 being Element of NAT
      st b3 + 1 <= len b1 &
         b4 = min_at(b1,b3 + 1,len b1) &
         b1 is_split_at b3 &
         b1 is_non_decreasing_on 1,b3 &
         b2 = (b1 +*(b3 + 1,b1 . b4)) +*(b4,b1 . (b3 + 1))
   holds b2 is_non_decreasing_on 1,b3 + 1;

:: GRAPH_2:th 66
theorem
for b1, b2 being FinSequence of INT
for b3, b4 being Element of NAT
      st b3 + 1 <= len b1 &
         b4 = min_at(b1,b3 + 1,len b1) &
         b1 is_split_at b3 &
         b2 = (b1 +*(b3 + 1,b1 . b4)) +*(b4,b1 . (b3 + 1))
   holds b2 is_split_at b3 + 1;