:: Recognizing Chordal Graphs: Lex BFS and MCS
:: by Broderick Arneson and Piotr Rudnicki
::
:: Received November 17, 2006
:: Copyright (c) 2006 Association of Mizar Users

:: LEXBFS semantic presentation

theorem :: LEXBFS:1
for A, B being Element of NAT
for X being non empty set
for F being Function of NAT ,X st F is one-to-one holds
Card { (F . w) where w is Element of NAT : ( A <= w & w <= A + B ) } = B + 1
proof end;

Lm1: for a, b, c being real number st a < b holds
(c - b) + 1 < (c - a) + 1
proof end;

theorem Th2: :: LEXBFS:2
for n, m, k being natural number st m <= k & n < m holds
k -' m < k -' n
proof end;

theorem Th3: :: LEXBFS:3
for n, k being natural number st n < k holds
(k -' (n + 1)) + 1 = k -' n
proof end;

theorem Th4: :: LEXBFS:4
for n, m, k being natural number st k <> 0 holds
(n + (m * k)) div k = (n div k) + m
proof end;

definition
let S be set ;
attr S is with_finite-elements means :Def1: :: LEXBFS:def 1
for x being Element of S holds x is finite;
end;

:: deftheorem Def1 defines with_finite-elements LEXBFS:def 1 :
for S being set holds
( S is with_finite-elements iff for x being Element of S holds x is finite );

registration
cluster non empty with_finite-elements set ;
existence
ex b1 being set st
( not b1 is empty & b1 is with_finite-elements )
proof end;
cluster non empty finite with_finite-elements Element of bool (bool NAT );
existence
ex b1 being Subset of (bool NAT ) st
( not b1 is empty & b1 is finite & b1 is with_finite-elements )
proof end;
end;

registration
let S be with_finite-elements set ;
cluster -> finite Element of S;
coherence
for b1 being Element of S holds b1 is finite
by Def1;
end;

definition
let f, g be Function;
func f .\/ g -> Function means :Def2: :: LEXBFS:def 2
( dom it = (dom f) \/ (dom g) & ( for x being set st x in (dom f) \/ (dom g) holds
it . x = (f . x) \/ (g . x) ) );
existence
ex b1 being Function st
( dom b1 = (dom f) \/ (dom g) & ( for x being set st x in (dom f) \/ (dom g) holds
b1 . x = (f . x) \/ (g . x) ) )
proof end;
uniqueness
for b1, b2 being Function st dom b1 = (dom f) \/ (dom g) & ( for x being set st x in (dom f) \/ (dom g) holds
b1 . x = (f . x) \/ (g . x) ) & dom b2 = (dom f) \/ (dom g) & ( for x being set st x in (dom f) \/ (dom g) holds
b2 . x = (f . x) \/ (g . x) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def2 defines .\/ LEXBFS:def 2 :
for f, g, b3 being Function holds
( b3 = f .\/ g iff ( dom b3 = (dom f) \/ (dom g) & ( for x being set st x in (dom f) \/ (dom g) holds
b3 . x = (f . x) \/ (g . x) ) ) );

theorem Th5: :: LEXBFS:5
for m, n, k being natural number holds
( m in (Seg k) \ (Seg (k -' n)) iff ( k -' n < m & m <= k ) )
proof end;

theorem Th6: :: LEXBFS:6
for n, k, m being natural number st n <= m holds
(Seg k) \ (Seg (k -' n)) c= (Seg k) \ (Seg (k -' m))
proof end;

theorem Th7: :: LEXBFS:7
for n, k being natural number st n < k holds
((Seg k) \ (Seg (k -' n))) \/ {(k -' n)} = (Seg k) \ (Seg (k -' (n + 1)))
proof end;

definition
let f be Relation;
attr f is natsubset-yielding means :Def3: :: LEXBFS:def 3
rng f c= bool NAT ;
end;

:: deftheorem Def3 defines natsubset-yielding LEXBFS:def 3 :
for f being Relation holds
( f is natsubset-yielding iff rng f c= bool NAT );

Lm2: for F being Function st ( for x being set st x in rng F holds
x is finite ) holds
F is finite-yielding
proof end;

Lm3: for F being finite-yielding Function
for x being set st x in rng F holds
x is finite
proof end;

registration
cluster finite-yielding natsubset-yielding set ;
existence
ex b1 being Function st
( b1 is finite-yielding & b1 is natsubset-yielding )
proof end;
end;

definition
let f be finite-yielding natsubset-yielding Function;
let x be set ;
:: original: .
redefine func f . x -> finite Subset of NAT ;
coherence
f . x is finite Subset of NAT
proof end;
end;

theorem Th8: :: LEXBFS:8
for X being Ordinal
for a, b being finite Subset of X st a <> b holds
a,1 -bag <> b,1 -bag
proof end;

definition
let F be natural-yielding Function;
let S be set ;
let k be natural number ;
func F .incSubset S,k -> natural-yielding Function means :Def4: :: LEXBFS:def 4
( dom it = dom F & ( for y being set holds
( ( y in S & y in dom F implies it . y = (F . y) + k ) & ( not y in S implies it . y = F . y ) ) ) );
existence
ex b1 being natural-yielding Function st
( dom b1 = dom F & ( for y being set holds
( ( y in S & y in dom F implies b1 . y = (F . y) + k ) & ( not y in S implies b1 . y = F . y ) ) ) )
proof end;
uniqueness
for b1, b2 being natural-yielding Function st dom b1 = dom F & ( for y being set holds
( ( y in S & y in dom F implies b1 . y = (F . y) + k ) & ( not y in S implies b1 . y = F . y ) ) ) & dom b2 = dom F & ( for y being set holds
( ( y in S & y in dom F implies b2 . y = (F . y) + k ) & ( not y in S implies b2 . y = F . y ) ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def4 defines .incSubset LEXBFS:def 4 :
for F being natural-yielding Function
for S being set
for k being natural number
for b4 being natural-yielding Function holds
( b4 = F .incSubset S,k iff ( dom b4 = dom F & ( for y being set holds
( ( y in S & y in dom F implies b4 . y = (F . y) + k ) & ( not y in S implies b4 . y = F . y ) ) ) ) );

definition
let n be Ordinal;
let T be connected TermOrder of n;
let B be non empty finite Subset of (Bags n);
func max B,T -> bag of n means :Def5: :: LEXBFS:def 5
( it in B & ( for x being bag of n st x in B holds
x <= it,T ) );
existence
ex b1 being bag of n st
( b1 in B & ( for x being bag of n st x in B holds
x <= b1,T ) )
proof end;
uniqueness
for b1, b2 being bag of n st b1 in B & ( for x being bag of n st x in B holds
x <= b1,T ) & b2 in B & ( for x being bag of n st x in B holds
x <= b2,T ) holds
b1 = b2
proof end;
end;

:: deftheorem Def5 defines max LEXBFS:def 5 :
for n being Ordinal
for T being connected TermOrder of n
for B being non empty finite Subset of (Bags n)
for b4 being bag of n holds
( b4 = max B,T iff ( b4 in B & ( for x being bag of n st x in B holds
x <= b4,T ) ) );

registration
let O be Ordinal;
cluster InvLexOrder O -> connected ;
coherence
InvLexOrder O is connected
proof end;
end;

registration
let G be _Graph;
cluster one-to-one non empty VertexSeq of G;
existence
ex b1 being VertexSeq of G st
( not b1 is empty & b1 is one-to-one )
proof end;
end;

definition
let G be _Graph;
let V be non empty VertexSeq of G;
mode Walk of V -> Walk of G means :Def6: :: LEXBFS:def 6
it .vertexSeq() = V;
existence
ex b1 being Walk of G st b1 .vertexSeq() = V
proof end;
end;

:: deftheorem Def6 defines Walk LEXBFS:def 6 :
for G being _Graph
for V being non empty VertexSeq of G
for b3 being Walk of G holds
( b3 is Walk of V iff b3 .vertexSeq() = V );

registration
let G be _Graph;
let V be one-to-one non empty VertexSeq of G;
cluster -> Path-like Walk of V;
correctness
coherence
for b1 being Walk of V holds b1 is Path-like
;
proof end;
end;

Lm4: for G being _Graph
for W being Walk of G
for e, v being set st e Joins W .last() ,v,G holds
(W .addEdge e) .length() = (W .length() ) + 1
proof end;

Lm5: for G being _Graph
for W being Walk of G holds W .length() = (W .reverse() ) .length()
proof end;

Lm6: for G being _Graph
for W being Walk of G
for e, x being set st e Joins W .last() ,x,G holds
for n being natural number st n in dom W holds
( (W .addEdge e) . n = W . n & n in dom (W .addEdge e) )
proof end;

theorem :: LEXBFS:9
for G being _Graph
for W1, W2 being Walk of G st W1 is trivial & W1 .last() = W2 .first() holds
W1 .append W2 = W2
proof end;

theorem :: LEXBFS:10
for G, H being _Graph
for A, B, C being set
for G1 being inducedSubgraph of G,A
for H1 being inducedSubgraph of H,B
for G2 being inducedSubgraph of G1,C
for H2 being inducedSubgraph of H1,C st G == H & A c= B & C c= A & C is non empty Subset of (the_Vertices_of G) holds
G2 == H2
proof end;

definition
let G be VGraph;
attr G is natural-vlabeled means :Def7: :: LEXBFS:def 7
the_VLabel_of G is natural-yielding;
end;

:: deftheorem Def7 defines natural-vlabeled LEXBFS:def 7 :
for G being VGraph holds
( G is natural-vlabeled iff the_VLabel_of G is natural-yielding );

definition
func V2LabelSelector -> natural number equals :: LEXBFS:def 8
8;
coherence
8 is natural number
;
end;

:: deftheorem defines V2LabelSelector LEXBFS:def 8 :
V2LabelSelector = 8;

definition
let G be GraphStruct ;
attr G is [V2Labeled] means :Def9: :: LEXBFS:def 9
( V2LabelSelector in dom G & ex f being Function st
( G . V2LabelSelector = f & dom f c= the_Vertices_of G ) );
end;

:: deftheorem Def9 defines [V2Labeled] LEXBFS:def 9 :
for G being GraphStruct holds
( G is [V2Labeled] iff ( V2LabelSelector in dom G & ex f being Function st
( G . V2LabelSelector = f & dom f c= the_Vertices_of G ) ) );

registration
cluster [Graph-like] [Weighted] [ELabeled] [VLabeled] [V2Labeled] GraphStruct ;
existence
ex b1 being GraphStruct st
( b1 is [Graph-like] & b1 is [Weighted] & b1 is [ELabeled] & b1 is [VLabeled] & b1 is [V2Labeled] )
proof end;
end;

definition
mode V2Graph is [V2Labeled] _Graph;
mode VVGraph is [VLabeled] [V2Labeled] _Graph;
end;

definition
let G be V2Graph;
func the_V2Label_of G -> Function equals :: LEXBFS:def 10
G . V2LabelSelector ;
coherence
G . V2LabelSelector is Function
proof end;
end;

:: deftheorem defines the_V2Label_of LEXBFS:def 10 :
for G being V2Graph holds the_V2Label_of G = G . V2LabelSelector ;

theorem Th11: :: LEXBFS:11
for G being V2Graph holds dom (the_V2Label_of G) c= the_Vertices_of G
proof end;

registration
let G be _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> [Graph-like] ;
coherence
G .set V2LabelSelector ,X is [Graph-like]
proof end;
end;

theorem Th12: :: LEXBFS:12
for G being _Graph
for X being set holds G .set V2LabelSelector ,X == G
proof end;

registration
let G be finite _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> finite ;
coherence
G .set V2LabelSelector ,X is finite
proof end;
end;

registration
let G be loopless _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> loopless ;
coherence
G .set V2LabelSelector ,X is loopless
proof end;
end;

registration
let G be trivial _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> trivial ;
coherence
G .set V2LabelSelector ,X is trivial
proof end;
end;

registration
let G be non trivial _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> non trivial ;
coherence
not G .set V2LabelSelector ,X is trivial
proof end;
end;

registration
let G be non-multi _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> non-multi ;
coherence
G .set V2LabelSelector ,X is non-multi
proof end;
end;

registration
let G be non-Dmulti _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> non-Dmulti ;
coherence
G .set V2LabelSelector ,X is non-Dmulti
proof end;
end;

registration
let G be connected _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> connected ;
coherence
G .set V2LabelSelector ,X is connected
proof end;
end;

registration
let G be acyclic _Graph;
let X be set ;
cluster G .set V2LabelSelector ,X -> acyclic ;
coherence
G .set V2LabelSelector ,X is acyclic
proof end;
end;

registration
let G be VGraph;
let X be set ;
cluster G .set V2LabelSelector ,X -> [VLabeled] ;
coherence
G .set V2LabelSelector ,X is [VLabeled]
proof end;
end;

registration
let G be EGraph;
let X be set ;
cluster G .set V2LabelSelector ,X -> [ELabeled] ;
coherence
G .set V2LabelSelector ,X is [ELabeled]
proof end;
end;

registration
let G be WGraph;
let X be set ;
cluster G .set V2LabelSelector ,X -> [Weighted] ;
coherence
G .set V2LabelSelector ,X is [Weighted]
proof end;
end;

registration
let G be V2Graph;
let X be set ;
cluster G .set VLabelSelector ,X -> [V2Labeled] ;
coherence
G .set VLabelSelector ,X is [V2Labeled]
proof end;
end;

registration
let G be _Graph;
let Y be set ;
let X be PartFunc of the_Vertices_of G,Y;
cluster G .set V2LabelSelector ,X -> [V2Labeled] ;
coherence
G .set V2LabelSelector ,X is [V2Labeled]
proof end;
end;

registration
let G be _Graph;
let X be ManySortedSet of the_Vertices_of G;
cluster G .set V2LabelSelector ,X -> [V2Labeled] ;
coherence
G .set V2LabelSelector ,X is [V2Labeled]
proof end;
end;

registration
let G be _Graph;
cluster G .set V2LabelSelector ,{} -> [V2Labeled] ;
coherence
G .set V2LabelSelector ,{} is [V2Labeled]
proof end;
end;

definition
let G be V2Graph;
attr G is natural-v2labeled means :Def11: :: LEXBFS:def 11
the_V2Label_of G is natural-yielding;
attr G is finite-v2labeled means :Def12: :: LEXBFS:def 12
the_V2Label_of G is finite-yielding;
attr G is natsubset-v2labeled means :Def13: :: LEXBFS:def 13
the_V2Label_of G is natsubset-yielding;
end;

:: deftheorem Def11 defines natural-v2labeled LEXBFS:def 11 :
for G being V2Graph holds
( G is natural-v2labeled iff the_V2Label_of G is natural-yielding );

:: deftheorem Def12 defines finite-v2labeled LEXBFS:def 12 :
for G being V2Graph holds
( G is finite-v2labeled iff the_V2Label_of G is finite-yielding );

:: deftheorem Def13 defines natsubset-v2labeled LEXBFS:def 13 :
for G being V2Graph holds
( G is natsubset-v2labeled iff the_V2Label_of G is natsubset-yielding );

registration
cluster finite [Weighted] [ELabeled] [VLabeled] chordal natural-vlabeled [V2Labeled] finite-v2labeled natsubset-v2labeled GraphStruct ;
existence
ex b1 being [Weighted] [ELabeled] [VLabeled] [V2Labeled] _Graph st
( b1 is finite & b1 is natural-vlabeled & b1 is finite-v2labeled & b1 is natsubset-v2labeled & b1 is chordal )
proof end;
cluster finite [Weighted] [ELabeled] [VLabeled] chordal natural-vlabeled [V2Labeled] natural-v2labeled GraphStruct ;
existence
ex b1 being [Weighted] [ELabeled] [VLabeled] [V2Labeled] _Graph st
( b1 is finite & b1 is natural-vlabeled & b1 is natural-v2labeled & b1 is chordal )
proof end;
end;

registration
let G be natural-vlabeled VGraph;
cluster the_VLabel_of G -> natural-yielding ;
coherence
the_VLabel_of G is natural-yielding
by Def7;
end;

registration
let G be natural-v2labeled V2Graph;
cluster the_V2Label_of G -> natural-yielding ;
coherence
the_V2Label_of G is natural-yielding
by Def11;
end;

registration
let G be finite-v2labeled V2Graph;
cluster the_V2Label_of G -> finite-yielding ;
coherence
the_V2Label_of G is finite-yielding
by Def12;
end;

registration
let G be natsubset-v2labeled V2Graph;
cluster the_V2Label_of G -> natsubset-yielding ;
coherence
the_V2Label_of G is natsubset-yielding
by Def13;
end;

registration
let G be VVGraph;
let v, x be set ;
cluster G .labelVertex v,x -> [V2Labeled] ;
coherence
G .labelVertex v,x is [V2Labeled]
proof end;
end;

theorem Th13: :: LEXBFS:13
for G being VVGraph
for v, x being set holds the_V2Label_of G = the_V2Label_of (G .labelVertex v,x)
proof end;

registration
let G be natural-vlabeled VVGraph;
let v be set ;
let x be natural number ;
cluster G .labelVertex v,x -> natural-vlabeled ;
coherence
G .labelVertex v,x is natural-vlabeled
proof end;
end;

registration
let G be natural-v2labeled VVGraph;
let v be set ;
let x be natural number ;
cluster G .labelVertex v,x -> natural-v2labeled ;
coherence
G .labelVertex v,x is natural-v2labeled
proof end;
end;

registration
let G be finite-v2labeled VVGraph;
let v be set ;
let x be natural number ;
cluster G .labelVertex v,x -> finite-v2labeled ;
coherence
G .labelVertex v,x is finite-v2labeled
proof end;
end;

registration
let G be natsubset-v2labeled VVGraph;
let v be set ;
let x be natural number ;
cluster G .labelVertex v,x -> natsubset-v2labeled ;
coherence
G .labelVertex v,x is natsubset-v2labeled
proof end;
end;

registration
let G be _Graph;
cluster [VLabeled] [V2Labeled] Subgraph of G;
existence
ex b1 being Subgraph of G st
( b1 is [VLabeled] & b1 is [V2Labeled] )
proof end;
end;

definition
let G be V2Graph;
let G2 be [V2Labeled] Subgraph of G;
attr G2 is v2label-inheriting means :Def14: :: LEXBFS:def 14
the_V2Label_of G2 = (the_V2Label_of G) | (the_Vertices_of G2);
end;

:: deftheorem Def14 defines v2label-inheriting LEXBFS:def 14 :
for G being V2Graph
for G2 being [V2Labeled] Subgraph of G holds
( G2 is v2label-inheriting iff the_V2Label_of G2 = (the_V2Label_of G) | (the_Vertices_of G2) );

registration
let G be V2Graph;
cluster [V2Labeled] v2label-inheriting Subgraph of G;
existence
ex b1 being [V2Labeled] Subgraph of G st b1 is v2label-inheriting
proof end;
end;

definition
let G be V2Graph;
mode V2Subgraph of G is [V2Labeled] v2label-inheriting Subgraph of G;
end;

registration
let G be VVGraph;
cluster [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting Subgraph of G;
existence
ex b1 being [VLabeled] [V2Labeled] Subgraph of G st
( b1 is vlabel-inheriting & b1 is v2label-inheriting )
proof end;
end;

definition
let G be VVGraph;
mode VVSubgraph of G is [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting Subgraph of G;
end;

registration
let G be natural-vlabeled VGraph;
cluster -> natural-vlabeled Subgraph of G;
coherence
for b1 being VSubgraph of G holds b1 is natural-vlabeled
proof end;
end;

registration
let G be _Graph;
let V, E be set ;
cluster [Weighted] [ELabeled] [VLabeled] [V2Labeled] inducedSubgraph of G,V,E;
existence
ex b1 being inducedSubgraph of G,V,E st
( b1 is [Weighted] & b1 is [ELabeled] & b1 is [VLabeled] & b1 is [V2Labeled] )
proof end;
end;

registration
let G be VVGraph;
let V, E be set ;
cluster [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting inducedSubgraph of G,V,E;
existence
ex b1 being [VLabeled] [V2Labeled] inducedSubgraph of G,V,E st
( b1 is vlabel-inheriting & b1 is v2label-inheriting )
proof end;
end;

definition
let G be VVGraph;
let V, E be set ;
mode inducedVVSubgraph of G,V,E is [VLabeled] vlabel-inheriting [V2Labeled] v2label-inheriting inducedSubgraph of G,V,E;
end;

definition
let G be VVGraph;
let V be set ;
mode inducedVVSubgraph of G,V is inducedVVSubgraph of G,V,G .edgesBetween V;
end;

definition
let s be ManySortedSet of NAT ;
attr s is iterative means :Def15: :: LEXBFS:def 15
for k, n being natural number st s . k = s . n holds
s . (k + 1) = s . (n + 1);
end;

:: deftheorem Def15 defines iterative LEXBFS:def 15 :
for s being ManySortedSet of NAT holds
( s is iterative iff for k, n being natural number st s . k = s . n holds
s . (k + 1) = s . (n + 1) );

definition
let GS be ManySortedSet of NAT ;
attr GS is eventually-constant means :Def16: :: LEXBFS:def 16
ex n being natural number st
for m being natural number st n <= m holds
GS . n = GS . m;
end;

:: deftheorem Def16 defines eventually-constant LEXBFS:def 16 :
for GS being ManySortedSet of NAT holds
( GS is eventually-constant iff ex n being natural number st
for m being natural number st n <= m holds
GS . n = GS . m );

registration
cluster halting iterative eventually-constant ManySortedSet of NAT ;
existence
ex b1 being ManySortedSet of NAT st
( b1 is halting & b1 is iterative & b1 is eventually-constant )
proof end;
end;

theorem Th14: :: LEXBFS:14
for Gs being ManySortedSet of NAT st Gs is halting & Gs is iterative holds
Gs is eventually-constant
proof end;

registration
cluster halting iterative -> eventually-constant ManySortedSet of NAT ;
coherence
for b1 being ManySortedSet of NAT st b1 is halting & b1 is iterative holds
b1 is eventually-constant
by Th14;
end;

theorem Th15: :: LEXBFS:15
for Gs being ManySortedSet of NAT st Gs is eventually-constant holds
Gs is halting
proof end;

registration
cluster eventually-constant -> halting ManySortedSet of NAT ;
coherence
for b1 being ManySortedSet of NAT st b1 is eventually-constant holds
b1 is halting
by Th15;
end;

theorem Th16: :: LEXBFS:16
for Gs being iterative eventually-constant ManySortedSet of NAT
for n being natural number st Gs .Lifespan() <= n holds
Gs . (Gs .Lifespan() ) = Gs . n
proof end;

theorem Th17: :: LEXBFS:17
for Gs being iterative eventually-constant ManySortedSet of NAT
for n, m being natural number st Gs .Lifespan() <= n & n <= m holds
Gs . m = Gs . n
proof end;

definition
let GS be VGraphSeq;
attr GS is natural-vlabeled means :Def17: :: LEXBFS:def 17
for x being natural number holds GS . x is natural-vlabeled;
end;

:: deftheorem Def17 defines natural-vlabeled LEXBFS:def 17 :
for GS being VGraphSeq holds
( GS is natural-vlabeled iff for x being natural number holds GS . x is natural-vlabeled );

definition
let GS be GraphSeq;
attr GS is chordal means :Def18: :: LEXBFS:def 18
for x being natural number holds GS . x is chordal;
attr GS is fixed-vertices means :Def19: :: LEXBFS:def 19
for n, m being natural number holds the_Vertices_of (GS . n) = the_Vertices_of (GS . m);
attr GS is [V2Labeled] means :Def20: :: LEXBFS:def 20
for x being natural number holds GS . x is [V2Labeled];
end;

:: deftheorem Def18 defines chordal LEXBFS:def 18 :
for GS being GraphSeq holds
( GS is chordal iff for x being natural number holds GS . x is chordal );

:: deftheorem Def19 defines fixed-vertices LEXBFS:def 19 :
for GS being GraphSeq holds
( GS is fixed-vertices iff for n, m being natural number holds the_Vertices_of (GS . n) = the_Vertices_of (GS . m) );

:: deftheorem Def20 defines [V2Labeled] LEXBFS:def 20 :
for GS being GraphSeq holds
( GS is [V2Labeled] iff for x being natural number holds GS . x is [V2Labeled] );

registration
cluster [Weighted] [ELabeled] [VLabeled] [V2Labeled] ManySortedSet of NAT ;
existence
ex b1 being GraphSeq st
( b1 is [Weighted] & b1 is [ELabeled] & b1 is [VLabeled] & b1 is [V2Labeled] )
proof end;
end;

definition
mode V2GraphSeq is [V2Labeled] GraphSeq;
mode VVGraphSeq is [VLabeled] [V2Labeled] GraphSeq;
end;

registration
let GSq be V2GraphSeq;
let x be natural number ;
cluster GSq . x -> [V2Labeled] _Graph;
coherence
GSq . x is [V2Labeled] _Graph
by Def20;
end;

definition
let GSq be V2GraphSeq;
attr GSq is natural-v2labeled means :Def21: :: LEXBFS:def 21
for x being natural number holds GSq . x is natural-v2labeled;
attr GSq is finite-v2labeled means :Def22: :: LEXBFS:def 22
for x being natural number holds GSq . x is finite-v2labeled;
attr GSq is natsubset-v2labeled means :Def23: :: LEXBFS:def 23
for x being natural number holds GSq . x is natsubset-v2labeled;
end;

:: deftheorem Def21 defines natural-v2labeled LEXBFS:def 21 :
for GSq being V2GraphSeq holds
( GSq is natural-v2labeled iff for x being natural number holds GSq . x is natural-v2labeled );

:: deftheorem Def22 defines finite-v2labeled LEXBFS:def 22 :
for GSq being V2GraphSeq holds
( GSq is finite-v2labeled iff for x being natural number holds GSq . x is finite-v2labeled );

:: deftheorem Def23 defines natsubset-v2labeled LEXBFS:def 23 :
for GSq being V2GraphSeq holds
( GSq is natsubset-v2labeled iff for x being natural number holds GSq . x is natsubset-v2labeled );

registration
cluster finite [Weighted] [ELabeled] [VLabeled] natural-vlabeled chordal [V2Labeled] finite-v2labeled natsubset-v2labeled ManySortedSet of NAT ;
existence
ex b1 being [Weighted] [ELabeled] [VLabeled] [V2Labeled] GraphSeq st
( b1 is finite & b1 is natural-vlabeled & b1 is finite-v2labeled & b1 is natsubset-v2labeled & b1 is chordal )
proof end;
cluster finite [Weighted] [ELabeled] [VLabeled] natural-vlabeled chordal [V2Labeled] natural-v2labeled ManySortedSet of NAT ;
existence
ex b1 being [Weighted] [ELabeled] [VLabeled] [V2Labeled] GraphSeq st
( b1 is finite & b1 is natural-vlabeled & b1 is natural-v2labeled & b1 is chordal )
proof end;
end;

definition
let Gs be VGraphSeq;
let x be natural number ;
:: original: .
redefine func Gs . x -> VGraph;
coherence
Gs . x is VGraph
by GLIB_003:def 26;
end;

registration
let GSq be natural-vlabeled VGraphSeq;
let x be natural number ;
cluster GSq . x -> natural-vlabeled VGraph;
coherence
GSq . x is natural-vlabeled VGraph
by Def17;
end;

registration
let GSq be natural-v2labeled V2GraphSeq;
let x be natural number ;
cluster GSq . x -> natural-v2labeled V2Graph;
coherence
GSq . x is natural-v2labeled V2Graph
by Def21;
end;

registration
let GSq be finite-v2labeled V2GraphSeq;
let x be natural number ;
cluster GSq . x -> finite-v2labeled V2Graph;
coherence
GSq . x is finite-v2labeled V2Graph
by Def22;
end;

registration
let GSq be natsubset-v2labeled V2GraphSeq;
let x be natural number ;
cluster GSq . x -> natsubset-v2labeled V2Graph;
coherence
GSq . x is natsubset-v2labeled V2Graph
by Def23;
end;

registration
let GSq be chordal GraphSeq;
let x be natural number ;
cluster GSq . x -> chordal _Graph;
coherence
GSq . x is chordal _Graph
by Def18;
end;

definition
let Gs be VGraphSeq;
let n be natural number ;
:: original: .
redefine func Gs . n -> VGraph;
coherence
Gs . n is VGraph
proof end;
end;

registration
let Gs be finite VGraphSeq;
let n be natural number ;
cluster Gs . n -> finite VGraph;
coherence
Gs . n is finite VGraph
by GLIB_000:def 60;
end;

definition
let Gs be VVGraphSeq;
let n be natural number ;
:: original: .
redefine func Gs . n -> VVGraph;
coherence
Gs . n is VVGraph
by Def20;
end;

registration
let Gs be finite VVGraphSeq;
let n be natural number ;
cluster Gs . n -> finite VVGraph;
coherence
Gs . n is finite VVGraph
;
end;

registration
let Gs be chordal VVGraphSeq;
let n be natural number ;
cluster Gs . n -> chordal VVGraph;
coherence
Gs . n is chordal VVGraph
;
end;

registration
let Gs be natural-vlabeled VVGraphSeq;
let n be natural number ;
cluster Gs . n -> natural-vlabeled VVGraph;
coherence
Gs . n is natural-vlabeled VVGraph
;
end;

registration
let Gs be finite-v2labeled VVGraphSeq;
let n be natural number ;
cluster Gs . n -> finite-v2labeled VVGraph;
coherence
Gs . n is finite-v2labeled VVGraph
;
end;

registration
let Gs be natsubset-v2labeled VVGraphSeq;
let n be natural number ;
cluster Gs . n -> natsubset-v2labeled VVGraph;
coherence
Gs . n is natsubset-v2labeled VVGraph
;
end;

registration
let Gs be natural-v2labeled VVGraphSeq;
let n be natural number ;
cluster Gs . n -> natural-v2labeled VVGraph;
coherence
Gs . n is natural-v2labeled VVGraph
;
end;

definition
let GS be VGraphSeq;
attr GS is vlabel-initially-empty means :Def24: :: LEXBFS:def 24
the_VLabel_of (GS . 0 ) = {} ;
attr GS is adds-one-at-a-step means :Def25: :: LEXBFS:def 25
for n being natural number st n < GS .Lifespan() holds
ex w being set st
( not w in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (w .--> ((GS .Lifespan() ) -' n)) );
end;

:: deftheorem Def24 defines vlabel-initially-empty LEXBFS:def 24 :
for GS being VGraphSeq holds
( GS is vlabel-initially-empty iff the_VLabel_of (GS . 0 ) = {} );

:: deftheorem Def25 defines adds-one-at-a-step LEXBFS:def 25 :
for GS being VGraphSeq holds
( GS is adds-one-at-a-step iff for n being natural number st n < GS .Lifespan() holds
ex w being set st
( not w in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (w .--> ((GS .Lifespan() ) -' n)) ) );

definition
let GS be VGraphSeq;
attr GS is vlabel-numbering means :Def26: :: LEXBFS:def 26
( GS is iterative & GS is eventually-constant & GS is finite & GS is fixed-vertices & GS is natural-vlabeled & GS is vlabel-initially-empty & GS is adds-one-at-a-step );
end;

:: deftheorem Def26 defines vlabel-numbering LEXBFS:def 26 :
for GS being VGraphSeq holds
( GS is vlabel-numbering iff ( GS is iterative & GS is eventually-constant & GS is finite & GS is fixed-vertices & GS is natural-vlabeled & GS is vlabel-initially-empty & GS is adds-one-at-a-step ) );

Lm7: ex GS being VGraphSeq st
( GS is iterative & GS is eventually-constant & GS is finite & GS is fixed-vertices & GS is natural-vlabeled & GS is vlabel-initially-empty & GS is adds-one-at-a-step )
proof end;

registration
cluster finite iterative eventually-constant natural-vlabeled fixed-vertices vlabel-initially-empty adds-one-at-a-step ManySortedSet of NAT ;
existence
ex b1 being VGraphSeq st
( 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 )
by Lm7;
end;

registration
cluster vlabel-numbering ManySortedSet of NAT ;
existence
ex b1 being VGraphSeq st b1 is vlabel-numbering
proof end;
end;

registration
cluster vlabel-numbering -> iterative ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is iterative
;
by Def26;
cluster vlabel-numbering -> eventually-constant ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is eventually-constant
;
by Def26;
cluster vlabel-numbering -> finite ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is finite
;
by Def26;
cluster vlabel-numbering -> fixed-vertices ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is fixed-vertices
;
by Def26;
cluster vlabel-numbering -> natural-vlabeled ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is natural-vlabeled
;
by Def26;
cluster vlabel-numbering -> vlabel-initially-empty ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is vlabel-initially-empty
;
by Def26;
cluster vlabel-numbering -> adds-one-at-a-step ManySortedSet of NAT ;
correctness
coherence
for b1 being VGraphSeq st b1 is vlabel-numbering holds
b1 is adds-one-at-a-step
;
by Def26;
end;

definition
mode VLabelNumberingSeq is vlabel-numbering VGraphSeq;
end;

definition
let GS be VLabelNumberingSeq;
let n be natural number ;
func GS .PickedAt n -> set means :Def27: :: LEXBFS:def 27
it = choose (the_Vertices_of (GS . 0 )) if n >= GS .Lifespan()
otherwise ( not it in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (it .--> ((GS .Lifespan() ) -' n)) );
existence
( ( n >= GS .Lifespan() implies ex b1 being set st b1 = choose (the_Vertices_of (GS . 0 )) ) & ( not n >= GS .Lifespan() implies ex b1 being set st
( not b1 in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (b1 .--> ((GS .Lifespan() ) -' n)) ) ) )
proof end;
uniqueness
for b1, b2 being set holds
( ( n >= GS .Lifespan() & b1 = choose (the_Vertices_of (GS . 0 )) & b2 = choose (the_Vertices_of (GS . 0 )) implies b1 = b2 ) & ( not n >= GS .Lifespan() & not b1 in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (b1 .--> ((GS .Lifespan() ) -' n)) & not b2 in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (b2 .--> ((GS .Lifespan() ) -' n)) implies b1 = b2 ) )
proof end;
consistency
for b1 being set holds verum
;
end;

:: deftheorem Def27 defines .PickedAt LEXBFS:def 27 :
for GS being VLabelNumberingSeq
for n being natural number
for b3 being set holds
( ( n >= GS .Lifespan() implies ( b3 = GS .PickedAt n iff b3 = choose (the_Vertices_of (GS . 0 )) ) ) & ( not n >= GS .Lifespan() implies ( b3 = GS .PickedAt n iff ( not b3 in dom (the_VLabel_of (GS . n)) & the_VLabel_of (GS . (n + 1)) = (the_VLabel_of (GS . n)) +* (b3 .--> ((GS .Lifespan() ) -' n)) ) ) ) );

theorem Th18: :: LEXBFS:18
for GS being VLabelNumberingSeq
for n being natural number st n < GS .Lifespan() holds
( GS .PickedAt n in (GS . (n + 1)) .labeledV() & (GS . (n + 1)) .labeledV() = ((GS . n) .labeledV() ) \/ {(GS .PickedAt n)} )
proof end;

theorem Th19: :: LEXBFS:19
for GS being VLabelNumberingSeq
for n being natural number st n < GS .Lifespan() holds
(the_VLabel_of (GS . (n + 1))) . (GS .PickedAt n) = (GS .Lifespan() ) -' n
proof end;

theorem :: LEXBFS:20
for GS being VLabelNumberingSeq
for n being natural number st n <= GS .Lifespan() holds
card ((GS . n) .labeledV() ) = n
proof end;

theorem Th21: :: LEXBFS:21
for GS being VLabelNumberingSeq
for n being natural number holds rng (the_VLabel_of (GS . n)) = (Seg (GS .Lifespan() )) \ (Seg ((GS .Lifespan() ) -' n))
proof end;

theorem Th22: :: LEXBFS:22
for GS being VLabelNumberingSeq
for n being natural number
for x being set holds
( (the_VLabel_of (GS . n)) . x <= GS .Lifespan() & ( x in (GS . n) .labeledV() implies 1 <= (the_VLabel_of (GS . n)) . x ) )
proof end;

theorem Th23: :: LEXBFS:23
for GS being VLabelNumberingSeq
for n, m being natural number st (GS .Lifespan() ) -' n < m & m <= GS .Lifespan() holds
ex v being Vertex of (GS . n) st
( v in (GS . n) .labeledV() & (the_VLabel_of (GS . n)) . v = m )
proof end;

theorem Th24: :: LEXBFS:24
for GS being VLabelNumberingSeq
for m, n being natural number st m <= n holds
the_VLabel_of (GS . m) c= the_VLabel_of (GS . n)
proof end;

theorem Th25: :: LEXBFS:25
for GS being VLabelNumberingSeq
for n being natural number holds the_VLabel_of (GS . n) is one-to-one
proof end;

theorem Th26: :: LEXBFS:26
for GS being VLabelNumberingSeq
for m, n being natural number
for v being set st v in (GS . m) .labeledV() & v in (GS . n) .labeledV() holds
(the_VLabel_of (GS . m)) . v = (the_VLabel_of (GS . n)) . v
proof end;

theorem Th27: :: LEXBFS:27
for GS being VLabelNumberingSeq
for v being set
for m, n being natural number st v in (GS . m) .labeledV() & (the_VLabel_of (GS . m)) . v = n holds
GS .PickedAt ((GS .Lifespan() ) -' n) = v
proof end;

theorem Th28: :: LEXBFS:28
for GS being VLabelNumberingSeq
for m, n being natural number st n < GS .Lifespan() & n < m holds
( GS .PickedAt n in (GS . m) .labeledV() & (the_VLabel_of (GS . m)) . (GS .PickedAt n) = (GS .Lifespan() ) -' n )
proof end;

theorem Th29: :: LEXBFS:29
for GS being VLabelNumberingSeq
for m being natural number
for v being set st v in (GS . m) .labeledV() holds
( (GS .Lifespan() ) -' ((the_VLabel_of (GS . m)) . v) < m & (GS .Lifespan() ) -' m < (the_VLabel_of (GS . m)) . v )
proof end;

theorem Th30: :: LEXBFS:30
for GS being VLabelNumberingSeq
for i being natural number
for a, b being set st a in (GS . i) .labeledV() & b in (GS . i) .labeledV() & (the_VLabel_of (GS . i)) . a < (the_VLabel_of (GS . i)) . b holds
b in (GS . ((GS .Lifespan() ) -' ((the_VLabel_of (GS . i)) . a))) .labeledV()
proof end;

theorem Th31: :: LEXBFS:31
for GS being VLabelNumberingSeq
for i being natural number
for a, b being set st a in (GS . i) .labeledV() & b in (GS . i) .labeledV() & (the_VLabel_of (GS . i)) . a < (the_VLabel_of (GS . i)) . b holds
not a in (GS . ((GS .Lifespan() ) -' ((the_VLabel_of (GS . i)) . b))) .labeledV()
proof end;

definition
let G be _Graph;
func LexBFS:Init G -> natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph equals :: LEXBFS:def 28
(G .set VLabelSelector ,{} ) .set V2LabelSelector ,((the_Vertices_of G) --> {} );
coherence
(G .set VLabelSelector ,{} ) .set V2LabelSelector ,((the_Vertices_of G) --> {} ) is natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph
proof end;
end;

:: deftheorem defines LexBFS:Init LEXBFS:def 28 :
for G being _Graph holds LexBFS:Init G = (G .set VLabelSelector ,{} ) .set V2LabelSelector ,((the_Vertices_of G) --> {} );

definition
let G be finite _Graph;
:: original: LexBFS:Init
redefine func LexBFS:Init G -> finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph;
coherence
LexBFS:Init G is finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph
;
end;

definition
let G be finite finite-v2labeled natsubset-v2labeled VVGraph;
assume A1: dom (the_V2Label_of G) = the_Vertices_of G ;
func LexBFS:PickUnnumbered G -> Vertex of G means :Def29: :: LEXBFS:def 29
it = choose (the_Vertices_of G) if dom (the_VLabel_of G) = the_Vertices_of G
otherwise ex S being non empty finite Subset of (bool NAT ) ex B being non empty finite Subset of (Bags NAT ) ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & ( for x being finite Subset of NAT st x in S holds
x,1 -bag in B ) & ( for x being set st x in B holds
ex y being finite Subset of NAT st
( y in S & x = y,1 -bag ) ) & it = choose (F " {(support (max B,(InvLexOrder NAT )))}) );
existence
( ( dom (the_VLabel_of G) = the_Vertices_of G implies ex b1 being Vertex of G st b1 = choose (the_Vertices_of G) ) & ( not dom (the_VLabel_of G) = the_Vertices_of G implies ex b1 being Vertex of G ex S being non empty finite Subset of (bool NAT ) ex B being non empty finite Subset of (Bags NAT ) ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & ( for x being finite Subset of NAT st x in S holds
x,1 -bag in B ) & ( for x being set st x in B holds
ex y being finite Subset of NAT st
( y in S & x = y,1 -bag ) ) & b1 = choose (F " {(support (max B,(InvLexOrder NAT )))}) ) ) )
proof end;
uniqueness
for b1, b2 being Vertex of G holds
( ( dom (the_VLabel_of G) = the_Vertices_of G & b1 = choose (the_Vertices_of G) & b2 = choose (the_Vertices_of G) implies b1 = b2 ) & ( not dom (the_VLabel_of G) = the_Vertices_of G & ex S being non empty finite Subset of (bool NAT ) ex B being non empty finite Subset of (Bags NAT ) ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & ( for x being finite Subset of NAT st x in S holds
x,1 -bag in B ) & ( for x being set st x in B holds
ex y being finite Subset of NAT st
( y in S & x = y,1 -bag ) ) & b1 = choose (F " {(support (max B,(InvLexOrder NAT )))}) ) & ex S being non empty finite Subset of (bool NAT ) ex B being non empty finite Subset of (Bags NAT ) ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & ( for x being finite Subset of NAT st x in S holds
x,1 -bag in B ) & ( for x being set st x in B holds
ex y being finite Subset of NAT st
( y in S & x = y,1 -bag ) ) & b2 = choose (F " {(support (max B,(InvLexOrder NAT )))}) ) implies b1 = b2 ) )
proof end;
consistency
for b1 being Vertex of G holds verum
;
end;

:: deftheorem Def29 defines LexBFS:PickUnnumbered LEXBFS:def 29 :
for G being finite finite-v2labeled natsubset-v2labeled VVGraph st dom (the_V2Label_of G) = the_Vertices_of G holds
for b2 being Vertex of G holds
( ( dom (the_VLabel_of G) = the_Vertices_of G implies ( b2 = LexBFS:PickUnnumbered G iff b2 = choose (the_Vertices_of G) ) ) & ( not dom (the_VLabel_of G) = the_Vertices_of G implies ( b2 = LexBFS:PickUnnumbered G iff ex S being non empty finite Subset of (bool NAT ) ex B being non empty finite Subset of (Bags NAT ) ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & ( for x being finite Subset of NAT st x in S holds
x,1 -bag in B ) & ( for x being set st x in B holds
ex y being finite Subset of NAT st
( y in S & x = y,1 -bag ) ) & b2 = choose (F " {(support (max B,(InvLexOrder NAT )))}) ) ) ) );

definition
let G be VVGraph;
let v be set ;
let k be natural number ;
func LexBFS:LabelAdjacent G,v,k -> VVGraph equals :: LEXBFS:def 30
G .set V2LabelSelector ,((the_V2Label_of G) .\/ (((G .AdjacentSet {v}) \ (dom (the_VLabel_of G))) --> {k}));
coherence
G .set V2LabelSelector ,((the_V2Label_of G) .\/ (((G .AdjacentSet {v}) \ (dom (the_VLabel_of G))) --> {k})) is VVGraph
proof end;
end;

:: deftheorem defines LexBFS:LabelAdjacent LEXBFS:def 30 :
for G being VVGraph
for v being set
for k being natural number holds LexBFS:LabelAdjacent G,v,k = G .set V2LabelSelector ,((the_V2Label_of G) .\/ (((G .AdjacentSet {v}) \ (dom (the_VLabel_of G))) --> {k}));

theorem Th32: :: LEXBFS:32
for G being VVGraph
for v, x being set
for k being natural number st not x in G .AdjacentSet {v} holds
(the_V2Label_of G) . x = (the_V2Label_of (LexBFS:LabelAdjacent G,v,k)) . x
proof end;

theorem Th33: :: LEXBFS:33
for G being VVGraph
for v, x being set
for k being natural number st x in dom (the_VLabel_of G) holds
(the_V2Label_of G) . x = (the_V2Label_of (LexBFS:LabelAdjacent G,v,k)) . x
proof end;

theorem Th34: :: LEXBFS:34
for G being VVGraph
for v, x being set
for k being natural number st x in G .AdjacentSet {v} & not x in dom (the_VLabel_of G) holds
(the_V2Label_of (LexBFS:LabelAdjacent G,v,k)) . x = ((the_V2Label_of G) . x) \/ {k}
proof end;

theorem Th35: :: LEXBFS:35
for G being VVGraph
for v being set
for k being natural number st dom (the_V2Label_of G) = the_Vertices_of G holds
dom (the_V2Label_of (LexBFS:LabelAdjacent G,v,k)) = the_Vertices_of G
proof end;

definition
let G be finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph;
let v be Vertex of G;
let k be natural number ;
:: original: LexBFS:LabelAdjacent
redefine func LexBFS:LabelAdjacent G,v,k -> finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph;
coherence
LexBFS:LabelAdjacent G,v,k is finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph
proof end;
end;

definition
let G be finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph;
let v be Vertex of G;
let n be natural number ;
func LexBFS:Update G,v,n -> finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph equals :: LEXBFS:def 31
LexBFS:LabelAdjacent (G .labelVertex v,((G .order() ) -' n)),v,((G .order() ) -' n);
coherence
LexBFS:LabelAdjacent (G .labelVertex v,((G .order() ) -' n)),v,((G .order() ) -' n) is finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph
proof end;
end;

:: deftheorem defines LexBFS:Update LEXBFS:def 31 :
for G being finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph
for v being Vertex of G
for n being natural number holds LexBFS:Update G,v,n = LexBFS:LabelAdjacent (G .labelVertex v,((G .order() ) -' n)),v,((G .order() ) -' n);

definition
let G be finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph;
func LexBFS:Step G -> finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph equals :Def32: :: LEXBFS:def 32
G if G .order() <= card (dom (the_VLabel_of G))
otherwise LexBFS:Update G,(LexBFS:PickUnnumbered G),(card (dom (the_VLabel_of G)));
coherence
( ( G .order() <= card (dom (the_VLabel_of G)) implies G is finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph ) & ( not G .order() <= card (dom (the_VLabel_of G)) implies LexBFS:Update G,(LexBFS:PickUnnumbered G),(card (dom (the_VLabel_of G))) is finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph ) )
;
consistency
for b1 being finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph holds verum
;
end;

:: deftheorem Def32 defines LexBFS:Step LEXBFS:def 32 :
for G being finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraph holds
( ( G .order() <= card (dom (the_VLabel_of G)) implies LexBFS:Step G = G ) & ( not G .order() <= card (dom (the_VLabel_of G)) implies LexBFS:Step G = LexBFS:Update G,(LexBFS:PickUnnumbered G),(card (dom (the_VLabel_of G))) ) );

definition
let G be finite _Graph;
func LexBFS:CSeq G -> finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraphSeq means :Def33: :: LEXBFS:def 33
( it . 0 = LexBFS:Init G & ( for n being natural number holds it . (n + 1) = LexBFS:Step (it . n) ) );
existence
ex b1 being finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraphSeq st
( b1 . 0 = LexBFS:Init G & ( for n being natural number holds b1 . (n + 1) = LexBFS:Step (b1 . n) ) )
proof end;
uniqueness
for b1, b2 being finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraphSeq st b1 . 0 = LexBFS:Init G & ( for n being natural number holds b1 . (n + 1) = LexBFS:Step (b1 . n) ) & b2 . 0 = LexBFS:Init G & ( for n being natural number holds b2 . (n + 1) = LexBFS:Step (b2 . n) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def33 defines LexBFS:CSeq LEXBFS:def 33 :
for G being finite _Graph
for b2 being finite natural-vlabeled finite-v2labeled natsubset-v2labeled VVGraphSeq holds
( b2 = LexBFS:CSeq G iff ( b2 . 0 = LexBFS:Init G & ( for n being natural number holds b2 . (n + 1) = LexBFS:Step (b2 . n) ) ) );

theorem Th36: :: LEXBFS:36
for G being finite _Graph holds LexBFS:CSeq G is iterative
proof end;

registration
let G be finite _Graph;
cluster LexBFS:CSeq G -> finite iterative natural-vlabeled finite-v2labeled natsubset-v2labeled ;
coherence
LexBFS:CSeq G is iterative
by Th36;
end;

theorem Th37: :: LEXBFS:37
for G being _Graph holds the_VLabel_of (LexBFS:Init G) = {}
proof end;

theorem Th38: :: LEXBFS:38
for G being _Graph
for v being set holds
( dom (the_V2Label_of (LexBFS:Init G)) = the_Vertices_of G & (the_V2Label_of (LexBFS:Init G)) . v = {} )
proof end;

theorem Th39: :: LEXBFS:39
for G being _Graph holds G == LexBFS:Init G
proof end;

theorem Th40: :: LEXBFS:40
for G being finite finite-v2labeled natsubset-v2labeled VVGraph
for x being set st not x in dom (the_VLabel_of G) & dom (the_V2Label_of G) = the_Vertices_of G & dom (the_VLabel_of G) <> the_Vertices_of G holds
((the_V2Label_of G) . x),1 -bag <= ((the_V2Label_of G) . (LexBFS:PickUnnumbered G)),1 -bag , InvLexOrder NAT
proof end;

theorem Th41: :: LEXBFS:41
for G being finite finite-v2labeled natsubset-v2labeled VVGraph st dom (the_V2Label_of G) = the_Vertices_of G & dom (the_VLabel_of G) <> the_Vertices_of G holds
not LexBFS:PickUnnumbered G in dom (the_VLabel_of G)
proof end;

theorem Th42: :: LEXBFS:42
for G being finite _Graph
for n being natural number holds (LexBFS:CSeq G) . n == G
proof end;

theorem Th43: :: LEXBFS:43
for G being finite _Graph
for m, n being natural number holds (LexBFS:CSeq G) . m == (LexBFS:CSeq G) . n
proof end;

theorem Th44: :: LEXBFS:44
for G being finite _Graph
for n being natural number st card (dom (the_VLabel_of ((LexBFS:CSeq G) . n))) < G .order() holds
the_VLabel_of ((LexBFS:CSeq G) . (n + 1)) = (the_VLabel_of ((LexBFS:CSeq G) . n)) +* ((LexBFS:PickUnnumbered ((LexBFS:CSeq G) . n)) .--> ((G .order() ) -' (card (dom (the_VLabel_of ((LexBFS:CSeq G) . n))))))
proof end;

theorem Th45: :: LEXBFS:45
for G being finite _Graph
for n being natural number holds dom (the_V2Label_of ((LexBFS:CSeq G) . n)) = the_Vertices_of ((LexBFS:CSeq G) . n)
proof end;

theorem Th46: :: LEXBFS:46
for G being finite _Graph
for n being natural number st n <= G .order() holds
card (dom (the_VLabel_of ((LexBFS:CSeq G) . n))) = n
proof end;

theorem Th47: :: LEXBFS:47
for G being finite _Graph
for n being natural number st G .order() <= n holds
(LexBFS:CSeq G) . (G .order() ) = (LexBFS:CSeq G) . n
proof end;

theorem Th48: :: LEXBFS:48
for G being finite _Graph
for m, n being natural number st G .order() <= m & m <= n holds
(LexBFS:CSeq G) . m = (LexBFS:CSeq G) . n
proof end;

theorem Th49: :: LEXBFS:49
for G being finite _Graph holds LexBFS:CSeq G is eventually-constant
proof end;

registration
let G be finite _Graph;
cluster LexBFS:CSeq G -> finite eventually-constant natural-vlabeled finite-v2labeled natsubset-v2labeled ;
coherence
LexBFS:CSeq G is eventually-constant
by Th49;
end;

theorem Th50: :: LEXBFS:50
for G being finite _Graph
for n being natural number holds
( dom (the_VLabel_of ((LexBFS:CSeq G) . n)) = the_Vertices_of ((LexBFS:CSeq G) . n) iff G .order() <= n )
proof end;

theorem Th51: :: LEXBFS:51
for G being finite _Graph holds (LexBFS:CSeq G) .Lifespan() = G .order()
proof end;

registration
let G be finite chordal _Graph;
let i be natural number ;
cluster (LexBFS:CSeq G) . i -> chordal VVGraph;
coherence
(LexBFS:CSeq G) . i is chordal VVGraph
proof end;
end;

registration
let G be finite chordal _Graph;
cluster LexBFS:CSeq G -> finite natural-vlabeled chordal finite-v2labeled natsubset-v2labeled ;
correctness
coherence
LexBFS:CSeq G is chordal
;
proof end;
end;

theorem Th52: :: LEXBFS:52
for G being finite _Graph holds LexBFS:CSeq G is vlabel-numbering
proof end;

registration
let G be finite _Graph;
cluster LexBFS:CSeq G -> finite natural-vlabeled finite-v2labeled natsubset-v2labeled vlabel-numbering ;
coherence
LexBFS:CSeq G is vlabel-numbering
by Th52;
end;

theorem Th53: :: LEXBFS:53
for G being finite _Graph
for n being natural number st n < G .order() holds
(LexBFS:CSeq G) .PickedAt n = LexBFS:PickUnnumbered ((LexBFS:CSeq G) . n)
proof end;

theorem Th54: :: LEXBFS:54
for G being finite _Graph
for n being natural number st n < G .order() holds
ex w being Vertex of ((LexBFS:CSeq G) . n) st
( w = LexBFS:PickUnnumbered ((LexBFS:CSeq G) . n) & ( for v being set holds
( ( v in G .AdjacentSet {w} & not v in dom (the_VLabel_of ((LexBFS:CSeq G) . n)) implies (the_V2Label_of ((LexBFS:CSeq G) . (n + 1))) . v = ((the_V2Label_of ((LexBFS:CSeq G) . n)) . v) \/ {((G .order() ) -' n)} ) & ( ( not v in G .AdjacentSet {w} or v in dom (the_VLabel_of ((LexBFS:CSeq G) . n)) ) implies (the_V2Label_of ((LexBFS:CSeq G) . (n + 1))) . v = (the_V2Label_of ((LexBFS:CSeq G) . n)) . v ) ) ) )
proof end;

theorem Th55: :: LEXBFS:55
for G being finite _Graph
for i being natural number
for v being set holds (the_V2Label_of ((LexBFS:CSeq G) . i)) . v c= (Seg (G .order() )) \ (Seg ((G .order() ) -' i))
proof end;

theorem Th56: :: LEXBFS:56
for G being finite _Graph
for x being set
for i, j being natural number st i <= j holds
(the_V2Label_of ((LexBFS:CSeq G) . i)) . x c= (the_V2Label_of ((LexBFS:CSeq G) . j)) . x
proof end;

theorem Th57: :: LEXBFS:57
for G being finite _Graph
for m, n being natural number
for x, y being set st n < G .order() & n < m & y = LexBFS:PickUnnumbered ((LexBFS:CSeq G) . n) & not x in dom (the_VLabel_of ((LexBFS:CSeq G) . n)) & x in G .AdjacentSet {y} holds
(G .order() ) -' n in (the_V2Label_of ((LexBFS:CSeq G) . m)) . x
proof end;

theorem Th58: :: LEXBFS:58
for G being finite _Graph
for m, n being natural number st m < n holds
for x being set st not (G .order() ) -' m in (the_V2Label_of ((LexBFS:CSeq G) . (m + 1))) . x holds
not (G .order() ) -' m in (the_V2Label_of ((LexBFS:CSeq G) . n)) . x
proof end;

theorem Th59: :: LEXBFS:59
for G being finite _Graph
for m, n, k being natural number st k < n & n <= m holds
for x being set st not (G .order() ) -' k in (the_V2Label_of ((LexBFS:CSeq G) . n)) . x holds
not (G .order() ) -' k in (the_V2Label_of ((LexBFS:CSeq G) . m)) . x
proof end;

theorem Th60: :: LEXBFS:60
for G being finite _Graph
for m, n being natural number
for x being Vertex of ((LexBFS:CSeq G) . m) st n in (the_V2Label_of ((LexBFS:CSeq G) . m)) . x holds
ex y being Vertex of ((LexBFS:CSeq G) . m) st
( LexBFS:PickUnnumbered ((LexBFS:CSeq G) . ((G .order() ) -' n)) = y & not y in dom (the_VLabel_of ((LexBFS:CSeq G) . ((G .order() ) -' n))) & x in G .AdjacentSet {y} )
proof end;

definition
let Gs be finite natural-vlabeled VVGraphSeq;
:: original: .Result()
redefine func Gs .Result() -> finite natural-vlabeled VVGraph;
coherence
Gs .Result() is finite natural-vlabeled VVGraph
proof end;
end;

theorem Th61: :: LEXBFS:61
for G being finite _Graph holds ((LexBFS:CSeq G) .Result() ) .labeledV() = the_Vertices_of G
proof end;

theorem Th62: :: LEXBFS:62
for G being finite _Graph holds (the_VLabel_of ((LexBFS:CSeq G) .Result() )) " is VertexScheme of G
proof end;

theorem Th63: :: LEXBFS:63
for G being finite _Graph
for i, j being natural number
for a, b being Vertex of ((LexBFS:CSeq G) . i) st a in dom (the_VLabel_of ((LexBFS:CSeq G) . i)) & b in dom (the_VLabel_of ((LexBFS:CSeq G) . i)) & (the_VLabel_of ((LexBFS:CSeq G) . i)) . a < (the_VLabel_of ((LexBFS:CSeq G) . i)) . b & j = (G .order() ) -' ((the_VLabel_of ((LexBFS:CSeq G) . i)) . b) holds
((the_V2Label_of ((LexBFS:CSeq G) . j)) . a),1 -bag <= ((the_V2Label_of ((LexBFS:CSeq G) . j)) . b),1 -bag , InvLexOrder NAT
proof end;

theorem Th64: :: LEXBFS:64
for G being finite _Graph
for i, j being natural number
for v being Vertex of ((LexBFS:CSeq G) . i) st j in (the_V2Label_of ((LexBFS:CSeq G) . i)) . v holds
ex w being Vertex of ((LexBFS:CSeq G) . i) st
( w in dom (the_VLabel_of ((LexBFS:CSeq G) . i)) & (the_VLabel_of ((LexBFS:CSeq G) . i)) . w = j & v in G .AdjacentSet {w} )
proof end;

definition
let G be natural-vlabeled VGraph;
attr G is with_property_L3 means :Def34: :: LEXBFS:def 34
for a, b, c being Vertex of G st a in dom (the_VLabel_of G) & b in dom (the_VLabel_of G) & c in dom (the_VLabel_of G) & (the_VLabel_of G) . a < (the_VLabel_of G) . b & (the_VLabel_of G) . b < (the_VLabel_of G) . c & a,c are_adjacent & not b,c are_adjacent holds
ex d being Vertex of G st
( d in dom (the_VLabel_of G) & (the_VLabel_of G) . c < (the_VLabel_of G) . d & b,d are_adjacent & not a,d are_adjacent & ( for e being Vertex of G st e <> d & e,b are_adjacent & not e,a are_adjacent holds
(the_VLabel_of G) . e < (the_VLabel_of G) . d ) );
end;

:: deftheorem Def34 defines with_property_L3 LEXBFS:def 34 :
for G being natural-vlabeled VGraph holds
( G is with_property_L3 iff for a, b, c being Vertex of G st a in dom (the_VLabel_of G) & b in dom (the_VLabel_of G) & c in dom (the_VLabel_of G) & (the_VLabel_of G) . a < (the_VLabel_of G) . b & (the_VLabel_of G) . b < (the_VLabel_of G) . c & a,c are_adjacent & not b,c are_adjacent holds
ex d being Vertex of G st
( d in dom (the_VLabel_of G) & (the_VLabel_of G) . c < (the_VLabel_of G) . d & b,d are_adjacent & not a,d are_adjacent & ( for e being Vertex of G st e <> d & e,b are_adjacent & not e,a are_adjacent holds
(the_VLabel_of G) . e < (the_VLabel_of G) . d ) ) );

theorem Th65: :: LEXBFS:65
for G being finite _Graph
for n being natural number holds (LexBFS:CSeq G) . n is with_property_L3
proof end;

theorem Th66: :: LEXBFS:66
for G being finite chordal natural-vlabeled VGraph st G is with_property_L3 & dom (the_VLabel_of G) = the_Vertices_of G holds
for V being VertexScheme of G st V " = the_VLabel_of G holds
V is perfect
proof end;

theorem :: LEXBFS:67
for G being finite chordal VVGraph holds (the_VLabel_of ((LexBFS:CSeq G) .Result() )) " is perfect VertexScheme of G
proof end;

definition
let G be finite _Graph;
func MCS:Init G -> finite natural-vlabeled natural-v2labeled VVGraph equals :: LEXBFS:def 35
(G .set VLabelSelector ,{} ) .set V2LabelSelector ,((the_Vertices_of G) --> 0 );
coherence
(G .set VLabelSelector ,{} ) .set V2LabelSelector ,((the_Vertices_of G) --> 0 ) is finite natural-vlabeled natural-v2labeled VVGraph
proof end;
end;

:: deftheorem defines MCS:Init LEXBFS:def 35 :
for G being finite _Graph holds MCS:Init G = (G .set VLabelSelector ,{} ) .set V2LabelSelector ,((the_Vertices_of G) --> 0 );

definition
let G be finite natural-v2labeled VVGraph;
assume A1: dom (the_V2Label_of G) = the_Vertices_of G ;
func MCS:PickUnnumbered G -> Vertex of G means :Def36: :: LEXBFS:def 36
it = choose (the_Vertices_of G) if dom (the_VLabel_of G) = the_Vertices_of G
otherwise ex S being non empty finite natural-membered set ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & it = choose (F " {(max S)}) );
existence
( ( dom (the_VLabel_of G) = the_Vertices_of G implies ex b1 being Vertex of G st b1 = choose (the_Vertices_of G) ) & ( not dom (the_VLabel_of G) = the_Vertices_of G implies ex b1 being Vertex of G ex S being non empty finite natural-membered set ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & b1 = choose (F " {(max S)}) ) ) )
proof end;
uniqueness
for b1, b2 being Vertex of G holds
( ( dom (the_VLabel_of G) = the_Vertices_of G & b1 = choose (the_Vertices_of G) & b2 = choose (the_Vertices_of G) implies b1 = b2 ) & ( not dom (the_VLabel_of G) = the_Vertices_of G & ex S being non empty finite natural-membered set ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & b1 = choose (F " {(max S)}) ) & ex S being non empty finite natural-membered set ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & b2 = choose (F " {(max S)}) ) implies b1 = b2 ) )
;
consistency
for b1 being Vertex of G holds verum
;
end;

:: deftheorem Def36 defines MCS:PickUnnumbered LEXBFS:def 36 :
for G being finite natural-v2labeled VVGraph st dom (the_V2Label_of G) = the_Vertices_of G holds
for b2 being Vertex of G holds
( ( dom (the_VLabel_of G) = the_Vertices_of G implies ( b2 = MCS:PickUnnumbered G iff b2 = choose (the_Vertices_of G) ) ) & ( not dom (the_VLabel_of G) = the_Vertices_of G implies ( b2 = MCS:PickUnnumbered G iff ex S being non empty finite natural-membered set ex F being Function st
( S = rng F & F = (the_V2Label_of G) | ((the_Vertices_of G) \ (dom (the_VLabel_of G))) & b2 = choose (F " {(max S)}) ) ) ) );

definition
let G be finite natural-v2labeled VVGraph;
let v be set ;
func MCS:LabelAdjacent G,v -> finite natural-v2labeled VVGraph equals :: LEXBFS:def 37
G .set V2LabelSelector ,((the_V2Label_of G) .incSubset ((G .AdjacentSet {v}) \ (dom (the_VLabel_of G))),1);
coherence
G .set V2LabelSelector ,((the_V2Label_of G) .incSubset ((G .AdjacentSet {v}) \ (dom (the_VLabel_of G))),1) is finite natural-v2labeled VVGraph
proof end;
end;

:: deftheorem defines MCS:LabelAdjacent LEXBFS:def 37 :
for G being finite natural-v2labeled VVGraph
for v being set holds MCS:LabelAdjacent G,v = G .set V2LabelSelector ,((the_V2Label_of G) .incSubset ((G .AdjacentSet {v}) \ (dom (the_VLabel_of G))),1);

definition
let G be finite natural-vlabeled natural-v2labeled VVGraph;
let v be Vertex of G;
:: original: MCS:LabelAdjacent
redefine func MCS:LabelAdjacent G,v -> finite natural-vlabeled natural-v2labeled VVGraph;
coherence
MCS:LabelAdjacent G,v is finite natural-vlabeled natural-v2labeled VVGraph
proof end;
end;

definition
let G be finite natural-vlabeled natural-v2labeled VVGraph;
let v be Vertex of G;
let n be natural number ;
func MCS:Update G,v,n -> finite natural-vlabeled natural-v2labeled VVGraph equals :: LEXBFS:def 38
MCS:LabelAdjacent (G .labelVertex v,((G .order() ) -' n)),v;
coherence
MCS:LabelAdjacent (G .labelVertex v,((G .order() ) -' n)),v is finite natural-vlabeled natural-v2labeled VVGraph
proof end;
end;

:: deftheorem defines MCS:Update LEXBFS:def 38 :
for G being finite natural-vlabeled natural-v2labeled VVGraph
for v being Vertex of G
for n being natural number holds MCS:Update G,v,n = MCS:LabelAdjacent (G .labelVertex v,((G .order() ) -' n)),v;

definition
let G be finite natural-vlabeled natural-v2labeled VVGraph;
func MCS:Step G -> finite natural-vlabeled natural-v2labeled VVGraph equals :Def39: :: LEXBFS:def 39
G if G .order() <= card (dom (the_VLabel_of G))
otherwise MCS:Update G,(MCS:PickUnnumbered G),(card (dom (the_VLabel_of G)));
coherence
( ( G .order() <= card (dom (the_VLabel_of G)) implies G is finite natural-vlabeled natural-v2labeled VVGraph ) & ( not G .order() <= card (dom (the_VLabel_of G)) implies MCS:Update G,(MCS:PickUnnumbered G),(card (dom (the_VLabel_of G))) is finite natural-vlabeled natural-v2labeled VVGraph ) )
;
consistency
for b1 being finite natural-vlabeled natural-v2labeled VVGraph holds verum
;
end;

:: deftheorem Def39 defines MCS:Step LEXBFS:def 39 :
for G being finite natural-vlabeled natural-v2labeled VVGraph holds
( ( G .order() <= card (dom (the_VLabel_of G)) implies MCS:Step G = G ) & ( not G .order() <= card (dom (the_VLabel_of G)) implies MCS:Step G = MCS:Update G,(MCS:PickUnnumbered G),(card (dom (the_VLabel_of G))) ) );

definition
let G be finite _Graph;
func MCS:CSeq G -> finite natural-vlabeled natural-v2labeled VVGraphSeq means :Def40: :: LEXBFS:def 40
( it . 0 = MCS:Init G & ( for n being natural number holds it . (n + 1) = MCS:Step (it . n) ) );
existence
ex b1 being finite natural-vlabeled natural-v2labeled VVGraphSeq st
( b1 . 0 = MCS:Init G & ( for n being natural number holds b1 . (n + 1) = MCS:Step (b1 . n) ) )
proof end;
uniqueness
for b1, b2 being finite natural-vlabeled natural-v2labeled VVGraphSeq st b1 . 0 = MCS:Init G & ( for n being natural number holds b1 . (n + 1) = MCS:Step (b1 . n) ) & b2 . 0 = MCS:Init G & ( for n being natural number holds b2 . (n + 1) = MCS:Step (b2 . n) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def40 defines MCS:CSeq LEXBFS:def 40 :
for G being finite _Graph
for b2 being finite natural-vlabeled natural-v2labeled VVGraphSeq holds
( b2 = MCS:CSeq G iff ( b2 . 0 = MCS:Init G & ( for n being natural number holds b2 . (n + 1) = MCS:Step (b2 . n) ) ) );

theorem Th68: :: LEXBFS:68
for G being finite _Graph holds MCS:CSeq G is iterative
proof end;

registration
let G be finite _Graph;
cluster MCS:CSeq G -> finite iterative natural-vlabeled natural-v2labeled ;
coherence
MCS:CSeq G is iterative
by Th68;
end;

theorem Th69: :: LEXBFS:69
for G being finite _Graph holds the_VLabel_of (MCS:Init G) = {}
proof end;

theorem Th70: :: LEXBFS:70
for G being finite _Graph
for v being set holds
( dom (the_V2Label_of (MCS:Init G)) = the_Vertices_of G & (the_V2Label_of (MCS:Init G)) . v = 0 )
proof end;

theorem Th71: :: LEXBFS:71
for G being finite _Graph holds G == MCS:Init G
proof end;

theorem Th72: :: LEXBFS:72
for G being finite natural-v2labeled VVGraph
for x being set st not x in dom (the_VLabel_of G) & dom (the_V2Label_of G) = the_Vertices_of G & dom (the_VLabel_of G) <> the_Vertices_of G holds
(the_V2Label_of G) . x <= (the_V2Label_of G) . (MCS:PickUnnumbered G)
proof end;

theorem Th73: :: LEXBFS:73
for G being finite natural-v2labeled VVGraph st dom (the_V2Label_of G) = the_Vertices_of G & dom (the_VLabel_of G) <> the_Vertices_of G holds
not MCS:PickUnnumbered G in dom (the_VLabel_of G)
proof end;

theorem Th74: :: LEXBFS:74
for G being finite natural-v2labeled VVGraph
for v, x being set st not x in G .AdjacentSet {v} holds
(the_V2Label_of G) . x = (the_V2Label_of (MCS:LabelAdjacent G,v)) . x
proof end;

theorem Th75: :: LEXBFS:75
for G being finite natural-v2labeled VVGraph
for v, x being set st x in dom (the_VLabel_of G) holds
(the_V2Label_of G) . x = (the_V2Label_of (MCS:LabelAdjacent G,v)) . x
proof end;

theorem Th76: :: LEXBFS:76
for G being finite natural-v2labeled VVGraph
for v, x being set st x in dom (the_V2Label_of G) & x in G .AdjacentSet {v} & not x in dom (the_VLabel_of G) holds
(the_V2Label_of (MCS:LabelAdjacent G,v)) . x = ((the_V2Label_of G) . x) + 1
proof end;

theorem Th77: :: LEXBFS:77
for G being finite natural-v2labeled VVGraph
for v being set st dom (the_V2Label_of G) = the_Vertices_of G holds
dom (the_V2Label_of (MCS:LabelAdjacent G,v)) = the_Vertices_of G
proof end;

theorem Th78: :: LEXBFS:78
for G being finite _Graph
for n being natural number holds (MCS:CSeq G) . n == G
proof end;

theorem Th79: :: LEXBFS:79
for G being finite _Graph
for m, n being natural number holds (MCS:CSeq G) . m == (MCS:CSeq G) . n
proof end;

registration
let G be finite chordal _Graph;
let n be natural number ;
cluster (MCS:CSeq G) . n -> chordal VVGraph;
coherence
(MCS:CSeq G) . n is chordal VVGraph
proof end;
end;

registration
let G be finite chordal _Graph;
cluster MCS:CSeq G -> finite natural-vlabeled chordal natural-v2labeled ;
correctness
coherence
MCS:CSeq G is chordal
;
proof end;
end;

theorem Th80: :: LEXBFS:80
for G being finite _Graph
for n being natural number holds dom (the_V2Label_of ((MCS:CSeq G) . n)) = the_Vertices_of ((MCS:CSeq G) . n)
proof end;

theorem Th81: :: LEXBFS:81
for G being finite _Graph
for n being natural number st card (dom (the_VLabel_of ((MCS:CSeq G) . n))) < G .order() holds
the_VLabel_of ((MCS:CSeq G) . (n + 1)) = (the_VLabel_of ((MCS:CSeq G) . n)) +* ((MCS:PickUnnumbered ((MCS:CSeq G) . n)) .--> ((G .order() ) -' (card (dom (the_VLabel_of ((MCS:CSeq G) . n))))))
proof end;

theorem Th82: :: LEXBFS:82
for G being finite _Graph
for n being natural number st n <= G .order() holds
card (dom (the_VLabel_of ((MCS:CSeq G) . n))) = n
proof end;

theorem Th83: :: LEXBFS:83
for G being finite _Graph
for n being natural number st G .order() <= n holds
(MCS:CSeq G) . (G .order() ) = (MCS:CSeq G) . n
proof end;

theorem Th84: :: LEXBFS:84
for G being finite _Graph
for m, n being natural number st G .order() <= m & m <= n holds
(MCS:CSeq G) . m = (MCS:CSeq G) . n
proof end;

theorem Th85: :: LEXBFS:85
for G being finite _Graph holds MCS:CSeq G is eventually-constant
proof end;

registration
let G be finite _Graph;
cluster MCS:CSeq G -> finite eventually-constant natural-vlabeled natural-v2labeled ;
coherence
MCS:CSeq G is eventually-constant
by Th85;
end;

theorem Th86: :: LEXBFS:86
for G being finite _Graph
for n being natural number holds
( dom (the_VLabel_of ((MCS:CSeq G) . n)) = the_Vertices_of ((MCS:CSeq G) . n) iff G .order() <= n )
proof end;

theorem Th87: :: LEXBFS:87
for G being finite _Graph holds (MCS:CSeq G) .Lifespan() = G .order()
proof end;

theorem Th88: :: LEXBFS:88
for G being finite _Graph holds MCS:CSeq G is vlabel-numbering
proof end;

registration
let G be finite _Graph;
cluster MCS:CSeq G -> finite natural-vlabeled natural-v2labeled vlabel-numbering ;
coherence
MCS:CSeq G is vlabel-numbering
by Th88;
end;

theorem Th89: :: LEXBFS:89
for G being finite _Graph
for n being natural number st n < G .order() holds
(MCS:CSeq G) .PickedAt n = MCS:PickUnnumbered ((MCS:CSeq G) . n)
proof end;

theorem Th90: :: LEXBFS:90
for G being finite _Graph
for n being natural number st n < G .order() holds
ex w being Vertex of ((MCS:CSeq G) . n) st
( w = MCS:PickUnnumbered ((MCS:CSeq G) . n) & ( for v being set holds
( ( v in G .AdjacentSet {w} & not v in dom (the_VLabel_of ((MCS:CSeq G) . n)) implies (the_V2Label_of ((MCS:CSeq G) . (n + 1))) . v = ((the_V2Label_of ((MCS:CSeq G) . n)) . v) + 1 ) & ( ( not v in G .AdjacentSet {w} or v in dom (the_VLabel_of ((MCS:CSeq G) . n)) ) implies (the_V2Label_of ((MCS:CSeq G) . (n + 1))) . v = (the_V2Label_of ((MCS:CSeq G) . n)) . v ) ) ) )
proof end;

theorem Th91: :: LEXBFS:91
for G being finite _Graph
for n being natural number
for x being set st not x in dom (the_VLabel_of ((MCS:CSeq G) . n)) holds
(the_V2Label_of ((MCS:CSeq G) . n)) . x = card ((G .AdjacentSet {x}) /\ (dom (the_VLabel_of ((MCS:CSeq G) . n))))
proof end;

definition
let G be natural-vlabeled VGraph;
attr G is with_property_T means :Def41: :: LEXBFS:def 41
for a, b, c being Vertex of G st a in dom (the_VLabel_of G) & b in dom (the_VLabel_of G) & c in dom (the_VLabel_of G) & (the_VLabel_of G) . a < (the_VLabel_of G) . b & (the_VLabel_of G) . b < (the_VLabel_of G) . c & a,c are_adjacent & not b,c are_adjacent holds
ex d being Vertex of G st
( d in dom (the_VLabel_of G) & (the_VLabel_of G) . b < (the_VLabel_of G) . d & b,d are_adjacent & not a,d are_adjacent );
end;

:: deftheorem Def41 defines with_property_T LEXBFS:def 41 :
for G being natural-vlabeled VGraph holds
( G is with_property_T iff for a, b, c being Vertex of G st a in dom (the_VLabel_of G) & b in dom (the_VLabel_of G) & c in dom (the_VLabel_of G) & (the_VLabel_of G) . a < (the_VLabel_of G) . b & (the_VLabel_of G) . b < (the_VLabel_of G) . c & a,c are_adjacent & not b,c are_adjacent holds
ex d being Vertex of G st
( d in dom (the_VLabel_of G) & (the_VLabel_of G) . b < (the_VLabel_of G) . d & b,d are_adjacent & not a,d are_adjacent ) );

theorem :: LEXBFS:92
for G being finite _Graph
for n being natural number holds (MCS:CSeq G) . n is with_property_T
proof end;

theorem :: LEXBFS:93
for G being finite _Graph holds (LexBFS:CSeq G) .Result() is with_property_T
proof end;

theorem :: LEXBFS:94
for G being finite chordal natural-vlabeled VGraph st G is with_property_T & dom (the_VLabel_of G) = the_Vertices_of G holds
for V being VertexScheme of G st V " = the_VLabel_of G holds
V is perfect
proof end;