Article GLIB_000, MML version 4.99.1005
:: GLIB_000:modenot 1 => GLIB_000:mode 1
definition
mode GraphStruct -> Relation-like Function-like finite set means
proj1 it c= NAT;
end;
:: GLIB_000:dfs 1
definiens
let a1 be Relation-like Function-like finite set;
To prove
a1 is GraphStruct
it is sufficient to prove
thus proj1 a1 c= NAT;
:: GLIB_000:def 1
theorem
for b1 being Relation-like Function-like finite set holds
b1 is GraphStruct
iff
proj1 b1 c= NAT;
:: GLIB_000:funcnot 1 => GLIB_000:func 1
definition
func VertexSelector -> Element of NAT equals
1;
end;
:: GLIB_000:def 2
theorem
VertexSelector = 1;
:: GLIB_000:funcnot 2 => GLIB_000:func 2
definition
func EdgeSelector -> Element of NAT equals
2;
end;
:: GLIB_000:def 3
theorem
EdgeSelector = 2;
:: GLIB_000:funcnot 3 => GLIB_000:func 3
definition
func SourceSelector -> Element of NAT equals
3;
end;
:: GLIB_000:def 4
theorem
SourceSelector = 3;
:: GLIB_000:funcnot 4 => GLIB_000:func 4
definition
func TargetSelector -> Element of NAT equals
4;
end;
:: GLIB_000:def 5
theorem
TargetSelector = 4;
:: GLIB_000:funcnot 5 => GLIB_000:func 5
definition
func _GraphSelectors -> non empty Element of bool NAT equals
{VertexSelector,EdgeSelector,SourceSelector,TargetSelector};
end;
:: GLIB_000:def 6
theorem
_GraphSelectors = {VertexSelector,EdgeSelector,SourceSelector,TargetSelector};
:: GLIB_000:funcnot 6 => GLIB_000:func 6
definition
let a1 be GraphStruct;
func the_Vertices_of A1 -> set equals
a1 . VertexSelector;
end;
:: GLIB_000:def 7
theorem
for b1 being GraphStruct holds
the_Vertices_of b1 = b1 . VertexSelector;
:: GLIB_000:funcnot 7 => GLIB_000:func 7
definition
let a1 be GraphStruct;
func the_Edges_of A1 -> set equals
a1 . EdgeSelector;
end;
:: GLIB_000:def 8
theorem
for b1 being GraphStruct holds
the_Edges_of b1 = b1 . EdgeSelector;
:: GLIB_000:funcnot 8 => GLIB_000:func 8
definition
let a1 be GraphStruct;
func the_Source_of A1 -> set equals
a1 . SourceSelector;
end;
:: GLIB_000:def 9
theorem
for b1 being GraphStruct holds
the_Source_of b1 = b1 . SourceSelector;
:: GLIB_000:funcnot 9 => GLIB_000:func 9
definition
let a1 be GraphStruct;
func the_Target_of A1 -> set equals
a1 . TargetSelector;
end;
:: GLIB_000:def 10
theorem
for b1 being GraphStruct holds
the_Target_of b1 = b1 . TargetSelector;
:: GLIB_000:attrnot 1 => GLIB_000:attr 1
definition
let a1 be GraphStruct;
attr a1 is [Graph-like] means
VertexSelector in proj1 a1 &
EdgeSelector in proj1 a1 &
SourceSelector in proj1 a1 &
TargetSelector in proj1 a1 &
the_Vertices_of a1 is non empty set &
the_Source_of a1 is Function-like quasi_total Relation of the_Edges_of a1,the_Vertices_of a1 &
the_Target_of a1 is Function-like quasi_total Relation of the_Edges_of a1,the_Vertices_of a1;
end;
:: GLIB_000:dfs 11
definiens
let a1 be GraphStruct;
To prove
a1 is [Graph-like]
it is sufficient to prove
thus VertexSelector in proj1 a1 &
EdgeSelector in proj1 a1 &
SourceSelector in proj1 a1 &
TargetSelector in proj1 a1 &
the_Vertices_of a1 is non empty set &
the_Source_of a1 is Function-like quasi_total Relation of the_Edges_of a1,the_Vertices_of a1 &
the_Target_of a1 is Function-like quasi_total Relation of the_Edges_of a1,the_Vertices_of a1;
:: GLIB_000:def 11
theorem
for b1 being GraphStruct holds
b1 is [Graph-like]
iff
VertexSelector in proj1 b1 &
EdgeSelector in proj1 b1 &
SourceSelector in proj1 b1 &
TargetSelector in proj1 b1 &
the_Vertices_of b1 is non empty set &
the_Source_of b1 is Function-like quasi_total Relation of the_Edges_of b1,the_Vertices_of b1 &
the_Target_of b1 is Function-like quasi_total Relation of the_Edges_of b1,the_Vertices_of b1;
:: GLIB_000:exreg 1
registration
cluster Relation-like Function-like finite [Graph-like] GraphStruct;
end;
:: GLIB_000:modenot 2
definition
mode _Graph is [Graph-like] GraphStruct;
end;
:: GLIB_000:funcreg 1
registration
let a1 be [Graph-like] GraphStruct;
cluster the_Vertices_of a1 -> non empty;
end;
:: GLIB_000:funcnot 10 => GLIB_000:func 10
definition
let a1 be [Graph-like] GraphStruct;
redefine func the_Source_of a1 -> Function-like quasi_total Relation of the_Edges_of a1,the_Vertices_of a1;
end;
:: GLIB_000:funcnot 11 => GLIB_000:func 11
definition
let a1 be [Graph-like] GraphStruct;
redefine func the_Target_of a1 -> Function-like quasi_total Relation of the_Edges_of a1,the_Vertices_of a1;
end;
:: GLIB_000:funcnot 12 => GLIB_000:func 12
definition
let a1 be non empty set;
let a2 be set;
let a3, a4 be Function-like quasi_total Relation of a2,a1;
func createGraph(A1,A2,A3,A4) -> [Graph-like] GraphStruct equals
<*a1,a2,a3,a4*>;
end;
:: GLIB_000:def 12
theorem
for b1 being non empty set
for b2 being set
for b3, b4 being Function-like quasi_total Relation of b2,b1 holds
createGraph(b1,b2,b3,b4) = <*b1,b2,b3,b4*>;
:: GLIB_000:funcnot 13 => GLIB_000:func 13
definition
let a1 be GraphStruct;
let a2 be natural set;
let a3 be set;
func A1 .set(A2,A3) -> GraphStruct equals
a1 +* (a2 .--> a3);
end;
:: GLIB_000:def 13
theorem
for b1 being GraphStruct
for b2 being natural set
for b3 being set holds
b1 .set(b2,b3) = b1 +* (b2 .--> b3);
:: GLIB_000:funcnot 14 => GLIB_000:func 14
definition
let a1 be GraphStruct;
let a2 be set;
func A1 .strict A2 -> GraphStruct equals
a1 | a2;
end;
:: GLIB_000:def 14
theorem
for b1 being GraphStruct
for b2 being set holds
b1 .strict b2 = b1 | b2;
:: GLIB_000:funcreg 2
registration
let a1 be [Graph-like] GraphStruct;
cluster a1 .strict _GraphSelectors -> [Graph-like];
end;
:: GLIB_000:prednot 1 => GLIB_000:pred 1
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
pred A4 Joins A2,A3,A1 means
a4 in the_Edges_of a1 &
((the_Source_of a1) . a4 = a2 & (the_Target_of a1) . a4 = a3 or (the_Source_of a1) . a4 = a3 & (the_Target_of a1) . a4 = a2);
end;
:: GLIB_000:dfs 15
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
To prove
a4 Joins a2,a3,a1
it is sufficient to prove
thus a4 in the_Edges_of a1 &
((the_Source_of a1) . a4 = a2 & (the_Target_of a1) . a4 = a3 or (the_Source_of a1) . a4 = a3 & (the_Target_of a1) . a4 = a2);
:: GLIB_000:def 15
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b4 Joins b2,b3,b1
iff
b4 in the_Edges_of b1 &
((the_Source_of b1) . b4 = b2 & (the_Target_of b1) . b4 = b3 or (the_Source_of b1) . b4 = b3 & (the_Target_of b1) . b4 = b2);
:: GLIB_000:prednot 2 => GLIB_000:pred 2
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
pred A4 DJoins A2,A3,A1 means
a4 in the_Edges_of a1 & (the_Source_of a1) . a4 = a2 & (the_Target_of a1) . a4 = a3;
end;
:: GLIB_000:dfs 16
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
To prove
a4 DJoins a2,a3,a1
it is sufficient to prove
thus a4 in the_Edges_of a1 & (the_Source_of a1) . a4 = a2 & (the_Target_of a1) . a4 = a3;
:: GLIB_000:def 16
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b4 DJoins b2,b3,b1
iff
b4 in the_Edges_of b1 & (the_Source_of b1) . b4 = b2 & (the_Target_of b1) . b4 = b3;
:: GLIB_000:prednot 3 => GLIB_000:pred 3
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
pred A4 SJoins A2,A3,A1 means
a4 in the_Edges_of a1 &
((the_Source_of a1) . a4 in a2 & (the_Target_of a1) . a4 in a3 or (the_Source_of a1) . a4 in a3 & (the_Target_of a1) . a4 in a2);
end;
:: GLIB_000:dfs 17
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
To prove
a4 SJoins a2,a3,a1
it is sufficient to prove
thus a4 in the_Edges_of a1 &
((the_Source_of a1) . a4 in a2 & (the_Target_of a1) . a4 in a3 or (the_Source_of a1) . a4 in a3 & (the_Target_of a1) . a4 in a2);
:: GLIB_000:def 17
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b4 SJoins b2,b3,b1
iff
b4 in the_Edges_of b1 &
((the_Source_of b1) . b4 in b2 & (the_Target_of b1) . b4 in b3 or (the_Source_of b1) . b4 in b3 & (the_Target_of b1) . b4 in b2);
:: GLIB_000:prednot 4 => GLIB_000:pred 4
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
pred A4 DSJoins A2,A3,A1 means
a4 in the_Edges_of a1 & (the_Source_of a1) . a4 in a2 & (the_Target_of a1) . a4 in a3;
end;
:: GLIB_000:dfs 18
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3, a4 be set;
To prove
a4 DSJoins a2,a3,a1
it is sufficient to prove
thus a4 in the_Edges_of a1 & (the_Source_of a1) . a4 in a2 & (the_Target_of a1) . a4 in a3;
:: GLIB_000:def 18
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b4 DSJoins b2,b3,b1
iff
b4 in the_Edges_of b1 & (the_Source_of b1) . b4 in b2 & (the_Target_of b1) . b4 in b3;
:: GLIB_000:attrnot 2 => GLIB_000:attr 2
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is finite means
the_Vertices_of a1 is finite & the_Edges_of a1 is finite;
end;
:: GLIB_000:dfs 19
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is finite
it is sufficient to prove
thus the_Vertices_of a1 is finite & the_Edges_of a1 is finite;
:: GLIB_000:def 19
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is finite
iff
the_Vertices_of b1 is finite & the_Edges_of b1 is finite;
:: GLIB_000:attrnot 3 => GLIB_000:attr 3
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is loopless means
for b1 being set
st b1 in the_Edges_of a1
holds (the_Source_of a1) . b1 <> (the_Target_of a1) . b1;
end;
:: GLIB_000:dfs 20
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is loopless
it is sufficient to prove
thus for b1 being set
st b1 in the_Edges_of a1
holds (the_Source_of a1) . b1 <> (the_Target_of a1) . b1;
:: GLIB_000:def 20
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is loopless
iff
for b2 being set
st b2 in the_Edges_of b1
holds (the_Source_of b1) . b2 <> (the_Target_of b1) . b2;
:: GLIB_000:attrnot 4 => GLIB_000:attr 4
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is trivial means
Card the_Vertices_of a1 = 1;
end;
:: GLIB_000:dfs 21
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is trivial
it is sufficient to prove
thus Card the_Vertices_of a1 = 1;
:: GLIB_000:def 21
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is trivial
iff
Card the_Vertices_of b1 = 1;
:: GLIB_000:attrnot 5 => GLIB_000:attr 5
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is non-multi means
for b1, b2, b3, b4 being set
st b1 Joins b3,b4,a1 & b2 Joins b3,b4,a1
holds b1 = b2;
end;
:: GLIB_000:dfs 22
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is non-multi
it is sufficient to prove
thus for b1, b2, b3, b4 being set
st b1 Joins b3,b4,a1 & b2 Joins b3,b4,a1
holds b1 = b2;
:: GLIB_000:def 22
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is non-multi
iff
for b2, b3, b4, b5 being set
st b2 Joins b4,b5,b1 & b3 Joins b4,b5,b1
holds b2 = b3;
:: GLIB_000:attrnot 6 => GLIB_000:attr 6
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is non-Dmulti means
for b1, b2, b3, b4 being set
st b1 DJoins b3,b4,a1 & b2 DJoins b3,b4,a1
holds b1 = b2;
end;
:: GLIB_000:dfs 23
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is non-Dmulti
it is sufficient to prove
thus for b1, b2, b3, b4 being set
st b1 DJoins b3,b4,a1 & b2 DJoins b3,b4,a1
holds b1 = b2;
:: GLIB_000:def 23
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is non-Dmulti
iff
for b2, b3, b4, b5 being set
st b2 DJoins b4,b5,b1 & b3 DJoins b4,b5,b1
holds b2 = b3;
:: GLIB_000:attrnot 7 => GLIB_000:attr 7
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is simple means
a1 is loopless & a1 is non-multi;
end;
:: GLIB_000:dfs 24
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is simple
it is sufficient to prove
thus a1 is loopless & a1 is non-multi;
:: GLIB_000:def 24
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is simple
iff
b1 is loopless & b1 is non-multi;
:: GLIB_000:attrnot 8 => GLIB_000:attr 8
definition
let a1 be [Graph-like] GraphStruct;
attr a1 is Dsimple means
a1 is loopless & a1 is non-Dmulti;
end;
:: GLIB_000:dfs 25
definiens
let a1 be [Graph-like] GraphStruct;
To prove
a1 is Dsimple
it is sufficient to prove
thus a1 is loopless & a1 is non-Dmulti;
:: GLIB_000:def 25
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is Dsimple
iff
b1 is loopless & b1 is non-Dmulti;
:: GLIB_000:condreg 1
registration
cluster [Graph-like] non-multi -> non-Dmulti (GraphStruct);
end;
:: GLIB_000:condreg 2
registration
cluster [Graph-like] simple -> loopless non-multi (GraphStruct);
end;
:: GLIB_000:condreg 3
registration
cluster [Graph-like] loopless non-multi -> simple (GraphStruct);
end;
:: GLIB_000:condreg 4
registration
cluster [Graph-like] loopless non-Dmulti -> Dsimple (GraphStruct);
end;
:: GLIB_000:condreg 5
registration
cluster [Graph-like] Dsimple -> loopless non-Dmulti (GraphStruct);
end;
:: GLIB_000:condreg 6
registration
cluster [Graph-like] loopless trivial -> finite (GraphStruct);
end;
:: GLIB_000:condreg 7
registration
cluster [Graph-like] trivial non-Dmulti -> finite (GraphStruct);
end;
:: GLIB_000:exreg 2
registration
cluster Relation-like Function-like finite [Graph-like] trivial simple GraphStruct;
end;
:: GLIB_000:exreg 3
registration
cluster Relation-like Function-like finite [Graph-like] finite non trivial simple GraphStruct;
end;
:: GLIB_000:funcreg 3
registration
let a1 be [Graph-like] finite GraphStruct;
cluster the_Vertices_of a1 -> finite;
end;
:: GLIB_000:funcreg 4
registration
let a1 be [Graph-like] finite GraphStruct;
cluster the_Edges_of a1 -> finite;
end;
:: GLIB_000:funcreg 5
registration
let a1 be [Graph-like] trivial GraphStruct;
cluster the_Vertices_of a1 -> finite;
end;
:: GLIB_000:funcreg 6
registration
let a1 be non empty finite set;
let a2 be finite set;
let a3, a4 be Function-like quasi_total Relation of a2,a1;
cluster createGraph(a1,a2,a3,a4) -> [Graph-like] finite;
end;
:: GLIB_000:funcreg 7
registration
let a1 be non empty set;
let a2 be empty set;
let a3, a4 be Function-like quasi_total Relation of a2,a1;
cluster createGraph(a1,a2,a3,a4) -> [Graph-like] simple;
end;
:: GLIB_000:funcreg 8
registration
let a1, a2 be set;
let a3, a4 be Function-like quasi_total Relation of a2,{a1};
cluster createGraph({a1},a2,a3,a4) -> [Graph-like] trivial;
end;
:: GLIB_000:funcnot 15 => GLIB_000:func 15
definition
let a1 be [Graph-like] GraphStruct;
func A1 .order() -> cardinal set equals
Card the_Vertices_of a1;
end;
:: GLIB_000:def 26
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .order() = Card the_Vertices_of b1;
:: GLIB_000:funcnot 16 => GLIB_000:func 16
definition
let a1 be [Graph-like] finite GraphStruct;
redefine func a1 .order() -> non empty Element of NAT;
end;
:: GLIB_000:funcnot 17 => GLIB_000:func 17
definition
let a1 be [Graph-like] GraphStruct;
func A1 .size() -> cardinal set equals
Card the_Edges_of a1;
end;
:: GLIB_000:def 27
theorem
for b1 being [Graph-like] GraphStruct holds
b1 .size() = Card the_Edges_of b1;
:: GLIB_000:funcnot 18 => GLIB_000:func 18
definition
let a1 be [Graph-like] finite GraphStruct;
redefine func a1 .size() -> Element of NAT;
end;
:: GLIB_000:funcnot 19 => GLIB_000:func 19
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
func A1 .edgesInto A2 -> Element of bool the_Edges_of a1 means
for b1 being set holds
b1 in it
iff
b1 in the_Edges_of a1 & (the_Target_of a1) . b1 in a2;
end;
:: GLIB_000:def 28
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of bool the_Edges_of b1 holds
b3 = b1 .edgesInto b2
iff
for b4 being set holds
b4 in b3
iff
b4 in the_Edges_of b1 & (the_Target_of b1) . b4 in b2;
:: GLIB_000:funcnot 20 => GLIB_000:func 20
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
func A1 .edgesOutOf A2 -> Element of bool the_Edges_of a1 means
for b1 being set holds
b1 in it
iff
b1 in the_Edges_of a1 & (the_Source_of a1) . b1 in a2;
end;
:: GLIB_000:def 29
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of bool the_Edges_of b1 holds
b3 = b1 .edgesOutOf b2
iff
for b4 being set holds
b4 in b3
iff
b4 in the_Edges_of b1 & (the_Source_of b1) . b4 in b2;
:: GLIB_000:funcnot 21 => GLIB_000:func 21
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
func A1 .edgesInOut A2 -> Element of bool the_Edges_of a1 equals
(a1 .edgesInto a2) \/ (a1 .edgesOutOf a2);
end;
:: GLIB_000:def 30
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
b1 .edgesInOut b2 = (b1 .edgesInto b2) \/ (b1 .edgesOutOf b2);
:: GLIB_000:funcnot 22 => GLIB_000:func 22
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
func A1 .edgesBetween A2 -> Element of bool the_Edges_of a1 equals
(a1 .edgesInto a2) /\ (a1 .edgesOutOf a2);
end;
:: GLIB_000:def 31
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
b1 .edgesBetween b2 = (b1 .edgesInto b2) /\ (b1 .edgesOutOf b2);
:: GLIB_000:funcnot 23 => GLIB_000:func 23
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
func A1 .edgesBetween(A2,A3) -> Element of bool the_Edges_of a1 means
for b1 being set holds
b1 in it
iff
b1 SJoins a2,a3,a1;
end;
:: GLIB_000:def 32
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4 being Element of bool the_Edges_of b1 holds
b4 = b1 .edgesBetween(b2,b3)
iff
for b5 being set holds
b5 in b4
iff
b5 SJoins b2,b3,b1;
:: GLIB_000:funcnot 24 => GLIB_000:func 24
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
func A1 .edgesDBetween(A2,A3) -> Element of bool the_Edges_of a1 means
for b1 being set holds
b1 in it
iff
b1 DSJoins a2,a3,a1;
end;
:: GLIB_000:def 33
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4 being Element of bool the_Edges_of b1 holds
b4 = b1 .edgesDBetween(b2,b3)
iff
for b5 being set holds
b5 in b4
iff
b5 DSJoins b2,b3,b1;
:: GLIB_000:sch 1
scheme GLIB_000:sch 1
for b1 being [Graph-like] finite GraphStruct holds
P1[b1]
provided
for b1 being [Graph-like] finite GraphStruct
st b1 .order() = 1
holds P1[b1]
and
for b1 being non empty Element of NAT
st for b2 being [Graph-like] finite GraphStruct
st b2 .order() = b1
holds P1[b2]
for b2 being [Graph-like] finite GraphStruct
st b2 .order() = b1 + 1
holds P1[b2];
:: GLIB_000:sch 2
scheme GLIB_000:sch 2
for b1 being [Graph-like] finite GraphStruct holds
P1[b1]
provided
for b1 being [Graph-like] finite GraphStruct
st b1 .size() = 0
holds P1[b1]
and
for b1 being Element of NAT
st for b2 being [Graph-like] finite GraphStruct
st b2 .size() = b1
holds P1[b2]
for b2 being [Graph-like] finite GraphStruct
st b2 .size() = b1 + 1
holds P1[b2];
:: GLIB_000:modenot 3 => GLIB_000:mode 2
definition
let a1 be [Graph-like] GraphStruct;
mode Subgraph of A1 -> [Graph-like] GraphStruct means
the_Vertices_of it c= the_Vertices_of a1 &
the_Edges_of it c= the_Edges_of a1 &
(for b1 being set
st b1 in the_Edges_of it
holds (the_Source_of it) . b1 = (the_Source_of a1) . b1 &
(the_Target_of it) . b1 = (the_Target_of a1) . b1);
end;
:: GLIB_000:dfs 34
definiens
let a1, a2 be [Graph-like] GraphStruct;
To prove
a2 is Subgraph of a1
it is sufficient to prove
thus the_Vertices_of a2 c= the_Vertices_of a1 &
the_Edges_of a2 c= the_Edges_of a1 &
(for b1 being set
st b1 in the_Edges_of a2
holds (the_Source_of a2) . b1 = (the_Source_of a1) . b1 &
(the_Target_of a2) . b1 = (the_Target_of a1) . b1);
:: GLIB_000:def 34
theorem
for b1, b2 being [Graph-like] GraphStruct holds
b2 is Subgraph of b1
iff
the_Vertices_of b2 c= the_Vertices_of b1 &
the_Edges_of b2 c= the_Edges_of b1 &
(for b3 being set
st b3 in the_Edges_of b2
holds (the_Source_of b2) . b3 = (the_Source_of b1) . b3 &
(the_Target_of b2) . b3 = (the_Target_of b1) . b3);
:: GLIB_000:funcnot 25 => GLIB_000:func 25
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Subgraph of a1;
redefine func the_Vertices_of a2 -> non empty Element of bool the_Vertices_of a1;
end;
:: GLIB_000:funcnot 26 => GLIB_000:func 26
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Subgraph of a1;
redefine func the_Edges_of a2 -> Element of bool the_Edges_of a1;
end;
:: GLIB_000:exreg 4
registration
let a1 be [Graph-like] GraphStruct;
cluster Relation-like Function-like finite [Graph-like] trivial simple Subgraph of a1;
end;
:: GLIB_000:condreg 8
registration
let a1 be [Graph-like] finite GraphStruct;
cluster -> finite (Subgraph of a1);
end;
:: GLIB_000:condreg 9
registration
let a1 be [Graph-like] loopless GraphStruct;
cluster -> loopless (Subgraph of a1);
end;
:: GLIB_000:condreg 10
registration
let a1 be [Graph-like] trivial GraphStruct;
cluster -> trivial (Subgraph of a1);
end;
:: GLIB_000:condreg 11
registration
let a1 be [Graph-like] non-multi GraphStruct;
cluster -> non-multi (Subgraph of a1);
end;
:: GLIB_000:attrnot 9 => GLIB_000:attr 9
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Subgraph of a1;
attr a2 is spanning means
the_Vertices_of a2 = the_Vertices_of a1;
end;
:: GLIB_000:dfs 35
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Subgraph of a1;
To prove
a2 is spanning
it is sufficient to prove
thus the_Vertices_of a2 = the_Vertices_of a1;
:: GLIB_000:def 35
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1 holds
b2 is spanning(b1)
iff
the_Vertices_of b2 = the_Vertices_of b1;
:: GLIB_000:exreg 5
registration
let a1 be [Graph-like] GraphStruct;
cluster Relation-like Function-like finite [Graph-like] spanning Subgraph of a1;
end;
:: GLIB_000:prednot 5 => GLIB_000:pred 5
definition
let a1, a2 be [Graph-like] GraphStruct;
pred A1 == A2 means
the_Vertices_of a1 = the_Vertices_of a2 & the_Edges_of a1 = the_Edges_of a2 & the_Source_of a1 = the_Source_of a2 & the_Target_of a1 = the_Target_of a2;
symmetry;
:: for a1, a2 being [Graph-like] GraphStruct
:: st a1 == a2
:: holds a2 == a1;
reflexivity;
:: for a1 being [Graph-like] GraphStruct holds
:: a1 == a1;
end;
:: GLIB_000:dfs 36
definiens
let a1, a2 be [Graph-like] GraphStruct;
To prove
a1 == a2
it is sufficient to prove
thus the_Vertices_of a1 = the_Vertices_of a2 & the_Edges_of a1 = the_Edges_of a2 & the_Source_of a1 = the_Source_of a2 & the_Target_of a1 = the_Target_of a2;
:: GLIB_000:def 36
theorem
for b1, b2 being [Graph-like] GraphStruct holds
b1 == b2
iff
the_Vertices_of b1 = the_Vertices_of b2 & the_Edges_of b1 = the_Edges_of b2 & the_Source_of b1 = the_Source_of b2 & the_Target_of b1 = the_Target_of b2;
:: GLIB_000:prednot 6 => not GLIB_000:pred 5
notation
let a1, a2 be [Graph-like] GraphStruct;
antonym a1 != a2 for a1 == a2;
end;
:: GLIB_000:prednot 7 => GLIB_000:pred 6
definition
let a1, a2 be [Graph-like] GraphStruct;
pred A1 c= A2 means
a1 is Subgraph of a2;
reflexivity;
:: for a1 being [Graph-like] GraphStruct holds
:: a1 c= a1;
end;
:: GLIB_000:dfs 37
definiens
let a1, a2 be [Graph-like] GraphStruct;
To prove
a1 c= a2
it is sufficient to prove
thus a1 is Subgraph of a2;
:: GLIB_000:def 37
theorem
for b1, b2 being [Graph-like] GraphStruct holds
b1 c= b2
iff
b1 is Subgraph of b2;
:: GLIB_000:prednot 8 => GLIB_000:pred 7
definition
let a1, a2 be [Graph-like] GraphStruct;
pred A1 c< A2 means
a1 c= a2 & a1 != a2;
irreflexivity;
:: for a1 being [Graph-like] GraphStruct holds
:: not a1 c< a1;
end;
:: GLIB_000:dfs 38
definiens
let a1, a2 be [Graph-like] GraphStruct;
To prove
a1 c< a2
it is sufficient to prove
thus a1 c= a2 & a1 != a2;
:: GLIB_000:def 38
theorem
for b1, b2 being [Graph-like] GraphStruct holds
b1 c< b2
iff
b1 c= b2 & b1 != b2;
:: GLIB_000:modenot 4 => GLIB_000:mode 3
definition
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
mode inducedSubgraph of A1,A2,A3 -> Subgraph of a1 means
the_Vertices_of it = a2 & the_Edges_of it = a3
if a2 is non empty Element of bool the_Vertices_of a1 & a3 c= a1 .edgesBetween a2
otherwise it == a1;
end;
:: GLIB_000:dfs 39
definiens
let a1 be [Graph-like] GraphStruct;
let a2, a3 be set;
let a4 be Subgraph of a1;
To prove
a4 is inducedSubgraph of a1,a2,a3
it is sufficient to prove
per cases;
case a2 is non empty Element of bool the_Vertices_of a1 & a3 c= a1 .edgesBetween a2;
thus the_Vertices_of a4 = a2 & the_Edges_of a4 = a3;
end;
case (a2 is non empty Element of bool the_Vertices_of a1 implies not a3 c= a1 .edgesBetween a2);
thus a4 == a1;
end;
:: GLIB_000:def 39
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4 being Subgraph of b1 holds
(b2 is non empty Element of bool the_Vertices_of b1 & b3 c= b1 .edgesBetween b2 implies (b4 is inducedSubgraph of b1,b2,b3
iff
the_Vertices_of b4 = b2 & the_Edges_of b4 = b3)) &
(b2 is non empty Element of bool the_Vertices_of b1 & b3 c= b1 .edgesBetween b2 or (b4 is inducedSubgraph of b1,b2,b3
iff
b4 == b1));
:: GLIB_000:modenot 5
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
mode inducedSubgraph of a1,a2 is inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;
:: GLIB_000:condreg 12
registration
let a1 be [Graph-like] GraphStruct;
let a2 be non empty finite Element of bool the_Vertices_of a1;
let a3 be finite Element of bool (a1 .edgesBetween a2);
cluster -> finite (inducedSubgraph of a1,a2,a3);
end;
:: GLIB_000:condreg 13
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
let a3 be Element of bool (a1 .edgesBetween {a2});
cluster -> trivial (inducedSubgraph of a1,{a2},a3);
end;
:: GLIB_000:condreg 14
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
cluster -> finite trivial (inducedSubgraph of a1,{a2},{});
end;
:: GLIB_000:condreg 15
registration
let a1 be [Graph-like] GraphStruct;
let a2 be non empty Element of bool the_Vertices_of a1;
cluster -> simple (inducedSubgraph of a1,a2,{});
end;
:: GLIB_000:condreg 16
registration
let a1 be [Graph-like] GraphStruct;
let a2 be Element of bool the_Edges_of a1;
cluster -> spanning (inducedSubgraph of a1,the_Vertices_of a1,a2);
end;
:: GLIB_000:condreg 17
registration
let a1 be [Graph-like] GraphStruct;
cluster -> spanning (inducedSubgraph of a1,the_Vertices_of a1,{});
end;
:: GLIB_000:modenot 6
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
mode removeVertex of a1,a2 is inducedSubgraph of a1,(the_Vertices_of a1) \ {a2},a1 .edgesBetween ((the_Vertices_of a1) \ {a2});
end;
:: GLIB_000:modenot 7
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
mode removeVertices of a1,a2 is inducedSubgraph of a1,(the_Vertices_of a1) \ a2,a1 .edgesBetween ((the_Vertices_of a1) \ a2);
end;
:: GLIB_000:modenot 8
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
mode removeEdge of a1,a2 is inducedSubgraph of a1,the_Vertices_of a1,(the_Edges_of a1) \ {a2};
end;
:: GLIB_000:modenot 9
definition
let a1 be [Graph-like] GraphStruct;
let a2 be set;
mode removeEdges of a1,a2 is inducedSubgraph of a1,the_Vertices_of a1,(the_Edges_of a1) \ a2;
end;
:: GLIB_000:condreg 18
registration
let a1 be [Graph-like] GraphStruct;
let a2 be set;
cluster -> spanning (inducedSubgraph of a1,the_Vertices_of a1,(the_Edges_of a1) \ {a2});
end;
:: GLIB_000:condreg 19
registration
let a1 be [Graph-like] GraphStruct;
let a2 be set;
cluster -> spanning (inducedSubgraph of a1,the_Vertices_of a1,(the_Edges_of a1) \ a2);
end;
:: GLIB_000:modenot 10
definition
let a1 be [Graph-like] GraphStruct;
mode Vertex of a1 is Element of the_Vertices_of a1;
end;
:: GLIB_000:funcnot 27 => GLIB_000:func 27
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .edgesIn() -> Element of bool the_Edges_of a1 equals
a1 .edgesInto {a2};
end;
:: GLIB_000:def 40
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .edgesIn() = b1 .edgesInto {b2};
:: GLIB_000:funcnot 28 => GLIB_000:func 28
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .edgesOut() -> Element of bool the_Edges_of a1 equals
a1 .edgesOutOf {a2};
end;
:: GLIB_000:def 41
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .edgesOut() = b1 .edgesOutOf {b2};
:: GLIB_000:funcnot 29 => GLIB_000:func 29
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .edgesInOut() -> Element of bool the_Edges_of a1 equals
a1 .edgesInOut {a2};
end;
:: GLIB_000:def 42
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .edgesInOut() = b1 .edgesInOut {b2};
:: GLIB_000:funcnot 30 => GLIB_000:func 30
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
let a3 be set;
func A2 .adj A3 -> Element of the_Vertices_of a1 equals
(the_Source_of a1) . a3
if a3 in the_Edges_of a1 & (the_Target_of a1) . a3 = a2,
(the_Target_of a1) . a3
if a3 in the_Edges_of a1 & (the_Source_of a1) . a3 = a2 & (the_Target_of a1) . a3 <> a2
otherwise a2;
end;
:: GLIB_000:def 43
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being set holds
(b3 in the_Edges_of b1 & (the_Target_of b1) . b3 = b2 implies b2 .adj b3 = (the_Source_of b1) . b3) &
(b3 in the_Edges_of b1 & (the_Source_of b1) . b3 = b2 & (the_Target_of b1) . b3 <> b2 implies b2 .adj b3 = (the_Target_of b1) . b3) &
((b3 in the_Edges_of b1 implies (the_Target_of b1) . b3 <> b2) &
(b3 in the_Edges_of b1 & (the_Source_of b1) . b3 = b2 implies (the_Target_of b1) . b3 = b2) implies b2 .adj b3 = b2);
:: GLIB_000:funcnot 31 => GLIB_000:func 31
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .inDegree() -> cardinal set equals
Card (a2 .edgesIn());
end;
:: GLIB_000:def 44
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .inDegree() = Card (b2 .edgesIn());
:: GLIB_000:funcnot 32 => GLIB_000:func 32
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .outDegree() -> cardinal set equals
Card (a2 .edgesOut());
end;
:: GLIB_000:def 45
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .outDegree() = Card (b2 .edgesOut());
:: GLIB_000:funcnot 33 => GLIB_000:func 33
definition
let a1 be [Graph-like] finite GraphStruct;
let a2 be Element of the_Vertices_of a1;
redefine func a2 .inDegree() -> Element of NAT;
end;
:: GLIB_000:funcnot 34 => GLIB_000:func 34
definition
let a1 be [Graph-like] finite GraphStruct;
let a2 be Element of the_Vertices_of a1;
redefine func a2 .outDegree() -> Element of NAT;
end;
:: GLIB_000:funcnot 35 => GLIB_000:func 35
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .degree() -> cardinal set equals
a2 .inDegree() +` (a2 .outDegree());
end;
:: GLIB_000:def 46
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .degree() = b2 .inDegree() +` (b2 .outDegree());
:: GLIB_000:funcnot 36 => GLIB_000:func 36
definition
let a1 be [Graph-like] finite GraphStruct;
let a2 be Element of the_Vertices_of a1;
redefine func A2 .degree() -> Element of NAT equals
a2 .inDegree() + (a2 .outDegree());
end;
:: GLIB_000:def 47
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .degree() = b2 .inDegree() + (b2 .outDegree());
:: GLIB_000:funcnot 37 => GLIB_000:func 37
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .inNeighbors() -> Element of bool the_Vertices_of a1 equals
(the_Source_of a1) .: (a2 .edgesIn());
end;
:: GLIB_000:def 48
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .inNeighbors() = (the_Source_of b1) .: (b2 .edgesIn());
:: GLIB_000:funcnot 38 => GLIB_000:func 38
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .outNeighbors() -> Element of bool the_Vertices_of a1 equals
(the_Target_of a1) .: (a2 .edgesOut());
end;
:: GLIB_000:def 49
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .outNeighbors() = (the_Target_of b1) .: (b2 .edgesOut());
:: GLIB_000:funcnot 39 => GLIB_000:func 39
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
func A2 .allNeighbors() -> Element of bool the_Vertices_of a1 equals
a2 .inNeighbors() \/ (a2 .outNeighbors());
end;
:: GLIB_000:def 50
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .allNeighbors() = b2 .inNeighbors() \/ (b2 .outNeighbors());
:: GLIB_000:attrnot 10 => GLIB_000:attr 10
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
attr a2 is isolated means
a2 .edgesInOut() = {};
end;
:: GLIB_000:dfs 51
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
To prove
a2 is isolated
it is sufficient to prove
thus a2 .edgesInOut() = {};
:: GLIB_000:def 51
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 is isolated(b1)
iff
b2 .edgesInOut() = {};
:: GLIB_000:attrnot 11 => GLIB_000:attr 10
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
attr a2 is isolated means
a2 .degree() = 0;
end;
:: GLIB_000:dfs 52
definiens
let a1 be [Graph-like] finite GraphStruct;
let a2 be Element of the_Vertices_of a1;
To prove
a2 is isolated
it is sufficient to prove
thus a2 .degree() = 0;
:: GLIB_000:def 52
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 is isolated(b1)
iff
b2 .degree() = 0;
:: GLIB_000:attrnot 12 => GLIB_000:attr 11
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
attr a2 is endvertex means
ex b1 being set st
a2 .edgesInOut() = {b1} & not b1 Joins a2,a2,a1;
end;
:: GLIB_000:dfs 53
definiens
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
To prove
a2 is endvertex
it is sufficient to prove
thus ex b1 being set st
a2 .edgesInOut() = {b1} & not b1 Joins a2,a2,a1;
:: GLIB_000:def 53
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 is endvertex(b1)
iff
ex b3 being set st
b2 .edgesInOut() = {b3} & not b3 Joins b2,b2,b1;
:: GLIB_000:attrnot 13 => GLIB_000:attr 11
definition
let a1 be [Graph-like] GraphStruct;
let a2 be Element of the_Vertices_of a1;
attr a2 is endvertex means
a2 .degree() = 1;
end;
:: GLIB_000:dfs 54
definiens
let a1 be [Graph-like] finite GraphStruct;
let a2 be Element of the_Vertices_of a1;
To prove
a2 is endvertex
it is sufficient to prove
thus a2 .degree() = 1;
:: GLIB_000:def 54
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 is endvertex(b1)
iff
b2 .degree() = 1;
:: GLIB_000:attrnot 14 => GLIB_000:attr 12
definition
let a1 be ManySortedSet of NAT;
attr a1 is Graph-yielding means
for b1 being natural set holds
a1 . b1 is [Graph-like] GraphStruct;
end;
:: GLIB_000:dfs 55
definiens
let a1 be ManySortedSet of NAT;
To prove
a1 is Graph-yielding
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is [Graph-like] GraphStruct;
:: GLIB_000:def 55
theorem
for b1 being ManySortedSet of NAT holds
b1 is Graph-yielding
iff
for b2 being natural set holds
b1 . b2 is [Graph-like] GraphStruct;
:: GLIB_000:attrnot 15 => GLIB_000:attr 13
definition
let a1 be ManySortedSet of NAT;
attr a1 is halting means
ex b1 being natural set st
a1 . b1 = a1 . (b1 + 1);
end;
:: GLIB_000:dfs 56
definiens
let a1 be ManySortedSet of NAT;
To prove
a1 is halting
it is sufficient to prove
thus ex b1 being natural set st
a1 . b1 = a1 . (b1 + 1);
:: GLIB_000:def 56
theorem
for b1 being ManySortedSet of NAT holds
b1 is halting
iff
ex b2 being natural set st
b1 . b2 = b1 . (b2 + 1);
:: GLIB_000:funcnot 40 => GLIB_000:func 40
definition
let a1 be ManySortedSet of NAT;
func A1 .Lifespan() -> Element of NAT means
a1 . it = a1 . (it + 1) &
(for b1 being natural set
st a1 . b1 = a1 . (b1 + 1)
holds it <= b1)
if a1 is halting
otherwise it = 0;
end;
:: GLIB_000:def 57
theorem
for b1 being ManySortedSet of NAT
for b2 being Element of NAT holds
(b1 is halting implies (b2 = b1 .Lifespan()
iff
b1 . b2 = b1 . (b2 + 1) &
(for b3 being natural set
st b1 . b3 = b1 . (b3 + 1)
holds b2 <= b3))) &
(b1 is halting or (b2 = b1 .Lifespan()
iff
b2 = 0));
:: GLIB_000:funcnot 41 => GLIB_000:func 41
definition
let a1 be ManySortedSet of NAT;
func A1 .Result() -> set equals
a1 . (a1 .Lifespan());
end;
:: GLIB_000:def 58
theorem
for b1 being ManySortedSet of NAT holds
b1 .Result() = b1 . (b1 .Lifespan());
:: GLIB_000:exreg 6
registration
cluster Relation-like Function-like Graph-yielding ManySortedSet of NAT;
end;
:: GLIB_000:modenot 11
definition
mode GraphSeq is Graph-yielding ManySortedSet of NAT;
end;
:: GLIB_000:funcnot 42 => GLIB_000:func 42
definition
let a1 be Graph-yielding ManySortedSet of NAT;
let a2 be natural set;
redefine func a1 . a2 -> [Graph-like] GraphStruct;
end;
:: GLIB_000:attrnot 16 => GLIB_000:attr 14
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is finite means
for b1 being natural set holds
a1 . b1 is finite;
end;
:: GLIB_000:dfs 59
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is finite
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is finite;
:: GLIB_000:def 60
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is finite
iff
for b2 being natural set holds
b1 . b2 is finite;
:: GLIB_000:attrnot 17 => GLIB_000:attr 15
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is loopless means
for b1 being natural set holds
a1 . b1 is loopless;
end;
:: GLIB_000:dfs 60
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is loopless
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is loopless;
:: GLIB_000:def 61
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is loopless
iff
for b2 being natural set holds
b1 . b2 is loopless;
:: GLIB_000:attrnot 18 => GLIB_000:attr 16
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is trivial means
for b1 being natural set holds
a1 . b1 is trivial;
end;
:: GLIB_000:dfs 61
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is trivial
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is trivial;
:: GLIB_000:def 62
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is trivial
iff
for b2 being natural set holds
b1 . b2 is trivial;
:: GLIB_000:attrnot 19 => GLIB_000:attr 17
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is non-trivial means
for b1 being natural set holds
a1 . b1 is not trivial;
end;
:: GLIB_000:dfs 62
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is non-trivial
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is not trivial;
:: GLIB_000:def 63
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is non-trivial
iff
for b2 being natural set holds
b1 . b2 is not trivial;
:: GLIB_000:attrnot 20 => GLIB_000:attr 18
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is non-multi means
for b1 being natural set holds
a1 . b1 is non-multi;
end;
:: GLIB_000:dfs 63
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is non-multi
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is non-multi;
:: GLIB_000:def 64
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is non-multi
iff
for b2 being natural set holds
b1 . b2 is non-multi;
:: GLIB_000:attrnot 21 => GLIB_000:attr 19
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is non-Dmulti means
for b1 being natural set holds
a1 . b1 is non-Dmulti;
end;
:: GLIB_000:dfs 64
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is non-Dmulti
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is non-Dmulti;
:: GLIB_000:def 65
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is non-Dmulti
iff
for b2 being natural set holds
b1 . b2 is non-Dmulti;
:: GLIB_000:attrnot 22 => GLIB_000:attr 20
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is simple means
for b1 being natural set holds
a1 . b1 is simple;
end;
:: GLIB_000:dfs 65
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is simple
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is simple;
:: GLIB_000:def 66
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is simple
iff
for b2 being natural set holds
b1 . b2 is simple;
:: GLIB_000:attrnot 23 => GLIB_000:attr 21
definition
let a1 be Graph-yielding ManySortedSet of NAT;
attr a1 is Dsimple means
for b1 being natural set holds
a1 . b1 is Dsimple;
end;
:: GLIB_000:dfs 66
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is Dsimple
it is sufficient to prove
thus for b1 being natural set holds
a1 . b1 is Dsimple;
:: GLIB_000:def 67
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is Dsimple
iff
for b2 being natural set holds
b1 . b2 is Dsimple;
:: GLIB_000:attrnot 24 => GLIB_000:attr 13
definition
let a1 be ManySortedSet of NAT;
attr a1 is halting means
ex b1 being natural set st
a1 . b1 = a1 . (b1 + 1);
end;
:: GLIB_000:dfs 67
definiens
let a1 be Graph-yielding ManySortedSet of NAT;
To prove
a1 is halting
it is sufficient to prove
thus ex b1 being natural set st
a1 . b1 = a1 . (b1 + 1);
:: GLIB_000:def 68
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
b1 is halting
iff
ex b2 being natural set st
b1 . b2 = b1 . (b2 + 1);
:: GLIB_000:exreg 7
registration
cluster Relation-like Function-like Graph-yielding halting finite loopless trivial non-multi non-Dmulti simple Dsimple ManySortedSet of NAT;
end;
:: GLIB_000:exreg 8
registration
cluster Relation-like Function-like Graph-yielding halting finite loopless non-trivial non-multi non-Dmulti simple Dsimple ManySortedSet of NAT;
end;
:: GLIB_000:funcreg 9
registration
let a1 be Graph-yielding finite ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> finite;
end;
:: GLIB_000:funcreg 10
registration
let a1 be Graph-yielding loopless ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] loopless;
end;
:: GLIB_000:funcreg 11
registration
let a1 be Graph-yielding trivial ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] trivial;
end;
:: GLIB_000:funcreg 12
registration
let a1 be Graph-yielding non-trivial ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] non trivial;
end;
:: GLIB_000:funcreg 13
registration
let a1 be Graph-yielding non-multi ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] non-multi;
end;
:: GLIB_000:funcreg 14
registration
let a1 be Graph-yielding non-Dmulti ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] non-Dmulti;
end;
:: GLIB_000:funcreg 15
registration
let a1 be Graph-yielding simple ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] simple;
end;
:: GLIB_000:funcreg 16
registration
let a1 be Graph-yielding Dsimple ManySortedSet of NAT;
let a2 be natural set;
cluster a1 . a2 -> [Graph-like] Dsimple;
end;
:: GLIB_000:condreg 20
registration
cluster Graph-yielding non-multi -> non-Dmulti (ManySortedSet of NAT);
end;
:: GLIB_000:condreg 21
registration
cluster Graph-yielding simple -> loopless non-multi (ManySortedSet of NAT);
end;
:: GLIB_000:condreg 22
registration
cluster Graph-yielding loopless non-multi -> simple (ManySortedSet of NAT);
end;
:: GLIB_000:condreg 23
registration
cluster Graph-yielding loopless non-Dmulti -> Dsimple (ManySortedSet of NAT);
end;
:: GLIB_000:condreg 24
registration
cluster Graph-yielding Dsimple -> loopless non-Dmulti (ManySortedSet of NAT);
end;
:: GLIB_000:condreg 25
registration
cluster Graph-yielding loopless trivial -> finite (ManySortedSet of NAT);
end;
:: GLIB_000:condreg 26
registration
cluster Graph-yielding trivial non-Dmulti -> finite (ManySortedSet of NAT);
end;
:: GLIB_000:th 1
theorem
VertexSelector = 1 & EdgeSelector = 2 & SourceSelector = 3 & TargetSelector = 4;
:: GLIB_000:th 3
theorem
for b1 being [Graph-like] GraphStruct holds
_GraphSelectors c= proj1 b1;
:: GLIB_000:th 4
theorem
for b1 being GraphStruct holds
the_Vertices_of b1 = b1 . VertexSelector & the_Edges_of b1 = b1 . EdgeSelector & the_Source_of b1 = b1 . SourceSelector & the_Target_of b1 = b1 . TargetSelector;
:: GLIB_000:th 5
theorem
for b1 being [Graph-like] GraphStruct holds
dom the_Source_of b1 = the_Edges_of b1 & dom the_Target_of b1 = the_Edges_of b1 & rng the_Source_of b1 c= the_Vertices_of b1 & rng the_Target_of b1 c= the_Vertices_of b1;
:: GLIB_000:th 7
theorem
for b1 being GraphStruct holds
b1 is [Graph-like]
iff
_GraphSelectors c= proj1 b1 &
the_Vertices_of b1 is not empty &
the_Source_of b1 is Function-like quasi_total Relation of the_Edges_of b1,the_Vertices_of b1 &
the_Target_of b1 is Function-like quasi_total Relation of the_Edges_of b1,the_Vertices_of b1;
:: GLIB_000:th 8
theorem
for b1 being non empty set
for b2 being set
for b3, b4 being Function-like quasi_total Relation of b2,b1 holds
the_Vertices_of createGraph(b1,b2,b3,b4) = b1 & the_Edges_of createGraph(b1,b2,b3,b4) = b2 & the_Source_of createGraph(b1,b2,b3,b4) = b3 & the_Target_of createGraph(b1,b2,b3,b4) = b4;
:: GLIB_000:th 9
theorem
for b1 being GraphStruct
for b2 being set
for b3 being natural set holds
proj1 (b1 .set(b3,b2)) = (proj1 b1) \/ {b3};
:: GLIB_000:th 11
theorem
for b1 being GraphStruct
for b2 being set
for b3 being natural set holds
(b1 .set(b3,b2)) . b3 = b2;
:: GLIB_000:th 12
theorem
for b1 being GraphStruct
for b2 being set
for b3, b4 being natural set
st b3 <> b4
holds b1 . b4 = (b1 .set(b3,b2)) . b4;
:: GLIB_000:th 13
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being natural set
st not b3 in _GraphSelectors
holds the_Vertices_of b1 = the_Vertices_of (b1 .set(b3,b2)) & the_Edges_of b1 = the_Edges_of (b1 .set(b3,b2)) & the_Source_of b1 = the_Source_of (b1 .set(b3,b2)) & the_Target_of b1 = the_Target_of (b1 .set(b3,b2)) & b1 .set(b3,b2) is [Graph-like] GraphStruct;
:: GLIB_000:th 14
theorem
for b1 being GraphStruct
for b2 being set holds
the_Vertices_of (b1 .set(VertexSelector,b2)) = b2 & the_Edges_of (b1 .set(EdgeSelector,b2)) = b2 & the_Source_of (b1 .set(SourceSelector,b2)) = b2 & the_Target_of (b1 .set(TargetSelector,b2)) = b2;
:: GLIB_000:th 15
theorem
for b1 being GraphStruct
for b2, b3 being set
for b4, b5 being natural set
st b4 <> b5
holds b4 in proj1 ((b1 .set(b4,b2)) .set(b5,b3)) & b5 in proj1 ((b1 .set(b4,b2)) .set(b5,b3)) & ((b1 .set(b4,b2)) .set(b5,b3)) . b4 = b2 & ((b1 .set(b4,b2)) .set(b5,b3)) . b5 = b3;
:: GLIB_000:th 16
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
st b2 Joins b3,b4,b1
holds b3 in the_Vertices_of b1 & b4 in the_Vertices_of b1;
:: GLIB_000:th 17
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
st b2 Joins b3,b4,b1
holds b2 Joins b4,b3,b1;
:: GLIB_000:th 18
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5, b6 being set
st b2 Joins b3,b4,b1 & b2 Joins b5,b6,b1 & (b3 = b5 implies b4 <> b6)
holds b3 = b6 & b4 = b5;
:: GLIB_000:th 19
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set holds
b2 Joins b3,b4,b1
iff
(b2 DJoins b3,b4,b1 or b2 DJoins b4,b3,b1);
:: GLIB_000:th 20
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5, b6 being set
st b2 Joins b3,b4,b1 &
(b3 in b5 & b4 in b6 or b3 in b6 & b4 in b5)
holds b2 SJoins b5,b6,b1;
:: GLIB_000:th 21
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is loopless
iff
for b2, b3 being set holds
not b3 Joins b2,b2,b1;
:: GLIB_000:th 22
theorem
for b1 being [Graph-like] finite loopless GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .degree() = card (b2 .edgesInOut());
:: GLIB_000:th 23
theorem
for b1 being [Graph-like] non trivial GraphStruct
for b2 being Element of the_Vertices_of b1 holds
(the_Vertices_of b1) \ {b2} is not empty;
:: GLIB_000:th 24
theorem
for b1 being [Graph-like] non trivial GraphStruct holds
ex b2, b3 being Element of the_Vertices_of b1 st
b2 <> b3;
:: GLIB_000:th 25
theorem
for b1 being [Graph-like] trivial GraphStruct holds
ex b2 being Element of the_Vertices_of b1 st
the_Vertices_of b1 = {b2};
:: GLIB_000:th 26
theorem
for b1 being [Graph-like] loopless trivial GraphStruct holds
the_Edges_of b1 = {};
:: GLIB_000:th 27
theorem
for b1 being [Graph-like] GraphStruct
st the_Edges_of b1 = {}
holds b1 is simple;
:: GLIB_000:th 28
theorem
for b1 being [Graph-like] finite GraphStruct holds
1 <= b1 .order();
:: GLIB_000:th 29
theorem
for b1 being [Graph-like] finite GraphStruct holds
b1 .order() = 1
iff
b1 is trivial;
:: GLIB_000:th 30
theorem
for b1 being [Graph-like] finite GraphStruct holds
b1 .order() = 1
iff
ex b2 being Element of the_Vertices_of b1 st
the_Vertices_of b1 = {b2};
:: GLIB_000:th 31
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set holds
b2 in the_Edges_of b1 &
((the_Source_of b1) . b2 in b3 or (the_Target_of b1) . b2 in b3)
iff
b2 in b1 .edgesInOut b3;
:: GLIB_000:th 32
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
b1 .edgesInto b2 c= b1 .edgesInOut b2 & b1 .edgesOutOf b2 c= b1 .edgesInOut b2;
:: GLIB_000:th 33
theorem
for b1 being [Graph-like] GraphStruct holds
the_Edges_of b1 = b1 .edgesInOut the_Vertices_of b1;
:: GLIB_000:th 34
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set holds
b2 in the_Edges_of b1 & (the_Source_of b1) . b2 in b3 & (the_Target_of b1) . b2 in b3
iff
b2 in b1 .edgesBetween b3;
:: GLIB_000:th 35
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5 being set
st b2 in b3 & b4 in b3 & b5 Joins b2,b4,b1
holds b5 in b1 .edgesBetween b3;
:: GLIB_000:th 36
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
b1 .edgesBetween b2 c= b1 .edgesInOut b2;
:: GLIB_000:th 37
theorem
for b1 being [Graph-like] GraphStruct holds
the_Edges_of b1 = b1 .edgesBetween the_Vertices_of b1;
:: GLIB_000:th 38
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
(the_Edges_of b1) \ (b1 .edgesInOut b2) = b1 .edgesBetween ((the_Vertices_of b1) \ b2);
:: GLIB_000:th 39
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
st b2 c= b3
holds b1 .edgesBetween b2 c= b1 .edgesBetween b3;
:: GLIB_000:th 40
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5 being set
st b2 c= b3 & b4 c= b5
holds b1 .edgesBetween(b2,b4) c= b1 .edgesBetween(b3,b5);
:: GLIB_000:th 41
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5 being set
st b2 c= b3 & b4 c= b5
holds b1 .edgesDBetween(b2,b4) c= b1 .edgesDBetween(b3,b5);
:: GLIB_000:th 42
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .edgesIn() = b1 .edgesDBetween(the_Vertices_of b1,{b2}) &
b2 .edgesOut() = b1 .edgesDBetween({b2},the_Vertices_of b1);
:: GLIB_000:th 43
theorem
for b1 being [Graph-like] GraphStruct holds
b1 is Subgraph of b1;
:: GLIB_000:th 44
theorem
for b1, b2 being [Graph-like] GraphStruct holds
b1 is Subgraph of b2 & b2 is Subgraph of b1
iff
the_Vertices_of b1 = the_Vertices_of b2 & the_Edges_of b1 = the_Edges_of b2 & the_Source_of b1 = the_Source_of b2 & the_Target_of b1 = the_Target_of b2;
:: GLIB_000:th 45
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being set holds
(b3 in the_Vertices_of b2 implies b3 in the_Vertices_of b1) & (b3 in the_Edges_of b2 implies b3 in the_Edges_of b1);
:: GLIB_000:th 46
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Subgraph of b2 holds
b3 is Subgraph of b1;
:: GLIB_000:th 47
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Subgraph of b1
st the_Vertices_of b2 c= the_Vertices_of b3 & the_Edges_of b2 c= the_Edges_of b3
holds b2 is Subgraph of b3;
:: GLIB_000:th 48
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1 holds
the_Source_of b2 = (the_Source_of b1) | the_Edges_of b2 &
the_Target_of b2 = (the_Target_of b1) | the_Edges_of b2;
:: GLIB_000:th 49
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4, b5 being set
for b6 being inducedSubgraph of b1,b2,b4
for b7 being inducedSubgraph of b1,b3,b5
st b3 c= b2 & b5 c= b4 & b3 is non empty Element of bool the_Vertices_of b1 & b5 c= b1 .edgesBetween b3
holds b7 is Subgraph of b6;
:: GLIB_000:th 50
theorem
for b1 being [Graph-like] non trivial GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2}) holds
the_Vertices_of b3 = (the_Vertices_of b1) \ {b2} &
the_Edges_of b3 = b1 .edgesBetween ((the_Vertices_of b1) \ {b2});
:: GLIB_000:th 51
theorem
for b1 being [Graph-like] finite non trivial GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ {b2},b1 .edgesBetween ((the_Vertices_of b1) \ {b2}) holds
b3 .order() + 1 = b1 .order() &
b3 .size() + card (b2 .edgesInOut()) = b1 .size();
:: GLIB_000:th 52
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ b2,b1 .edgesBetween ((the_Vertices_of b1) \ b2)
st b2 c< the_Vertices_of b1
holds the_Vertices_of b3 = (the_Vertices_of b1) \ b2 &
the_Edges_of b3 = b1 .edgesBetween ((the_Vertices_of b1) \ b2);
:: GLIB_000:th 53
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Element of bool the_Vertices_of b1
for b3 being inducedSubgraph of b1,(the_Vertices_of b1) \ b2,b1 .edgesBetween ((the_Vertices_of b1) \ b2)
st b2 <> the_Vertices_of b1
holds b3 .order() + card b2 = b1 .order() &
b3 .size() + card (b1 .edgesInOut b2) = b1 .size();
:: GLIB_000:th 54
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ {b2} holds
the_Vertices_of b3 = the_Vertices_of b1 &
the_Edges_of b3 = (the_Edges_of b1) \ {b2};
:: GLIB_000:th 55
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being set
for b3 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ {b2} holds
b1 .order() = b3 .order() &
(b2 in the_Edges_of b1 implies b3 .size() + 1 = b1 .size());
:: GLIB_000:th 56
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ b2 holds
the_Vertices_of b3 = the_Vertices_of b1 & the_Edges_of b3 = (the_Edges_of b1) \ b2;
:: GLIB_000:th 57
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being set
for b3 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ b2 holds
b1 .order() = b3 .order();
:: GLIB_000:th 58
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Element of bool the_Edges_of b1
for b3 being inducedSubgraph of b1,the_Vertices_of b1,(the_Edges_of b1) \ b2 holds
b3 .size() + card b2 = b1 .size();
:: GLIB_000:th 59
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesIn()
iff
b2 in the_Edges_of b1 & (the_Target_of b1) . b2 = b3;
:: GLIB_000:th 60
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesIn()
iff
ex b4 being set st
b2 DJoins b4,b3,b1;
:: GLIB_000:th 61
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesOut()
iff
b2 in the_Edges_of b1 & (the_Source_of b1) . b2 = b3;
:: GLIB_000:th 62
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesOut()
iff
ex b4 being set st
b2 DJoins b3,b4,b1;
:: GLIB_000:th 63
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Element of the_Vertices_of b1 holds
b2 .edgesInOut() = b2 .edgesIn() \/ (b2 .edgesOut());
:: GLIB_000:th 64
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesInOut()
iff
b2 in the_Edges_of b1 &
((the_Source_of b1) . b2 = b3 or (the_Target_of b1) . b2 = b3);
:: GLIB_000:th 65
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4 being Element of the_Vertices_of b1
st b2 Joins b4,b3,b1
holds b2 in b4 .edgesInOut();
:: GLIB_000:th 66
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3, b4 being Element of the_Vertices_of b1
st b2 Joins b3,b4,b1 & (b2 in b3 .edgesIn() implies not b2 in b4 .edgesOut())
holds b2 in b4 .edgesIn() & b2 in b3 .edgesOut();
:: GLIB_000:th 67
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesInOut()
iff
ex b4 being Element of the_Vertices_of b1 st
b2 Joins b3,b4,b1;
:: GLIB_000:th 68
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3, b4 being set
for b5 being Element of the_Vertices_of b1
st b2 in b5 .edgesInOut() & b2 Joins b3,b4,b1 & b5 <> b3
holds b5 = b4;
:: GLIB_000:th 69
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3, b4 being Element of the_Vertices_of b1
st b2 Joins b3,b4,b1
holds b3 .adj b2 = b4 & b4 .adj b2 = b3;
:: GLIB_000:th 70
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .edgesInOut()
iff
b2 Joins b3,b3 .adj b2,b1;
:: GLIB_000:th 71
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being set
for b3, b4 being Element of the_Vertices_of b1
st b2 Joins b3,b4,b1
holds 1 <= b3 .degree() & 1 <= b4 .degree();
:: GLIB_000:th 72
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .inNeighbors()
iff
ex b4 being set st
b4 DJoins b2,b3,b1;
:: GLIB_000:th 73
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .outNeighbors()
iff
ex b4 being set st
b4 DJoins b3,b2,b1;
:: GLIB_000:th 74
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set
for b3 being Element of the_Vertices_of b1 holds
b2 in b3 .allNeighbors()
iff
ex b4 being set st
b4 Joins b3,b2,b1;
:: GLIB_000:th 75
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3, b4, b5 being set holds
(b5 Joins b3,b4,b2 implies b5 Joins b3,b4,b1) & (b5 DJoins b3,b4,b2 implies b5 DJoins b3,b4,b1) & (b5 SJoins b3,b4,b2 implies b5 SJoins b3,b4,b1) & (b5 DSJoins b3,b4,b2 implies b5 DSJoins b3,b4,b1);
:: GLIB_000:th 76
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3, b4, b5 being set
st b5 in the_Edges_of b2
holds (b5 Joins b3,b4,b1 implies b5 Joins b3,b4,b2) & (b5 DJoins b3,b4,b1 implies b5 DJoins b3,b4,b2) & (b5 SJoins b3,b4,b1 implies b5 SJoins b3,b4,b2) & (b5 DSJoins b3,b4,b1 implies b5 DSJoins b3,b4,b2);
:: GLIB_000:th 77
theorem
for b1 being [Graph-like] GraphStruct
for b2 being spanning Subgraph of b1
for b3 being spanning Subgraph of b2 holds
b3 is spanning Subgraph of b1;
:: GLIB_000:th 78
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Subgraph of b1 holds
b2 .order() <= b1 .order() & b2 .size() <= b1 .size();
:: GLIB_000:th 79
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being set holds
b2 .edgesInto b3 c= b1 .edgesInto b3 & b2 .edgesOutOf b3 c= b1 .edgesOutOf b3 & b2 .edgesInOut b3 c= b1 .edgesInOut b3 & b2 .edgesBetween b3 c= b1 .edgesBetween b3;
:: GLIB_000:th 80
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3, b4 being set holds
b2 .edgesBetween(b3,b4) c= b1 .edgesBetween(b3,b4) & b2 .edgesDBetween(b3,b4) c= b1 .edgesDBetween(b3,b4);
:: GLIB_000:th 81
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4
holds b4 .edgesIn() c= b3 .edgesIn() & b4 .edgesOut() c= b3 .edgesOut() & b4 .edgesInOut() c= b3 .edgesInOut();
:: GLIB_000:th 82
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4
holds b4 .edgesIn() = b3 .edgesIn() /\ the_Edges_of b2 &
b4 .edgesOut() = b3 .edgesOut() /\ the_Edges_of b2 &
b4 .edgesInOut() = b3 .edgesInOut() /\ the_Edges_of b2;
:: GLIB_000:th 83
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
for b5 being set
st b3 = b4 & b5 in the_Edges_of b2
holds b3 .adj b5 = b4 .adj b5;
:: GLIB_000:th 84
theorem
for b1 being [Graph-like] finite GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4
holds b4 .inDegree() <= b3 .inDegree() & b4 .outDegree() <= b3 .outDegree() & b4 .degree() <= b3 .degree();
:: GLIB_000:th 85
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4
holds b4 .inNeighbors() c= b3 .inNeighbors() & b4 .outNeighbors() c= b3 .outNeighbors() & b4 .allNeighbors() c= b3 .allNeighbors();
:: GLIB_000:th 86
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4 & b3 is isolated(b1)
holds b4 is isolated(b2);
:: GLIB_000:th 87
theorem
for b1 being [Graph-like] GraphStruct
for b2 being Subgraph of b1
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4 & b3 is endvertex(b1) & b4 is not endvertex(b2)
holds b4 is isolated(b2);
:: GLIB_000:th 88
theorem
for b1, b2, b3 being [Graph-like] GraphStruct
st b1 == b2 & b2 == b3
holds b1 == b3;
:: GLIB_000:th 89
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Subgraph of b1
st the_Vertices_of b2 = the_Vertices_of b3 & the_Edges_of b2 = the_Edges_of b3
holds b2 == b3;
:: GLIB_000:th 90
theorem
for b1, b2 being [Graph-like] GraphStruct holds
b1 == b2
iff
b1 is Subgraph of b2 & b2 is Subgraph of b1;
:: GLIB_000:th 91
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4, b5, b6, b7 being set
st b1 == b2
holds (b3 Joins b4,b5,b1 implies b3 Joins b4,b5,b2) & (b3 DJoins b4,b5,b1 implies b3 DJoins b4,b5,b2) & (b3 SJoins b6,b7,b1 implies b3 SJoins b6,b7,b2) & (b3 DSJoins b6,b7,b1 implies b3 DSJoins b6,b7,b2);
:: GLIB_000:th 92
theorem
for b1, b2 being [Graph-like] GraphStruct
st b1 == b2
holds (b1 is finite implies b2 is finite) & (b1 is loopless implies b2 is loopless) & (b1 is trivial implies b2 is trivial) & (b1 is non-multi implies b2 is non-multi) & (b1 is non-Dmulti implies b2 is non-Dmulti) & (b1 is simple implies b2 is simple) & (b1 is Dsimple implies b2 is Dsimple);
:: GLIB_000:th 93
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4 being set
st b1 == b2
holds b1 .order() = b2 .order() & b1 .size() = b2 .size() & b1 .edgesInto b3 = b2 .edgesInto b3 & b1 .edgesOutOf b3 = b2 .edgesOutOf b3 & b1 .edgesInOut b3 = b2 .edgesInOut b3 & b1 .edgesBetween b3 = b2 .edgesBetween b3 & b1 .edgesDBetween(b3,b4) = b2 .edgesDBetween(b3,b4);
:: GLIB_000:th 94
theorem
for b1, b2, b3 being [Graph-like] GraphStruct
st b1 == b2 & b3 is Subgraph of b1
holds b3 is Subgraph of b2;
:: GLIB_000:th 95
theorem
for b1, b2, b3 being [Graph-like] GraphStruct
st b1 == b2 & b1 is Subgraph of b3
holds b2 is Subgraph of b3;
:: GLIB_000:th 96
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being set
for b4, b5 being inducedSubgraph of b1,b2,b3 holds
b4 == b5;
:: GLIB_000:th 97
theorem
for b1 being [Graph-like] GraphStruct
for b2 being inducedSubgraph of b1,the_Vertices_of b1,b1 .edgesBetween the_Vertices_of b1 holds
b1 == b2;
:: GLIB_000:th 98
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3, b4 being set
for b5 being inducedSubgraph of b1,b3,b4
st b1 == b2
holds b5 is inducedSubgraph of b2,b3,b4;
:: GLIB_000:th 99
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being set
for b4 being Element of the_Vertices_of b1
for b5 being Element of the_Vertices_of b2
st b4 = b5 & b1 == b2
holds b4 .edgesIn() = b5 .edgesIn() & b4 .edgesOut() = b5 .edgesOut() & b4 .edgesInOut() = b5 .edgesInOut() & b4 .adj b3 = b5 .adj b3 & b4 .inDegree() = b5 .inDegree() & b4 .outDegree() = b5 .outDegree() & b4 .degree() = b5 .degree() & b4 .inNeighbors() = b5 .inNeighbors() & b4 .outNeighbors() = b5 .outNeighbors() & b4 .allNeighbors() = b5 .allNeighbors();
:: GLIB_000:th 100
theorem
for b1, b2 being [Graph-like] GraphStruct
for b3 being Element of the_Vertices_of b1
for b4 being Element of the_Vertices_of b2
st b3 = b4 & b1 == b2
holds (b3 is isolated(b1) implies b4 is isolated(b2)) & (b3 is endvertex(b1) implies b4 is endvertex(b2));
:: GLIB_000:th 101
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Subgraph of b1
st b2 c< b3 & not the_Vertices_of b2 c< the_Vertices_of b3
holds the_Edges_of b2 c< the_Edges_of b3;
:: GLIB_000:th 102
theorem
for b1 being [Graph-like] GraphStruct
for b2, b3 being Subgraph of b1
st b2 c< b3 &
(for b4 being set
st b4 in the_Vertices_of b3
holds b4 in the_Vertices_of b2)
holds ex b4 being set st
b4 in the_Edges_of b3 & not b4 in the_Edges_of b2;