Article CHORD, MML version 4.99.1005

:: CHORD:th 1
theorem
for b1 being non empty natural set holds
   b1 - 1 is natural set & 1 <= b1;

:: CHORD:th 2
theorem
for b1 being natural odd set holds
   b1 - 1 is natural set & 1 <= b1;

:: CHORD:th 3
theorem
for b1, b2 being integer odd set
      st b1 < b2
   holds b1 <= b2 - 2;

:: CHORD:th 4
theorem
for b1, b2 being integer odd set
      st b2 < b1
   holds b2 + 2 <= b1;

:: CHORD:th 5
theorem
for b1 being natural odd set
      st 1 <> b1
   holds ex b2 being natural odd set st
      b2 + 2 = b1;

:: CHORD:th 6
theorem
for b1 being natural odd set
      st b1 <= 2
   holds b1 = 1;

:: CHORD:th 7
theorem
for b1 being natural odd set
      st b1 <= 4 & b1 <> 1
   holds b1 = 3;

:: CHORD:th 8
theorem
for b1 being natural odd set
      st b1 <= 6 & b1 <> 1 & b1 <> 3
   holds b1 = 5;

:: CHORD:th 9
theorem
for b1 being natural odd set
      st b1 <= 8 & b1 <> 1 & b1 <> 3 & b1 <> 5
   holds b1 = 7;

:: CHORD:th 10
theorem
for b1 being natural even set
      st b1 <= 1
   holds b1 = 0;

:: CHORD:th 11
theorem
for b1 being natural even set
      st b1 <= 3 & b1 <> 0
   holds b1 = 2;

:: CHORD:th 12
theorem
for b1 being natural even set
      st b1 <= 5 & b1 <> 0 & b1 <> 2
   holds b1 = 4;

:: CHORD:th 13
theorem
for b1 being natural even set
      st b1 <= 7 & b1 <> 0 & b1 <> 2 & b1 <> 4
   holds b1 = 6;

:: CHORD:th 14
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being non empty natural set
      st b1 is one-to-one & b2 <= len b1
   holds (b1 . b2) .. b1 = b2;

:: CHORD:th 15
theorem
for b1 being non empty Relation-like Function-like FinSequence-like set
for b2 being non empty Element of bool proj2 b1 holds
   ex b3 being set st
      b3 in b2 &
       (for b4 being set
             st b4 in b2
          holds b3 .. b1 <= b4 .. b1);

:: CHORD:funcnot 1 => CHORD:func 1
definition
  let a1 be Relation-like Function-like FinSequence-like set;
  let a2 be natural set;
  func A1 .followSet A2 -> finite set equals
    proj2 ((a2,len a1)-cut a1);
end;

:: CHORD:def 1
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being natural set holds
   b1 .followSet b2 = proj2 ((b2,len b1)-cut b1);

:: CHORD:th 16
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being set
for b3 being natural set
      st b2 in proj2 b1 & b3 in dom b1 & b1 is one-to-one
   holds    b2 in b1 .followSet b3
   iff
      b3 <= b2 .. b1;

:: CHORD:th 17
theorem
for b1, b2 being Relation-like Function-like FinSequence-like set
for b3 being set
   st b1 = <*b3*> ^ b2
for b4 being non empty natural set holds
   b1 .followSet (b4 + 1) = b2 .followSet b4;

:: CHORD:th 18
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2
      st len Seq b3 = len b2
   holds Seq b3 = b2;

:: CHORD:th 19
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4, b5 being set
   st b4 in b2 & b5 in b2
for b6 being set
      st b6 Joins b4,b5,b1
   holds b6 Joins b4,b5,b3;

:: CHORD:th 20
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is Trail-like(b1)
   iff
      len b2 = (2 * card (b2 .edges())) + 1;

:: CHORD:th 21
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ b2,b1 .edgesBetween ((the_Vertices_of b1) \ b2)
for b4 being Walk of b1
      st for b5 being natural odd set
              st b5 <= len b4
           holds not b4 . b5 in b2
   holds b4 is Walk of b3;

:: CHORD:th 22
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
   st b2 <> b3
for b4 being Walk of b1
      st b4 .vertices() = {b2,b3}
   holds ex b5 being set st
      b5 Joins b2,b3,b1;

:: CHORD:th 23
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Walk of b1
      st b4 .vertices() c= b2
   holds b4 is Walk of b3;

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

:: CHORD:th 25
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being natural odd set
      st b3 <= len b2 & b4 <= len b2 & b2 . b3 = b2 . b4 & b3 <> b4 & (b3 = 1 implies b4 <> len b2)
   holds b3 = len b2 & b4 = 1;

:: CHORD:th 26
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is open(b1)
for b3, b4, b5 being set
      st not b3 in b2 .vertices() & b5 = b2 .first() & b4 Joins b3,b5,b1
   holds (b1 .walkOf(b3,b4,b5)) .append b2 is Path-like(b1);

:: CHORD:th 27
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Path-like Walk of b1
      st b2 .edges() misses b3 .edges() &
         b2 is not trivial(b1) &
         b2 is open(b1) &
         b3 is not trivial(b1) &
         b3 is open(b1) &
         b2 .vertices() /\ (b3 .vertices()) = {b2 .first(),b2 .last()} &
         b3 .first() = b2 .last() &
         b3 .last() = b2 .first()
   holds b2 .append b3 is Cycle-like(b1);

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

:: CHORD:th 29
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being non empty Element of bool the_Vertices_of b1
   st b3 c= b2
for b4 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b5 being inducedSubgraph of b4,b3,b4 .edgesBetween b3 holds
   b5 is inducedSubgraph of b1,b3,b1 .edgesBetween b3;

:: CHORD:th 30
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being non empty Element of bool the_Vertices_of b1
   st b3 c= b2
for b4 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b5 being inducedSubgraph of b1,b3,b1 .edgesBetween b3 holds
   b5 is inducedSubgraph of b4,b3,b4 .edgesBetween b3;

:: CHORD:th 31
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being non empty Element of bool the_Vertices_of b1
   st b3 c= b2
for b4 being inducedSubgraph of b1,b2,b1 .edgesBetween b2 holds
   b4 .edgesBetween b3 = b1 .edgesBetween b3;

:: CHORD:sch 1
scheme CHORD:sch 1
for b1 being [Graph-like] finite GraphStruct holds
   P1[b1]
provided
   for b1 being non empty natural set
      st for b2 being [Graph-like] finite GraphStruct
              st b2 .order() < b1
           holds P1[b2]
   for b2 being [Graph-like] finite GraphStruct
         st b2 .order() = b1
      holds P1[b2];


:: CHORD:th 32
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is open(b1) & b2 is Path-like(b1)
   holds b2 is vertex-distinct(b1);

:: CHORD:th 33
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is open(b1) & 3 < len b2
for b3 being set
      st b3 Joins b2 .last(),b2 .first(),b1
   holds b2 .addEdge b3 is Cycle-like(b1);

:: CHORD:attrnot 1 => CHORD:attr 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is minlength means
    for b1 being Walk of a1
          st b1 is_Walk_from a2 .first(),a2 .last()
       holds len a2 <= len b1;
end;

:: CHORD:dfs 2
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is minlength
it is sufficient to prove
  thus for b1 being Walk of a1
          st b1 is_Walk_from a2 .first(),a2 .last()
       holds len a2 <= len b1;

:: CHORD:def 2
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is minlength(b1)
   iff
      for b3 being Walk of b1
            st b3 is_Walk_from b2 .first(),b2 .last()
         holds len b2 <= len b3;

:: CHORD:th 34
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Subwalk of b2
      st b3 .first() = b2 .first() & b3 .edgeSeq() = b2 .edgeSeq()
   holds b3 = b2;

:: CHORD:th 35
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Subwalk of b2
      st len b3 = len b2
   holds b3 = b2;

:: CHORD:th 36
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is minlength(b1)
   holds b2 is Path-like(b1);

:: CHORD:th 37
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is minlength(b1)
   holds b2 is Path-like(b1);

:: CHORD:th 38
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st for b3 being Path-like Walk of b1
              st b3 is_Walk_from b2 .first(),b2 .last()
           holds len b2 <= len b3
   holds b2 is minlength(b1);

:: CHORD:th 39
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
   ex b3 being Path-like Walk of b1 st
      b3 is_Walk_from b2 .first(),b2 .last() & b3 is minlength(b1);

:: CHORD:th 40
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
   st b2 is minlength(b1)
for b3, b4 being natural odd set
   st b3 + 2 < b4 & b4 <= len b2
for b5 being set holds
   not b5 Joins b2 . b3,b2 . b4,b1;

:: CHORD:th 41
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Walk of b3
   st b4 is minlength(b3)
for b5, b6 being natural odd set
   st b5 + 2 < b6 & b6 <= len b4
for b7 being set holds
   not b7 Joins b4 . b5,b4 . b6,b1;

:: CHORD:th 42
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
   st b2 is minlength(b1)
for b3, b4 being natural odd set
      st b3 <= b4 & b4 <= len b2
   holds b2 .cut(b3,b4) is minlength(b1);

:: CHORD:th 43
theorem
for b1 being [Graph-like] GraphStruct
   st b1 is connected
for b2, b3 being non empty Element of bool the_Vertices_of b1
      st b2 misses b3
   holds ex b4 being Path-like Walk of b1 st
      b4 is minlength(b1) &
       b4 is not trivial(b1) &
       b4 .first() in b2 &
       b4 .last() in b3 &
       (for b5 being natural odd set
             st 1 < b5 & b5 < len b4
          holds not b4 . b5 in b2 & not b4 . b5 in b3);

:: CHORD:prednot 1 => CHORD:pred 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Element of the_Vertices_of a1;
  pred A2,A3 are_adjacent means
    ex b1 being set st
       b1 Joins a2,a3,a1;
  symmetry;
::  for a1 being [Graph-like] GraphStruct
::  for a2, a3 being Element of the_Vertices_of a1
::        st a2,a3 are_adjacent
::     holds a3,a2 are_adjacent;
end;

:: CHORD:dfs 3
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Element of the_Vertices_of a1;
To prove
     a2,a3 are_adjacent
it is sufficient to prove
  thus ex b1 being set st
       b1 Joins a2,a3,a1;

:: CHORD:def 3
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1 holds
   b2,b3 are_adjacent
iff
   ex b4 being set st
      b4 Joins b2,b3,b1;

:: CHORD:th 44
theorem
for b1, b2 being [Graph-like] GraphStruct
   st b1 == b2
for b3, b4 being Element of the_Vertices_of b1
   st b3,b4 are_adjacent
for b5, b6 being Element of the_Vertices_of b2
      st b3 = b5 & b4 = b6
   holds b5,b6 are_adjacent;

:: CHORD:th 45
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4, b5 being Element of the_Vertices_of b1
for b6, b7 being Element of the_Vertices_of b3
      st b4 = b6 & b5 = b7
   holds    b4,b5 are_adjacent
   iff
      b6,b7 are_adjacent;

:: CHORD:th 46
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 .first() <> b2 .last() & not b2 .first(),b2 .last() are_adjacent
   holds 2 <= b2 .length();

:: CHORD:th 47
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being Element of the_Vertices_of b1
      st b2 <> b3 & b2 <> b4 & b3 <> b4 & b2,b3 are_adjacent & b3,b4 are_adjacent
   holds ex b5 being Path-like Walk of b1 st
      ex b6, b7 being set st
         b5 is open(b1) & len b5 = 5 & b5 .length() = 2 & b6 Joins b2,b3,b1 & b7 Joins b3,b4,b1 & b5 .edges() = {b6,b7} & b5 .vertices() = {b2,b3,b4} & b5 . 1 = b2 & b5 . 3 = b3 & b5 . 5 = b4;

:: CHORD:th 48
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5 being Element of the_Vertices_of b1
      st b2 <> b3 & b2 <> b4 & b3 <> b4 & b3 <> b5 & b4 <> b5 & b2,b3 are_adjacent & b3,b4 are_adjacent & b4,b5 are_adjacent
   holds ex b6 being Path-like Walk of b1 st
      len b6 = 7 & b6 .length() = 3 & b6 .vertices() = {b2,b3,b4,b5} & b6 . 1 = b2 & b6 . 3 = b3 & b6 . 5 = b4 & b6 . 7 = b5;

:: CHORD:funcnot 2 => CHORD:func 2
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  func A1 .AdjacentSet A2 -> Element of bool the_Vertices_of a1 equals
    {b1 where b1 is Element of the_Vertices_of a1: not b1 in a2 &
     (ex b2 being Element of the_Vertices_of a1 st
        b2 in a2 & b1,b2 are_adjacent)};
end;

:: CHORD:def 4
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
   b1 .AdjacentSet b2 = {b3 where b3 is Element of the_Vertices_of b1: not b3 in b2 &
    (ex b4 being Element of the_Vertices_of b1 st
       b4 in b2 & b3,b4 are_adjacent)};

:: CHORD:th 49
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
      st b3 in b1 .AdjacentSet b2
   holds not b3 in b2;

:: CHORD:th 50
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
      b3 in b1 .AdjacentSet b2
   iff
      not b3 in b2 &
       (ex b4 being Element of the_Vertices_of b1 st
          b4 in b2 & b3,b4 are_adjacent);

:: CHORD:th 51
theorem
for b1, b2 being [Graph-like] GraphStruct
   st b1 == b2
for b3 being set holds
   b1 .AdjacentSet b3 = b2 .AdjacentSet b3;

:: CHORD:th 52
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1 holds
   b2 in b1 .AdjacentSet {b3}
iff
   b2 <> b3 & b3,b2 are_adjacent;

:: CHORD:th 53
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set holds
   b2 in b1 .AdjacentSet {b3}
iff
   b3 in b1 .AdjacentSet {b2};

:: CHORD:th 54
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is Cycle-like(b1) & 3 < b2 .length()
for b3 being Element of the_Vertices_of b1
      st b3 in b2 .vertices()
   holds ex b4, b5 being natural odd set st
      b4 + 2 < b5 &
       b5 <= len b2 &
       (b4 = 1 implies b5 <> len b2) &
       (b4 = 1 implies b5 <> (len b2) - 2) &
       (b4 = 3 implies b5 <> len b2) &
       b2 . b4 <> b2 . b5 &
       b2 . b4 in b1 .AdjacentSet {b3} &
       b2 . b5 in b1 .AdjacentSet {b3};

:: CHORD:th 55
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is Cycle-like(b1) & 3 < b2 .length()
for b3 being Element of the_Vertices_of b1
      st b3 in b2 .vertices()
   holds ex b4, b5 being natural odd set st
      b4 + 2 < b5 &
       b5 <= len b2 &
       b2 . b4 <> b2 . b5 &
       b2 . b4 in b1 .AdjacentSet {b3} &
       b2 . b5 in b1 .AdjacentSet {b3} &
       (for b6 being set
             st b6 in b2 .edges()
          holds not b6 Joins b2 . b4,b2 . b5,b1);

:: CHORD:th 56
theorem
for b1 being [Graph-like] loopless GraphStruct
for b2 being Element of the_Vertices_of b1 holds
      b1 .AdjacentSet {b2} = {}
   iff
      b2 is isolated(b1);

:: CHORD:th 57
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being non empty Element of bool the_Vertices_of b1
for b4 being Element of the_Vertices_of b1
for b5 being inducedSubgraph of b1,b3,b1 .edgesBetween b3
for b6 being inducedSubgraph of b1,b3 \/ {b4},b1 .edgesBetween (b3 \/ {b4})
      st b5 is connected & b4 in b1 .AdjacentSet the_Vertices_of b5
   holds b6 is connected;

:: CHORD:th 58
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Element of the_Vertices_of b1
   st b4 in b2 & b1 .AdjacentSet {b4} c= b2
for b5 being Element of the_Vertices_of b3
      st b4 = b5
   holds b1 .AdjacentSet {b4} = b3 .AdjacentSet {b5};

:: CHORD:modenot 1 => CHORD:mode 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  mode AdjGraph of A1,A2 -> Subgraph of a1 means
      case a2 is Element of bool the_Vertices_of a1;
    thus it is inducedSubgraph of a1,a1 .AdjacentSet a2,a1 .edgesBetween (a1 .AdjacentSet a2);
  end;
;
end;

:: CHORD:dfs 5
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  let a3 be Subgraph of a1;
To prove
     a3 is AdjGraph of a1,a2
it is sufficient to prove
  thus   case a2 is Element of bool the_Vertices_of a1;
    thus a3 is inducedSubgraph of a1,a1 .AdjacentSet a2,a1 .edgesBetween (a1 .AdjacentSet a2);
  end;
;

:: CHORD:def 5
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Subgraph of b1
      st b2 is Element of bool the_Vertices_of b1
   holds    b3 is AdjGraph of b1,b2
   iff
      b3 is inducedSubgraph of b1,b1 .AdjacentSet b2,b1 .edgesBetween (b1 .AdjacentSet b2);

:: CHORD:th 59
theorem
for b1, b2 being [Graph-like] GraphStruct
   st b1 == b2
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
   st b3 = b4
for b5 being AdjGraph of b1,{b3}
for b6 being AdjGraph of b2,{b4} holds
   b5 == b6;

:: CHORD:th 60
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Element of the_Vertices_of b1
   st b4 in b2 & b1 .AdjacentSet {b4} c= b2 & b1 .AdjacentSet {b4} <> {}
for b5 being Element of the_Vertices_of b3
   st b4 = b5
for b6 being AdjGraph of b1,{b4}
for b7 being AdjGraph of b3,{b5} holds
   b6 == b7;

:: CHORD:attrnot 2 => CHORD:attr 2
definition
  let a1 be [Graph-like] GraphStruct;
  attr a1 is complete means
    for b1, b2 being Element of the_Vertices_of a1
          st b1 <> b2
       holds b1,b2 are_adjacent;
end;

:: CHORD:dfs 6
definiens
  let a1 be [Graph-like] GraphStruct;
To prove
     a1 is complete
it is sufficient to prove
  thus for b1, b2 being Element of the_Vertices_of a1
          st b1 <> b2
       holds b1,b2 are_adjacent;

:: CHORD:def 6
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is complete
   iff
      for b2, b3 being Element of the_Vertices_of b1
            st b2 <> b3
         holds b2,b3 are_adjacent;

:: CHORD:th 61
theorem
for b1 being [Graph-like] GraphStruct
      st b1 is trivial
   holds b1 is complete;

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

:: CHORD:exreg 1
registration
  cluster Relation-like Function-like finite [Graph-like] trivial simple complete GraphStruct;
end;

:: CHORD:exreg 2
registration
  cluster Relation-like Function-like finite [Graph-like] finite non trivial simple complete GraphStruct;
end;

:: CHORD:th 62
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2 & b1 is complete
   holds b2 is complete;

:: CHORD:th 63
theorem
for b1 being [Graph-like] complete GraphStruct
for b2 being Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2 holds
   b3 is complete;

:: CHORD:attrnot 3 => CHORD:attr 3
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  attr a2 is simplicial means
    (a1 .AdjacentSet {a2} <> {}) implies for b1 being AdjGraph of a1,{a2} holds
       b1 is complete;
end;

:: CHORD:dfs 7
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
To prove
     a2 is simplicial
it is sufficient to prove
  thus (a1 .AdjacentSet {a2} <> {}) implies for b1 being AdjGraph of a1,{a2} holds
       b1 is complete;

:: CHORD:def 7
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
      b2 is simplicial(b1)
   iff
      (b1 .AdjacentSet {b2} = {} or for b3 being AdjGraph of b1,{b2} holds
         b3 is complete);

:: CHORD:th 64
theorem
for b1 being [Graph-like] complete GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b2 is simplicial(b1);

:: CHORD:th 65
theorem
for b1 being [Graph-like] trivial GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   b2 is simplicial(b1);

:: CHORD:th 66
theorem
for b1, b2 being [Graph-like] GraphStruct
   st b1 == b2
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
      st b3 = b4 & b3 is simplicial(b1)
   holds b4 is simplicial(b2);

:: CHORD:th 67
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Element of the_Vertices_of b1
   st b4 in b2 & b1 .AdjacentSet {b4} c= b2
for b5 being Element of the_Vertices_of b3
      st b4 = b5
   holds    b4 is simplicial(b1)
   iff
      b5 is simplicial(b3);

:: CHORD:th 68
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
   st b2 is simplicial(b1)
for b3, b4 being set
      st b3 <> b4 & b3 in b1 .AdjacentSet {b2} & b4 in b1 .AdjacentSet {b2}
   holds ex b5 being set st
      b5 Joins b3,b4,b1;

:: CHORD:th 69
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
      st b2 is not simplicial(b1)
   holds ex b3, b4 being Element of the_Vertices_of b1 st
      b3 <> b4 & b2 <> b3 & b2 <> b4 & b2,b3 are_adjacent & b2,b4 are_adjacent & not b3,b4 are_adjacent;

:: CHORD:modenot 2 => CHORD:mode 2
definition
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Element of the_Vertices_of a1;
  assume a2 <> a3 & not a2,a3 are_adjacent;
  mode VertexSeparator of A2,A3 -> Element of bool the_Vertices_of a1 means
    not a2 in it &
     not a3 in it &
     (for b1 being inducedSubgraph of a1,(the_Vertices_of a1) \ it,a1 .edgesBetween ((the_Vertices_of a1) \ it)
     for b2 being Walk of b1 holds
        not b2 is_Walk_from a2,a3);
end;

:: CHORD:dfs 8
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Element of the_Vertices_of a1;
  let a4 be Element of bool the_Vertices_of a1;
To prove
     a4 is VertexSeparator of a2,a3
it is sufficient to prove
thus a2 <> a3 & not a2,a3 are_adjacent;
  thus not a2 in a4 &
     not a3 in a4 &
     (for b1 being inducedSubgraph of a1,(the_Vertices_of a1) \ a4,a1 .edgesBetween ((the_Vertices_of a1) \ a4)
     for b2 being Walk of b1 holds
        not b2 is_Walk_from a2,a3);

:: CHORD:def 8
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being Element of bool the_Vertices_of b1 holds
      b4 is VertexSeparator of b2,b3
   iff
      not b2 in b4 &
       not b3 in b4 &
       (for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
       for b6 being Walk of b5 holds
          not b6 is_Walk_from b2,b3);

:: CHORD:th 70
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3 holds
   b4 is VertexSeparator of b3,b2;

:: CHORD:th 71
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being Element of bool the_Vertices_of b1 holds
      b4 is VertexSeparator of b2,b3
   iff
      not b2 in b4 &
       not b3 in b4 &
       (for b5 being Walk of b1
             st b5 is_Walk_from b2,b3
          holds ex b6 being Element of the_Vertices_of b1 st
             b6 in b4 & b6 in b5 .vertices());

:: CHORD:th 72
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
for b5 being Walk of b1
      st b5 is_Walk_from b2,b3
   holds ex b6 being natural odd set st
      1 < b6 & b6 < len b5 & b5 . b6 in b4;

:: CHORD:th 73
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 = {}
for b5 being Walk of b1 holds
   not b5 is_Walk_from b2,b3;

:: CHORD:th 74
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
      st b2 <> b3 &
         not b2,b3 are_adjacent &
         (for b4 being Walk of b1 holds
            not b4 is_Walk_from b2,b3)
   holds {} is VertexSeparator of b2,b3;

:: CHORD:th 75
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
for b6 being Element of the_Vertices_of b5
      st b6 = b2
   holds (b5 .reachableFrom b6) /\ b4 = {};

:: CHORD:th 76
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
for b6, b7 being Element of the_Vertices_of b5
      st b6 = b2 & b7 = b3
   holds (b5 .reachableFrom b6) /\ (b5 .reachableFrom b7) = {};

:: CHORD:th 77
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4) holds
   b2 is Element of the_Vertices_of b5 & b3 is Element of the_Vertices_of b5;

:: CHORD:attrnot 4 => CHORD:attr 4
definition
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Element of the_Vertices_of a1;
  let a4 be VertexSeparator of a2,a3;
  attr a4 is minimal means
    for b1 being Element of bool a4
          st b1 <> a4
       holds b1 is not VertexSeparator of a2,a3;
end;

:: CHORD:dfs 9
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be Element of the_Vertices_of a1;
  let a4 be VertexSeparator of a2,a3;
To prove
     a4 is minimal
it is sufficient to prove
  thus for b1 being Element of bool a4
          st b1 <> a4
       holds b1 is not VertexSeparator of a2,a3;

:: CHORD:def 9
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
for b4 being VertexSeparator of b2,b3 holds
      b4 is minimal(b1, b2, b3)
   iff
      for b5 being Element of bool b4
            st b5 <> b4
         holds b5 is not VertexSeparator of b2,b3;

:: CHORD:th 78
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
for b4 being VertexSeparator of b2,b3
      st b4 = {}
   holds b4 is minimal(b1, b2, b3);

:: CHORD:th 79
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being Element of the_Vertices_of b1 holds
ex b4 being VertexSeparator of b2,b3 st
   b4 is minimal(b1, b2, b3);

:: CHORD:th 80
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3)
for b5 being VertexSeparator of b3,b2
      st b4 = b5
   holds b5 is minimal(b1, b3, b2);

:: CHORD:th 81
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3)
for b5 being Element of the_Vertices_of b1
      st b5 in b4
   holds ex b6 being Walk of b1 st
      b6 is_Walk_from b2,b3 & b5 in b6 .vertices();

:: CHORD:th 82
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3)
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
for b6 being Element of the_Vertices_of b5
   st b6 = b2
for b7 being Element of the_Vertices_of b1
      st b7 in b4
   holds ex b8 being Element of the_Vertices_of b1 st
      b8 in b5 .reachableFrom b6 & b7,b8 are_adjacent;

:: CHORD:th 83
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3)
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
for b6 being Element of the_Vertices_of b5
   st b6 = b3
for b7 being Element of the_Vertices_of b1
      st b7 in b4
   holds ex b8 being Element of the_Vertices_of b1 st
      b8 in b5 .reachableFrom b6 & b7,b8 are_adjacent;

:: CHORD:attrnot 5 => CHORD:attr 5
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  attr a2 is chordal means
    ex b1, b2 being natural odd set st
       b1 + 2 < b2 &
        b2 <= len a2 &
        a2 . b1 <> a2 . b2 &
        (ex b3 being set st
           b3 Joins a2 . b1,a2 . b2,a1) &
        (for b3 being set
              st b3 in a2 .edges()
           holds not b3 Joins a2 . b1,a2 . b2,a1);
end;

:: CHORD:dfs 10
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
To prove
     a2 is chordal
it is sufficient to prove
  thus ex b1, b2 being natural odd set st
       b1 + 2 < b2 &
        b2 <= len a2 &
        a2 . b1 <> a2 . b2 &
        (ex b3 being set st
           b3 Joins a2 . b1,a2 . b2,a1) &
        (for b3 being set
              st b3 in a2 .edges()
           holds not b3 Joins a2 . b1,a2 . b2,a1);

:: CHORD:def 10
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is chordal(b1)
   iff
      ex b3, b4 being natural odd set st
         b3 + 2 < b4 &
          b4 <= len b2 &
          b2 . b3 <> b2 . b4 &
          (ex b5 being set st
             b5 Joins b2 . b3,b2 . b4,b1) &
          (for b5 being set
                st b5 in b2 .edges()
             holds not b5 Joins b2 . b3,b2 . b4,b1);

:: CHORD:attrnot 6 => CHORD:attr 5
notation
  let a1 be [Graph-like] GraphStruct;
  let a2 be Walk of a1;
  antonym chordless for chordal;
end;

:: CHORD:th 84
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is chordal(b1)
   holds ex b3, b4 being natural odd set st
      b3 + 2 < b4 &
       b4 <= len b2 &
       b2 . b3 <> b2 . b4 &
       (ex b5 being set st
          b5 Joins b2 . b3,b2 . b4,b1) &
       (b2 is Cycle-like(b1) implies (b3 = 1 implies b4 <> len b2) &
        (b3 = 1 implies b4 <> (len b2) - 2) &
        (b3 = 3 implies b4 <> len b2));

:: CHORD:th 85
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
      st ex b3, b4 being natural odd set st
           b3 + 2 < b4 &
            b4 <= len b2 &
            (ex b5 being set st
               b5 Joins b2 . b3,b2 . b4,b1) &
            (b2 is Cycle-like(b1) implies (b3 = 1 implies b4 <> len b2) &
             (b3 = 1 implies b4 <> (len b2) - 2) &
             (b3 = 3 implies b4 <> len b2))
   holds b2 is chordal(b1);

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

:: CHORD:th 87
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Walk of b1
for b5 being Walk of b3
      st b4 = b5
   holds    b5 is chordal(b3)
   iff
      b4 is chordal(b1);

:: CHORD:th 88
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is Cycle-like(b1) & b2 is chordal(b1) & b2 .length() = 4
   holds ex b3 being set st
      (b3 Joins b2 . 1,b2 . 5,b1 or b3 Joins b2 . 3,b2 . 7,b1);

:: CHORD:th 89
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is minlength(b1)
   holds b2 is chordless(b1);

:: CHORD:th 90
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
      st b2 is open(b1) & len b2 = 5 & not b2 .first(),b2 .last() are_adjacent
   holds b2 is chordless(b1);

:: CHORD:th 91
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
      b2 is chordal(b1)
   iff
      b2 .reverse() is chordal(b1);

:: CHORD:th 92
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is open(b1) & b2 is chordless(b1)
for b3, b4 being natural odd set
      st b3 < b4 & b4 <= len b2
   holds    ex b5 being set st
         b5 Joins b2 . b3,b2 . b4,b1
   iff
      b3 + 2 = b4;

:: CHORD:th 93
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
   st b2 is open(b1) & b2 is chordless(b1)
for b3, b4 being natural odd set
      st b3 < b4 & b4 <= len b2
   holds b2 .cut(b3,b4) is chordless(b1) & b2 .cut(b3,b4) is open(b1);

:: CHORD:th 94
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,b2,b1 .edgesBetween b2
for b4 being Walk of b1
for b5 being Walk of b3
      st b4 = b5
   holds    b4 is chordless(b1)
   iff
      b5 is chordless(b3);

:: CHORD:attrnot 7 => CHORD:attr 6
definition
  let a1 be [Graph-like] GraphStruct;
  attr a1 is chordal means
    for b1 being Walk of a1
          st 3 < b1 .length() & b1 is Cycle-like(a1)
       holds b1 is chordal(a1);
end;

:: CHORD:dfs 11
definiens
  let a1 be [Graph-like] GraphStruct;
To prove
     a1 is chordal
it is sufficient to prove
  thus for b1 being Walk of a1
          st 3 < b1 .length() & b1 is Cycle-like(a1)
       holds b1 is chordal(a1);

:: CHORD:def 11
theorem
for b1 being [Graph-like] GraphStruct holds
      b1 is chordal
   iff
      for b2 being Walk of b1
            st 3 < b2 .length() & b2 is Cycle-like(b1)
         holds b2 is chordal(b1);

:: CHORD:th 95
theorem
for b1, b2 being [Graph-like] GraphStruct
      st b1 == b2 & b1 is chordal
   holds b2 is chordal;

:: CHORD:th 96
theorem
for b1 being [Graph-like] finite GraphStruct
      st card the_Vertices_of b1 <= 3
   holds b1 is chordal;

:: CHORD:exreg 3
registration
  cluster Relation-like Function-like finite [Graph-like] finite trivial chordal GraphStruct;
end;

:: CHORD:exreg 4
registration
  cluster Relation-like Function-like finite [Graph-like] finite non trivial simple chordal GraphStruct;
end;

:: CHORD:condreg 2
registration
  cluster [Graph-like] complete -> chordal (GraphStruct);
end;

:: CHORD:condreg 3
registration
  let a1 be [Graph-like] chordal GraphStruct;
  let a2 be set;
  cluster -> chordal (inducedSubgraph of a1,a2,a1 .edgesBetween a2);
end;

:: CHORD:th 97
theorem
for b1 being [Graph-like] chordal GraphStruct
for b2 being Path-like Walk of b1
   st b2 is open(b1) & b2 is chordless(b1)
for b3, b4 being set
      st not b3 in b2 .vertices() &
         b4 Joins b2 .last(),b3,b1 &
         (for b5 being set holds
            not b5 Joins b2 . ((len b2) - 2),b3,b1)
   holds b2 .addEdge b4 is Path-like(b1) & b2 .addEdge b4 is open(b1) & b2 .addEdge b4 is chordless(b1);

:: CHORD:th 98
theorem
for b1 being [Graph-like] chordal GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3) & b4 is not empty
for b5 being inducedSubgraph of b1,b4,b1 .edgesBetween b4 holds
   b5 is complete;

:: CHORD:th 99
theorem
for b1 being [Graph-like] finite GraphStruct
      st for b2, b3 being Element of the_Vertices_of b1
           st b2 <> b3 & not b2,b3 are_adjacent
        for b4 being VertexSeparator of b2,b3
           st b4 is minimal(b1, b2, b3) & b4 is not empty
        for b5 being inducedSubgraph of b1,b4,b1 .edgesBetween b4 holds
           b5 is complete
   holds b1 is chordal;

:: CHORD:th 100
theorem
for b1 being [Graph-like] finite chordal GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3)
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
for b6 being Element of the_Vertices_of b5
      st b2 = b6
   holds ex b7 being Element of the_Vertices_of b1 st
      b7 in b5 .reachableFrom b6 &
       (for b8 being Element of the_Vertices_of b1
             st b8 in b4
          holds b7,b8 are_adjacent);

:: CHORD:th 101
theorem
for b1 being [Graph-like] finite chordal GraphStruct
for b2, b3 being Element of the_Vertices_of b1
   st b2 <> b3 & not b2,b3 are_adjacent
for b4 being VertexSeparator of b2,b3
   st b4 is minimal(b1, b2, b3)
for b5 being inducedSubgraph of b1,(the_Vertices_of b1) \ b4,b1 .edgesBetween ((the_Vertices_of b1) \ b4)
for b6 being Element of the_Vertices_of b5
   st b2 = b6
for b7, b8 being Element of the_Vertices_of b1
      st b7 in b4 & b8 in b4
   holds ex b9 being Element of the_Vertices_of b1 st
      b9 in b5 .reachableFrom b6 & b9,b7 are_adjacent & b9,b8 are_adjacent;

:: CHORD:th 102
theorem
for b1 being [Graph-like] finite non trivial chordal GraphStruct
      st b1 is not complete
   holds ex b2, b3 being Element of the_Vertices_of b1 st
      b2 <> b3 & not b2,b3 are_adjacent & b2 is simplicial(b1) & b3 is simplicial(b1);

:: CHORD:th 103
theorem
for b1 being [Graph-like] finite chordal GraphStruct holds
   ex b2 being Element of the_Vertices_of b1 st
      b2 is simplicial(b1);

:: CHORD:modenot 3 => CHORD:mode 3
definition
  let a1 be [Graph-like] finite GraphStruct;
  mode VertexScheme of A1 -> FinSequence of the_Vertices_of a1 means
    it is one-to-one & proj2 it = the_Vertices_of a1;
end;

:: CHORD:dfs 12
definiens
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be FinSequence of the_Vertices_of a1;
To prove
     a2 is VertexScheme of a1
it is sufficient to prove
  thus a2 is one-to-one & proj2 a2 = the_Vertices_of a1;

:: CHORD:def 12
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being FinSequence of the_Vertices_of b1 holds
      b2 is VertexScheme of b1
   iff
      b2 is one-to-one & proj2 b2 = the_Vertices_of b1;

:: CHORD:condreg 4
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster -> non empty (VertexScheme of a1);
end;

:: CHORD:th 104
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being VertexScheme of b1 holds
   len b2 = card the_Vertices_of b1;

:: CHORD:th 105
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being VertexScheme of b1 holds
   1 <= len b2;

:: CHORD:th 106
theorem
for b1, b2 being [Graph-like] finite GraphStruct
for b3 being VertexScheme of b1
      st b1 == b2
   holds b3 is VertexScheme of b2;

:: CHORD:funcnot 3 => CHORD:func 3
definition
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be VertexScheme of a1;
  let a3 be Element of the_Vertices_of a1;
  redefine func a3 .. a2 -> non empty Element of NAT;
end;

:: CHORD:funcnot 4 => CHORD:func 4
definition
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be VertexScheme of a1;
  let a3 be natural set;
  redefine func a2 .followSet a3 -> Element of bool the_Vertices_of a1;
end;

:: CHORD:th 107
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being VertexScheme of b1
for b3 being non empty natural set
      st b3 <= len b2
   holds b2 .followSet b3 is not empty;

:: CHORD:attrnot 8 => CHORD:attr 7
definition
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be VertexScheme of a1;
  attr a2 is perfect means
    for b1 being non empty natural set
       st b1 <= len a2
    for b2 being inducedSubgraph of a1,a2 .followSet b1,a1 .edgesBetween (a2 .followSet b1)
    for b3 being Element of the_Vertices_of b2
          st b3 = a2 . b1
       holds b3 is simplicial(b2);
end;

:: CHORD:dfs 13
definiens
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be VertexScheme of a1;
To prove
     a2 is perfect
it is sufficient to prove
  thus for b1 being non empty natural set
       st b1 <= len a2
    for b2 being inducedSubgraph of a1,a2 .followSet b1,a1 .edgesBetween (a2 .followSet b1)
    for b3 being Element of the_Vertices_of b2
          st b3 = a2 . b1
       holds b3 is simplicial(b2);

:: CHORD:def 13
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being VertexScheme of b1 holds
      b2 is perfect(b1)
   iff
      for b3 being non empty natural set
         st b3 <= len b2
      for b4 being inducedSubgraph of b1,b2 .followSet b3,b1 .edgesBetween (b2 .followSet b3)
      for b5 being Element of the_Vertices_of b4
            st b5 = b2 . b3
         holds b5 is simplicial(b4);

:: CHORD:th 108
theorem
for b1 being [Graph-like] finite trivial GraphStruct
for b2 being Element of the_Vertices_of b1 holds
   ex b3 being VertexScheme of b1 st
      b3 = <*b2*> & b3 is perfect(b1);

:: CHORD:th 109
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being VertexScheme of b1 holds
      b2 is perfect(b1)
   iff
      for b3, b4, b5 being Element of the_Vertices_of b1
         st b4 <> b5 & b3,b4 are_adjacent & b3,b5 are_adjacent
      for b6, b7, b8 being natural set
            st b6 in dom b2 & b7 in dom b2 & b8 in dom b2 & b2 . b6 = b3 & b2 . b7 = b4 & b2 . b8 = b5 & b6 < b7 & b6 < b8
         holds b4,b5 are_adjacent;

:: CHORD:exreg 5
registration
  let a1 be [Graph-like] finite chordal GraphStruct;
  cluster non empty Relation-like Function-like finite FinSequence-like perfect VertexScheme of a1;
end;

:: CHORD:th 110
theorem
for b1, b2 being [Graph-like] finite chordal GraphStruct
for b3 being perfect VertexScheme of b1
      st b1 == b2
   holds b3 is perfect VertexScheme of b2;

:: CHORD:th 111
theorem
for b1 being [Graph-like] finite GraphStruct
      st ex b2 being VertexScheme of b1 st
           b2 is perfect(b1)
   holds b1 is chordal;