Article GLIB_003, MML version 4.99.1005

:: GLIB_003:funcnot 1 => GLIB_003:func 1
definition
  let a1 be set;
  let a2 be FinSequence of a1;
  let a3 be Element of bool a2;
  redefine func Seq a3 -> FinSequence of a1;
end;

:: GLIB_003:funcreg 1
registration
  let a1 be Relation-like real-valued set;
  let a2 be set;
  cluster a1 | a2 -> Relation-like real-valued;
end;

:: GLIB_003:th 1
theorem
for b1, b2, b3, b4, b5, b6, b7, b8, b9, b10 being set
for b11 being Relation-like Function-like FinSequence-like set
      st b11 = ((((((((<*b1*> ^ <*b2*>) ^ <*b3*>) ^ <*b4*>) ^ <*b5*>) ^ <*b6*>) ^ <*b7*>) ^ <*b8*>) ^ <*b9*>) ^ <*b10*>
   holds len b11 = 10 & b11 . 1 = b1 & b11 . 2 = b2 & b11 . 3 = b3 & b11 . 4 = b4 & b11 . 5 = b5 & b11 . 6 = b6 & b11 . 7 = b7 & b11 . 8 = b8 & b11 . 9 = b9 & b11 . 10 = b10;

:: GLIB_003:th 2
theorem
for b1 being FinSequence of REAL
for b2 being Element of bool b1
      st for b3 being Element of NAT
              st b3 in dom b1
           holds 0 <= b1 . b3
   holds Sum Seq b2 <= Sum b1;

:: GLIB_003:funcnot 2 => GLIB_003:func 2
definition
  func WeightSelector -> Element of NAT equals
    5;
end;

:: GLIB_003:def 1
theorem
WeightSelector = 5;

:: GLIB_003:funcnot 3 => GLIB_003:func 3
definition
  func ELabelSelector -> Element of NAT equals
    6;
end;

:: GLIB_003:def 2
theorem
ELabelSelector = 6;

:: GLIB_003:funcnot 4 => GLIB_003:func 4
definition
  func VLabelSelector -> Element of NAT equals
    7;
end;

:: GLIB_003:def 3
theorem
VLabelSelector = 7;

:: GLIB_003:attrnot 1 => GLIB_003:attr 1
definition
  let a1 be GraphStruct;
  attr a1 is [Weighted] means
    WeightSelector in proj1 a1 & a1 . WeightSelector is ManySortedSet of the_Edges_of a1;
end;

:: GLIB_003:dfs 4
definiens
  let a1 be GraphStruct;
To prove
     a1 is [Weighted]
it is sufficient to prove
  thus WeightSelector in proj1 a1 & a1 . WeightSelector is ManySortedSet of the_Edges_of a1;

:: GLIB_003:def 4
theorem
for b1 being GraphStruct holds
      b1 is [Weighted]
   iff
      WeightSelector in proj1 b1 & b1 . WeightSelector is ManySortedSet of the_Edges_of b1;

:: GLIB_003:attrnot 2 => GLIB_003:attr 2
definition
  let a1 be GraphStruct;
  attr a1 is [ELabeled] means
    ELabelSelector in proj1 a1 &
     (ex b1 being Relation-like Function-like set st
        a1 . ELabelSelector = b1 & proj1 b1 c= the_Edges_of a1);
end;

:: GLIB_003:dfs 5
definiens
  let a1 be GraphStruct;
To prove
     a1 is [ELabeled]
it is sufficient to prove
  thus ELabelSelector in proj1 a1 &
     (ex b1 being Relation-like Function-like set st
        a1 . ELabelSelector = b1 & proj1 b1 c= the_Edges_of a1);

:: GLIB_003:def 5
theorem
for b1 being GraphStruct holds
      b1 is [ELabeled]
   iff
      ELabelSelector in proj1 b1 &
       (ex b2 being Relation-like Function-like set st
          b1 . ELabelSelector = b2 & proj1 b2 c= the_Edges_of b1);

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

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

:: GLIB_003:def 6
theorem
for b1 being GraphStruct holds
      b1 is [VLabeled]
   iff
      VLabelSelector in proj1 b1 &
       (ex b2 being Relation-like Function-like set st
          b1 . VLabelSelector = b2 & proj1 b2 c= the_Vertices_of b1);

:: GLIB_003:exreg 1
registration
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
end;

:: GLIB_003:modenot 1
definition
  mode WGraph is [Graph-like] [Weighted] GraphStruct;
end;

:: GLIB_003:modenot 2
definition
  mode EGraph is [Graph-like] [ELabeled] GraphStruct;
end;

:: GLIB_003:modenot 3
definition
  mode VGraph is [Graph-like] [VLabeled] GraphStruct;
end;

:: GLIB_003:modenot 4
definition
  mode WEGraph is [Graph-like] [Weighted] [ELabeled] GraphStruct;
end;

:: GLIB_003:modenot 5
definition
  mode WVGraph is [Graph-like] [Weighted] [VLabeled] GraphStruct;
end;

:: GLIB_003:modenot 6
definition
  mode EVGraph is [Graph-like] [ELabeled] [VLabeled] GraphStruct;
end;

:: GLIB_003:modenot 7
definition
  mode WEVGraph is [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
end;

:: GLIB_003:funcnot 5 => GLIB_003:func 5
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  func the_Weight_of A1 -> ManySortedSet of the_Edges_of a1 equals
    a1 . WeightSelector;
end;

:: GLIB_003:def 7
theorem
for b1 being [Graph-like] [Weighted] GraphStruct holds
   the_Weight_of b1 = b1 . WeightSelector;

:: GLIB_003:funcnot 6 => GLIB_003:func 6
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  func the_ELabel_of A1 -> Relation-like Function-like set equals
    a1 . ELabelSelector;
end;

:: GLIB_003:def 8
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct holds
   the_ELabel_of b1 = b1 . ELabelSelector;

:: GLIB_003:funcnot 7 => GLIB_003:func 7
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  func the_VLabel_of A1 -> Relation-like Function-like set equals
    a1 . VLabelSelector;
end;

:: GLIB_003:def 9
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct holds
   the_VLabel_of b1 = b1 . VLabelSelector;

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

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

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

:: GLIB_003:funcreg 5
registration
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> finite;
end;

:: GLIB_003:funcreg 6
registration
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> finite;
end;

:: GLIB_003:funcreg 7
registration
  let a1 be [Graph-like] finite GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> finite;
end;

:: GLIB_003:funcreg 8
registration
  let a1 be [Graph-like] loopless GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> loopless;
end;

:: GLIB_003:funcreg 9
registration
  let a1 be [Graph-like] loopless GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> loopless;
end;

:: GLIB_003:funcreg 10
registration
  let a1 be [Graph-like] loopless GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> loopless;
end;

:: GLIB_003:funcreg 11
registration
  let a1 be [Graph-like] trivial GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> trivial;
end;

:: GLIB_003:funcreg 12
registration
  let a1 be [Graph-like] trivial GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> trivial;
end;

:: GLIB_003:funcreg 13
registration
  let a1 be [Graph-like] trivial GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> trivial;
end;

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

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

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

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

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

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

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

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

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

:: GLIB_003:funcreg 23
registration
  let a1 be [Graph-like] connected GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> connected;
end;

:: GLIB_003:funcreg 24
registration
  let a1 be [Graph-like] connected GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> connected;
end;

:: GLIB_003:funcreg 25
registration
  let a1 be [Graph-like] connected GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> connected;
end;

:: GLIB_003:funcreg 26
registration
  let a1 be [Graph-like] acyclic GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> acyclic;
end;

:: GLIB_003:funcreg 27
registration
  let a1 be [Graph-like] acyclic GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> acyclic;
end;

:: GLIB_003:funcreg 28
registration
  let a1 be [Graph-like] acyclic GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> acyclic;
end;

:: GLIB_003:funcreg 29
registration
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> [Weighted];
end;

:: GLIB_003:funcreg 30
registration
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> [Weighted];
end;

:: GLIB_003:funcreg 31
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be ManySortedSet of the_Edges_of a1;
  cluster a1 .set(WeightSelector,a2) -> [Weighted];
end;

:: GLIB_003:funcreg 32
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be non empty set;
  let a3 be Function-like quasi_total Relation of the_Edges_of a1,a2;
  cluster a1 .set(WeightSelector,a3) -> [Weighted];
end;

:: GLIB_003:funcreg 33
registration
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> [ELabeled];
end;

:: GLIB_003:funcreg 34
registration
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> [ELabeled];
end;

:: GLIB_003:funcreg 35
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  let a3 be Function-like Relation of the_Edges_of a1,a2;
  cluster a1 .set(ELabelSelector,a3) -> [ELabeled];
end;

:: GLIB_003:funcreg 36
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be ManySortedSet of the_Edges_of a1;
  cluster a1 .set(ELabelSelector,a2) -> [ELabeled];
end;

:: GLIB_003:funcreg 37
registration
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> [VLabeled];
end;

:: GLIB_003:funcreg 38
registration
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> [VLabeled];
end;

:: GLIB_003:funcreg 39
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be set;
  let a3 be Function-like Relation of the_Vertices_of a1,a2;
  cluster a1 .set(VLabelSelector,a3) -> [VLabeled];
end;

:: GLIB_003:funcreg 40
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be ManySortedSet of the_Vertices_of a1;
  cluster a1 .set(VLabelSelector,a2) -> [VLabeled];
end;

:: GLIB_003:funcreg 41
registration
  let a1 be [Graph-like] GraphStruct;
  cluster a1 .set(ELabelSelector,{}) -> [ELabeled];
end;

:: GLIB_003:funcreg 42
registration
  let a1 be [Graph-like] GraphStruct;
  cluster a1 .set(VLabelSelector,{}) -> [VLabeled];
end;

:: GLIB_003:exreg 2
registration
  let a1 be [Graph-like] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [ELabeled] [VLabeled] Subgraph of a1;
end;

:: GLIB_003:attrnot 4 => GLIB_003:attr 4
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be [Weighted] Subgraph of a1;
  attr a2 is weight-inheriting means
    the_Weight_of a2 = (the_Weight_of a1) | the_Edges_of a2;
end;

:: GLIB_003:dfs 10
definiens
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be [Weighted] Subgraph of a1;
To prove
     a2 is weight-inheriting
it is sufficient to prove
  thus the_Weight_of a2 = (the_Weight_of a1) | the_Edges_of a2;

:: GLIB_003:def 10
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being [Weighted] Subgraph of b1 holds
      b2 is weight-inheriting(b1)
   iff
      the_Weight_of b2 = (the_Weight_of b1) | the_Edges_of b2;

:: GLIB_003:attrnot 5 => GLIB_003:attr 5
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2 be [ELabeled] Subgraph of a1;
  attr a2 is elabel-inheriting means
    the_ELabel_of a2 = (the_ELabel_of a1) | the_Edges_of a2;
end;

:: GLIB_003:dfs 11
definiens
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2 be [ELabeled] Subgraph of a1;
To prove
     a2 is elabel-inheriting
it is sufficient to prove
  thus the_ELabel_of a2 = (the_ELabel_of a1) | the_Edges_of a2;

:: GLIB_003:def 11
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2 being [ELabeled] Subgraph of b1 holds
      b2 is elabel-inheriting(b1)
   iff
      the_ELabel_of b2 = (the_ELabel_of b1) | the_Edges_of b2;

:: GLIB_003:attrnot 6 => GLIB_003:attr 6
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2 be [VLabeled] Subgraph of a1;
  attr a2 is vlabel-inheriting means
    the_VLabel_of a2 = (the_VLabel_of a1) | the_Vertices_of a2;
end;

:: GLIB_003:dfs 12
definiens
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2 be [VLabeled] Subgraph of a1;
To prove
     a2 is vlabel-inheriting
it is sufficient to prove
  thus the_VLabel_of a2 = (the_VLabel_of a1) | the_Vertices_of a2;

:: GLIB_003:def 12
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2 being [VLabeled] Subgraph of b1 holds
      b2 is vlabel-inheriting(b1)
   iff
      the_VLabel_of b2 = (the_VLabel_of b1) | the_Vertices_of b2;

:: GLIB_003:exreg 3
registration
  let a1 be [Graph-like] [Weighted] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] weight-inheriting Subgraph of a1;
end;

:: GLIB_003:exreg 4
registration
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [ELabeled] elabel-inheriting Subgraph of a1;
end;

:: GLIB_003:exreg 5
registration
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [VLabeled] vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:exreg 6
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [ELabeled] weight-inheriting elabel-inheriting Subgraph of a1;
end;

:: GLIB_003:exreg 7
registration
  let a1 be [Graph-like] [Weighted] [VLabeled] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [VLabeled] weight-inheriting vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:exreg 8
registration
  let a1 be [Graph-like] [ELabeled] [VLabeled] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [ELabeled] [VLabeled] elabel-inheriting vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:exreg 9
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [ELabeled] [VLabeled] weight-inheriting elabel-inheriting vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 8
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  mode WSubgraph of a1 is [Weighted] weight-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 9
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  mode ESubgraph of a1 is [ELabeled] elabel-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 10
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  mode VSubgraph of a1 is [VLabeled] vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 11
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] GraphStruct;
  mode WESubgraph of a1 is [Weighted] [ELabeled] weight-inheriting elabel-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 12
definition
  let a1 be [Graph-like] [Weighted] [VLabeled] GraphStruct;
  mode WVSubgraph of a1 is [Weighted] [VLabeled] weight-inheriting vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 13
definition
  let a1 be [Graph-like] [ELabeled] [VLabeled] GraphStruct;
  mode EVSubgraph of a1 is [ELabeled] [VLabeled] elabel-inheriting vlabel-inheriting Subgraph of a1;
end;

:: GLIB_003:modenot 14
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
  mode WEVSubgraph of a1 is [Weighted] [ELabeled] [VLabeled] weight-inheriting elabel-inheriting vlabel-inheriting Subgraph of a1;
end;

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

:: GLIB_003:exreg 11
registration
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] weight-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:exreg 12
registration
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [ELabeled] elabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:exreg 13
registration
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [VLabeled] vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:exreg 14
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [ELabeled] weight-inheriting elabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:exreg 15
registration
  let a1 be [Graph-like] [Weighted] [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [VLabeled] weight-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:exreg 16
registration
  let a1 be [Graph-like] [ELabeled] [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [ELabeled] [VLabeled] elabel-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:exreg 17
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster Relation-like Function-like finite [Graph-like] [Weighted] [ELabeled] [VLabeled] weight-inheriting elabel-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 15
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2, a3 be set;
  mode inducedWSubgraph of a1,a2,a3 is [Weighted] weight-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 16
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2, a3 be set;
  mode inducedESubgraph of a1,a2,a3 is [ELabeled] elabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 17
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2, a3 be set;
  mode inducedVSubgraph of a1,a2,a3 is [VLabeled] vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 18
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] GraphStruct;
  let a2, a3 be set;
  mode inducedWESubgraph of a1,a2,a3 is [Weighted] [ELabeled] weight-inheriting elabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 19
definition
  let a1 be [Graph-like] [Weighted] [VLabeled] GraphStruct;
  let a2, a3 be set;
  mode inducedWVSubgraph of a1,a2,a3 is [Weighted] [VLabeled] weight-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 20
definition
  let a1 be [Graph-like] [ELabeled] [VLabeled] GraphStruct;
  let a2, a3 be set;
  mode inducedEVSubgraph of a1,a2,a3 is [ELabeled] [VLabeled] elabel-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 21
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
  let a2, a3 be set;
  mode inducedWEVSubgraph of a1,a2,a3 is [Weighted] [ELabeled] [VLabeled] weight-inheriting elabel-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a3;
end;

:: GLIB_003:modenot 22
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be set;
  mode inducedWSubgraph of a1,a2 is [Weighted] weight-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:modenot 23
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2 be set;
  mode inducedESubgraph of a1,a2 is [ELabeled] elabel-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:modenot 24
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2 be set;
  mode inducedVSubgraph of a1,a2 is [VLabeled] vlabel-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:modenot 25
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] GraphStruct;
  let a2 be set;
  mode inducedWESubgraph of a1,a2 is [Weighted] [ELabeled] weight-inheriting elabel-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:modenot 26
definition
  let a1 be [Graph-like] [Weighted] [VLabeled] GraphStruct;
  let a2 be set;
  mode inducedWVSubgraph of a1,a2 is [Weighted] [VLabeled] weight-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:modenot 27
definition
  let a1 be [Graph-like] [ELabeled] [VLabeled] GraphStruct;
  let a2 be set;
  mode inducedEVSubgraph of a1,a2 is [ELabeled] [VLabeled] elabel-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:modenot 28
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
  let a2 be set;
  mode inducedWEVSubgraph of a1,a2 is [Weighted] [ELabeled] [VLabeled] weight-inheriting elabel-inheriting vlabel-inheriting inducedSubgraph of a1,a2,a1 .edgesBetween a2;
end;

:: GLIB_003:attrnot 7 => GLIB_003:attr 7
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  attr a1 is real-weighted means
    the_Weight_of a1 is real-valued;
end;

:: GLIB_003:dfs 13
definiens
  let a1 be [Graph-like] [Weighted] GraphStruct;
To prove
     a1 is real-weighted
it is sufficient to prove
  thus the_Weight_of a1 is real-valued;

:: GLIB_003:def 13
theorem
for b1 being [Graph-like] [Weighted] GraphStruct holds
      b1 is real-weighted
   iff
      the_Weight_of b1 is real-valued;

:: GLIB_003:attrnot 8 => GLIB_003:attr 8
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  attr a1 is nonnegative-weighted means
    proj2 the_Weight_of a1 c= Real>=0;
end;

:: GLIB_003:dfs 14
definiens
  let a1 be [Graph-like] [Weighted] GraphStruct;
To prove
     a1 is nonnegative-weighted
it is sufficient to prove
  thus proj2 the_Weight_of a1 c= Real>=0;

:: GLIB_003:def 14
theorem
for b1 being [Graph-like] [Weighted] GraphStruct holds
      b1 is nonnegative-weighted
   iff
      proj2 the_Weight_of b1 c= Real>=0;

:: GLIB_003:condreg 1
registration
  cluster [Graph-like] [Weighted] nonnegative-weighted -> real-weighted (GraphStruct);
end;

:: GLIB_003:attrnot 9 => GLIB_003:attr 9
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  attr a1 is real-elabeled means
    the_ELabel_of a1 is real-valued;
end;

:: GLIB_003:dfs 15
definiens
  let a1 be [Graph-like] [ELabeled] GraphStruct;
To prove
     a1 is real-elabeled
it is sufficient to prove
  thus the_ELabel_of a1 is real-valued;

:: GLIB_003:def 15
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct holds
      b1 is real-elabeled
   iff
      the_ELabel_of b1 is real-valued;

:: GLIB_003:attrnot 10 => GLIB_003:attr 10
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  attr a1 is real-vlabeled means
    the_VLabel_of a1 is real-valued;
end;

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

:: GLIB_003:def 16
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct holds
      b1 is real-vlabeled
   iff
      the_VLabel_of b1 is real-valued;

:: GLIB_003:attrnot 11 => GLIB_003:attr 11
definition
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
  attr a1 is real-WEV means
    a1 is real-weighted & a1 is real-elabeled & a1 is real-vlabeled;
end;

:: GLIB_003:dfs 17
definiens
  let a1 be [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct;
To prove
     a1 is real-WEV
it is sufficient to prove
  thus a1 is real-weighted & a1 is real-elabeled & a1 is real-vlabeled;

:: GLIB_003:def 17
theorem
for b1 being [Graph-like] [Weighted] [ELabeled] [VLabeled] GraphStruct holds
      b1 is real-WEV
   iff
      b1 is real-weighted & b1 is real-elabeled & b1 is real-vlabeled;

:: GLIB_003:condreg 2
registration
  cluster [Graph-like] [Weighted] [ELabeled] [VLabeled] real-WEV -> real-weighted real-elabeled real-vlabeled (GraphStruct);
end;

:: GLIB_003:condreg 3
registration
  cluster [Graph-like] [Weighted] [ELabeled] [VLabeled] real-weighted real-elabeled real-vlabeled -> real-WEV (GraphStruct);
end;

:: GLIB_003:funcreg 43
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Function-like quasi_total Relation of the_Edges_of a1,REAL;
  cluster a1 .set(WeightSelector,a2) -> real-weighted;
end;

:: GLIB_003:funcreg 44
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Function-like Relation of the_Edges_of a1,REAL;
  cluster a1 .set(ELabelSelector,a2) -> real-elabeled;
end;

:: GLIB_003:funcreg 45
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be real-valued ManySortedSet of the_Edges_of a1;
  cluster a1 .set(ELabelSelector,a2) -> real-elabeled;
end;

:: GLIB_003:funcreg 46
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Function-like Relation of the_Vertices_of a1,REAL;
  cluster a1 .set(VLabelSelector,a2) -> real-vlabeled;
end;

:: GLIB_003:funcreg 47
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be real-valued ManySortedSet of the_Vertices_of a1;
  cluster a1 .set(VLabelSelector,a2) -> real-vlabeled;
end;

:: GLIB_003:funcreg 48
registration
  let a1 be [Graph-like] GraphStruct;
  cluster a1 .set(ELabelSelector,{}) -> real-elabeled;
end;

:: GLIB_003:funcreg 49
registration
  let a1 be [Graph-like] GraphStruct;
  cluster a1 .set(VLabelSelector,{}) -> real-vlabeled;
end;

:: GLIB_003:funcreg 50
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  let a3 be real set;
  cluster a1 .set(VLabelSelector,a2 .--> a3) -> [VLabeled];
end;

:: GLIB_003:funcreg 51
registration
  let a1 be [Graph-like] GraphStruct;
  let a2 be Element of the_Vertices_of a1;
  let a3 be real set;
  cluster a1 .set(VLabelSelector,a2 .--> a3) -> real-vlabeled;
end;

:: GLIB_003:exreg 18
registration
  cluster Relation-like Function-like finite [Graph-like] finite trivial Tree-like [Weighted] [ELabeled] [VLabeled] nonnegative-weighted real-WEV GraphStruct;
end;

:: GLIB_003:exreg 19
registration
  cluster Relation-like Function-like finite [Graph-like] finite non trivial Tree-like [Weighted] [ELabeled] [VLabeled] nonnegative-weighted real-WEV GraphStruct;
end;

:: GLIB_003:funcreg 52
registration
  let a1 be [Graph-like] finite [Weighted] GraphStruct;
  cluster the_Weight_of a1 -> finite;
end;

:: GLIB_003:funcreg 53
registration
  let a1 be [Graph-like] finite [ELabeled] GraphStruct;
  cluster the_ELabel_of a1 -> Relation-like Function-like finite;
end;

:: GLIB_003:funcreg 54
registration
  let a1 be [Graph-like] finite [VLabeled] GraphStruct;
  cluster the_VLabel_of a1 -> Relation-like Function-like finite;
end;

:: GLIB_003:funcreg 55
registration
  let a1 be [Graph-like] [Weighted] real-weighted GraphStruct;
  cluster the_Weight_of a1 -> real-valued;
end;

:: GLIB_003:funcreg 56
registration
  let a1 be [Graph-like] [ELabeled] real-elabeled GraphStruct;
  cluster the_ELabel_of a1 -> Relation-like Function-like real-valued;
end;

:: GLIB_003:funcreg 57
registration
  let a1 be [Graph-like] [VLabeled] real-vlabeled GraphStruct;
  cluster the_VLabel_of a1 -> Relation-like Function-like real-valued;
end;

:: GLIB_003:funcreg 58
registration
  let a1 be [Graph-like] [Weighted] real-weighted GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> real-weighted;
end;

:: GLIB_003:funcreg 59
registration
  let a1 be [Graph-like] [Weighted] real-weighted GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> real-weighted;
end;

:: GLIB_003:funcreg 60
registration
  let a1 be [Graph-like] [Weighted] nonnegative-weighted GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> nonnegative-weighted;
end;

:: GLIB_003:funcreg 61
registration
  let a1 be [Graph-like] [Weighted] nonnegative-weighted GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> nonnegative-weighted;
end;

:: GLIB_003:funcreg 62
registration
  let a1 be [Graph-like] [ELabeled] real-elabeled GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> real-elabeled;
end;

:: GLIB_003:funcreg 63
registration
  let a1 be [Graph-like] [ELabeled] real-elabeled GraphStruct;
  let a2 be set;
  cluster a1 .set(VLabelSelector,a2) -> real-elabeled;
end;

:: GLIB_003:funcreg 64
registration
  let a1 be [Graph-like] [VLabeled] real-vlabeled GraphStruct;
  let a2 be set;
  cluster a1 .set(WeightSelector,a2) -> real-vlabeled;
end;

:: GLIB_003:funcreg 65
registration
  let a1 be [Graph-like] [VLabeled] real-vlabeled GraphStruct;
  let a2 be set;
  cluster a1 .set(ELabelSelector,a2) -> real-vlabeled;
end;

:: GLIB_003:funcnot 8 => GLIB_003:func 8
definition
  let a1 be [Graph-like] [Weighted] GraphStruct;
  let a2 be Walk of a1;
  func A2 .weightSeq() -> Relation-like Function-like FinSequence-like set means
    len it = len (a2 .edgeSeq()) &
     (for b1 being natural set
           st 1 <= b1 & b1 <= len it
        holds it . b1 = (the_Weight_of a1) . (a2 .edgeSeq() . b1));
end;

:: GLIB_003:def 18
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being Walk of b1
for b3 being Relation-like Function-like FinSequence-like set holds
      b3 = b2 .weightSeq()
   iff
      len b3 = len (b2 .edgeSeq()) &
       (for b4 being natural set
             st 1 <= b4 & b4 <= len b3
          holds b3 . b4 = (the_Weight_of b1) . (b2 .edgeSeq() . b4));

:: GLIB_003:funcnot 9 => GLIB_003:func 9
definition
  let a1 be [Graph-like] [Weighted] real-weighted GraphStruct;
  let a2 be Walk of a1;
  redefine func a2 .weightSeq() -> FinSequence of REAL;
end;

:: GLIB_003:funcnot 10 => GLIB_003:func 10
definition
  let a1 be [Graph-like] [Weighted] real-weighted GraphStruct;
  let a2 be Walk of a1;
  func A2 .cost() -> Element of REAL equals
    Sum (a2 .weightSeq());
end;

:: GLIB_003:def 19
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2 being Walk of b1 holds
   b2 .cost() = Sum (b2 .weightSeq());

:: GLIB_003:funcnot 11 => GLIB_003:func 11
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  func A1 .labeledE() -> Element of bool the_Edges_of a1 equals
    proj1 the_ELabel_of a1;
end;

:: GLIB_003:def 20
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct holds
   b1 .labeledE() = proj1 the_ELabel_of b1;

:: GLIB_003:funcnot 12 => GLIB_003:func 12
definition
  let a1 be [Graph-like] [ELabeled] GraphStruct;
  let a2, a3 be set;
  func A1 .labelEdge(A2,A3) -> [Graph-like] [ELabeled] GraphStruct equals
    a1 .set(ELabelSelector,(the_ELabel_of a1) +* (a2 .--> a3))
    if a2 in the_Edges_of a1
    otherwise a1;
end;

:: GLIB_003:def 21
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set holds
(b2 in the_Edges_of b1 implies b1 .labelEdge(b2,b3) = b1 .set(ELabelSelector,(the_ELabel_of b1) +* (b2 .--> b3))) &
 (b2 in the_Edges_of b1 or b1 .labelEdge(b2,b3) = b1);

:: GLIB_003:funcreg 66
registration
  let a1 be [Graph-like] finite [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] finite [ELabeled];
end;

:: GLIB_003:funcreg 67
registration
  let a1 be [Graph-like] loopless [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] loopless [ELabeled];
end;

:: GLIB_003:funcreg 68
registration
  let a1 be [Graph-like] trivial [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] trivial [ELabeled];
end;

:: GLIB_003:funcreg 69
registration
  let a1 be [Graph-like] non trivial [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] non trivial [ELabeled];
end;

:: GLIB_003:funcreg 70
registration
  let a1 be [Graph-like] non-multi [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] non-multi [ELabeled];
end;

:: GLIB_003:funcreg 71
registration
  let a1 be [Graph-like] non-Dmulti [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] non-Dmulti [ELabeled];
end;

:: GLIB_003:funcreg 72
registration
  let a1 be [Graph-like] connected [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] connected [ELabeled];
end;

:: GLIB_003:funcreg 73
registration
  let a1 be [Graph-like] acyclic [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] acyclic [ELabeled];
end;

:: GLIB_003:funcreg 74
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] [Weighted] [ELabeled];
end;

:: GLIB_003:funcreg 75
registration
  let a1 be [Graph-like] [ELabeled] [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] [ELabeled] [VLabeled];
end;

:: GLIB_003:funcreg 76
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] real-weighted GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] [ELabeled] real-weighted;
end;

:: GLIB_003:funcreg 77
registration
  let a1 be [Graph-like] [Weighted] [ELabeled] nonnegative-weighted GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] [ELabeled] nonnegative-weighted;
end;

:: GLIB_003:funcreg 78
registration
  let a1 be [Graph-like] [ELabeled] real-elabeled GraphStruct;
  let a2 be set;
  let a3 be Element of REAL;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] [ELabeled] real-elabeled;
end;

:: GLIB_003:funcreg 79
registration
  let a1 be [Graph-like] [ELabeled] [VLabeled] real-vlabeled GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelEdge(a2,a3) -> [Graph-like] [ELabeled] real-vlabeled;
end;

:: GLIB_003:funcnot 13 => GLIB_003:func 13
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  let a2, a3 be set;
  func A1 .labelVertex(A2,A3) -> [Graph-like] [VLabeled] GraphStruct equals
    a1 .set(VLabelSelector,(the_VLabel_of a1) +* (a2 .--> a3))
    if a2 in the_Vertices_of a1
    otherwise a1;
end;

:: GLIB_003:def 22
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3 being set holds
(b2 in the_Vertices_of b1 implies b1 .labelVertex(b2,b3) = b1 .set(VLabelSelector,(the_VLabel_of b1) +* (b2 .--> b3))) &
 (b2 in the_Vertices_of b1 or b1 .labelVertex(b2,b3) = b1);

:: GLIB_003:funcnot 14 => GLIB_003:func 14
definition
  let a1 be [Graph-like] [VLabeled] GraphStruct;
  func A1 .labeledV() -> Element of bool the_Vertices_of a1 equals
    proj1 the_VLabel_of a1;
end;

:: GLIB_003:def 23
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct holds
   b1 .labeledV() = proj1 the_VLabel_of b1;

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

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

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

:: GLIB_003:funcreg 83
registration
  let a1 be [Graph-like] non trivial [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] non trivial [VLabeled];
end;

:: GLIB_003:funcreg 84
registration
  let a1 be [Graph-like] non-multi [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] non-multi [VLabeled];
end;

:: GLIB_003:funcreg 85
registration
  let a1 be [Graph-like] non-Dmulti [VLabeled] GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] non-Dmulti [VLabeled];
end;

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

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

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

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

:: GLIB_003:funcreg 90
registration
  let a1 be [Graph-like] [Weighted] [VLabeled] real-weighted GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] real-weighted;
end;

:: GLIB_003:funcreg 91
registration
  let a1 be [Graph-like] [Weighted] [VLabeled] nonnegative-weighted GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] nonnegative-weighted;
end;

:: GLIB_003:funcreg 92
registration
  let a1 be [Graph-like] [ELabeled] [VLabeled] real-elabeled GraphStruct;
  let a2, a3 be set;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] real-elabeled;
end;

:: GLIB_003:funcreg 93
registration
  let a1 be [Graph-like] [VLabeled] real-vlabeled GraphStruct;
  let a2 be set;
  let a3 be Element of REAL;
  cluster a1 .labelVertex(a2,a3) -> [Graph-like] [VLabeled] real-vlabeled;
end;

:: GLIB_003:condreg 4
registration
  let a1 be [Graph-like] [Weighted] real-weighted GraphStruct;
  cluster [Weighted] weight-inheriting -> real-weighted (Subgraph of a1);
end;

:: GLIB_003:condreg 5
registration
  let a1 be [Graph-like] [Weighted] nonnegative-weighted GraphStruct;
  cluster [Weighted] weight-inheriting -> nonnegative-weighted (Subgraph of a1);
end;

:: GLIB_003:condreg 6
registration
  let a1 be [Graph-like] [ELabeled] real-elabeled GraphStruct;
  cluster [ELabeled] elabel-inheriting -> real-elabeled (Subgraph of a1);
end;

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

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

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

:: GLIB_003:def 24
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is [Weighted]
   iff
      for b2 being natural set holds
         b1 . b2 is [Weighted];

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

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

:: GLIB_003:def 25
theorem
for b1 being Graph-yielding ManySortedSet of NAT holds
      b1 is [ELabeled]
   iff
      for b2 being natural set holds
         b1 . b2 is [ELabeled];

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

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

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

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

:: GLIB_003:modenot 29
definition
  mode WGraphSeq is Graph-yielding [Weighted] ManySortedSet of NAT;
end;

:: GLIB_003:modenot 30
definition
  mode EGraphSeq is Graph-yielding [ELabeled] ManySortedSet of NAT;
end;

:: GLIB_003:modenot 31
definition
  mode VGraphSeq is Graph-yielding [VLabeled] ManySortedSet of NAT;
end;

:: GLIB_003:modenot 32
definition
  mode WEGraphSeq is Graph-yielding [Weighted] [ELabeled] ManySortedSet of NAT;
end;

:: GLIB_003:modenot 33
definition
  mode WVGraphSeq is Graph-yielding [Weighted] [VLabeled] ManySortedSet of NAT;
end;

:: GLIB_003:modenot 34
definition
  mode EVGraphSeq is Graph-yielding [ELabeled] [VLabeled] ManySortedSet of NAT;
end;

:: GLIB_003:modenot 35
definition
  mode WEVGraphSeq is Graph-yielding [Weighted] [ELabeled] [VLabeled] ManySortedSet of NAT;
end;

:: GLIB_003:funcreg 94
registration
  let a1 be Graph-yielding [Weighted] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [Weighted];
end;

:: GLIB_003:funcreg 95
registration
  let a1 be Graph-yielding [ELabeled] ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [ELabeled];
end;

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

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

:: GLIB_003:dfs 27
definiens
  let a1 be Graph-yielding [Weighted] ManySortedSet of NAT;
To prove
     a1 is real-weighted
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is real-weighted;

:: GLIB_003:def 27
theorem
for b1 being Graph-yielding [Weighted] ManySortedSet of NAT holds
      b1 is real-weighted
   iff
      for b2 being natural set holds
         b1 . b2 is real-weighted;

:: GLIB_003:attrnot 16 => GLIB_003:attr 16
definition
  let a1 be Graph-yielding [Weighted] ManySortedSet of NAT;
  attr a1 is nonnegative-weighted means
    for b1 being natural set holds
       a1 . b1 is nonnegative-weighted;
end;

:: GLIB_003:dfs 28
definiens
  let a1 be Graph-yielding [Weighted] ManySortedSet of NAT;
To prove
     a1 is nonnegative-weighted
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is nonnegative-weighted;

:: GLIB_003:def 28
theorem
for b1 being Graph-yielding [Weighted] ManySortedSet of NAT holds
      b1 is nonnegative-weighted
   iff
      for b2 being natural set holds
         b1 . b2 is nonnegative-weighted;

:: GLIB_003:attrnot 17 => GLIB_003:attr 17
definition
  let a1 be Graph-yielding [ELabeled] ManySortedSet of NAT;
  attr a1 is real-elabeled means
    for b1 being natural set holds
       a1 . b1 is real-elabeled;
end;

:: GLIB_003:dfs 29
definiens
  let a1 be Graph-yielding [ELabeled] ManySortedSet of NAT;
To prove
     a1 is real-elabeled
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is real-elabeled;

:: GLIB_003:def 29
theorem
for b1 being Graph-yielding [ELabeled] ManySortedSet of NAT holds
      b1 is real-elabeled
   iff
      for b2 being natural set holds
         b1 . b2 is real-elabeled;

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

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

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

:: GLIB_003:attrnot 19 => GLIB_003:attr 19
definition
  let a1 be Graph-yielding [Weighted] [ELabeled] [VLabeled] ManySortedSet of NAT;
  attr a1 is real-WEV means
    for b1 being natural set holds
       a1 . b1 is real-WEV;
end;

:: GLIB_003:dfs 31
definiens
  let a1 be Graph-yielding [Weighted] [ELabeled] [VLabeled] ManySortedSet of NAT;
To prove
     a1 is real-WEV
it is sufficient to prove
  thus for b1 being natural set holds
       a1 . b1 is real-WEV;

:: GLIB_003:def 31
theorem
for b1 being Graph-yielding [Weighted] [ELabeled] [VLabeled] ManySortedSet of NAT holds
      b1 is real-WEV
   iff
      for b2 being natural set holds
         b1 . b2 is real-WEV;

:: GLIB_003:condreg 8
registration
  cluster Graph-yielding [Weighted] [ELabeled] [VLabeled] real-WEV -> real-weighted real-elabeled real-vlabeled (ManySortedSet of NAT);
end;

:: GLIB_003:condreg 9
registration
  cluster Graph-yielding [Weighted] [ELabeled] [VLabeled] real-weighted real-elabeled real-vlabeled -> real-WEV (ManySortedSet of NAT);
end;

:: GLIB_003:exreg 21
registration
  cluster Relation-like Function-like Graph-yielding halting finite loopless trivial non-multi simple Tree-like [Weighted] [ELabeled] [VLabeled] nonnegative-weighted real-WEV ManySortedSet of NAT;
end;

:: GLIB_003:funcreg 97
registration
  let a1 be Graph-yielding [Weighted] real-weighted ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [Weighted] real-weighted;
end;

:: GLIB_003:funcreg 98
registration
  let a1 be Graph-yielding [Weighted] nonnegative-weighted ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [Weighted] nonnegative-weighted;
end;

:: GLIB_003:funcreg 99
registration
  let a1 be Graph-yielding [ELabeled] real-elabeled ManySortedSet of NAT;
  let a2 be natural set;
  cluster a1 . a2 -> [Graph-like] [ELabeled] real-elabeled;
end;

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

:: GLIB_003:th 3
theorem
WeightSelector = 5 & ELabelSelector = 6 & VLabelSelector = 7;

:: GLIB_003:th 4
theorem
(for b1 being [Graph-like] [Weighted] GraphStruct holds
    the_Weight_of b1 = b1 . WeightSelector) &
 (for b1 being [Graph-like] [ELabeled] GraphStruct holds
    the_ELabel_of b1 = b1 . ELabelSelector) &
 (for b1 being [Graph-like] [VLabeled] GraphStruct holds
    the_VLabel_of b1 = b1 . VLabelSelector);

:: GLIB_003:th 6
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct holds
   proj1 the_ELabel_of b1 c= the_Edges_of b1;

:: GLIB_003:th 7
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct holds
   proj1 the_VLabel_of b1 c= the_Vertices_of b1;

:: GLIB_003:th 8
theorem
for b1 being [Graph-like] GraphStruct
for b2 being set holds
   b1 == b1 .set(WeightSelector,b2) & b1 == b1 .set(ELabelSelector,b2) & b1 == b1 .set(VLabelSelector,b2);

:: GLIB_003:th 15
theorem
for b1, b2, b3 being [Graph-like] [Weighted] GraphStruct
      st b1 == b2 & the_Weight_of b1 = the_Weight_of b2 & b1 is [Weighted] weight-inheriting Subgraph of b3
   holds b2 is [Weighted] weight-inheriting Subgraph of b3;

:: GLIB_003:th 16
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being [Weighted] weight-inheriting Subgraph of b1
for b3 being [Weighted] weight-inheriting Subgraph of b2 holds
   b3 is [Weighted] weight-inheriting Subgraph of b1;

:: GLIB_003:th 17
theorem
for b1, b2 being [Graph-like] [Weighted] GraphStruct
for b3 being [Weighted] weight-inheriting Subgraph of b1
      st b1 == b2 & the_Weight_of b1 = the_Weight_of b2
   holds b3 is [Weighted] weight-inheriting Subgraph of b2;

:: GLIB_003:th 18
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being [Weighted] weight-inheriting Subgraph of b1
for b3 being set
      st b3 in the_Edges_of b2
   holds (the_Weight_of b2) . b3 = (the_Weight_of b1) . b3;

:: GLIB_003:th 19
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being Walk of b1
      st b2 is trivial(b1)
   holds b2 .weightSeq() = {};

:: GLIB_003:th 20
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being Walk of b1 holds
   len (b2 .weightSeq()) = b2 .length();

:: GLIB_003:th 21
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2, b3, b4 being set
      st b4 Joins b2,b3,b1
   holds (b1 .walkOf(b2,b4,b3)) .weightSeq() = <*(the_Weight_of b1) . b4*>;

:: GLIB_003:th 22
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being Walk of b1 holds
   b2 .reverse() .weightSeq() = Rev (b2 .weightSeq());

:: GLIB_003:th 23
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (b2 .append b3) .weightSeq() = b2 .weightSeq() ^ (b3 .weightSeq());

:: GLIB_003:th 24
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being Walk of b1
for b3 being set
      st b3 in b2 .last() .edgesInOut()
   holds (b2 .addEdge b3) .weightSeq() = b2 .weightSeq() ^ <*(the_Weight_of b1) . b3*>;

:: GLIB_003:th 25
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2 being Walk of b1
for b3 being Subwalk of b2 holds
   ex b4 being Element of bool (b2 .weightSeq()) st
      b3 .weightSeq() = Seq b4;

:: GLIB_003:th 26
theorem
for b1, b2 being [Graph-like] [Weighted] GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4 & the_Weight_of b1 = the_Weight_of b2
   holds b3 .weightSeq() = b4 .weightSeq();

:: GLIB_003:th 27
theorem
for b1 being [Graph-like] [Weighted] GraphStruct
for b2 being [Weighted] weight-inheriting Subgraph of b1
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .weightSeq() = b4 .weightSeq();

:: GLIB_003:th 28
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2 being Walk of b1
      st b2 is trivial(b1)
   holds b2 .cost() = 0;

:: GLIB_003:th 29
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2, b3 being Element of the_Vertices_of b1
for b4 being set
      st b4 Joins b2,b3,b1
   holds (b1 .walkOf(b2,b4,b3)) .cost() = (the_Weight_of b1) . b4;

:: GLIB_003:th 30
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2 being Walk of b1 holds
   b2 .cost() = b2 .reverse() .cost();

:: GLIB_003:th 31
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2, b3 being Walk of b1
      st b2 .last() = b3 .first()
   holds (b2 .append b3) .cost() = b2 .cost() + (b3 .cost());

:: GLIB_003:th 32
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2 being Walk of b1
for b3 being set
      st b3 in b2 .last() .edgesInOut()
   holds (b2 .addEdge b3) .cost() = b2 .cost() + ((the_Weight_of b1) . b3);

:: GLIB_003:th 33
theorem
for b1, b2 being [Graph-like] [Weighted] real-weighted GraphStruct
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4 & the_Weight_of b1 = the_Weight_of b2
   holds b3 .cost() = b4 .cost();

:: GLIB_003:th 34
theorem
for b1 being [Graph-like] [Weighted] real-weighted GraphStruct
for b2 being [Weighted] weight-inheriting Subgraph of b1
for b3 being Walk of b1
for b4 being Walk of b2
      st b3 = b4
   holds b3 .cost() = b4 .cost();

:: GLIB_003:th 35
theorem
for b1 being [Graph-like] [Weighted] nonnegative-weighted GraphStruct
for b2 being Walk of b1
for b3 being Element of NAT
      st b3 in dom (b2 .weightSeq())
   holds 0 <= b2 .weightSeq() . b3;

:: GLIB_003:th 36
theorem
for b1 being [Graph-like] [Weighted] nonnegative-weighted GraphStruct
for b2 being Walk of b1 holds
   0 <= b2 .cost();

:: GLIB_003:th 37
theorem
for b1 being [Graph-like] [Weighted] nonnegative-weighted GraphStruct
for b2 being Walk of b1
for b3 being Subwalk of b2 holds
   b3 .cost() <= b2 .cost();

:: GLIB_003:th 38
theorem
for b1 being [Graph-like] [Weighted] nonnegative-weighted GraphStruct
for b2 being set
      st b2 in the_Edges_of b1
   holds 0 <= (the_Weight_of b1) . b2;

:: GLIB_003:th 39
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Edges_of b1
   holds the_ELabel_of (b1 .labelEdge(b2,b3)) = (the_ELabel_of b1) +* (b2 .--> b3);

:: GLIB_003:th 40
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Edges_of b1
   holds (the_ELabel_of (b1 .labelEdge(b2,b3))) . b2 = b3;

:: GLIB_003:th 41
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set holds
b1 == b1 .labelEdge(b2,b3);

:: GLIB_003:th 42
theorem
for b1 being [Graph-like] [Weighted] [ELabeled] GraphStruct
for b2, b3 being set holds
the_Weight_of b1 = the_Weight_of (b1 .labelEdge(b2,b3));

:: GLIB_003:th 43
theorem
for b1 being [Graph-like] [ELabeled] [VLabeled] GraphStruct
for b2, b3 being set holds
the_VLabel_of b1 = the_VLabel_of (b1 .labelEdge(b2,b3));

:: GLIB_003:th 44
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3, b4 being set
      st b2 <> b3
   holds (the_ELabel_of (b1 .labelEdge(b2,b4))) . b3 = (the_ELabel_of b1) . b3;

:: GLIB_003:th 45
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Vertices_of b1
   holds the_VLabel_of (b1 .labelVertex(b2,b3)) = (the_VLabel_of b1) +* (b2 .--> b3);

:: GLIB_003:th 46
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Vertices_of b1
   holds (the_VLabel_of (b1 .labelVertex(b2,b3))) . b2 = b3;

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

:: GLIB_003:th 48
theorem
for b1 being [Graph-like] [Weighted] [VLabeled] GraphStruct
for b2, b3 being set holds
the_Weight_of b1 = the_Weight_of (b1 .labelVertex(b2,b3));

:: GLIB_003:th 49
theorem
for b1 being [Graph-like] [ELabeled] [VLabeled] GraphStruct
for b2, b3 being set holds
the_ELabel_of b1 = the_ELabel_of (b1 .labelVertex(b2,b3));

:: GLIB_003:th 50
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3, b4 being set
      st b2 <> b3
   holds (the_VLabel_of (b1 .labelVertex(b2,b4))) . b3 = (the_VLabel_of b1) . b3;

:: GLIB_003:th 51
theorem
for b1, b2 being [Graph-like] [ELabeled] GraphStruct
      st the_ELabel_of b1 = the_ELabel_of b2
   holds b1 .labeledE() = b2 .labeledE();

:: GLIB_003:th 52
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Edges_of b1
   holds (b1 .labelEdge(b2,b3)) .labeledE() = b1 .labeledE() \/ {b2};

:: GLIB_003:th 53
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Edges_of b1
   holds b1 .labeledE() c= (b1 .labelEdge(b2,b3)) .labeledE();

:: GLIB_003:th 54
theorem
for b1 being [Graph-like] finite [ELabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Edges_of b1 & not b2 in b1 .labeledE()
   holds card ((b1 .labelEdge(b2,b3)) .labeledE()) = (card (b1 .labeledE())) + 1;

:: GLIB_003:th 55
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3, b4 being set
      st not b3 in b1 .labeledE() & b3 in (b1 .labelEdge(b2,b4)) .labeledE()
   holds b2 = b3 & b2 in the_Edges_of b1;

:: GLIB_003:th 56
theorem
for b1 being [Graph-like] [ELabeled] [VLabeled] GraphStruct
for b2, b3 being set holds
b1 .labeledE() = (b1 .labelVertex(b2,b3)) .labeledE();

:: GLIB_003:th 57
theorem
for b1 being [Graph-like] [ELabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Edges_of b1
   holds b2 in (b1 .labelEdge(b2,b3)) .labeledE();

:: GLIB_003:th 58
theorem
for b1, b2 being [Graph-like] [VLabeled] GraphStruct
      st the_VLabel_of b1 = the_VLabel_of b2
   holds b1 .labeledV() = b2 .labeledV();

:: GLIB_003:th 59
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Vertices_of b1
   holds (b1 .labelVertex(b2,b3)) .labeledV() = b1 .labeledV() \/ {b2};

:: GLIB_003:th 60
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Vertices_of b1
   holds b1 .labeledV() c= (b1 .labelVertex(b2,b3)) .labeledV();

:: GLIB_003:th 61
theorem
for b1 being [Graph-like] finite [VLabeled] GraphStruct
for b2, b3 being set
      st b2 in the_Vertices_of b1 & not b2 in b1 .labeledV()
   holds card ((b1 .labelVertex(b2,b3)) .labeledV()) = (card (b1 .labeledV())) + 1;

:: GLIB_003:th 62
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2, b3, b4 being set
      st not b3 in b1 .labeledV() & b3 in (b1 .labelVertex(b2,b4)) .labeledV()
   holds b2 = b3 & b2 in the_Vertices_of b1;

:: GLIB_003:th 63
theorem
for b1 being [Graph-like] [ELabeled] [VLabeled] GraphStruct
for b2, b3 being set holds
b1 .labeledV() = (b1 .labelEdge(b2,b3)) .labeledV();

:: GLIB_003:th 64
theorem
for b1 being [Graph-like] [VLabeled] GraphStruct
for b2 being Element of the_Vertices_of b1
for b3 being set holds
   b2 in (b1 .labelVertex(b2,b3)) .labeledV();