Article LEXBFS, MML version 4.99.1005

:: LEXBFS:th 1
theorem
for b1, b2 being Element of NAT
for b3 being non empty set
for b4 being Function-like quasi_total Relation of NAT,b3
      st b4 is one-to-one
   holds Card {b4 . b5 where b5 is Element of NAT: b1 <= b5 & b5 <= b1 + b2} = b2 + 1;

:: LEXBFS:th 2
theorem
for b1, b2, b3 being natural set
      st b2 <= b3 & b1 < b2
   holds b3 -' b2 < b3 -' b1;

:: LEXBFS:th 3
theorem
for b1, b2 being natural set
      st b1 < b2
   holds (b2 -' (b1 + 1)) + 1 = b2 -' b1;

:: LEXBFS:th 4
theorem
for b1, b2, b3 being natural set
      st b3 <> 0
   holds (b1 + (b2 * b3)) div b3 = (b1 div b3) + b2;

:: LEXBFS:attrnot 1 => LEXBFS:attr 1
definition
  let a1 be set;
  attr a1 is with_finite-elements means
    for b1 being Element of a1 holds
       b1 is finite;
end;

:: LEXBFS:dfs 1
definiens
  let a1 be set;
To prove
     a1 is with_finite-elements
it is sufficient to prove
  thus for b1 being Element of a1 holds
       b1 is finite;

:: LEXBFS:def 1
theorem
for b1 being set holds
      b1 is with_finite-elements
   iff
      for b2 being Element of b1 holds
         b2 is finite;

:: LEXBFS:exreg 1
registration
  cluster non empty with_finite-elements set;
end;

:: LEXBFS:exreg 2
registration
  cluster non empty finite with_finite-elements Element of bool bool NAT;
end;

:: LEXBFS:condreg 1
registration
  let a1 be with_finite-elements set;
  cluster -> finite (Element of a1);
end;

:: LEXBFS:funcnot 1 => LEXBFS:func 1
definition
  let a1, a2 be Relation-like Function-like set;
  func A1 .\/ A2 -> Relation-like Function-like set means
    proj1 it = (proj1 a1) \/ proj1 a2 &
     (for b1 being set
           st b1 in (proj1 a1) \/ proj1 a2
        holds it . b1 = (a1 . b1) \/ (a2 . b1));
end;

:: LEXBFS:def 2
theorem
for b1, b2, b3 being Relation-like Function-like set holds
   b3 = b1 .\/ b2
iff
   proj1 b3 = (proj1 b1) \/ proj1 b2 &
    (for b4 being set
          st b4 in (proj1 b1) \/ proj1 b2
       holds b3 . b4 = (b1 . b4) \/ (b2 . b4));

:: LEXBFS:th 5
theorem
for b1, b2, b3 being natural set holds
   b1 in (Seg b3) \ Seg (b3 -' b2)
iff
   b3 -' b2 < b1 & b1 <= b3;

:: LEXBFS:th 6
theorem
for b1, b2, b3 being natural set
      st b1 <= b3
   holds (Seg b2) \ Seg (b2 -' b1) c= (Seg b2) \ Seg (b2 -' b3);

:: LEXBFS:th 7
theorem
for b1, b2 being natural set
      st b1 < b2
   holds ((Seg b2) \ Seg (b2 -' b1)) \/ {b2 -' b1} = (Seg b2) \ Seg (b2 -' (b1 + 1));

:: LEXBFS:attrnot 2 => LEXBFS:attr 2
definition
  let a1 be Relation-like set;
  attr a1 is natsubset-yielding means
    proj2 a1 c= bool NAT;
end;

:: LEXBFS:dfs 3
definiens
  let a1 be Relation-like set;
To prove
     a1 is natsubset-yielding
it is sufficient to prove
  thus proj2 a1 c= bool NAT;

:: LEXBFS:def 3
theorem
for b1 being Relation-like set holds
      b1 is natsubset-yielding
   iff
      proj2 b1 c= bool NAT;

:: LEXBFS:exreg 3
registration
  cluster Relation-like Function-like finite-yielding natsubset-yielding set;
end;

:: LEXBFS:funcnot 2 => LEXBFS:func 2
definition
  let a1 be Relation-like Function-like finite-yielding natsubset-yielding set;
  let a2 be set;
  redefine func a1 . a2 -> finite Element of bool NAT;
end;

:: LEXBFS:th 8
theorem
for b1 being ordinal set
for b2, b3 being finite Element of bool b1
      st b2 <> b3
   holds (b2,1)-bag <> (b3,1)-bag;

:: LEXBFS:funcnot 3 => LEXBFS:func 3
definition
  let a1 be Relation-like Function-like natural-valued set;
  let a2 be set;
  let a3 be natural set;
  func A1 .incSubset(A2,A3) -> Relation-like Function-like natural-valued set means
    proj1 it = proj1 a1 &
     (for b1 being set holds
        (b1 in a2 & b1 in proj1 a1 implies it . b1 = (a1 . b1) + a3) &
         (b1 in a2 or it . b1 = a1 . b1));
end;

:: LEXBFS:def 4
theorem
for b1 being Relation-like Function-like natural-valued set
for b2 being set
for b3 being natural set
for b4 being Relation-like Function-like natural-valued set holds
      b4 = b1 .incSubset(b2,b3)
   iff
      proj1 b4 = proj1 b1 &
       (for b5 being set holds
          (b5 in b2 & b5 in proj1 b1 implies b4 . b5 = (b1 . b5) + b3) &
           (b5 in b2 or b4 . b5 = b1 . b5));

:: LEXBFS:funcnot 4 => LEXBFS:func 4
definition
  let a1 be ordinal set;
  let a2 be total reflexive antisymmetric connected transitive Relation of Bags a1,Bags a1;
  let a3 be non empty finite Element of bool Bags a1;
  func max(A3,A2) -> natural-valued finite-support ManySortedSet of a1 means
    it in a3 &
     (for b1 being natural-valued finite-support ManySortedSet of a1
           st b1 in a3
        holds b1 <= it,a2);
end;

:: LEXBFS:def 5
theorem
for b1 being ordinal set
for b2 being total reflexive antisymmetric connected transitive Relation of Bags b1,Bags b1
for b3 being non empty finite Element of bool Bags b1
for b4 being natural-valued finite-support ManySortedSet of b1 holds
      b4 = max(b3,b2)
   iff
      b4 in b3 &
       (for b5 being natural-valued finite-support ManySortedSet of b1
             st b5 in b3
          holds b5 <= b4,b2);

:: LEXBFS:funcreg 1
registration
  let a1 be ordinal set;
  cluster InvLexOrder a1 -> total reflexive antisymmetric connected transitive;
end;

:: LEXBFS:exreg 4
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like one-to-one non empty finite FinSequence-like finite-support VertexSeq of a1;
end;

:: LEXBFS:modenot 1 => LEXBFS:mode 1
definition
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty VertexSeq of a1;
  mode Walk of A2 -> Walk of a1 means
    it .vertexSeq() = a2;
end;

:: LEXBFS:dfs 6
definiens
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty VertexSeq of a1;
  let a3 be Walk of a1;
To prove
     a3 is Walk of a2
it is sufficient to prove
  thus a3 .vertexSeq() = a2;

:: LEXBFS:def 6
theorem
for b1 being [Graph-like] GraphStruct
for b2 being non empty VertexSeq of b1
for b3 being Walk of b1 holds
      b3 is Walk of b2
   iff
      b3 .vertexSeq() = b2;

:: LEXBFS:condreg 2
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be one-to-one non empty VertexSeq of a1;
  cluster -> Path-like (Walk of a2);
end;

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

:: LEXBFS:th 10
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4, b5 being set
for b6 being inducedSubgraph of b1,b3,b1 .edgesBetween b3
for b7 being inducedSubgraph of b2,b4,b2 .edgesBetween b4
for b8 being inducedSubgraph of b6,b5,b6 .edgesBetween b5
for b9 being inducedSubgraph of b7,b5,b7 .edgesBetween b5
      st b1 == b2 & b3 c= b4 & b5 c= b3 & b5 is non empty Element of bool the_Vertices_of b1
   holds b8 == b9;

:: LEXBFS:attrnot 3 => LEXBFS:attr 3
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  attr a1 is natural-vlabeled means
    the_VLabel_of a1 is natural-valued;
end;

:: LEXBFS:dfs 7
definiens
  let a1 be [Graph-like] [VLabeled] GraphStruct;
To prove
     a1 is natural-vlabeled
it is sufficient to prove
  thus the_VLabel_of a1 is natural-valued;

:: LEXBFS:def 7
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct holds
      b1 is natural-vlabeled
   iff
      the_VLabel_of b1 is natural-valued;

:: LEXBFS:funcnot 5 => LEXBFS:func 5
definition
  func V2LabelSelector -> natural set equals
    8;
end;

:: LEXBFS:def 8
theorem
V2LabelSelector = 8;

:: LEXBFS:attrnot 4 => LEXBFS:attr 4
definition
  let a1 be GraphStruct;
  attr a1 is [V2Labeled] means
    V2LabelSelector in proj1 a1 &
     (ex b1 being Relation-like Function-like set st
        a1 . V2LabelSelector = b1 & proj1 b1 c= the_Vertices_of a1);
end;

:: LEXBFS:dfs 9
definiens
  let a1 be GraphStruct;
To prove
     a1 is [V2Labeled]
it is sufficient to prove
  thus V2LabelSelector in proj1 a1 &
     (ex b1 being Relation-like Function-like set st
        a1 . V2LabelSelector = b1 & proj1 b1 c= the_Vertices_of a1);

:: LEXBFS:def 9
theorem
for b1 being GraphStruct holds
      b1 is [V2Labeled]
   iff
      V2LabelSelector in proj1 b1 &
       (ex b2 being Relation-like Function-like set st
          b1 . V2LabelSelector = b2 & proj1 b2 c= the_Vertices_of b1);

:: LEXBFS:exreg 5
registration
  cluster Relation-like Function-like finite finite-support [Graph-like] [Weighted] [ELabeled] [VLabeled] [V2Labeled] GraphStruct;
end;

:: LEXBFS:modenot 2
definition
  mode V2Graph is [Graph-like] [V2Labeled] GraphStruct;
end;

:: LEXBFS:modenot 3
definition
  mode VVGraph is [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
end;

:: LEXBFS:funcnot 6 => LEXBFS:func 6
definition
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  func the_V2Label_of A1 -> Relation-like Function-like set equals
    a1 . V2LabelSelector;
end;

:: LEXBFS:def 10
theorem
for b1 being [Graph-like] [V2Labeled] GraphStruct holds
   the_V2Label_of b1 = b1 . V2LabelSelector;

:: LEXBFS:th 11
theorem
for b1 being [Graph-like] [V2Labeled] GraphStruct holds
   proj1 the_V2Label_of b1 c= the_Vertices_of b1;

:: LEXBFS:funcreg 2
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> [Graph-like];
end;

:: LEXBFS:th 12
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
   b1 .set(V2LabelSelector,b2) == b1;

:: LEXBFS:funcreg 3
registration
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> finite;
end;

:: LEXBFS:funcreg 4
registration
  let a1 be [Graph-like] loopless GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> loopless;
end;

:: LEXBFS:funcreg 5
registration
  let a1 be [Graph-like] trivial GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> trivial;
end;

:: LEXBFS:funcreg 6
registration
  let a1 be [Graph-like] non trivial GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> non trivial;
end;

:: LEXBFS:funcreg 7
registration
  let a1 be [Graph-like] non-multi GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> non-multi;
end;

:: LEXBFS:funcreg 8
registration
  let a1 be [Graph-like] non-Dmulti GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> non-Dmulti;
end;

:: LEXBFS:funcreg 9
registration
  let a1 be [Graph-like] connected GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> connected;
end;

:: LEXBFS:funcreg 10
registration
  let a1 be [Graph-like] acyclic GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> acyclic;
end;

:: LEXBFS:funcreg 11
registration
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> [VLabeled];
end;

:: LEXBFS:funcreg 12
registration
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> [ELabeled];
end;

:: LEXBFS:funcreg 13
registration
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be set;
  cluster a1 .set(V2LabelSelector,a2) -> [Weighted];
end;

:: LEXBFS:funcreg 14
registration
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> [V2Labeled];
end;

:: LEXBFS:funcreg 15
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  let a3 be Function-like Relation of the_Vertices_of a1,a2;
  cluster a1 .set(V2LabelSelector,a3) -> [V2Labeled];
end;

:: LEXBFS:funcreg 16
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be ManySortedSet of the_Vertices_of a1;
  cluster a1 .set(V2LabelSelector,a2) -> [V2Labeled];
end;

:: LEXBFS:funcreg 17
registration
  let a1 be [Graph-like] GraphStruct;
  cluster a1 .set(V2LabelSelector,{}) -> [V2Labeled];
end;

:: LEXBFS:attrnot 5 => LEXBFS:attr 5
definition
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  attr a1 is natural-v2labeled means
    the_V2Label_of a1 is natural-valued;
end;

:: LEXBFS:dfs 11
definiens
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
To prove
     a1 is natural-v2labeled
it is sufficient to prove
  thus the_V2Label_of a1 is natural-valued;

:: LEXBFS:def 11
theorem
for b1 being [Graph-like] [V2Labeled] GraphStruct holds
      b1 is natural-v2labeled
   iff
      the_V2Label_of b1 is natural-valued;

:: LEXBFS:attrnot 6 => LEXBFS:attr 6
definition
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  attr a1 is finite-v2labeled means
    the_V2Label_of a1 is finite-yielding;
end;

:: LEXBFS:dfs 12
definiens
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
To prove
     a1 is finite-v2labeled
it is sufficient to prove
  thus the_V2Label_of a1 is finite-yielding;

:: LEXBFS:def 12
theorem
for b1 being [Graph-like] [V2Labeled] GraphStruct holds
      b1 is finite-v2labeled
   iff
      the_V2Label_of b1 is finite-yielding;

:: LEXBFS:attrnot 7 => LEXBFS:attr 7
definition
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  attr a1 is natsubset-v2labeled means
    the_V2Label_of a1 is natsubset-yielding;
end;

:: LEXBFS:dfs 13
definiens
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
To prove
     a1 is natsubset-v2labeled
it is sufficient to prove
  thus the_V2Label_of a1 is natsubset-yielding;

:: LEXBFS:def 13
theorem
for b1 being [Graph-like] [V2Labeled] GraphStruct holds
      b1 is natsubset-v2labeled
   iff
      the_V2Label_of b1 is natsubset-yielding;

:: LEXBFS:exreg 6
registration
  cluster Relation-like Function-like finite finite-support [Graph-like] finite [Weighted] [ELabeled] [VLabeled] chordal natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
end;

:: LEXBFS:exreg 7
registration
  cluster Relation-like Function-like finite finite-support [Graph-like] finite [Weighted] [ELabeled] [VLabeled] chordal natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct;
end;

:: LEXBFS:funcreg 18
registration
  let a1 be [Graph-like] [VLabeled] natural-vlabeled GraphStruct;
  cluster the_VLabel_of a1 -> Relation-like Function-like natural-valued;
end;

:: LEXBFS:funcreg 19
registration
  let a1 be [Graph-like] [V2Labeled] natural-v2labeled GraphStruct;
  cluster the_V2Label_of a1 -> Relation-like Function-like natural-valued;
end;

:: LEXBFS:funcreg 20
registration
  let a1 be [Graph-like] [V2Labeled] finite-v2labeled GraphStruct;
  cluster the_V2Label_of a1 -> Relation-like Function-like finite-yielding;
end;

:: LEXBFS:funcreg 21
registration
  let a1 be [Graph-like] [V2Labeled] natsubset-v2labeled GraphStruct;
  cluster the_V2Label_of a1 -> Relation-like Function-like natsubset-yielding;
end;

:: LEXBFS:funcreg 22
registration
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] [V2Labeled];
end;

:: LEXBFS:th 13
theorem
for b1 being [Graph-like] [VLabeled] [V2Labeled] GraphStruct
for b2, b3 being set holds
the_V2Label_of b1 = the_V2Label_of (b1 .labelVertex(b2,b3));

:: LEXBFS:funcreg 23
registration
  let a1 be [Graph-like] [VLabeled] natural-vlabeled [V2Labeled] GraphStruct;
  let a2 be set;
  let a3 be natural set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] natural-vlabeled;
end;

:: LEXBFS:funcreg 24
registration
  let a1 be [Graph-like] [VLabeled] [V2Labeled] natural-v2labeled GraphStruct;
  let a2 be set;
  let a3 be natural set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] natural-v2labeled;
end;

:: LEXBFS:funcreg 25
registration
  let a1 be [Graph-like] [VLabeled] [V2Labeled] finite-v2labeled GraphStruct;
  let a2 be set;
  let a3 be natural set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] finite-v2labeled;
end;

:: LEXBFS:funcreg 26
registration
  let a1 be [Graph-like] [VLabeled] [V2Labeled] natsubset-v2labeled GraphStruct;
  let a2 be set;
  let a3 be natural set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] natsubset-v2labeled;
end;

:: LEXBFS:exreg 8
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like finite finite-support [Graph-like] [VLabeled] [V2Labeled] Subgraph of a1;
end;

:: LEXBFS:attrnot 8 => LEXBFS:attr 8
definition
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  let a2 be [V2Labeled] Subgraph of a1;
  attr a2 is v2label-inheriting means
    the_V2Label_of a2 = (the_V2Label_of a1) | the_Vertices_of a2;
end;

:: LEXBFS:dfs 14
definiens
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  let a2 be [V2Labeled] Subgraph of a1;
To prove
     a2 is v2label-inheriting
it is sufficient to prove
  thus the_V2Label_of a2 = (the_V2Label_of a1) | the_Vertices_of a2;

:: LEXBFS:def 14
theorem
for b1 being [Graph-like] [V2Labeled] GraphStruct
for b2 being [V2Labeled] Subgraph of b1 holds
      b2 is v2label-inheriting(b1)
   iff
      the_V2Label_of b2 = (the_V2Label_of b1) | the_Vertices_of b2;

:: LEXBFS:exreg 9
registration
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  cluster Relation-like Function-like finite finite-support [Graph-like] [V2Labeled] v2label-inheriting Subgraph of a1;
end;

:: LEXBFS:modenot 4
definition
  let a1 be [Graph-like] [V2Labeled] GraphStruct;
  mode V2Subgraph of a1 is [V2Labeled] v2label-inheriting Subgraph of a1;
end;

:: LEXBFS:exreg 10
registration
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  cluster Relation-like Function-like finite finite-support [Graph-like] [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting Subgraph of a1;
end;

:: LEXBFS:modenot 5
definition
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  mode VVSubgraph of a1 is [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting Subgraph of a1;
end;

:: LEXBFS:condreg 3
registration
  let a1 be [Graph-like] [VLabeled] natural-vlabeled GraphStruct;
  cluster [VLabeled] vlabel-inheriting -> natural-vlabeled (Subgraph of a1);
end;

:: LEXBFS:exreg 11
registration
  let a1 be [Graph-like] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite finite-support [Graph-like] [Weighted] [ELabeled] [VLabeled] [V2Labeled] inducedSubgraph of a1,a2,a3;
end;

:: LEXBFS:exreg 12
registration
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite finite-support [Graph-like] [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting inducedSubgraph of a1,a2,a3;
end;

:: LEXBFS:modenot 6
definition
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  let a2, a3 be set;
  mode inducedVVSubgraph of a1,a2,a3 is [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting inducedSubgraph of a1,a2,a3;
end;

:: LEXBFS:modenot 7
definition
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  let a2 be set;
  mode inducedVVSubgraph of a1,a2 is [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: LEXBFS:attrnot 9 => LEXBFS:attr 9
definition
  let a1 be ManySortedSet of NAT;
  attr a1 is iterative means
    for b1, b2 being natural set
          st a1 . b1 = a1 . b2
       holds a1 . (b1 + 1) = a1 . (b2 + 1);
end;

:: LEXBFS:dfs 15
definiens
  let a1 be ManySortedSet of NAT;
To prove
     a1 is iterative
it is sufficient to prove
  thus for b1, b2 being natural set
          st a1 . b1 = a1 . b2
       holds a1 . (b1 + 1) = a1 . (b2 + 1);

:: LEXBFS:def 15
theorem
for b1 being ManySortedSet of NAT holds
      b1 is iterative
   iff
      for b2, b3 being natural set
            st b1 . b2 = b1 . b3
         holds b1 . (b2 + 1) = b1 . (b3 + 1);

:: LEXBFS:attrnot 10 => LEXBFS:attr 10
definition
  let a1 be ManySortedSet of NAT;
  attr a1 is eventually-constant means
    ex b1 being natural set st
       for b2 being natural set
             st b1 <= b2
          holds a1 . b1 = a1 . b2;
end;

:: LEXBFS:dfs 16
definiens
  let a1 be ManySortedSet of NAT;
To prove
     a1 is eventually-constant
it is sufficient to prove
  thus ex b1 being natural set st
       for b2 being natural set
             st b1 <= b2
          holds a1 . b1 = a1 . b2;

:: LEXBFS:def 16
theorem
for b1 being ManySortedSet of NAT holds
      b1 is eventually-constant
   iff
      ex b2 being natural set st
         for b3 being natural set
               st b2 <= b3
            holds b1 . b2 = b1 . b3;

:: LEXBFS:exreg 13
registration
  cluster Relation-like Function-like halting iterative eventually-constant ManySortedSet of NAT;
end;

:: LEXBFS:th 14
theorem
for b1 being ManySortedSet of NAT
      st b1 is halting & b1 is iterative
   holds b1 is eventually-constant;

:: LEXBFS:condreg 4
registration
  cluster halting iterative -> eventually-constant (ManySortedSet of NAT);
end;

:: LEXBFS:th 15
theorem
for b1 being ManySortedSet of NAT
      st b1 is eventually-constant
   holds b1 is halting;

:: LEXBFS:condreg 5
registration
  cluster eventually-constant -> halting (ManySortedSet of NAT);
end;

:: LEXBFS:th 16
theorem
for b1 being iterative eventually-constant ManySortedSet of NAT
for b2 being natural set
      st b1 .Lifespan() <= b2
   holds b1 . (b1 .Lifespan()) = b1 . b2;

:: LEXBFS:th 17
theorem
for b1 being iterative eventually-constant ManySortedSet of NAT
for b2, b3 being natural set
      st b1 .Lifespan() <= b2 & b2 <= b3
   holds b1 . b3 = b1 . b2;

:: LEXBFS:attrnot 11 => LEXBFS:attr 11
definition
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
  attr a1 is natural-vlabeled means
    for b1 being natural set holds
       a1 . b1 is natural-vlabeled;
end;

:: LEXBFS:dfs 17
definiens
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
To prove
     a1 is natural-vlabeled
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is natural-vlabeled;

:: LEXBFS:def 17
theorem
for b1 being Graph-yielding [VLabeled] ManySortedSet of NAT holds
      b1 is natural-vlabeled
   iff
      for b2 being natural set holds
         b1 . b2 is natural-vlabeled;

:: LEXBFS:attrnot 12 => LEXBFS:attr 12
definition
  let a1 be Graph-yielding ManySortedSet of NAT;
  attr a1 is chordal means
    for b1 being natural set holds
       a1 . b1 is chordal;
end;

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

:: LEXBFS:def 18
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is chordal
   iff
      for b2 being natural set holds
         b1 . b2 is chordal;

:: LEXBFS:attrnot 13 => LEXBFS:attr 13
definition
  let a1 be Graph-yielding ManySortedSet of NAT;
  attr a1 is fixed-vertices means
    for b1, b2 being natural set holds
    the_Vertices_of (a1 . b1) = the_Vertices_of (a1 . b2);
end;

:: LEXBFS:dfs 19
definiens
  let a1 be Graph-yielding ManySortedSet of NAT;
To prove
     a1 is fixed-vertices
it is sufficient to prove
  thus for b1, b2 being natural set holds
    the_Vertices_of (a1 . b1) = the_Vertices_of (a1 . b2);

:: LEXBFS:def 19
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is fixed-vertices
   iff
      for b2, b3 being natural set holds
      the_Vertices_of (b1 . b2) = the_Vertices_of (b1 . b3);

:: LEXBFS:attrnot 14 => LEXBFS:attr 14
definition
  let a1 be Graph-yielding ManySortedSet of NAT;
  attr a1 is [V2Labeled] means
    for b1 being natural set holds
       a1 . b1 is [V2Labeled];
end;

:: LEXBFS:dfs 20
definiens
  let a1 be Graph-yielding ManySortedSet of NAT;
To prove
     a1 is [V2Labeled]
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is [V2Labeled];

:: LEXBFS:def 20
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is [V2Labeled]
   iff
      for b2 being natural set holds
         b1 . b2 is [V2Labeled];

:: LEXBFS:exreg 14
registration
  cluster Relation-like Function-like Graph-yielding [Weighted] [ELabeled] [VLabeled] [V2Labeled] ManySortedSet of NAT;
end;

:: LEXBFS:modenot 8
definition
  mode V2GraphSeq is Graph-yielding [V2Labeled] ManySortedSet of NAT;
end;

:: LEXBFS:modenot 9
definition
  mode VVGraphSeq is Graph-yielding [VLabeled] [V2Labeled] ManySortedSet of NAT;
end;

:: LEXBFS:funcreg 27
registration
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [V2Labeled];
end;

:: LEXBFS:attrnot 15 => LEXBFS:attr 15
definition
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
  attr a1 is natural-v2labeled means
    for b1 being natural set holds
       a1 . b1 is natural-v2labeled;
end;

:: LEXBFS:dfs 21
definiens
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
To prove
     a1 is natural-v2labeled
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is natural-v2labeled;

:: LEXBFS:def 21
theorem
for b1 being Graph-yielding [V2Labeled] ManySortedSet of NAT holds
      b1 is natural-v2labeled
   iff
      for b2 being natural set holds
         b1 . b2 is natural-v2labeled;

:: LEXBFS:attrnot 16 => LEXBFS:attr 16
definition
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
  attr a1 is finite-v2labeled means
    for b1 being natural set holds
       a1 . b1 is finite-v2labeled;
end;

:: LEXBFS:dfs 22
definiens
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
To prove
     a1 is finite-v2labeled
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is finite-v2labeled;

:: LEXBFS:def 22
theorem
for b1 being Graph-yielding [V2Labeled] ManySortedSet of NAT holds
      b1 is finite-v2labeled
   iff
      for b2 being natural set holds
         b1 . b2 is finite-v2labeled;

:: LEXBFS:attrnot 17 => LEXBFS:attr 17
definition
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
  attr a1 is natsubset-v2labeled means
    for b1 being natural set holds
       a1 . b1 is natsubset-v2labeled;
end;

:: LEXBFS:dfs 23
definiens
  let a1 be Graph-yielding [V2Labeled] ManySortedSet of NAT;
To prove
     a1 is natsubset-v2labeled
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is natsubset-v2labeled;

:: LEXBFS:def 23
theorem
for b1 being Graph-yielding [V2Labeled] ManySortedSet of NAT holds
      b1 is natsubset-v2labeled
   iff
      for b2 being natural set holds
         b1 . b2 is natsubset-v2labeled;

:: LEXBFS:exreg 15
registration
  cluster Relation-like Function-like Graph-yielding finite [Weighted] [ELabeled] [VLabeled] natural-vlabeled chordal [V2Labeled] finite-v2labeled natsubset-v2labeled ManySortedSet of NAT;
end;

:: LEXBFS:exreg 16
registration
  cluster Relation-like Function-like Graph-yielding finite [Weighted] [ELabeled] [VLabeled] natural-vlabeled chordal [V2Labeled] natural-v2labeled ManySortedSet of NAT;
end;

:: LEXBFS:funcnot 7 => LEXBFS:func 7
definition
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
  let a2 be natural set;
  redefine func a1 . a2 -> [Graph-like] [VLabeled] GraphStruct;
end;

:: LEXBFS:funcreg 28
registration
  let a1 be Graph-yielding [VLabeled] natural-vlabeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [VLabeled] natural-vlabeled;
end;

:: LEXBFS:funcreg 29
registration
  let a1 be Graph-yielding [V2Labeled] natural-v2labeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [V2Labeled] natural-v2labeled;
end;

:: LEXBFS:funcreg 30
registration
  let a1 be Graph-yielding [V2Labeled] finite-v2labeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [V2Labeled] finite-v2labeled;
end;

:: LEXBFS:funcreg 31
registration
  let a1 be Graph-yielding [V2Labeled] natsubset-v2labeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [V2Labeled] natsubset-v2labeled;
end;

:: LEXBFS:funcreg 32
registration
  let a1 be Graph-yielding chordal ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] chordal;
end;

:: LEXBFS:funcnot 8 => LEXBFS:func 8
definition
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
  let a2 be natural set;
  redefine func a1 . a2 -> [Graph-like] [VLabeled] GraphStruct;
end;

:: LEXBFS:funcreg 33
registration
  let a1 be Graph-yielding finite [VLabeled] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] finite [VLabeled];
end;

:: LEXBFS:funcnot 9 => LEXBFS:func 9
definition
  let a1 be Graph-yielding [VLabeled] [V2Labeled] ManySortedSet of NAT;
  let a2 be natural set;
  redefine func a1 . a2 -> [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
end;

:: LEXBFS:funcreg 34
registration
  let a1 be Graph-yielding finite [VLabeled] [V2Labeled] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] finite [VLabeled] [V2Labeled];
end;

:: LEXBFS:funcreg 35
registration
  let a1 be Graph-yielding [VLabeled] chordal [V2Labeled] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [VLabeled] chordal [V2Labeled];
end;

:: LEXBFS:funcreg 36
registration
  let a1 be Graph-yielding [VLabeled] natural-vlabeled [V2Labeled] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [VLabeled] natural-vlabeled [V2Labeled];
end;

:: LEXBFS:funcreg 37
registration
  let a1 be Graph-yielding [VLabeled] [V2Labeled] finite-v2labeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [VLabeled] [V2Labeled] finite-v2labeled;
end;

:: LEXBFS:funcreg 38
registration
  let a1 be Graph-yielding [VLabeled] [V2Labeled] natsubset-v2labeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [VLabeled] [V2Labeled] natsubset-v2labeled;
end;

:: LEXBFS:funcreg 39
registration
  let a1 be Graph-yielding [VLabeled] [V2Labeled] natural-v2labeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [VLabeled] [V2Labeled] natural-v2labeled;
end;

:: LEXBFS:attrnot 18 => LEXBFS:attr 18
definition
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
  attr a1 is vlabel-initially-empty means
    the_VLabel_of (a1 . 0) = {};
end;

:: LEXBFS:dfs 24
definiens
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
To prove
     a1 is vlabel-initially-empty
it is sufficient to prove
  thus the_VLabel_of (a1 . 0) = {};

:: LEXBFS:def 24
theorem
for b1 being Graph-yielding [VLabeled] ManySortedSet of NAT holds
      b1 is vlabel-initially-empty
   iff
      the_VLabel_of (b1 . 0) = {};

:: LEXBFS:attrnot 19 => LEXBFS:attr 19
definition
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
  attr a1 is adds-one-at-a-step means
    for b1 being natural set
          st b1 < a1 .Lifespan()
       holds ex b2 being set st
          not b2 in proj1 the_VLabel_of (a1 . b1) &
           the_VLabel_of (a1 . (b1 + 1)) = (the_VLabel_of (a1 . b1)) +* (b2 .--> (a1 .Lifespan() -' b1));
end;

:: LEXBFS:dfs 25
definiens
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
To prove
     a1 is adds-one-at-a-step
it is sufficient to prove
  thus for b1 being natural set
          st b1 < a1 .Lifespan()
       holds ex b2 being set st
          not b2 in proj1 the_VLabel_of (a1 . b1) &
           the_VLabel_of (a1 . (b1 + 1)) = (the_VLabel_of (a1 . b1)) +* (b2 .--> (a1 .Lifespan() -' b1));

:: LEXBFS:def 25
theorem
for b1 being Graph-yielding [VLabeled] ManySortedSet of NAT holds
      b1 is adds-one-at-a-step
   iff
      for b2 being natural set
            st b2 < b1 .Lifespan()
         holds ex b3 being set st
            not b3 in proj1 the_VLabel_of (b1 . b2) &
             the_VLabel_of (b1 . (b2 + 1)) = (the_VLabel_of (b1 . b2)) +* (b3 .--> (b1 .Lifespan() -' b2));

:: LEXBFS:attrnot 20 => LEXBFS:attr 20
definition
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
  attr a1 is vlabel-numbering means
    a1 is iterative & a1 is eventually-constant & a1 is finite & a1 is fixed-vertices & a1 is natural-vlabeled & a1 is vlabel-initially-empty & a1 is adds-one-at-a-step;
end;

:: LEXBFS:dfs 26
definiens
  let a1 be Graph-yielding [VLabeled] ManySortedSet of NAT;
To prove
     a1 is vlabel-numbering
it is sufficient to prove
  thus a1 is iterative & a1 is eventually-constant & a1 is finite & a1 is fixed-vertices & a1 is natural-vlabeled & a1 is vlabel-initially-empty & a1 is adds-one-at-a-step;

:: LEXBFS:def 26
theorem
for b1 being Graph-yielding [VLabeled] ManySortedSet of NAT holds
      b1 is vlabel-numbering
   iff
      b1 is iterative & b1 is eventually-constant & b1 is finite & b1 is fixed-vertices & b1 is natural-vlabeled & b1 is vlabel-initially-empty & b1 is adds-one-at-a-step;

:: LEXBFS:exreg 17
registration
  cluster Relation-like Function-like Graph-yielding finite [VLabeled] iterative eventually-constant natural-vlabeled fixed-vertices vlabel-initially-empty adds-one-at-a-step ManySortedSet of NAT;
end;

:: LEXBFS:exreg 18
registration
  cluster Relation-like Function-like Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT;
end;

:: LEXBFS:condreg 6
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> iterative (ManySortedSet of NAT);
end;

:: LEXBFS:condreg 7
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> eventually-constant (ManySortedSet of NAT);
end;

:: LEXBFS:condreg 8
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> finite (ManySortedSet of NAT);
end;

:: LEXBFS:condreg 9
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> fixed-vertices (ManySortedSet of NAT);
end;

:: LEXBFS:condreg 10
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> natural-vlabeled (ManySortedSet of NAT);
end;

:: LEXBFS:condreg 11
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> vlabel-initially-empty (ManySortedSet of NAT);
end;

:: LEXBFS:condreg 12
registration
  cluster Graph-yielding [VLabeled] vlabel-numbering -> adds-one-at-a-step (ManySortedSet of NAT);
end;

:: LEXBFS:modenot 10
definition
  mode VLabelNumberingSeq is Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT;
end;

:: LEXBFS:funcnot 10 => LEXBFS:func 10
definition
  let a1 be Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT;
  let a2 be natural set;
  func A1 .PickedAt A2 -> set means
    it = choose the_Vertices_of (a1 . 0)
    if a1 .Lifespan() <= a2
    otherwise not it in proj1 the_VLabel_of (a1 . a2) &
     the_VLabel_of (a1 . (a2 + 1)) = (the_VLabel_of (a1 . a2)) +* (it .--> (a1 .Lifespan() -' a2));
end;

:: LEXBFS:def 27
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
for b3 being set holds
   (b1 .Lifespan() <= b2 implies    (b3 = b1 .PickedAt b2
    iff
       b3 = choose the_Vertices_of (b1 . 0))) &
    (b1 .Lifespan() <= b2 or    (b3 = b1 .PickedAt b2
    iff
       not b3 in proj1 the_VLabel_of (b1 . b2) &
        the_VLabel_of (b1 . (b2 + 1)) = (the_VLabel_of (b1 . b2)) +* (b3 .--> (b1 .Lifespan() -' b2))));

:: LEXBFS:th 18
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
      st b2 < b1 .Lifespan()
   holds b1 .PickedAt b2 in (b1 . (b2 + 1)) .labeledV() &
    (b1 . (b2 + 1)) .labeledV() = (b1 . b2) .labeledV() \/ {b1 .PickedAt b2};

:: LEXBFS:th 19
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
      st b2 < b1 .Lifespan()
   holds (the_VLabel_of (b1 . (b2 + 1))) . (b1 .PickedAt b2) = b1 .Lifespan() -' b2;

:: LEXBFS:th 20
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
      st b2 <= b1 .Lifespan()
   holds card ((b1 . b2) .labeledV()) = b2;

:: LEXBFS:th 21
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set holds
   proj2 the_VLabel_of (b1 . b2) = (Seg (b1 .Lifespan())) \ Seg (b1 .Lifespan() -' b2);

:: LEXBFS:th 22
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
for b3 being set holds
   (the_VLabel_of (b1 . b2)) . b3 <= b1 .Lifespan() &
    (b3 in (b1 . b2) .labeledV() implies 1 <= (the_VLabel_of (b1 . b2)) . b3);

:: LEXBFS:th 23
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2, b3 being natural set
      st b1 .Lifespan() -' b2 < b3 & b3 <= b1 .Lifespan()
   holds ex b4 being Element of the_Vertices_of (b1 . b2) st
      b4 in (b1 . b2) .labeledV() & (the_VLabel_of (b1 . b2)) . b4 = b3;

:: LEXBFS:th 24
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2, b3 being natural set
      st b2 <= b3
   holds the_VLabel_of (b1 . b2) c= the_VLabel_of (b1 . b3);

:: LEXBFS:th 25
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set holds
   the_VLabel_of (b1 . b2) is one-to-one;

:: LEXBFS:th 26
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2, b3 being natural set
for b4 being set
      st b4 in (b1 . b2) .labeledV() & b4 in (b1 . b3) .labeledV()
   holds (the_VLabel_of (b1 . b2)) . b4 = (the_VLabel_of (b1 . b3)) . b4;

:: LEXBFS:th 27
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being set
for b3, b4 being natural set
      st b2 in (b1 . b3) .labeledV() & (the_VLabel_of (b1 . b3)) . b2 = b4
   holds b1 .PickedAt (b1 .Lifespan() -' b4) = b2;

:: LEXBFS:th 28
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2, b3 being natural set
      st b3 < b1 .Lifespan() & b3 < b2
   holds b1 .PickedAt b3 in (b1 . b2) .labeledV() &
    (the_VLabel_of (b1 . b2)) . (b1 .PickedAt b3) = b1 .Lifespan() -' b3;

:: LEXBFS:th 29
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
for b3 being set
      st b3 in (b1 . b2) .labeledV()
   holds b1 .Lifespan() -' ((the_VLabel_of (b1 . b2)) . b3) < b2 &
    b1 .Lifespan() -' b2 < (the_VLabel_of (b1 . b2)) . b3;

:: LEXBFS:th 30
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
for b3, b4 being set
      st b3 in (b1 . b2) .labeledV() &
         b4 in (b1 . b2) .labeledV() &
         (the_VLabel_of (b1 . b2)) . b3 < (the_VLabel_of (b1 . b2)) . b4
   holds b4 in (b1 . (b1 .Lifespan() -' ((the_VLabel_of (b1 . b2)) . b3))) .labeledV();

:: LEXBFS:th 31
theorem
for b1 being Graph-yielding [VLabeled] vlabel-numbering ManySortedSet of NAT
for b2 being natural set
for b3, b4 being set
      st b3 in (b1 . b2) .labeledV() &
         b4 in (b1 . b2) .labeledV() &
         (the_VLabel_of (b1 . b2)) . b3 < (the_VLabel_of (b1 . b2)) . b4
   holds not b3 in (b1 . (b1 .Lifespan() -' ((the_VLabel_of (b1 . b2)) . b4))) .labeledV();

:: LEXBFS:funcnot 11 => LEXBFS:func 11
definition
  let a1 be [Graph-like] GraphStruct;
  func LexBFS:Init A1 -> [Graph-like] [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct equals
    (a1 .set(VLabelSelector,{})) .set(V2LabelSelector,(the_Vertices_of a1) --> {});
end;

:: LEXBFS:def 28
theorem
for b1 being [Graph-like] GraphStruct holds
   LexBFS:Init b1 = (b1 .set(VLabelSelector,{})) .set(V2LabelSelector,(the_Vertices_of b1) --> {});

:: LEXBFS:funcnot 12 => LEXBFS:func 12
definition
  let a1 be [Graph-like] finite GraphStruct;
  redefine func LexBFS:Init a1 -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
end;

:: LEXBFS:funcnot 13 => LEXBFS:func 13
definition
  let a1 be [Graph-like] finite [VLabeled] [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
  assume proj1 the_V2Label_of a1 = the_Vertices_of a1;
  func LexBFS:PickUnnumbered A1 -> Element of the_Vertices_of a1 means
    it = choose the_Vertices_of a1
    if proj1 the_VLabel_of a1 = the_Vertices_of a1
    otherwise ex b1 being non empty finite Element of bool bool NAT st
       ex b2 being non empty finite Element of bool Bags NAT st
          ex b3 being Relation-like Function-like set st
             b1 = proj2 b3 &
              b3 = (the_V2Label_of a1) | ((the_Vertices_of a1) \ proj1 the_VLabel_of a1) &
              (for b4 being finite Element of bool NAT
                    st b4 in b1
                 holds (b4,1)-bag in b2) &
              (for b4 being set
                    st b4 in b2
                 holds ex b5 being finite Element of bool NAT st
                    b5 in b1 & b4 = (b5,1)-bag) &
              it = choose (b3 " {support max(b2,InvLexOrder NAT)});
end;

:: LEXBFS:def 29
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct
   st proj1 the_V2Label_of b1 = the_Vertices_of b1
for b2 being Element of the_Vertices_of b1 holds
   (proj1 the_VLabel_of b1 = the_Vertices_of b1 implies    (b2 = LexBFS:PickUnnumbered b1
    iff
       b2 = choose the_Vertices_of b1)) &
    (proj1 the_VLabel_of b1 = the_Vertices_of b1 or    (b2 = LexBFS:PickUnnumbered b1
    iff
       ex b3 being non empty finite Element of bool bool NAT st
          ex b4 being non empty finite Element of bool Bags NAT st
             ex b5 being Relation-like Function-like set st
                b3 = proj2 b5 &
                 b5 = (the_V2Label_of b1) | ((the_Vertices_of b1) \ proj1 the_VLabel_of b1) &
                 (for b6 being finite Element of bool NAT
                       st b6 in b3
                    holds (b6,1)-bag in b4) &
                 (for b6 being set
                       st b6 in b4
                    holds ex b7 being finite Element of bool NAT st
                       b7 in b3 & b6 = (b7,1)-bag) &
                 b2 = choose (b5 " {support max(b4,InvLexOrder NAT)})));

:: LEXBFS:funcnot 14 => LEXBFS:func 14
definition
  let a1 be [Graph-like] [VLabeled] [V2Labeled] GraphStruct;
  let a2 be set;
  let a3 be natural set;
  func LexBFS:LabelAdjacent(A1,A2,A3) -> [Graph-like] [VLabeled] [V2Labeled] GraphStruct equals
    a1 .set(V2LabelSelector,(the_V2Label_of a1) .\/ (((a1 .AdjacentSet {a2}) \ proj1 the_VLabel_of a1) --> {a3}));
end;

:: LEXBFS:def 30
theorem
for b1 being [Graph-like] [VLabeled] [V2Labeled] GraphStruct
for b2 being set
for b3 being natural set holds
   LexBFS:LabelAdjacent(b1,b2,b3) = b1 .set(V2LabelSelector,(the_V2Label_of b1) .\/ (((b1 .AdjacentSet {b2}) \ proj1 the_VLabel_of b1) --> {b3}));

:: LEXBFS:th 32
theorem
for b1 being [Graph-like] [VLabeled] [V2Labeled] GraphStruct
for b2, b3 being set
for b4 being natural set
      st not b3 in b1 .AdjacentSet {b2}
   holds (the_V2Label_of b1) . b3 = (the_V2Label_of LexBFS:LabelAdjacent(b1,b2,b4)) . b3;

:: LEXBFS:th 33
theorem
for b1 being [Graph-like] [VLabeled] [V2Labeled] GraphStruct
for b2, b3 being set
for b4 being natural set
      st b3 in proj1 the_VLabel_of b1
   holds (the_V2Label_of b1) . b3 = (the_V2Label_of LexBFS:LabelAdjacent(b1,b2,b4)) . b3;

:: LEXBFS:th 34
theorem
for b1 being [Graph-like] [VLabeled] [V2Labeled] GraphStruct
for b2, b3 being set
for b4 being natural set
      st b3 in b1 .AdjacentSet {b2} & not b3 in proj1 the_VLabel_of b1
   holds (the_V2Label_of LexBFS:LabelAdjacent(b1,b2,b4)) . b3 = ((the_V2Label_of b1) . b3) \/ {b4};

:: LEXBFS:th 35
theorem
for b1 being [Graph-like] [VLabeled] [V2Labeled] GraphStruct
for b2 being set
for b3 being natural set
      st proj1 the_V2Label_of b1 = the_Vertices_of b1
   holds proj1 the_V2Label_of LexBFS:LabelAdjacent(b1,b2,b3) = the_Vertices_of b1;

:: LEXBFS:funcnot 15 => LEXBFS:func 15
definition
  let a1 be [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  let a3 be natural set;
  redefine func LexBFS:LabelAdjacent(a1,a2,a3) -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
end;

:: LEXBFS:funcnot 16 => LEXBFS:func 16
definition
  let a1 be [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  let a3 be natural set;
  func LexBFS:Update(A1,A2,A3) -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct equals
    LexBFS:LabelAdjacent(a1 .labelVertex(a2,a1 .order() -' a3),a2,a1 .order() -' a3);
end;

:: LEXBFS:def 31
theorem
for b1 being [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being natural set holds
   LexBFS:Update(b1,b2,b3) = LexBFS:LabelAdjacent(b1 .labelVertex(b2,b1 .order() -' b3),b2,b1 .order() -' b3);

:: LEXBFS:funcnot 17 => LEXBFS:func 17
definition
  let a1 be [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct;
  func LexBFS:Step A1 -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct equals
    a1
    if a1 .order() <= card proj1 the_VLabel_of a1
    otherwise LexBFS:Update(a1,LexBFS:PickUnnumbered a1,card proj1 the_VLabel_of a1);
end;

:: LEXBFS:def 32
theorem
for b1 being [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct holds
   (b1 .order() <= card proj1 the_VLabel_of b1 implies LexBFS:Step b1 = b1) &
    (b1 .order() <= card proj1 the_VLabel_of b1 or LexBFS:Step b1 = LexBFS:Update(b1,LexBFS:PickUnnumbered b1,card proj1 the_VLabel_of b1));

:: LEXBFS:funcnot 18 => LEXBFS:func 18
definition
  let a1 be [Graph-like] finite GraphStruct;
  func LexBFS:CSeq A1 -> Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled ManySortedSet of NAT means
    it . 0 = LexBFS:Init a1 &
     (for b1 being natural set holds
        it . (b1 + 1) = LexBFS:Step (it . b1));
end;

:: LEXBFS:def 33
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled ManySortedSet of NAT holds
      b2 = LexBFS:CSeq b1
   iff
      b2 . 0 = LexBFS:Init b1 &
       (for b3 being natural set holds
          b2 . (b3 + 1) = LexBFS:Step (b2 . b3));

:: LEXBFS:th 36
theorem
for b1 being [Graph-like] finite GraphStruct holds
   LexBFS:CSeq b1 is iterative;

:: LEXBFS:funcreg 40
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster LexBFS:CSeq a1 -> Graph-yielding finite [VLabeled] iterative natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled;
end;

:: LEXBFS:th 37
theorem
for b1 being [Graph-like] GraphStruct holds
   the_VLabel_of LexBFS:Init b1 = {};

:: LEXBFS:th 38
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
   proj1 the_V2Label_of LexBFS:Init b1 = the_Vertices_of b1 & (the_V2Label_of LexBFS:Init b1) . b2 = {};

:: LEXBFS:th 39
theorem
for b1 being [Graph-like] GraphStruct holds
   b1 == LexBFS:Init b1;

:: LEXBFS:th 40
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct
for b2 being set
      st not b2 in proj1 the_VLabel_of b1 & proj1 the_V2Label_of b1 = the_Vertices_of b1 & proj1 the_VLabel_of b1 <> the_Vertices_of b1
   holds ((the_V2Label_of b1) . b2,1)-bag <= ((the_V2Label_of b1) . LexBFS:PickUnnumbered b1,1)-bag,InvLexOrder NAT;

:: LEXBFS:th 41
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct
      st proj1 the_V2Label_of b1 = the_Vertices_of b1 & proj1 the_VLabel_of b1 <> the_Vertices_of b1
   holds not LexBFS:PickUnnumbered b1 in proj1 the_VLabel_of b1;

:: LEXBFS:th 42
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
   (LexBFS:CSeq b1) . b2 == b1;

:: LEXBFS:th 43
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set holds
(LexBFS:CSeq b1) . b2 == (LexBFS:CSeq b1) . b3;

:: LEXBFS:th 44
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st card proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) < b1 .order()
   holds the_VLabel_of ((LexBFS:CSeq b1) . (b2 + 1)) = (the_VLabel_of ((LexBFS:CSeq b1) . b2)) +* ((LexBFS:PickUnnumbered ((LexBFS:CSeq b1) . b2)) .--> (b1 .order() -' card proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2)));

:: LEXBFS:th 45
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
   proj1 the_V2Label_of ((LexBFS:CSeq b1) . b2) = the_Vertices_of ((LexBFS:CSeq b1) . b2);

:: LEXBFS:th 46
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b2 <= b1 .order()
   holds card proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) = b2;

:: LEXBFS:th 47
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b1 .order() <= b2
   holds (LexBFS:CSeq b1) . (b1 .order()) = (LexBFS:CSeq b1) . b2;

:: LEXBFS:th 48
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
      st b1 .order() <= b2 & b2 <= b3
   holds (LexBFS:CSeq b1) . b2 = (LexBFS:CSeq b1) . b3;

:: LEXBFS:th 49
theorem
for b1 being [Graph-like] finite GraphStruct holds
   LexBFS:CSeq b1 is eventually-constant;

:: LEXBFS:funcreg 41
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster LexBFS:CSeq a1 -> Graph-yielding finite [VLabeled] eventually-constant natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled;
end;

:: LEXBFS:th 50
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
      proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) = the_Vertices_of ((LexBFS:CSeq b1) . b2)
   iff
      b1 .order() <= b2;

:: LEXBFS:th 51
theorem
for b1 being [Graph-like] finite GraphStruct holds
   (LexBFS:CSeq b1) .Lifespan() = b1 .order();

:: LEXBFS:funcreg 42
registration
  let a1 be [Graph-like] finite chordal GraphStruct;
  let a2 be natural set;
  cluster (LexBFS:CSeq a1) . a2 -> [Graph-like] [VLabeled] chordal [V2Labeled];
end;

:: LEXBFS:funcreg 43
registration
  let a1 be [Graph-like] finite chordal GraphStruct;
  cluster LexBFS:CSeq a1 -> Graph-yielding finite [VLabeled] natural-vlabeled chordal [V2Labeled] finite-v2labeled natsubset-v2labeled;
end;

:: LEXBFS:th 52
theorem
for b1 being [Graph-like] finite GraphStruct holds
   LexBFS:CSeq b1 is vlabel-numbering;

:: LEXBFS:funcreg 44
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster LexBFS:CSeq a1 -> Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled vlabel-numbering;
end;

:: LEXBFS:th 53
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b2 < b1 .order()
   holds (LexBFS:CSeq b1) .PickedAt b2 = LexBFS:PickUnnumbered ((LexBFS:CSeq b1) . b2);

:: LEXBFS:th 54
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b2 < b1 .order()
   holds ex b3 being Element of the_Vertices_of ((LexBFS:CSeq b1) . b2) st
      b3 = LexBFS:PickUnnumbered ((LexBFS:CSeq b1) . b2) &
       (for b4 being set holds
          (b4 in b1 .AdjacentSet {b3} & not b4 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) implies (the_V2Label_of ((LexBFS:CSeq b1) . (b2 + 1))) . b4 = ((the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b4) \/ {b1 .order() -' b2}) &
           (b4 in b1 .AdjacentSet {b3} & not b4 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) or (the_V2Label_of ((LexBFS:CSeq b1) . (b2 + 1))) . b4 = (the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b4));

:: LEXBFS:th 55
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
for b3 being set holds
   (the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b3 c= (Seg (b1 .order())) \ Seg (b1 .order() -' b2);

:: LEXBFS:th 56
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being set
for b3, b4 being natural set
      st b3 <= b4
   holds (the_V2Label_of ((LexBFS:CSeq b1) . b3)) . b2 c= (the_V2Label_of ((LexBFS:CSeq b1) . b4)) . b2;

:: LEXBFS:th 57
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
for b4, b5 being set
      st b3 < b1 .order() & b3 < b2 & b5 = LexBFS:PickUnnumbered ((LexBFS:CSeq b1) . b3) & not b4 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . b3) & b4 in b1 .AdjacentSet {b5}
   holds b1 .order() -' b3 in (the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b4;

:: LEXBFS:th 58
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
   st b2 < b3
for b4 being set
      st not b1 .order() -' b2 in (the_V2Label_of ((LexBFS:CSeq b1) . (b2 + 1))) . b4
   holds not b1 .order() -' b2 in (the_V2Label_of ((LexBFS:CSeq b1) . b3)) . b4;

:: LEXBFS:th 59
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3, b4 being natural set
   st b4 < b3 & b3 <= b2
for b5 being set
      st not b1 .order() -' b4 in (the_V2Label_of ((LexBFS:CSeq b1) . b3)) . b5
   holds not b1 .order() -' b4 in (the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b5;

:: LEXBFS:th 60
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
for b4 being Element of the_Vertices_of ((LexBFS:CSeq b1) . b2)
      st b3 in (the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b4
   holds ex b5 being Element of the_Vertices_of ((LexBFS:CSeq b1) . b2) st
      LexBFS:PickUnnumbered ((LexBFS:CSeq b1) . (b1 .order() -' b3)) = b5 &
       not b5 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . (b1 .order() -' b3)) &
       b4 in b1 .AdjacentSet {b5};

:: LEXBFS:funcnot 19 => LEXBFS:func 19
definition
  let a1 be Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] ManySortedSet of NAT;
  redefine func a1 .Result() -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] GraphStruct;
end;

:: LEXBFS:th 61
theorem
for b1 being [Graph-like] finite GraphStruct holds
   (LexBFS:CSeq b1) .Result() .labeledV() = the_Vertices_of b1;

:: LEXBFS:th 62
theorem
for b1 being [Graph-like] finite GraphStruct holds
   (the_VLabel_of ((LexBFS:CSeq b1) .Result())) " is VertexScheme of b1;

:: LEXBFS:th 63
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
for b4, b5 being Element of the_Vertices_of ((LexBFS:CSeq b1) . b2)
      st b4 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) &
         b5 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) &
         (the_VLabel_of ((LexBFS:CSeq b1) . b2)) . b4 < (the_VLabel_of ((LexBFS:CSeq b1) . b2)) . b5 &
         b3 = b1 .order() -' ((the_VLabel_of ((LexBFS:CSeq b1) . b2)) . b5)
   holds ((the_V2Label_of ((LexBFS:CSeq b1) . b3)) . b4,1)-bag <= ((the_V2Label_of ((LexBFS:CSeq b1) . b3)) . b5,1)-bag,InvLexOrder NAT;

:: LEXBFS:th 64
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
for b4 being Element of the_Vertices_of ((LexBFS:CSeq b1) . b2)
      st b3 in (the_V2Label_of ((LexBFS:CSeq b1) . b2)) . b4
   holds ex b5 being Element of the_Vertices_of ((LexBFS:CSeq b1) . b2) st
      b5 in proj1 the_VLabel_of ((LexBFS:CSeq b1) . b2) &
       (the_VLabel_of ((LexBFS:CSeq b1) . b2)) . b5 = b3 &
       b4 in b1 .AdjacentSet {b5};

:: LEXBFS:attrnot 21 => LEXBFS:attr 21
definition
  let a1 be [Graph-like] [VLabeled] natural-vlabeled GraphStruct;
  attr a1 is with_property_L3 means
    for b1, b2, b3 being Element of the_Vertices_of a1
          st b1 in proj1 the_VLabel_of a1 &
             b2 in proj1 the_VLabel_of a1 &
             b3 in proj1 the_VLabel_of a1 &
             (the_VLabel_of a1) . b1 < (the_VLabel_of a1) . b2 &
             (the_VLabel_of a1) . b2 < (the_VLabel_of a1) . b3 &
             b1,b3 are_adjacent &
             not b2,b3 are_adjacent
       holds ex b4 being Element of the_Vertices_of a1 st
          b4 in proj1 the_VLabel_of a1 &
           (the_VLabel_of a1) . b3 < (the_VLabel_of a1) . b4 &
           b2,b4 are_adjacent &
           not b1,b4 are_adjacent &
           (for b5 being Element of the_Vertices_of a1
                 st b5 <> b4 & b5,b2 are_adjacent & not b5,b1 are_adjacent
              holds (the_VLabel_of a1) . b5 < (the_VLabel_of a1) . b4);
end;

:: LEXBFS:dfs 34
definiens
  let a1 be [Graph-like] [VLabeled] natural-vlabeled GraphStruct;
To prove
     a1 is with_property_L3
it is sufficient to prove
  thus for b1, b2, b3 being Element of the_Vertices_of a1
          st b1 in proj1 the_VLabel_of a1 &
             b2 in proj1 the_VLabel_of a1 &
             b3 in proj1 the_VLabel_of a1 &
             (the_VLabel_of a1) . b1 < (the_VLabel_of a1) . b2 &
             (the_VLabel_of a1) . b2 < (the_VLabel_of a1) . b3 &
             b1,b3 are_adjacent &
             not b2,b3 are_adjacent
       holds ex b4 being Element of the_Vertices_of a1 st
          b4 in proj1 the_VLabel_of a1 &
           (the_VLabel_of a1) . b3 < (the_VLabel_of a1) . b4 &
           b2,b4 are_adjacent &
           not b1,b4 are_adjacent &
           (for b5 being Element of the_Vertices_of a1
                 st b5 <> b4 & b5,b2 are_adjacent & not b5,b1 are_adjacent
              holds (the_VLabel_of a1) . b5 < (the_VLabel_of a1) . b4);

:: LEXBFS:def 34
theorem
for b1 being [Graph-like] [VLabeled] natural-vlabeled GraphStruct holds
      b1 is with_property_L3
   iff
      for b2, b3, b4 being Element of the_Vertices_of b1
            st b2 in proj1 the_VLabel_of b1 &
               b3 in proj1 the_VLabel_of b1 &
               b4 in proj1 the_VLabel_of b1 &
               (the_VLabel_of b1) . b2 < (the_VLabel_of b1) . b3 &
               (the_VLabel_of b1) . b3 < (the_VLabel_of b1) . b4 &
               b2,b4 are_adjacent &
               not b3,b4 are_adjacent
         holds ex b5 being Element of the_Vertices_of b1 st
            b5 in proj1 the_VLabel_of b1 &
             (the_VLabel_of b1) . b4 < (the_VLabel_of b1) . b5 &
             b3,b5 are_adjacent &
             not b2,b5 are_adjacent &
             (for b6 being Element of the_Vertices_of b1
                   st b6 <> b5 & b6,b3 are_adjacent & not b6,b2 are_adjacent
                holds (the_VLabel_of b1) . b6 < (the_VLabel_of b1) . b5);

:: LEXBFS:th 65
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
   (LexBFS:CSeq b1) . b2 is with_property_L3;

:: LEXBFS:th 66
theorem
for b1 being [Graph-like] finite [VLabeled] chordal natural-vlabeled GraphStruct
   st b1 is with_property_L3 & proj1 the_VLabel_of b1 = the_Vertices_of b1
for b2 being VertexScheme of b1
      st b2 " = the_VLabel_of b1
   holds b2 is perfect(b1);

:: LEXBFS:th 67
theorem
for b1 being [Graph-like] finite [VLabeled] chordal [V2Labeled] GraphStruct holds
   (the_VLabel_of ((LexBFS:CSeq b1) .Result())) " is perfect VertexScheme of b1;

:: LEXBFS:funcnot 20 => LEXBFS:func 20
definition
  let a1 be [Graph-like] finite GraphStruct;
  func MCS:Init A1 -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct equals
    (a1 .set(VLabelSelector,{})) .set(V2LabelSelector,(the_Vertices_of a1) --> 0);
end;

:: LEXBFS:def 35
theorem
for b1 being [Graph-like] finite GraphStruct holds
   MCS:Init b1 = (b1 .set(VLabelSelector,{})) .set(V2LabelSelector,(the_Vertices_of b1) --> 0);

:: LEXBFS:funcnot 21 => LEXBFS:func 21
definition
  let a1 be [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct;
  assume proj1 the_V2Label_of a1 = the_Vertices_of a1;
  func MCS:PickUnnumbered A1 -> Element of the_Vertices_of a1 means
    it = choose the_Vertices_of a1
    if proj1 the_VLabel_of a1 = the_Vertices_of a1
    otherwise ex b1 being non empty finite natural-membered set st
       ex b2 being Relation-like Function-like set st
          b1 = proj2 b2 &
           b2 = (the_V2Label_of a1) | ((the_Vertices_of a1) \ proj1 the_VLabel_of a1) &
           it = choose (b2 " {max b1});
end;

:: LEXBFS:def 36
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
   st proj1 the_V2Label_of b1 = the_Vertices_of b1
for b2 being Element of the_Vertices_of b1 holds
   (proj1 the_VLabel_of b1 = the_Vertices_of b1 implies    (b2 = MCS:PickUnnumbered b1
    iff
       b2 = choose the_Vertices_of b1)) &
    (proj1 the_VLabel_of b1 = the_Vertices_of b1 or    (b2 = MCS:PickUnnumbered b1
    iff
       ex b3 being non empty finite natural-membered set st
          ex b4 being Relation-like Function-like set st
             b3 = proj2 b4 &
              b4 = (the_V2Label_of b1) | ((the_Vertices_of b1) \ proj1 the_VLabel_of b1) &
              b2 = choose (b4 " {max b3})));

:: LEXBFS:funcnot 22 => LEXBFS:func 22
definition
  let a1 be [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct;
  let a2 be set;
  func MCS:LabelAdjacent(A1,A2) -> [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct equals
    a1 .set(V2LabelSelector,(the_V2Label_of a1) .incSubset((a1 .AdjacentSet {a2}) \ proj1 the_VLabel_of a1,1));
end;

:: LEXBFS:def 37
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
for b2 being set holds
   MCS:LabelAdjacent(b1,b2) = b1 .set(V2LabelSelector,(the_V2Label_of b1) .incSubset((b1 .AdjacentSet {b2}) \ proj1 the_VLabel_of b1,1));

:: LEXBFS:funcnot 23 => LEXBFS:func 23
definition
  let a1 be [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  redefine func MCS:LabelAdjacent(a1,a2) -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct;
end;

:: LEXBFS:funcnot 24 => LEXBFS:func 24
definition
  let a1 be [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  let a3 be natural set;
  func MCS:Update(A1,A2,A3) -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct equals
    MCS:LabelAdjacent(a1 .labelVertex(a2,a1 .order() -' a3),a2);
end;

:: LEXBFS:def 38
theorem
for b1 being [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being natural set holds
   MCS:Update(b1,b2,b3) = MCS:LabelAdjacent(b1 .labelVertex(b2,b1 .order() -' b3),b2);

:: LEXBFS:funcnot 25 => LEXBFS:func 25
definition
  let a1 be [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct;
  func MCS:Step A1 -> [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct equals
    a1
    if a1 .order() <= card proj1 the_VLabel_of a1
    otherwise MCS:Update(a1,MCS:PickUnnumbered a1,card proj1 the_VLabel_of a1);
end;

:: LEXBFS:def 39
theorem
for b1 being [Graph-like] finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct holds
   (b1 .order() <= card proj1 the_VLabel_of b1 implies MCS:Step b1 = b1) &
    (b1 .order() <= card proj1 the_VLabel_of b1 or MCS:Step b1 = MCS:Update(b1,MCS:PickUnnumbered b1,card proj1 the_VLabel_of b1));

:: LEXBFS:funcnot 26 => LEXBFS:func 26
definition
  let a1 be [Graph-like] finite GraphStruct;
  func MCS:CSeq A1 -> Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled ManySortedSet of NAT means
    it . 0 = MCS:Init a1 &
     (for b1 being natural set holds
        it . (b1 + 1) = MCS:Step (it . b1));
end;

:: LEXBFS:def 40
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled ManySortedSet of NAT holds
      b2 = MCS:CSeq b1
   iff
      b2 . 0 = MCS:Init b1 &
       (for b3 being natural set holds
          b2 . (b3 + 1) = MCS:Step (b2 . b3));

:: LEXBFS:th 68
theorem
for b1 being [Graph-like] finite GraphStruct holds
   MCS:CSeq b1 is iterative;

:: LEXBFS:funcreg 45
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster MCS:CSeq a1 -> Graph-yielding finite [VLabeled] iterative natural-vlabeled [V2Labeled] natural-v2labeled;
end;

:: LEXBFS:th 69
theorem
for b1 being [Graph-like] finite GraphStruct holds
   the_VLabel_of MCS:Init b1 = {};

:: LEXBFS:th 70
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being set holds
   proj1 the_V2Label_of MCS:Init b1 = the_Vertices_of b1 & (the_V2Label_of MCS:Init b1) . b2 = 0;

:: LEXBFS:th 71
theorem
for b1 being [Graph-like] finite GraphStruct holds
   b1 == MCS:Init b1;

:: LEXBFS:th 72
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
for b2 being set
      st not b2 in proj1 the_VLabel_of b1 & proj1 the_V2Label_of b1 = the_Vertices_of b1 & proj1 the_VLabel_of b1 <> the_Vertices_of b1
   holds (the_V2Label_of b1) . b2 <= (the_V2Label_of b1) . MCS:PickUnnumbered b1;

:: LEXBFS:th 73
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
      st proj1 the_V2Label_of b1 = the_Vertices_of b1 & proj1 the_VLabel_of b1 <> the_Vertices_of b1
   holds not MCS:PickUnnumbered b1 in proj1 the_VLabel_of b1;

:: LEXBFS:th 74
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
for b2, b3 being set
      st not b3 in b1 .AdjacentSet {b2}
   holds (the_V2Label_of b1) . b3 = (the_V2Label_of MCS:LabelAdjacent(b1,b2)) . b3;

:: LEXBFS:th 75
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
for b2, b3 being set
      st b3 in proj1 the_VLabel_of b1
   holds (the_V2Label_of b1) . b3 = (the_V2Label_of MCS:LabelAdjacent(b1,b2)) . b3;

:: LEXBFS:th 76
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
for b2, b3 being set
      st b3 in proj1 the_V2Label_of b1 & b3 in b1 .AdjacentSet {b2} & not b3 in proj1 the_VLabel_of b1
   holds (the_V2Label_of MCS:LabelAdjacent(b1,b2)) . b3 = ((the_V2Label_of b1) . b3) + 1;

:: LEXBFS:th 77
theorem
for b1 being [Graph-like] finite [VLabeled] [V2Labeled] natural-v2labeled GraphStruct
for b2 being set
      st proj1 the_V2Label_of b1 = the_Vertices_of b1
   holds proj1 the_V2Label_of MCS:LabelAdjacent(b1,b2) = the_Vertices_of b1;

:: LEXBFS:th 78
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
   (MCS:CSeq b1) . b2 == b1;

:: LEXBFS:th 79
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set holds
(MCS:CSeq b1) . b2 == (MCS:CSeq b1) . b3;

:: LEXBFS:funcreg 46
registration
  let a1 be [Graph-like] finite chordal GraphStruct;
  let a2 be natural set;
  cluster (MCS:CSeq a1) . a2 -> [Graph-like] [VLabeled] chordal [V2Labeled];
end;

:: LEXBFS:funcreg 47
registration
  let a1 be [Graph-like] finite chordal GraphStruct;
  cluster MCS:CSeq a1 -> Graph-yielding finite [VLabeled] natural-vlabeled chordal [V2Labeled] natural-v2labeled;
end;

:: LEXBFS:th 80
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
   proj1 the_V2Label_of ((MCS:CSeq b1) . b2) = the_Vertices_of ((MCS:CSeq b1) . b2);

:: LEXBFS:th 81
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st card proj1 the_VLabel_of ((MCS:CSeq b1) . b2) < b1 .order()
   holds the_VLabel_of ((MCS:CSeq b1) . (b2 + 1)) = (the_VLabel_of ((MCS:CSeq b1) . b2)) +* ((MCS:PickUnnumbered ((MCS:CSeq b1) . b2)) .--> (b1 .order() -' card proj1 the_VLabel_of ((MCS:CSeq b1) . b2)));

:: LEXBFS:th 82
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b2 <= b1 .order()
   holds card proj1 the_VLabel_of ((MCS:CSeq b1) . b2) = b2;

:: LEXBFS:th 83
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b1 .order() <= b2
   holds (MCS:CSeq b1) . (b1 .order()) = (MCS:CSeq b1) . b2;

:: LEXBFS:th 84
theorem
for b1 being [Graph-like] finite GraphStruct
for b2, b3 being natural set
      st b1 .order() <= b2 & b2 <= b3
   holds (MCS:CSeq b1) . b2 = (MCS:CSeq b1) . b3;

:: LEXBFS:th 85
theorem
for b1 being [Graph-like] finite GraphStruct holds
   MCS:CSeq b1 is eventually-constant;

:: LEXBFS:funcreg 48
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster MCS:CSeq a1 -> Graph-yielding finite [VLabeled] eventually-constant natural-vlabeled [V2Labeled] natural-v2labeled;
end;

:: LEXBFS:th 86
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
      proj1 the_VLabel_of ((MCS:CSeq b1) . b2) = the_Vertices_of ((MCS:CSeq b1) . b2)
   iff
      b1 .order() <= b2;

:: LEXBFS:th 87
theorem
for b1 being [Graph-like] finite GraphStruct holds
   (MCS:CSeq b1) .Lifespan() = b1 .order();

:: LEXBFS:th 88
theorem
for b1 being [Graph-like] finite GraphStruct holds
   MCS:CSeq b1 is vlabel-numbering;

:: LEXBFS:funcreg 49
registration
  let a1 be [Graph-like] finite GraphStruct;
  cluster MCS:CSeq a1 -> Graph-yielding finite [VLabeled] natural-vlabeled [V2Labeled] natural-v2labeled vlabel-numbering;
end;

:: LEXBFS:th 89
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b2 < b1 .order()
   holds (MCS:CSeq b1) .PickedAt b2 = MCS:PickUnnumbered ((MCS:CSeq b1) . b2);

:: LEXBFS:th 90
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
      st b2 < b1 .order()
   holds ex b3 being Element of the_Vertices_of ((MCS:CSeq b1) . b2) st
      b3 = MCS:PickUnnumbered ((MCS:CSeq b1) . b2) &
       (for b4 being set holds
          (b4 in b1 .AdjacentSet {b3} & not b4 in proj1 the_VLabel_of ((MCS:CSeq b1) . b2) implies (the_V2Label_of ((MCS:CSeq b1) . (b2 + 1))) . b4 = ((the_V2Label_of ((MCS:CSeq b1) . b2)) . b4) + 1) &
           (b4 in b1 .AdjacentSet {b3} & not b4 in proj1 the_VLabel_of ((MCS:CSeq b1) . b2) or (the_V2Label_of ((MCS:CSeq b1) . (b2 + 1))) . b4 = (the_V2Label_of ((MCS:CSeq b1) . b2)) . b4));

:: LEXBFS:th 91
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set
for b3 being set
      st not b3 in proj1 the_VLabel_of ((MCS:CSeq b1) . b2)
   holds (the_V2Label_of ((MCS:CSeq b1) . b2)) . b3 = card ((b1 .AdjacentSet {b3}) /\ proj1 the_VLabel_of ((MCS:CSeq b1) . b2));

:: LEXBFS:attrnot 22 => LEXBFS:attr 22
definition
  let a1 be [Graph-like] [VLabeled] natural-vlabeled GraphStruct;
  attr a1 is with_property_T means
    for b1, b2, b3 being Element of the_Vertices_of a1
          st b1 in proj1 the_VLabel_of a1 &
             b2 in proj1 the_VLabel_of a1 &
             b3 in proj1 the_VLabel_of a1 &
             (the_VLabel_of a1) . b1 < (the_VLabel_of a1) . b2 &
             (the_VLabel_of a1) . b2 < (the_VLabel_of a1) . b3 &
             b1,b3 are_adjacent &
             not b2,b3 are_adjacent
       holds ex b4 being Element of the_Vertices_of a1 st
          b4 in proj1 the_VLabel_of a1 &
           (the_VLabel_of a1) . b2 < (the_VLabel_of a1) . b4 &
           b2,b4 are_adjacent &
           not b1,b4 are_adjacent;
end;

:: LEXBFS:dfs 41
definiens
  let a1 be [Graph-like] [VLabeled] natural-vlabeled GraphStruct;
To prove
     a1 is with_property_T
it is sufficient to prove
  thus for b1, b2, b3 being Element of the_Vertices_of a1
          st b1 in proj1 the_VLabel_of a1 &
             b2 in proj1 the_VLabel_of a1 &
             b3 in proj1 the_VLabel_of a1 &
             (the_VLabel_of a1) . b1 < (the_VLabel_of a1) . b2 &
             (the_VLabel_of a1) . b2 < (the_VLabel_of a1) . b3 &
             b1,b3 are_adjacent &
             not b2,b3 are_adjacent
       holds ex b4 being Element of the_Vertices_of a1 st
          b4 in proj1 the_VLabel_of a1 &
           (the_VLabel_of a1) . b2 < (the_VLabel_of a1) . b4 &
           b2,b4 are_adjacent &
           not b1,b4 are_adjacent;

:: LEXBFS:def 41
theorem
for b1 being [Graph-like] [VLabeled] natural-vlabeled GraphStruct holds
      b1 is with_property_T
   iff
      for b2, b3, b4 being Element of the_Vertices_of b1
            st b2 in proj1 the_VLabel_of b1 &
               b3 in proj1 the_VLabel_of b1 &
               b4 in proj1 the_VLabel_of b1 &
               (the_VLabel_of b1) . b2 < (the_VLabel_of b1) . b3 &
               (the_VLabel_of b1) . b3 < (the_VLabel_of b1) . b4 &
               b2,b4 are_adjacent &
               not b3,b4 are_adjacent
         holds ex b5 being Element of the_Vertices_of b1 st
            b5 in proj1 the_VLabel_of b1 &
             (the_VLabel_of b1) . b3 < (the_VLabel_of b1) . b5 &
             b3,b5 are_adjacent &
             not b2,b5 are_adjacent;

:: LEXBFS:th 92
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being natural set holds
   (MCS:CSeq b1) . b2 is with_property_T;

:: LEXBFS:th 93
theorem
for b1 being [Graph-like] finite GraphStruct holds
   (LexBFS:CSeq b1) .Result() is with_property_T;

:: LEXBFS:th 94
theorem
for b1 being [Graph-like] finite [VLabeled] chordal natural-vlabeled GraphStruct
   st b1 is with_property_T & proj1 the_VLabel_of b1 = the_Vertices_of b1
for b2 being VertexScheme of b1
      st b2 " = the_VLabel_of b1
   holds b2 is perfect(b1);