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;