Article GLIB_001, MML version 4.99.1005
:: GLIB_001:th 1
theorem
for b1, b2 being odd Element of NAT holds
b1 < b2
iff
b1 + 2 <= b2;
:: GLIB_001:th 2
theorem
for b1 being set
for b2 being Element of NAT
st b1 c= Seg b2
for b3, b4 being Element of NAT
st b3 in dom Sgm b1 & b4 = (Sgm b1) . b3
holds b3 <= b4;
:: GLIB_001:th 3
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
len Seq b3 <= len b2;
:: GLIB_001:th 4
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2
for b4 being Element of NAT
st b4 in dom Seq b3
holds ex b5 being Element of NAT st
b5 in dom b2 & b4 <= b5 & (Seq b3) . b4 = b2 . b5;
:: GLIB_001:th 5
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
len Seq b3 = card b3;
:: GLIB_001:th 6
theorem
for b1 being set
for b2 being FinSequence of b1
for b3 being Element of bool b2 holds
dom Seq b3 = dom Sgm proj1 b3;
:: GLIB_001:modenot 1 => GLIB_001:mode 1
definition
let a1 be [Graph-like] GraphStruct;
mode VertexSeq of A1 -> FinSequence of the_Vertices_of a1 means
for b1 being Element of NAT
st 1 <= b1 & b1 < len it
holds ex b2 being set st
b2 Joins it . b1,it . (b1 + 1),a1;
end;
:: GLIB_001:dfs 1
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be FinSequence of the_Vertices_of a1;
To prove
a2 is VertexSeq of a1
it is sufficient to prove
thus for b1 being Element of NAT
st 1 <= b1 & b1 < len a2
holds ex b2 being set st
b2 Joins a2 . b1,a2 . (b1 + 1),a1;
:: GLIB_001:def 1
theorem
for b1 being [Graph-like] GraphStruct
for b2 being FinSequence of the_Vertices_of b1 holds
b2 is VertexSeq of b1
iff
for b3 being Element of NAT
st 1 <= b3 & b3 < len b2
holds ex b4 being set st
b4 Joins b2 . b3,b2 . (b3 + 1),b1;
:: GLIB_001:modenot 2 => GLIB_001:mode 2
definition
let a1 be [Graph-like] GraphStruct;
mode EdgeSeq of A1 -> FinSequence of the_Edges_of a1 means
ex b1 being FinSequence of the_Vertices_of a1 st
len b1 = (len it) + 1 &
(for b2 being Element of NAT
st 1 <= b2 & b2 <= len it
holds it . b2 Joins b1 . b2,b1 . (b2 + 1),a1);
end;
:: GLIB_001:dfs 2
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be FinSequence of the_Edges_of a1;
To prove
a2 is EdgeSeq of a1
it is sufficient to prove
thus ex b1 being FinSequence of the_Vertices_of a1 st
len b1 = (len a2) + 1 &
(for b2 being Element of NAT
st 1 <= b2 & b2 <= len a2
holds a2 . b2 Joins b1 . b2,b1 . (b2 + 1),a1);
:: GLIB_001:def 2
theorem
for b1 being [Graph-like] GraphStruct
for b2 being FinSequence of the_Edges_of b1 holds
b2 is EdgeSeq of b1
iff
ex b3 being FinSequence of the_Vertices_of b1 st
len b3 = (len b2) + 1 &
(for b4 being Element of NAT
st 1 <= b4 & b4 <= len b2
holds b2 . b4 Joins b3 . b4,b3 . (b4 + 1),b1);
:: GLIB_001:modenot 3 => GLIB_001:mode 3
definition
let a1 be [Graph-like] GraphStruct;
mode Walk of A1 -> FinSequence of (the_Vertices_of a1) \/ the_Edges_of a1 means
len it is odd &
it . 1 in the_Vertices_of a1 &
(for b1 being odd Element of NAT
st b1 < len it
holds it . (b1 + 1) Joins it . b1,it . (b1 + 2),a1);
end;
:: GLIB_001:dfs 3
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be FinSequence of (the_Vertices_of a1) \/ the_Edges_of a1;
To prove
a2 is Walk of a1
it is sufficient to prove
thus len a2 is odd &
a2 . 1 in the_Vertices_of a1 &
(for b1 being odd Element of NAT
st b1 < len a2
holds a2 . (b1 + 1) Joins a2 . b1,a2 . (b1 + 2),a1);
:: GLIB_001:def 3
theorem
for b1 being [Graph-like] GraphStruct
for b2 being FinSequence of (the_Vertices_of b1) \/ the_Edges_of b1 holds
b2 is Walk of b1
iff
len b2 is odd &
b2 . 1 in the_Vertices_of b1 &
(for b3 being odd Element of NAT
st b3 < len b2
holds b2 . (b3 + 1) Joins b2 . b3,b2 . (b3 + 2),b1);
:: GLIB_001:funcreg 1
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
cluster Card a2 -> non empty cardinal odd;
end;
:: GLIB_001:funcnot 1 => GLIB_001:func 1
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A1 .walkOf A2 -> Walk of a1 equals
<*a2*>;
end;
:: GLIB_001:def 4
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b1 .walkOf b2 = <*b2*>;
:: GLIB_001:funcnot 2 => GLIB_001:func 2
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
func A1 .walkOf(A2,A4,A3) -> Walk of a1 equals
<*a2,a4,a3*>
if a4 Joins a2,a3,a1
otherwise a1 .walkOf choose the_Vertices_of a1;
end;
:: GLIB_001:def 5
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
(b4 Joins b2,b3,b1 implies b1 .walkOf(b2,b4,b3) = <*b2,b4,b3*>) &
(b4 Joins b2,b3,b1 or b1 .walkOf(b2,b4,b3) = b1 .walkOf choose the_Vertices_of b1);
:: GLIB_001:funcnot 3 => GLIB_001:func 3
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .first() -> Element of the_Vertices_of a1 equals
a2 . 1;
end;
:: GLIB_001:def 6
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .first() = b2 . 1;
:: GLIB_001:funcnot 4 => GLIB_001:func 4
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .last() -> Element of the_Vertices_of a1 equals
a2 . len a2;
end;
:: GLIB_001:def 7
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .last() = b2 . len b2;
:: GLIB_001:funcnot 5 => GLIB_001:func 5
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3 be natural set;
func A2 .vertexAt A3 -> Element of the_Vertices_of a1 equals
a2 . a3
if a3 is odd & a3 <= len a2
otherwise a2 .first();
end;
:: GLIB_001:def 8
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being natural set holds
(b3 is odd & b3 <= len b2 implies b2 .vertexAt b3 = b2 . b3) &
(b3 is odd & b3 <= len b2 or b2 .vertexAt b3 = b2 .first());
:: GLIB_001:funcnot 6 => GLIB_001:func 6
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .reverse() -> Walk of a1 equals
Rev a2;
end;
:: GLIB_001:def 9
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .reverse() = Rev b2;
:: GLIB_001:funcnot 7 => GLIB_001:func 7
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3 be Walk of a1;
func A2 .append A3 -> Walk of a1 equals
a2 ^' a3
if a2 .last() = a3 .first()
otherwise a2;
end;
:: GLIB_001:def 10
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1 holds
(b2 .last() = b3 .first() implies b2 .append b3 = b2 ^' b3) &
(b2 .last() = b3 .first() or b2 .append b3 = b2);
:: GLIB_001:funcnot 8 => GLIB_001:func 8
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3, a4 be natural set;
func A2 .cut(A3,A4) -> Walk of a1 equals
(a3,a4)-cut a2
if a3 is odd & a4 is odd & a3 <= a4 & a4 <= len a2
otherwise a2;
end;
:: GLIB_001:def 11
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being natural set holds
(b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 implies b2 .cut(b3,b4) = (b3,b4)-cut b2) &
(b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 or b2 .cut(b3,b4) = b2);
:: GLIB_001:funcnot 9 => GLIB_001:func 9
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3, a4 be Element of NAT;
func A2 .remove(A3,A4) -> Walk of a1 equals
(a2 .cut(1,a3)) .append (a2 .cut(a4,len a2))
if a3 is odd & a4 is odd & a3 <= a4 & a4 <= len a2 & a2 . a3 = a2 . a4
otherwise a2;
end;
:: GLIB_001:def 12
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
(b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4 implies b2 .remove(b3,b4) = (b2 .cut(1,b3)) .append (b2 .cut(b4,len b2))) &
(b3 is odd & b4 is odd & b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4 or b2 .remove(b3,b4) = b2);
:: GLIB_001:funcnot 10 => GLIB_001:func 10
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3 be set;
func A2 .addEdge A3 -> Walk of a1 equals
a2 .append (a1 .walkOf(a2 .last(),a3,a2 .last() .adj a3));
end;
:: GLIB_001:def 13
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
b2 .addEdge b3 = b2 .append (b1 .walkOf(b2 .last(),b3,b2 .last() .adj b3));
:: GLIB_001:funcnot 11 => GLIB_001:func 11
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .vertexSeq() -> VertexSeq of a1 means
(len a2) + 1 = 2 * len it &
(for b1 being natural set
st 1 <= b1 & b1 <= len it
holds it . b1 = a2 . ((2 * b1) - 1));
end;
:: GLIB_001:def 14
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being VertexSeq of b1 holds
b3 = b2 .vertexSeq()
iff
(len b2) + 1 = 2 * len b3 &
(for b4 being natural set
st 1 <= b4 & b4 <= len b3
holds b3 . b4 = b2 . ((2 * b4) - 1));
:: GLIB_001:funcnot 12 => GLIB_001:func 12
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .edgeSeq() -> EdgeSeq of a1 means
len a2 = (2 * len it) + 1 &
(for b1 being natural set
st 1 <= b1 & b1 <= len it
holds it . b1 = a2 . (2 * b1));
end;
:: GLIB_001:def 15
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being EdgeSeq of b1 holds
b3 = b2 .edgeSeq()
iff
len b2 = (2 * len b3) + 1 &
(for b4 being natural set
st 1 <= b4 & b4 <= len b3
holds b3 . b4 = b2 . (2 * b4));
:: GLIB_001:funcnot 13 => GLIB_001:func 13
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .vertices() -> finite Element of bool the_Vertices_of a1 equals
rng (a2 .vertexSeq());
end;
:: GLIB_001:def 16
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .vertices() = rng (b2 .vertexSeq());
:: GLIB_001:funcnot 14 => GLIB_001:func 14
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .edges() -> finite Element of bool the_Edges_of a1 equals
rng (a2 .edgeSeq());
end;
:: GLIB_001:def 17
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .edges() = rng (b2 .edgeSeq());
:: GLIB_001:funcnot 15 => GLIB_001:func 15
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
func A2 .length() -> Element of NAT equals
len (a2 .edgeSeq());
end;
:: GLIB_001:def 18
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .length() = len (b2 .edgeSeq());
:: GLIB_001:funcnot 16 => GLIB_001:func 16
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3 be set;
func A2 .find A3 -> odd Element of NAT means
it <= len a2 &
a2 . it = a3 &
(for b1 being natural odd set
st b1 <= len a2 & a2 . b1 = a3
holds it <= b1)
if a3 in a2 .vertices()
otherwise it = len a2;
end;
:: GLIB_001:def 19
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
for b4 being odd Element of NAT holds
(b3 in b2 .vertices() implies (b4 = b2 .find b3
iff
b4 <= len b2 &
b2 . b4 = b3 &
(for b5 being natural odd set
st b5 <= len b2 & b2 . b5 = b3
holds b4 <= b5))) &
(b3 in b2 .vertices() or (b4 = b2 .find b3
iff
b4 = len b2));
:: GLIB_001:funcnot 17 => GLIB_001:func 17
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3 be Element of NAT;
func A2 .find A3 -> odd Element of NAT means
it <= len a2 &
a2 . it = a2 . a3 &
(for b1 being natural odd set
st b1 <= len a2 & a2 . b1 = a2 . a3
holds it <= b1)
if a3 is odd & a3 <= len a2
otherwise it = len a2;
end;
:: GLIB_001:def 20
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
for b4 being odd Element of NAT holds
(b3 is odd & b3 <= len b2 implies (b4 = b2 .find b3
iff
b4 <= len b2 &
b2 . b4 = b2 . b3 &
(for b5 being natural odd set
st b5 <= len b2 & b2 . b5 = b2 . b3
holds b4 <= b5))) &
(b3 is odd & b3 <= len b2 or (b4 = b2 .find b3
iff
b4 = len b2));
:: GLIB_001:funcnot 18 => GLIB_001:func 18
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3 be set;
func A2 .rfind A3 -> odd Element of NAT means
it <= len a2 &
a2 . it = a3 &
(for b1 being odd Element of NAT
st b1 <= len a2 & a2 . b1 = a3
holds b1 <= it)
if a3 in a2 .vertices()
otherwise it = len a2;
end;
:: GLIB_001:def 21
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
for b4 being odd Element of NAT holds
(b3 in b2 .vertices() implies (b4 = b2 .rfind b3
iff
b4 <= len b2 &
b2 . b4 = b3 &
(for b5 being odd Element of NAT
st b5 <= len b2 & b2 . b5 = b3
holds b5 <= b4))) &
(b3 in b2 .vertices() or (b4 = b2 .rfind b3
iff
b4 = len b2));
:: GLIB_001:funcnot 19 => GLIB_001:func 19
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3 be Element of NAT;
func A2 .rfind A3 -> odd Element of NAT means
it <= len a2 &
a2 . it = a2 . a3 &
(for b1 being odd Element of NAT
st b1 <= len a2 & a2 . b1 = a2 . a3
holds b1 <= it)
if a3 is odd & a3 <= len a2
otherwise it = len a2;
end;
:: GLIB_001:def 22
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
for b4 being odd Element of NAT holds
(b3 is odd & b3 <= len b2 implies (b4 = b2 .rfind b3
iff
b4 <= len b2 &
b2 . b4 = b2 . b3 &
(for b5 being odd Element of NAT
st b5 <= len b2 & b2 . b5 = b2 . b3
holds b5 <= b4))) &
(b3 is odd & b3 <= len b2 or (b4 = b2 .rfind b3
iff
b4 = len b2));
:: GLIB_001:prednot 1 => GLIB_001:pred 1
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
let a4 be Walk of a1;
pred A4 is_Walk_from A2,A3 means
a4 .first() = a2 & a4 .last() = a3;
end;
:: GLIB_001:dfs 23
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
let a4 be Walk of a1;
To prove
a4 is_Walk_from a2,a3
it is sufficient to prove
thus a4 .first() = a2 & a4 .last() = a3;
:: GLIB_001:def 23
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4 being Walk of b1 holds
b4 is_Walk_from b2,b3
iff
b4 .first() = b2 & b4 .last() = b3;
:: GLIB_001:attrnot 1 => GLIB_001:attr 1
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is closed means
a2 .first() = a2 .last();
end;
:: GLIB_001:dfs 24
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is closed
it is sufficient to prove
thus a2 .first() = a2 .last();
:: GLIB_001:def 24
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is closed(b1)
iff
b2 .first() = b2 .last();
:: GLIB_001:attrnot 2 => GLIB_001:attr 2
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is directed means
for b1 being odd Element of NAT
st b1 < len a2
holds (the_Source_of a1) . (a2 . (b1 + 1)) = a2 . b1;
end;
:: GLIB_001:dfs 25
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is directed
it is sufficient to prove
thus for b1 being odd Element of NAT
st b1 < len a2
holds (the_Source_of a1) . (a2 . (b1 + 1)) = a2 . b1;
:: GLIB_001:def 25
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is directed(b1)
iff
for b3 being odd Element of NAT
st b3 < len b2
holds (the_Source_of b1) . (b2 . (b3 + 1)) = b2 . b3;
:: GLIB_001:attrnot 3 => GLIB_001:attr 3
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is trivial means
a2 .length() = 0;
end;
:: GLIB_001:dfs 26
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is trivial
it is sufficient to prove
thus a2 .length() = 0;
:: GLIB_001:def 26
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is trivial(b1)
iff
b2 .length() = 0;
:: GLIB_001:attrnot 4 => GLIB_001:attr 4
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is Trail-like means
a2 .edgeSeq() is one-to-one;
end;
:: GLIB_001:dfs 27
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is Trail-like
it is sufficient to prove
thus a2 .edgeSeq() is one-to-one;
:: GLIB_001:def 27
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Trail-like(b1)
iff
b2 .edgeSeq() is one-to-one;
:: GLIB_001:attrnot 5 => GLIB_001:attr 1
notation
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
antonym open for closed;
end;
:: GLIB_001:attrnot 6 => GLIB_001:attr 5
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is Path-like means
a2 is Trail-like(a1) &
(for b1, b2 being odd Element of NAT
st b1 < b2 & b2 <= len a2 & a2 . b1 = a2 . b2
holds b1 = 1 & b2 = len a2);
end;
:: GLIB_001:dfs 28
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is Path-like
it is sufficient to prove
thus a2 is Trail-like(a1) &
(for b1, b2 being odd Element of NAT
st b1 < b2 & b2 <= len a2 & a2 . b1 = a2 . b2
holds b1 = 1 & b2 = len a2);
:: GLIB_001:def 28
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Path-like(b1)
iff
b2 is Trail-like(b1) &
(for b3, b4 being odd Element of NAT
st b3 < b4 & b4 <= len b2 & b2 . b3 = b2 . b4
holds b3 = 1 & b4 = len b2);
:: GLIB_001:attrnot 7 => GLIB_001:attr 6
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is vertex-distinct means
for b1, b2 being odd Element of NAT
st b1 <= len a2 & b2 <= len a2 & a2 . b1 = a2 . b2
holds b1 = b2;
end;
:: GLIB_001:dfs 29
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is vertex-distinct
it is sufficient to prove
thus for b1, b2 being odd Element of NAT
st b1 <= len a2 & b2 <= len a2 & a2 . b1 = a2 . b2
holds b1 = b2;
:: GLIB_001:def 29
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is vertex-distinct(b1)
iff
for b3, b4 being odd Element of NAT
st b3 <= len b2 & b4 <= len b2 & b2 . b3 = b2 . b4
holds b3 = b4;
:: GLIB_001:attrnot 8 => GLIB_001:attr 7
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is Circuit-like means
a2 is closed(a1) & a2 is Trail-like(a1) & a2 is not trivial(a1);
end;
:: GLIB_001:dfs 30
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is Circuit-like
it is sufficient to prove
thus a2 is closed(a1) & a2 is Trail-like(a1) & a2 is not trivial(a1);
:: GLIB_001:def 30
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Circuit-like(b1)
iff
b2 is closed(b1) & b2 is Trail-like(b1) & b2 is not trivial(b1);
:: GLIB_001:attrnot 9 => GLIB_001:attr 8
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
attr a2 is Cycle-like means
a2 is closed(a1) & a2 is Path-like(a1) & a2 is not trivial(a1);
end;
:: GLIB_001:dfs 31
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
To prove
a2 is Cycle-like
it is sufficient to prove
thus a2 is closed(a1) & a2 is Path-like(a1) & a2 is not trivial(a1);
:: GLIB_001:def 31
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Cycle-like(b1)
iff
b2 is closed(b1) & b2 is Path-like(b1) & b2 is not trivial(b1);
:: GLIB_001:condreg 1
registration
let a1 be [Graph-like] GraphStruct;
cluster Path-like -> Trail-like (Walk of a1);
end;
:: GLIB_001:condreg 2
registration
let a1 be [Graph-like] GraphStruct;
cluster trivial -> Path-like (Walk of a1);
end;
:: GLIB_001:condreg 3
registration
let a1 be [Graph-like] GraphStruct;
cluster trivial -> vertex-distinct (Walk of a1);
end;
:: GLIB_001:condreg 4
registration
let a1 be [Graph-like] GraphStruct;
cluster vertex-distinct -> Path-like (Walk of a1);
end;
:: GLIB_001:condreg 5
registration
let a1 be [Graph-like] GraphStruct;
cluster Circuit-like -> closed non trivial Trail-like (Walk of a1);
end;
:: GLIB_001:condreg 6
registration
let a1 be [Graph-like] GraphStruct;
cluster Cycle-like -> closed non trivial Path-like (Walk of a1);
end;
:: GLIB_001:exreg 1
registration
let a1 be [Graph-like] GraphStruct;
cluster Relation-like Function-like finite FinSequence-like closed directed trivial Walk of a1;
end;
:: GLIB_001:exreg 2
registration
let a1 be [Graph-like] GraphStruct;
cluster Relation-like Function-like finite FinSequence-like vertex-distinct Walk of a1;
end;
:: GLIB_001:modenot 4
definition
let a1 be [Graph-like] GraphStruct;
mode Trail of a1 is Trail-like Walk of a1;
end;
:: GLIB_001:modenot 5
definition
let a1 be [Graph-like] GraphStruct;
mode Path of a1 is Path-like Walk of a1;
end;
:: GLIB_001:modenot 6
definition
let a1 be [Graph-like] GraphStruct;
mode DWalk of a1 is directed Walk of a1;
end;
:: GLIB_001:modenot 7
definition
let a1 be [Graph-like] GraphStruct;
mode DTrail of a1 is directed Trail-like Walk of a1;
end;
:: GLIB_001:modenot 8
definition
let a1 be [Graph-like] GraphStruct;
mode DPath of a1 is directed Path-like Walk of a1;
end;
:: GLIB_001:funcreg 2
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
cluster a1 .walkOf a2 -> closed directed trivial;
end;
:: GLIB_001:funcreg 3
registration
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
cluster a1 .walkOf(a2,a3,a4) -> Path-like;
end;
:: GLIB_001:funcreg 4
registration
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
cluster a1 .walkOf(a2,a3,a2) -> closed;
end;
:: GLIB_001:funcreg 5
registration
let a1 be [Graph-like] GraphStruct;
let a2 be closed Walk of a1;
cluster a2 .reverse() -> closed;
end;
:: GLIB_001:funcreg 6
registration
let a1 be [Graph-like] GraphStruct;
let a2 be trivial Walk of a1;
cluster a2 .reverse() -> trivial;
end;
:: GLIB_001:funcreg 7
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Trail-like Walk of a1;
cluster a2 .reverse() -> Trail-like;
end;
:: GLIB_001:funcreg 8
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Path-like Walk of a1;
cluster a2 .reverse() -> Path-like;
end;
:: GLIB_001:funcreg 9
registration
let a1 be [Graph-like] GraphStruct;
let a2, a3 be closed Walk of a1;
cluster a2 .append a3 -> closed;
end;
:: GLIB_001:funcreg 10
registration
let a1 be [Graph-like] GraphStruct;
let a2, a3 be directed Walk of a1;
cluster a2 .append a3 -> directed;
end;
:: GLIB_001:funcreg 11
registration
let a1 be [Graph-like] GraphStruct;
let a2, a3 be trivial Walk of a1;
cluster a2 .append a3 -> trivial;
end;
:: GLIB_001:funcreg 12
registration
let a1 be [Graph-like] GraphStruct;
let a2 be directed Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .cut(a3,a4) -> directed;
end;
:: GLIB_001:funcreg 13
registration
let a1 be [Graph-like] GraphStruct;
let a2 be trivial Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .cut(a3,a4) -> trivial;
end;
:: GLIB_001:funcreg 14
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Trail-like Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .cut(a3,a4) -> Trail-like;
end;
:: GLIB_001:funcreg 15
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Path-like Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .cut(a3,a4) -> Path-like;
end;
:: GLIB_001:funcreg 16
registration
let a1 be [Graph-like] GraphStruct;
let a2 be vertex-distinct Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .cut(a3,a4) -> vertex-distinct;
end;
:: GLIB_001:funcreg 17
registration
let a1 be [Graph-like] GraphStruct;
let a2 be closed Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .remove(a3,a4) -> closed;
end;
:: GLIB_001:funcreg 18
registration
let a1 be [Graph-like] GraphStruct;
let a2 be directed Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .remove(a3,a4) -> directed;
end;
:: GLIB_001:funcreg 19
registration
let a1 be [Graph-like] GraphStruct;
let a2 be trivial Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .remove(a3,a4) -> trivial;
end;
:: GLIB_001:funcreg 20
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Trail-like Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .remove(a3,a4) -> Trail-like;
end;
:: GLIB_001:funcreg 21
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Path-like Walk of a1;
let a3, a4 be Element of NAT;
cluster a2 .remove(a3,a4) -> Path-like;
end;
:: GLIB_001:modenot 9 => GLIB_001:mode 4
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
mode Subwalk of A2 -> Walk of a1 means
it is_Walk_from a2 .first(),a2 .last() &
(ex b1 being Element of bool (a2 .edgeSeq()) st
it .edgeSeq() = Seq b1);
end;
:: GLIB_001:dfs 32
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3 be Walk of a1;
To prove
a3 is Subwalk of a2
it is sufficient to prove
thus a3 is_Walk_from a2 .first(),a2 .last() &
(ex b1 being Element of bool (a2 .edgeSeq()) st
a3 .edgeSeq() = Seq b1);
:: GLIB_001:def 32
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1 holds
b3 is Subwalk of b2
iff
b3 is_Walk_from b2 .first(),b2 .last() &
(ex b4 being Element of bool (b2 .edgeSeq()) st
b3 .edgeSeq() = Seq b4);
:: GLIB_001:funcnot 20 => GLIB_001:func 20
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
let a3, a4 be Element of NAT;
redefine func a2 .remove(a3,a4) -> Subwalk of a2;
end;
:: GLIB_001:exreg 3
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
cluster Relation-like Function-like finite FinSequence-like Trail-like Path-like Subwalk of a2;
end;
:: GLIB_001:modenot 10
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
mode Trail of a2 is Trail-like Subwalk of a2;
end;
:: GLIB_001:modenot 11
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Walk of a1;
mode Path of a2 is Path-like Subwalk of a2;
end;
:: GLIB_001:exreg 4
registration
let a1 be [Graph-like] GraphStruct;
let a2 be directed Walk of a1;
cluster Relation-like Function-like finite FinSequence-like directed Trail-like Path-like Subwalk of a2;
end;
:: GLIB_001:modenot 12
definition
let a1 be [Graph-like] GraphStruct;
let a2 be directed Walk of a1;
mode DWalk of a2 is directed Subwalk of a2;
end;
:: GLIB_001:modenot 13
definition
let a1 be [Graph-like] GraphStruct;
let a2 be directed Walk of a1;
mode DTrail of a2 is directed Trail-like Subwalk of a2;
end;
:: GLIB_001:modenot 14
definition
let a1 be [Graph-like] GraphStruct;
let a2 be directed Walk of a1;
mode DPath of a2 is directed Path-like Subwalk of a2;
end;
:: GLIB_001:funcnot 21 => GLIB_001:func 21
definition
let a1 be [Graph-like] GraphStruct;
func A1 .allWalks() -> non empty Element of bool (((the_Vertices_of a1) \/ the_Edges_of a1) *) equals
{b1 where b1 is Walk of a1: TRUE};
end;
:: GLIB_001:def 33
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .allWalks() = {b2 where b2 is Walk of b1: TRUE};
:: GLIB_001:funcnot 22 => GLIB_001:func 22
definition
let a1 be [Graph-like] GraphStruct;
func A1 .allTrails() -> non empty Element of bool (a1 .allWalks()) equals
{b1 where b1 is Trail-like Walk of a1: TRUE};
end;
:: GLIB_001:def 34
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .allTrails() = {b2 where b2 is Trail-like Walk of b1: TRUE};
:: GLIB_001:funcnot 23 => GLIB_001:func 23
definition
let a1 be [Graph-like] GraphStruct;
func A1 .allPaths() -> non empty Element of bool (a1 .allTrails()) equals
{b1 where b1 is Path-like Walk of a1: TRUE};
end;
:: GLIB_001:def 35
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .allPaths() = {b2 where b2 is Path-like Walk of b1: TRUE};
:: GLIB_001:funcnot 24 => GLIB_001:func 24
definition
let a1 be [Graph-like] GraphStruct;
func A1 .allDWalks() -> non empty Element of bool (a1 .allWalks()) equals
{b1 where b1 is directed Walk of a1: TRUE};
end;
:: GLIB_001:def 36
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .allDWalks() = {b2 where b2 is directed Walk of b1: TRUE};
:: GLIB_001:funcnot 25 => GLIB_001:func 25
definition
let a1 be [Graph-like] GraphStruct;
func A1 .allDTrails() -> non empty Element of bool (a1 .allTrails()) equals
{b1 where b1 is directed Trail-like Walk of a1: TRUE};
end;
:: GLIB_001:def 37
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .allDTrails() = {b2 where b2 is directed Trail-like Walk of b1: TRUE};
:: GLIB_001:funcnot 26 => GLIB_001:func 26
definition
let a1 be [Graph-like] GraphStruct;
func A1 .allDPaths() -> non empty Element of bool (a1 .allDTrails()) equals
{b1 where b1 is directed Path-like Walk of a1: TRUE};
end;
:: GLIB_001:def 38
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .allDPaths() = {b2 where b2 is directed Path-like Walk of b1: TRUE};
:: GLIB_001:funcreg 22
registration
let a1 be [Graph-like] finite GraphStruct;
cluster a1 .allTrails() -> non empty finite;
end;
:: GLIB_001:modenot 15 => GLIB_001:mode 5
definition
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool (a1 .allWalks());
redefine mode Element of a2 -> Walk of a1;
end;
:: GLIB_001:modenot 16 => GLIB_001:mode 6
definition
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool (a1 .allTrails());
redefine mode Element of a2 -> Trail-like Walk of a1;
end;
:: GLIB_001:modenot 17 => GLIB_001:mode 7
definition
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool (a1 .allPaths());
redefine mode Element of a2 -> Path-like Walk of a1;
end;
:: GLIB_001:modenot 18 => GLIB_001:mode 8
definition
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool (a1 .allDWalks());
redefine mode Element of a2 -> directed Walk of a1;
end;
:: GLIB_001:modenot 19 => GLIB_001:mode 9
definition
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool (a1 .allDTrails());
redefine mode Element of a2 -> directed Trail-like Walk of a1;
end;
:: GLIB_001:modenot 20 => GLIB_001:mode 10
definition
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool (a1 .allDPaths());
redefine mode Element of a2 -> directed Path-like Walk of a1;
end;
:: GLIB_001:th 8
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds b2 . b3 in the_Vertices_of b1;
:: GLIB_001:th 9
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being even Element of NAT
st b3 in dom b2
holds b2 . b3 in the_Edges_of b1;
:: GLIB_001:th 10
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being even Element of NAT
st b3 in dom b2
holds ex b4 being odd Element of NAT st
b4 = b3 - 1 &
b3 - 1 in dom b2 &
b3 + 1 in dom b2 &
b2 . b3 Joins b2 . b4,b2 . (b3 + 1),b1;
:: GLIB_001:th 11
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 < len b2
holds b2 . (b3 + 1) in (b2 .vertexAt b3) .edgesInOut();
:: GLIB_001:th 12
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st 1 < b3 & b3 <= len b2
holds b2 . (b3 - 1) in (b2 .vertexAt b3) .edgesInOut();
:: GLIB_001:th 13
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 < len b2
holds b3 in dom b2 & b3 + 1 in dom b2 & b3 + 2 in dom b2;
:: GLIB_001:th 14
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
len (b1 .walkOf b2) = 1 & (b1 .walkOf b2) . 1 = b2 & (b1 .walkOf b2) .first() = b2 & (b1 .walkOf b2) .last() = b2 & b1 .walkOf b2 is_Walk_from b2,b2;
:: GLIB_001:th 15
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
st b2 Joins b3,b4,b1
holds len (b1 .walkOf(b3,b2,b4)) = 3;
:: GLIB_001:th 16
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
st b2 Joins b3,b4,b1
holds (b1 .walkOf(b3,b2,b4)) .first() = b3 & (b1 .walkOf(b3,b2,b4)) .last() = b4 & b1 .walkOf(b3,b2,b4) is_Walk_from b3,b4;
:: GLIB_001:th 17
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .first() = b4 .first() & b3 .last() = b4 .last();
:: GLIB_001:th 18
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set holds
b2 is_Walk_from b3,b4
iff
b2 . 1 = b3 & b2 . len b2 = b4;
:: GLIB_001:th 19
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b2 is_Walk_from b3,b4
holds b3 is Element of the_Vertices_of b1 & b4 is Element of the_Vertices_of b1;
:: GLIB_001:th 20
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4 being set
for b5 being Walk of b1
for b6 being Walk of b2
st b5 = b6
holds b5 is_Walk_from b3,b4
iff
b6 is_Walk_from b3,b4;
:: GLIB_001:th 21
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
for b5 being Element of NAT holds
b3 .vertexAt b5 = b4 .vertexAt b5;
:: GLIB_001:th 22
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
len b2 = len (b2 .reverse()) & dom b2 = dom (b2 .reverse()) & rng b2 = rng (b2 .reverse());
:: GLIB_001:th 23
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .first() = b2 .reverse() .last() & b2 .last() = b2 .reverse() .first();
:: GLIB_001:th 24
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set holds
b2 is_Walk_from b3,b4
iff
b2 .reverse() is_Walk_from b4,b3;
:: GLIB_001:th 25
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
st b3 in dom b2
holds b2 . b3 = b2 .reverse() . (((len b2) - b3) + 1) &
((len b2) - b3) + 1 in dom (b2 .reverse());
:: GLIB_001:th 26
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
st b3 in dom (b2 .reverse())
holds b2 .reverse() . b3 = b2 . (((len b2) - b3) + 1) &
((len b2) - b3) + 1 in dom b2;
:: GLIB_001:th 27
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .reverse() .reverse() = b2;
:: GLIB_001:th 28
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .reverse() = b4 .reverse();
:: GLIB_001:th 29
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
holds (len (b2 .append b3)) + 1 = (len b2) + len b3;
:: GLIB_001:th 30
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
holds len b2 <= len (b2 .append b3) & len b3 <= len (b2 .append b3);
:: GLIB_001:th 31
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
holds (b2 .append b3) .first() = b2 .first() & (b2 .append b3) .last() = b3 .last() & b2 .append b3 is_Walk_from b2 .first(),b3 .last();
:: GLIB_001:th 32
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4, b5, b6 being set
st b2 is_Walk_from b4,b5 & b3 is_Walk_from b5,b6
holds b2 .append b3 is_Walk_from b4,b6;
:: GLIB_001:th 33
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4 being Element of NAT
st b4 in dom b2
holds (b2 .append b3) . b4 = b2 . b4 & b4 in dom (b2 .append b3);
:: GLIB_001:th 34
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
for b4 being Element of NAT
st b4 < len b3
holds (b2 .append b3) . ((len b2) + b4) = b3 . (b4 + 1) &
(len b2) + b4 in dom (b2 .append b3);
:: GLIB_001:th 35
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4 being Element of NAT
st b4 in dom (b2 .append b3) & not b4 in dom b2
holds ex b5 being Element of NAT st
b5 < len b3 & b4 = (len b2) + b5;
:: GLIB_001:th 36
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4 being Walk of b1
for b5, b6 being Walk of b2
st b3 = b5 & b4 = b6
holds b3 .append b4 = b5 .append b6;
:: GLIB_001:th 37
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2
holds (len (b2 .cut(b3,b4))) + b3 = b4 + 1 &
(for b5 being Element of NAT
st b5 < len (b2 .cut(b3,b4))
holds (b2 .cut(b3,b4)) . (b5 + 1) = b2 . (b3 + b5) &
b3 + b5 in dom b2);
:: GLIB_001:th 38
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2
holds (b2 .cut(b3,b4)) .first() = b2 . b3 & (b2 .cut(b3,b4)) .last() = b2 . b4 & b2 .cut(b3,b4) is_Walk_from b2 . b3,b2 . b4;
:: GLIB_001:th 39
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5 being odd Element of NAT
st b3 <= b4 & b4 <= b5 & b5 <= len b2
holds (b2 .cut(b3,b4)) .append (b2 .cut(b4,b5)) = b2 .cut(b3,b5);
:: GLIB_001:th 40
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .cut(1,len b2) = b2;
:: GLIB_001:th 41
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 < len b2
holds b1 .walkOf(b2 . b3,b2 . (b3 + 1),b2 . (b3 + 2)) = b2 .cut(b3,b3 + 2);
:: GLIB_001:th 42
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 < len b2
holds (b2 .cut(b3,b4)) .addEdge (b2 . (b4 + 1)) = b2 .cut(b3,b4 + 2);
:: GLIB_001:th 43
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .cut(b3,b3) = <*b2 .vertexAt b3*>;
:: GLIB_001:th 44
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT
st b3 is odd & b3 <= b4
holds (b2 .cut(1,b4)) .cut(1,b3) = b2 .cut(1,b3);
:: GLIB_001:th 45
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4, b5 being odd Element of NAT
st b4 <= b5 & b5 <= len b2 & b2 .last() = b3 .first()
holds (b2 .append b3) .cut(b4,b5) = b2 .cut(b4,b5);
:: GLIB_001:th 46
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds len (b2 .cut(1,b3)) = b3;
:: GLIB_001:th 47
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
for b4 being Element of NAT
st b4 in dom (b2 .cut(1,b3)) & b3 <= len b2
holds (b2 .cut(1,b3)) . b4 = b2 . b4;
:: GLIB_001:th 48
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
for b5 being Element of NAT
st b3 <= b4 & b4 <= len b2 & b5 in dom (b2 .cut(b3,b4))
holds (b2 .cut(b3,b4)) . b5 = b2 . ((b3 + b5) - 1) &
(b3 + b5) - 1 in dom b2;
:: GLIB_001:th 49
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
for b5, b6 being Element of NAT
st b3 = b4
holds b3 .cut(b5,b6) = b4 .cut(b5,b6);
:: GLIB_001:th 50
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
holds (len (b2 .remove(b3,b4))) + b4 = (len b2) + b3;
:: GLIB_001:th 51
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
for b5, b6 being Element of NAT
st b2 is_Walk_from b3,b4
holds b2 .remove(b5,b6) is_Walk_from b3,b4;
:: GLIB_001:th 52
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
len (b2 .remove(b3,b4)) <= len b2;
:: GLIB_001:th 53
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
b2 .remove(b3,b3) = b2;
:: GLIB_001:th 54
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
holds (b2 .cut(1,b3)) .last() = (b2 .cut(b4,len b2)) .first();
:: GLIB_001:th 55
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
for b5 being Element of NAT
st b5 in Seg b3
holds (b2 .remove(b3,b4)) . b5 = b2 . b5;
:: GLIB_001:th 56
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
for b5 being Element of NAT
st b3 <= b5 & b5 <= len (b2 .remove(b3,b4))
holds (b2 .remove(b3,b4)) . b5 = b2 . ((b5 - b3) + b4) &
(b5 - b3) + b4 is Element of NAT &
(b5 - b3) + b4 <= len b2;
:: GLIB_001:th 57
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4
holds len (b2 .remove(b3,b4)) = ((len b2) + b3) - b4;
:: GLIB_001:th 58
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
st b2 . b3 = b2 .last()
holds b2 .remove(b3,len b2) = b2 .cut(1,b3);
:: GLIB_001:th 59
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
st b2 .first() = b2 . b3
holds b2 .remove(1,b3) = b2 .cut(b3,len b2);
:: GLIB_001:th 60
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
(b2 .remove(b3,b4)) .first() = b2 .first() & (b2 .remove(b3,b4)) .last() = b2 .last();
:: GLIB_001:th 61
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
for b5 being Element of NAT
st b3 <= b4 & b4 <= len b2 & b2 . b3 = b2 . b4 & b5 in dom (b2 .remove(b3,b4)) & not b5 in Seg b3
holds b3 <= b5 & b5 <= len (b2 .remove(b3,b4));
:: GLIB_001:th 62
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
for b5, b6 being Element of NAT
st b3 = b4
holds b3 .remove(b5,b6) = b4 .remove(b5,b6);
:: GLIB_001:th 63
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds b2 .addEdge b3 = b2 ^ <*b3,b4*>;
:: GLIB_001:th 64
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds (b2 .addEdge b3) .first() = b2 .first() & (b2 .addEdge b3) .last() = b4 & b2 .addEdge b3 is_Walk_from b2 .first(),b4;
:: GLIB_001:th 65
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds len (b2 .addEdge b3) = (len b2) + 2;
:: GLIB_001:th 66
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds (b2 .addEdge b3) . ((len b2) + 1) = b3 &
(b2 .addEdge b3) . ((len b2) + 2) = b4 &
(for b5 being Element of NAT
st b5 in dom b2
holds (b2 .addEdge b3) . b5 = b2 . b5);
:: GLIB_001:th 67
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5, b6 being set
st b2 is_Walk_from b3,b4 & b5 Joins b4,b6,b1
holds b2 .addEdge b5 is_Walk_from b3,b6;
:: GLIB_001:th 68
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
1 <= len (b2 .vertexSeq());
:: GLIB_001:th 69
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds (2 * ((b3 + 1) div 2)) - 1 = b3 &
1 <= (b3 + 1) div 2 &
(b3 + 1) div 2 <= len (b2 .vertexSeq());
:: GLIB_001:th 70
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
(b1 .walkOf b2) .vertexSeq() = <*b2*>;
:: GLIB_001:th 71
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
st b2 Joins b3,b4,b1
holds (b1 .walkOf(b3,b2,b4)) .vertexSeq() = <*b3,b4*>;
:: GLIB_001:th 72
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .first() = b2 .vertexSeq() . 1 &
b2 .last() = b2 .vertexSeq() . len (b2 .vertexSeq());
:: GLIB_001:th 73
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .vertexAt b3 = b2 .vertexSeq() . ((b3 + 1) div 2);
:: GLIB_001:th 74
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
b3 in dom (b2 .vertexSeq())
iff
(2 * b3) - 1 in dom b2;
:: GLIB_001:th 75
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
(b2 .cut(1,b3)) .vertexSeq() c= b2 .vertexSeq();
:: GLIB_001:th 76
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds (b2 .addEdge b3) .vertexSeq() = b2 .vertexSeq() ^ <*b4*>;
:: GLIB_001:th 77
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .vertexSeq() = b4 .vertexSeq();
:: GLIB_001:th 78
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being even Element of NAT
st 1 <= b3 & b3 <= len b2
holds b3 div 2 in dom (b2 .edgeSeq()) &
b2 . b3 = b2 .edgeSeq() . (b3 div 2);
:: GLIB_001:th 79
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
b3 in dom (b2 .edgeSeq())
iff
2 * b3 in dom b2;
:: GLIB_001:th 80
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
st b3 in dom (b2 .edgeSeq())
holds b2 .edgeSeq() . b3 in the_Edges_of b1;
:: GLIB_001:th 81
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
ex b3 being even Element of NAT st
b3 = (len b2) - 1 & len (b2 .edgeSeq()) = b3 div 2;
:: GLIB_001:th 82
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT holds
(b2 .cut(1,b3)) .edgeSeq() c= b2 .edgeSeq();
:: GLIB_001:th 83
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds (b2 .addEdge b3) .edgeSeq() = b2 .edgeSeq() ^ <*b3*>;
:: GLIB_001:th 84
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b2 Joins b3,b4,b1
iff
(b1 .walkOf(b3,b2,b4)) .edgeSeq() = <*b2*>;
:: GLIB_001:th 85
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .reverse() .edgeSeq() = Rev (b2 .edgeSeq());
:: GLIB_001:th 86
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
holds (b2 .append b3) .edgeSeq() = b2 .edgeSeq() ^ (b3 .edgeSeq());
:: GLIB_001:th 87
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .edgeSeq() = b4 .edgeSeq();
:: GLIB_001:th 88
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
b3 in b2 .vertices()
iff
ex b4 being odd Element of NAT st
b4 <= len b2 & b2 . b4 = b3;
:: GLIB_001:th 89
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .first() in b2 .vertices() & b2 .last() in b2 .vertices();
:: GLIB_001:th 90
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .vertexAt b3 in b2 .vertices();
:: GLIB_001:th 91
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
(b1 .walkOf b2) .vertices() = {b2};
:: GLIB_001:th 92
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
st b2 Joins b3,b4,b1
holds (b1 .walkOf(b3,b2,b4)) .vertices() = {b3,b4};
:: GLIB_001:th 93
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .vertices() = b2 .reverse() .vertices();
:: GLIB_001:th 94
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
holds (b2 .append b3) .vertices() = b2 .vertices() \/ (b3 .vertices());
:: GLIB_001:th 95
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2
holds (b2 .cut(b3,b4)) .vertices() c= b2 .vertices();
:: GLIB_001:th 96
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds (b2 .addEdge b3) .vertices() = b2 .vertices() \/ {b4};
:: GLIB_001:th 97
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1 & not b4 in b2 .vertices()
holds card ((b2 .addEdge b3) .vertices()) = (card (b2 .vertices())) + 1;
:: GLIB_001:th 98
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 in b2 .vertices() & b4 in b2 .vertices()
holds ex b5 being Walk of b1 st
b5 is_Walk_from b3,b4;
:: GLIB_001:th 99
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .vertices() = b4 .vertices();
:: GLIB_001:th 100
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
b3 in b2 .edges()
iff
ex b4 being even Element of NAT st
1 <= b4 & b4 <= len b2 & b2 . b4 = b3;
:: GLIB_001:th 101
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
b3 in b2 .edges()
iff
ex b4 being odd Element of NAT st
b4 < len b2 & b2 . (b4 + 1) = b3;
:: GLIB_001:th 102
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
rng b2 = b2 .vertices() \/ (b2 .edges());
:: GLIB_001:th 103
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 .last() = b3 .first()
holds (b2 .append b3) .edges() = b2 .edges() \/ (b3 .edges());
:: GLIB_001:th 104
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
st b3 in b2 .edges()
holds ex b4, b5 being Element of the_Vertices_of b1 st
ex b6 being odd Element of NAT st
b6 + 2 <= len b2 & b4 = b2 . b6 & b3 = b2 . (b6 + 1) & b5 = b2 . (b6 + 2) & b3 Joins b4,b5,b1;
:: GLIB_001:th 105
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set holds
b3 in b2 .edges()
iff
ex b4 being Element of NAT st
b4 in dom (b2 .edgeSeq()) & b2 .edgeSeq() . b4 = b3;
:: GLIB_001:th 106
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5 being set
st b3 in b2 .edges() & b3 Joins b4,b5,b1
holds b4 in b2 .vertices() & b5 in b2 .vertices();
:: GLIB_001:th 107
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being Element of NAT holds
(b2 .cut(b3,b4)) .edges() c= b2 .edges();
:: GLIB_001:th 108
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .edges() = b2 .reverse() .edges();
:: GLIB_001:th 109
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b2 Joins b3,b4,b1
iff
(b1 .walkOf(b3,b2,b4)) .edges() = {b2};
:: GLIB_001:th 110
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 .edges() c= b1 .edgesBetween (b2 .vertices());
:: GLIB_001:th 111
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .edges() = b4 .edges();
:: GLIB_001:th 112
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds (b2 .addEdge b3) .edges() = b2 .edges() \/ {b3};
:: GLIB_001:th 113
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
len b2 = (2 * (b2 .length())) + 1;
:: GLIB_001:th 114
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1 holds
len b2 = len b3
iff
b2 .length() = b3 .length();
:: GLIB_001:th 115
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds b3 .length() = b4 .length();
:: GLIB_001:th 116
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .find (b2 . b3) <= b3 & b3 <= b2 .rfind (b2 . b3);
:: GLIB_001:th 117
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
for b5 being set
st b3 = b4
holds b3 .find b5 = b4 .find b5 & b3 .rfind b5 = b4 .rfind b5;
:: GLIB_001:th 118
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .find b3 <= b3 & b3 <= b2 .rfind b3;
:: GLIB_001:th 119
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is closed(b1)
iff
b2 . 1 = b2 . len b2;
:: GLIB_001:th 120
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is closed(b1)
iff
ex b3 being set st
b2 is_Walk_from b3,b3;
:: GLIB_001:th 121
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is closed(b1)
iff
b2 .reverse() is closed(b1);
:: GLIB_001:th 122
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4 & b3 is closed(b1)
holds b4 is closed(b2);
:: GLIB_001:th 123
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is directed(b1)
iff
for b3 being odd Element of NAT
st b3 < len b2
holds b2 . (b3 + 1) DJoins b2 . b3,b2 . (b3 + 2),b1;
:: GLIB_001:th 124
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5, b6 being set
st b2 is directed(b1) & b2 is_Walk_from b3,b4 & b5 DJoins b4,b6,b1
holds b2 .addEdge b5 is directed(b1) & b2 .addEdge b5 is_Walk_from b3,b6;
:: GLIB_001:th 125
theorem
for b1 being [Graph-like] GraphStruct
for b2 being directed Walk of b1
for b3, b4 being Element of NAT holds
b2 .cut(b3,b4) is directed(b1);
:: GLIB_001:th 126
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is not trivial(b1)
iff
3 <= len b2;
:: GLIB_001:th 127
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is not trivial(b1)
iff
len b2 <> 1;
:: GLIB_001:th 128
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st b2 .first() <> b2 .last()
holds b2 is not trivial(b1);
:: GLIB_001:th 129
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is trivial(b1)
iff
ex b3 being Element of the_Vertices_of b1 st
b2 = b1 .walkOf b3;
:: GLIB_001:th 130
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is trivial(b1)
iff
b2 .reverse() is trivial(b1);
:: GLIB_001:th 131
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is trivial(b1)
holds b3 .append b2 = b3;
:: GLIB_001:th 132
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being odd Element of NAT
st b3 <= b4 & b4 <= len b2
holds b2 .cut(b3,b4) is trivial(b1)
iff
b3 = b4;
:: GLIB_001:th 133
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1
holds b2 .addEdge b3 is not trivial(b1);
:: GLIB_001:th 134
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st b2 is not trivial(b1)
holds ex b3 being odd Element of NAT st
b3 = (len b2) - 2 &
(b2 .cut(1,b3)) .addEdge (b2 . (b3 + 1)) = b2;
:: GLIB_001:th 135
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is not trivial(b1) & b2 .edges() c= b3 .edges()
holds b2 .vertices() c= b3 .vertices();
:: GLIB_001:th 136
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st b2 is not trivial(b1)
for b3 being Element of the_Vertices_of b1
st b3 in b2 .vertices()
holds b3 is not isolated(b1);
:: GLIB_001:th 137
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is trivial(b1)
iff
b2 .edges() = {};
:: GLIB_001:th 138
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4 & b3 is trivial(b1)
holds b4 is trivial(b2);
:: GLIB_001:th 139
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Trail-like(b1)
iff
for b3, b4 being even Element of NAT
st 1 <= b3 & b3 < b4 & b4 <= len b2
holds b2 . b3 <> b2 . b4;
:: GLIB_001:th 140
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st len b2 <= 3
holds b2 is Trail-like(b1);
:: GLIB_001:th 141
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Trail-like(b1)
iff
b2 .reverse() is Trail-like(b1);
:: GLIB_001:th 142
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
for b3, b4 being Element of NAT holds
b2 .cut(b3,b4) is Trail-like(b1);
:: GLIB_001:th 143
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
for b3 being set
st b3 in b2 .last() .edgesInOut() & not b3 in b2 .edges()
holds b2 .addEdge b3 is Trail-like(b1);
:: GLIB_001:th 144
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
for b3 being Element of the_Vertices_of b1
st b3 in b2 .vertices() & b3 is endvertex(b1) & b3 <> b2 .first()
holds b3 = b2 .last();
:: GLIB_001:th 145
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Trail-like Walk of b1 holds
len (b2 .edgeSeq()) <= b1 .size();
:: GLIB_001:th 146
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st len b2 <= 3
holds b2 is Path-like(b1);
:: GLIB_001:th 147
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st for b3, b4 being odd Element of NAT
st b3 <= len b2 & b4 <= len b2 & b2 . b3 = b2 . b4
holds b3 = b4
holds b2 is Path-like(b1);
:: GLIB_001:th 148
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
st b2 is open(b1)
for b3, b4 being odd Element of NAT
st b3 < b4 & b4 <= len b2
holds b2 . b3 <> b2 . b4;
:: GLIB_001:th 149
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Path-like(b1)
iff
b2 .reverse() is Path-like(b1);
:: GLIB_001:th 150
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being Element of NAT holds
b2 .cut(b3,b4) is Path-like(b1);
:: GLIB_001:th 151
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1 &
not b3 in b2 .edges() &
(b2 is not trivial(b1) implies b2 is open(b1)) &
(for b5 being odd Element of NAT
st 1 < b5 & b5 <= len b2
holds b2 . b5 <> b4)
holds b2 .addEdge b3 is Path-like(b1);
:: GLIB_001:th 152
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Path-like Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1 & not b4 in b2 .vertices() & (b2 is not trivial(b1) implies b2 is open(b1))
holds b2 .addEdge b3 is Path-like(b1);
:: GLIB_001:th 153
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .find (b2 . b3) = b2 .rfind (b2 . b3)
holds b2 is Path-like(b1);
:: GLIB_001:th 154
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
st for b3 being odd Element of NAT
st b3 <= len b2
holds b2 .rfind b3 = b3
holds b2 is Path-like(b1);
:: GLIB_001:th 155
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Path-like Walk of b1 holds
len (b2 .vertexSeq()) <= b1 .order() + 1;
:: GLIB_001:th 156
theorem
for b1 being [Graph-like] GraphStruct
for b2 being vertex-distinct Walk of b1
for b3, b4 being set
st b3 Joins b2 .last(),b4,b1 & not b4 in b2 .vertices()
holds b2 .addEdge b3 is vertex-distinct(b1);
:: GLIB_001:th 157
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
st b2 Joins b3,b3,b1
holds b1 .walkOf(b3,b2,b3) is Cycle-like(b1);
:: GLIB_001:th 158
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3, b4, b5 being set
st b3 Joins b4,b5,b1 & b3 in b2 .edges() & b2 is Cycle-like(b1)
holds ex b6 being Walk of b1 st
b6 is_Walk_from b4,b5 & not b3 in b6 .edges();
:: GLIB_001:th 159
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1 holds
b2 is Subwalk of b2;
:: GLIB_001:th 160
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being Subwalk of b2
for b4 being Subwalk of b3 holds
b4 is Subwalk of b2;
:: GLIB_001:th 161
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
for b4, b5 being set
st b2 is Subwalk of b3
holds b2 is_Walk_from b4,b5
iff
b3 is_Walk_from b4,b5;
:: GLIB_001:th 162
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is Subwalk of b3
holds b2 .first() = b3 .first() & b2 .last() = b3 .last();
:: GLIB_001:th 163
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is Subwalk of b3
holds len b2 <= len b3;
:: GLIB_001:th 164
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is Subwalk of b3
holds b2 .edges() c= b3 .edges() & b2 .vertices() c= b3 .vertices();
:: GLIB_001:th 165
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is Subwalk of b3
for b4 being odd Element of NAT
st b4 <= len b2
holds ex b5 being odd Element of NAT st
b4 <= b5 & b5 <= len b3 & b2 . b4 = b3 . b5;
:: GLIB_001:th 166
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Walk of b1
st b2 is Subwalk of b3
for b4 being even Element of NAT
st 1 <= b4 & b4 <= len b2
holds ex b5 being even Element of NAT st
b4 <= b5 & b5 <= len b3 & b2 . b4 = b3 . b5;
:: GLIB_001:th 167
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Trail-like Walk of b1
st b2 is not trivial(b1)
holds ex b3 being Path-like Subwalk of b2 st
b3 is not trivial(b1);
:: GLIB_001:th 168
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b2 holds
b3 is Walk of b1;
:: GLIB_001:th 169
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
st b3 is trivial(b1) & b3 .first() in the_Vertices_of b2
holds b3 is Walk of b2;
:: GLIB_001:th 170
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
st b3 is not trivial(b1) & b3 .edges() c= the_Edges_of b2
holds b3 is Walk of b2;
:: GLIB_001:th 171
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
st b3 .vertices() c= the_Vertices_of b2 & b3 .edges() c= the_Edges_of b2
holds b3 is Walk of b2;
:: GLIB_001:th 172
theorem
for b1 being [Graph-like] non trivial GraphStruct
for b2 being Walk of b1
for b3 being Element of the_Vertices_of b1
for b4 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b3},b1 .edgesBetween ((the_Vertices_of b1) \ {b3})
st not b3 in b2 .vertices()
holds b2 is Walk of b4;
:: GLIB_001:th 173
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Walk of b1
for b3 being set
for b4 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ {b3}
st not b3 in b2 .edges()
holds b2 is Walk of b4;
:: GLIB_001:th 174
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3, b4, b5 being set
st b5 Joins b3,b4,b2
holds b1 .walkOf(b3,b5,b4) = b2 .walkOf(b3,b5,b4);
:: GLIB_001:th 175
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
for b4 being Walk of b2
for b5 being set
st b3 = b4 & b5 in b4 .last() .edgesInOut()
holds b3 .addEdge b5 = b4 .addEdge b5;
:: GLIB_001:th 176
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b2 holds
(b3 is closed(b2) implies b3 is closed Walk of b1) & (b3 is directed(b2) implies b3 is directed Walk of b1) & (b3 is trivial(b2) implies b3 is trivial Walk of b1) & (b3 is Trail-like(b2) implies b3 is Trail-like Walk of b1) & (b3 is Path-like(b2) implies b3 is Path-like Walk of b1) & (b3 is vertex-distinct(b2) implies b3 is vertex-distinct Walk of b1);
:: GLIB_001:th 177
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Walk of b1
for b4 being Walk of b2
st b3 = b4
holds (b3 is closed(b1) implies b4 is closed(b2)) & (b4 is closed(b2) implies b3 is closed(b1)) & (b3 is directed(b1) implies b4 is directed(b2)) & (b4 is directed(b2) implies b3 is directed(b1)) & (b3 is trivial(b1) implies b4 is trivial(b2)) & (b4 is trivial(b2) implies b3 is trivial(b1)) & (b3 is Trail-like(b1) implies b4 is Trail-like(b2)) & (b4 is Trail-like(b2) implies b3 is Trail-like(b1)) & (b3 is Path-like(b1) implies b4 is Path-like(b2)) & (b4 is Path-like(b2) implies b3 is Path-like(b1)) & (b3 is vertex-distinct(b1) implies b4 is vertex-distinct(b2)) & (b4 is vertex-distinct(b2) implies b3 is vertex-distinct(b1));
:: GLIB_001:th 178
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
st b1 == b2 & b3 is VertexSeq of b1
holds b3 is VertexSeq of b2;
:: GLIB_001:th 179
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
st b1 == b2 & b3 is EdgeSeq of b1
holds b3 is EdgeSeq of b2;
:: GLIB_001:th 180
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
st b1 == b2 & b3 is Walk of b1
holds b3 is Walk of b2;
:: GLIB_001:th 181
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4, b5 being set
st b1 == b2
holds b1 .walkOf(b3,b4,b5) = b2 .walkOf(b3,b4,b5);
:: GLIB_001:th 182
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
st b1 == b2 & b3 = b4
holds (b3 is closed(b1) implies b4 is closed(b2)) & (b4 is closed(b2) implies b3 is closed(b1)) & (b3 is directed(b1) implies b4 is directed(b2)) & (b4 is directed(b2) implies b3 is directed(b1)) & (b3 is trivial(b1) implies b4 is trivial(b2)) & (b4 is trivial(b2) implies b3 is trivial(b1)) & (b3 is Trail-like(b1) implies b4 is Trail-like(b2)) & (b4 is Trail-like(b2) implies b3 is Trail-like(b1)) & (b3 is Path-like(b1) implies b4 is Path-like(b2)) & (b4 is Path-like(b2) implies b3 is Path-like(b1)) & (b3 is vertex-distinct(b1) implies b4 is vertex-distinct(b2)) & (b4 is vertex-distinct(b2) implies b3 is vertex-distinct(b1));