Article YELLOW_6, MML version 4.99.1005

:: YELLOW_6:funcnot 1 => YELLOW_6:func 1
definition
  let a1 be Relation-like Function-like set;
  assume a1 is not empty & a1 is constant;
  func the_value_of A1 -> set means
    ex b1 being set st
       b1 in proj1 a1 & it = a1 . b1;
end;

:: YELLOW_6:def 1
theorem
for b1 being Relation-like Function-like set
   st b1 is not empty & b1 is constant
for b2 being set holds
      b2 = the_value_of b1
   iff
      ex b3 being set st
         b3 in proj1 b1 & b2 = b1 . b3;

:: YELLOW_6:exreg 1
registration
  cluster Relation-like Function-like constant non empty set;
end;

:: YELLOW_6:th 2
theorem
for b1 being non empty set
for b2 being set holds
   the_value_of (b1 --> b2) = b2;

:: YELLOW_6:condreg 1
registration
  cluster universal -> epsilon-transitive being_Tarski-Class (set);
end;

:: YELLOW_6:condreg 2
registration
  cluster epsilon-transitive being_Tarski-Class -> universal (set);
end;

:: YELLOW_6:funcnot 2 => YELLOW_6:func 2
definition
  let a1 be set;
  func the_universe_of A1 -> set equals
    Tarski-Class the_transitive-closure_of a1;
end;

:: YELLOW_6:def 3
theorem
for b1 being set holds
   the_universe_of b1 = Tarski-Class the_transitive-closure_of b1;

:: YELLOW_6:funcreg 1
registration
  let a1 be set;
  cluster the_universe_of a1 -> epsilon-transitive being_Tarski-Class;
end;

:: YELLOW_6:funcreg 2
registration
  let a1 be set;
  cluster the_universe_of a1 -> non empty universal;
end;

:: YELLOW_6:th 5
theorem
for b1 being non empty universal set
for b2 being Relation-like Function-like set
      st proj1 b2 in b1 & proj2 b2 c= b1
   holds product b2 in b1;

:: YELLOW_6:th 9
theorem
for b1 being non empty set
for b2 being 1-sorted-yielding ManySortedSet of b1
for b3 being Element of b1 holds
   (Carrier b2) . b3 = the carrier of b2 . b3;

:: YELLOW_6:exreg 2
registration
  cluster Relation-like Function-like constant non empty 1-sorted-yielding set;
end;

:: YELLOW_6:attrnot 1 => WAYBEL_3:attr 4
notation
  let a1 be Relation-like Function-like 1-sorted-yielding set;
  synonym yielding_non-empty_carriers for non-Empty;
end;

:: YELLOW_6:attrnot 2 => WAYBEL_3:attr 4
definition
  let a1 be Relation-like set;
  attr a1 is yielding_non-empty_carriers means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty 1-sorted;
end;

:: YELLOW_6:dfs 3
definiens
  let a1 be Relation-like Function-like 1-sorted-yielding set;
To prove
     a1 is non-Empty
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty 1-sorted;

:: YELLOW_6:def 4
theorem
for b1 being Relation-like Function-like 1-sorted-yielding set holds
      b1 is non-Empty
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is non empty 1-sorted;

:: YELLOW_6:funcreg 3
registration
  let a1 be set;
  let a2 be 1-sorted;
  cluster a1 --> a2 -> 1-sorted-yielding;
end;

:: YELLOW_6:exreg 3
registration
  let a1 be set;
  cluster Relation-like Function-like 1-sorted-yielding non-Empty ManySortedSet of a1;
end;

:: YELLOW_6:funcreg 4
registration
  let a1 be non empty set;
  let a2 be RelStr-yielding ManySortedSet of a1;
  cluster the carrier of product a2 -> functional;
end;

:: YELLOW_6:funcreg 5
registration
  let a1 be set;
  let a2 be 1-sorted-yielding non-Empty ManySortedSet of a1;
  cluster Carrier a2 -> non-empty;
end;

:: YELLOW_6:funcreg 6
registration
  let a1 be non empty RelStr;
  let a2 be lower Element of bool the carrier of a1;
  cluster a2 ` -> upper;
end;

:: YELLOW_6:funcreg 7
registration
  let a1 be non empty RelStr;
  let a2 be upper Element of bool the carrier of a1;
  cluster a2 ` -> lower;
end;

:: YELLOW_6:attrnot 3 => WAYBEL_0:attr 7
definition
  let a1 be RelStr;
  attr a1 is directed means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 <= b3 & b2 <= b3;
end;

:: YELLOW_6:dfs 4
definiens
  let a1 be non empty RelStr;
To prove
     a1 is directed
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 <= b3 & b2 <= b3;

:: YELLOW_6:def 5
theorem
for b1 being non empty RelStr holds
      b1 is directed
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being Element of the carrier of b1 st
         b2 <= b4 & b3 <= b4;

:: YELLOW_6:funcreg 8
registration
  let a1 be set;
  cluster BoolePoset a1 -> strict directed;
end;

:: YELLOW_6:exreg 4
registration
  cluster non empty strict transitive directed RelStr;
end;

:: YELLOW_6:funcnot 3 => YELLOW_6:func 3
definition
  let a1 be non empty set;
  let a2 be non empty RelStr;
  let a3 be Function-like quasi_total Relation of a1,the carrier of a2;
  let a4 be Element of a1;
  redefine func a3 . a4 -> Element of the carrier of a2;
end;

:: YELLOW_6:exreg 5
registration
  let a1 be set;
  cluster Relation-like Function-like 1-sorted-yielding RelStr-yielding non-Empty ManySortedSet of a1;
end;

:: YELLOW_6:funcreg 9
registration
  let a1 be non empty set;
  let a2 be RelStr-yielding non-Empty ManySortedSet of a1;
  cluster product a2 -> non empty strict;
end;

:: YELLOW_6:funcreg 10
registration
  let a1, a2 be directed RelStr;
  cluster [:a1,a2:] -> strict directed;
end;

:: YELLOW_6:th 12
theorem
for b1 being RelStr holds
   the carrier of b1 = the carrier of b1 ~;

:: YELLOW_6:attrnot 4 => YELLOW_6:attr 1
definition
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  attr a2 is constant means
    the mapping of a2 is constant;
end;

:: YELLOW_6:dfs 5
definiens
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
To prove
     a2 is constant
it is sufficient to prove
  thus the mapping of a2 is constant;

:: YELLOW_6:def 6
theorem
for b1 being 1-sorted
for b2 being NetStr over b1 holds
      b2 is constant(b1)
   iff
      the mapping of b2 is constant;

:: YELLOW_6:funcnot 4 => YELLOW_6:func 4
definition
  let a1 be RelStr;
  let a2 be non empty 1-sorted;
  let a3 be Element of the carrier of a2;
  func A1 --> A3 -> strict NetStr over a2 means
    RelStr(#the carrier of it,the InternalRel of it#) = RelStr(#the carrier of a1,the InternalRel of a1#) &
     the mapping of it = (the carrier of it) --> a3;
end;

:: YELLOW_6:def 7
theorem
for b1 being RelStr
for b2 being non empty 1-sorted
for b3 being Element of the carrier of b2
for b4 being strict NetStr over b2 holds
      b4 = b1 --> b3
   iff
      RelStr(#the carrier of b4,the InternalRel of b4#) = RelStr(#the carrier of b1,the InternalRel of b1#) &
       the mapping of b4 = (the carrier of b4) --> b3;

:: YELLOW_6:funcreg 11
registration
  let a1 be RelStr;
  let a2 be non empty 1-sorted;
  let a3 be Element of the carrier of a2;
  cluster a1 --> a3 -> strict constant;
end;

:: YELLOW_6:funcreg 12
registration
  let a1 be non empty RelStr;
  let a2 be non empty 1-sorted;
  let a3 be Element of the carrier of a2;
  cluster a1 --> a3 -> non empty strict;
end;

:: YELLOW_6:funcreg 13
registration
  let a1 be non empty directed RelStr;
  let a2 be non empty 1-sorted;
  let a3 be Element of the carrier of a2;
  cluster a1 --> a3 -> strict directed;
end;

:: YELLOW_6:funcreg 14
registration
  let a1 be non empty transitive RelStr;
  let a2 be non empty 1-sorted;
  let a3 be Element of the carrier of a2;
  cluster a1 --> a3 -> transitive strict;
end;

:: YELLOW_6:th 13
theorem
for b1 being RelStr
for b2 being non empty 1-sorted
for b3 being Element of the carrier of b2 holds
   the carrier of b1 --> b3 = the carrier of b1;

:: YELLOW_6:th 14
theorem
for b1 being non empty RelStr
for b2 being non empty 1-sorted
for b3 being Element of the carrier of b2
for b4 being Element of the carrier of b1 --> b3 holds
   (b1 --> b3) . b4 = b3;

:: YELLOW_6:funcreg 15
registration
  let a1 be non empty 1-sorted;
  let a2 be non empty NetStr over a1;
  cluster the mapping of a2 -> Function-like non empty quasi_total;
end;

:: YELLOW_6:th 15
theorem
for b1 being RelStr holds
   b1 is full SubRelStr of b1;

:: YELLOW_6:th 16
theorem
for b1 being RelStr
for b2 being SubRelStr of b1
for b3 being SubRelStr of b2 holds
   b3 is SubRelStr of b1;

:: YELLOW_6:modenot 1 => YELLOW_6:mode 1
definition
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  mode SubNetStr of A2 -> NetStr over a1 means
    it is SubRelStr of a2 & the mapping of it = (the mapping of a2) | the carrier of it;
end;

:: YELLOW_6:dfs 7
definiens
  let a1 be 1-sorted;
  let a2, a3 be NetStr over a1;
To prove
     a3 is SubNetStr of a2
it is sufficient to prove
  thus a3 is SubRelStr of a2 &
     the mapping of a3 = (the mapping of a2) | the carrier of a3;

:: YELLOW_6:def 8
theorem
for b1 being 1-sorted
for b2, b3 being NetStr over b1 holds
   b3 is SubNetStr of b2
iff
   b3 is SubRelStr of b2 &
    the mapping of b3 = (the mapping of b2) | the carrier of b3;

:: YELLOW_6:th 17
theorem
for b1 being 1-sorted
for b2 being NetStr over b1 holds
   b2 is SubNetStr of b2;

:: YELLOW_6:th 18
theorem
for b1 being 1-sorted
for b2 being NetStr over b1
for b3 being SubNetStr of b2
for b4 being SubNetStr of b3 holds
   b4 is SubNetStr of b2;

:: YELLOW_6:attrnot 5 => YELLOW_6:attr 2
definition
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  let a3 be SubNetStr of a2;
  attr a3 is full means
    a3 is full SubRelStr of a2;
end;

:: YELLOW_6:dfs 8
definiens
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  let a3 be SubNetStr of a2;
To prove
     a3 is full
it is sufficient to prove
  thus a3 is full SubRelStr of a2;

:: YELLOW_6:def 9
theorem
for b1 being 1-sorted
for b2 being NetStr over b1
for b3 being SubNetStr of b2 holds
      b3 is full(b1, b2)
   iff
      b3 is full SubRelStr of b2;

:: YELLOW_6:exreg 6
registration
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  cluster strict full SubNetStr of a2;
end;

:: YELLOW_6:exreg 7
registration
  let a1 be 1-sorted;
  let a2 be non empty NetStr over a1;
  cluster non empty strict full SubNetStr of a2;
end;

:: YELLOW_6:th 19
theorem
for b1 being 1-sorted
for b2 being NetStr over b1
for b3 being SubNetStr of b2 holds
   the carrier of b3 c= the carrier of b2;

:: YELLOW_6:th 20
theorem
for b1 being 1-sorted
for b2 being NetStr over b1
for b3 being SubNetStr of b2
for b4, b5 being Element of the carrier of b2
for b6, b7 being Element of the carrier of b3
      st b4 = b6 & b5 = b7 & b6 <= b7
   holds b4 <= b5;

:: YELLOW_6:th 21
theorem
for b1 being 1-sorted
for b2 being non empty NetStr over b1
for b3 being non empty full SubNetStr of b2
for b4, b5 being Element of the carrier of b2
for b6, b7 being Element of the carrier of b3
      st b4 = b6 & b5 = b7 & b4 <= b5
   holds b6 <= b7;

:: YELLOW_6:exreg 8
registration
  let a1 be non empty 1-sorted;
  cluster non empty transitive strict directed constant NetStr over a1;
end;

:: YELLOW_6:funcreg 16
registration
  let a1 be non empty 1-sorted;
  let a2 be constant NetStr over a1;
  cluster the mapping of a2 -> Function-like constant quasi_total;
end;

:: YELLOW_6:funcnot 5 => YELLOW_6:func 5
definition
  let a1 be non empty 1-sorted;
  let a2 be NetStr over a1;
  assume a2 is constant(a1) & a2 is not empty;
  func the_value_of A2 -> Element of the carrier of a1 equals
    the_value_of the mapping of a2;
end;

:: YELLOW_6:def 10
theorem
for b1 being non empty 1-sorted
for b2 being NetStr over b1
      st b2 is constant(b1) & b2 is not empty
   holds the_value_of b2 = the_value_of the mapping of b2;

:: YELLOW_6:th 22
theorem
for b1 being non empty RelStr
for b2 being non empty 1-sorted
for b3 being Element of the carrier of b2 holds
   the_value_of (b1 --> b3) = b3;

:: YELLOW_6:modenot 2 => YELLOW_6:mode 2
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty transitive directed NetStr over a1;
  mode subnet of A2 -> non empty transitive directed NetStr over a1 means
    ex b1 being Function-like quasi_total Relation of the carrier of it,the carrier of a2 st
       the mapping of it = (the mapping of a2) * b1 &
        (for b2 being Element of the carrier of a2 holds
           ex b3 being Element of the carrier of it st
              for b4 being Element of the carrier of it
                    st b3 <= b4
                 holds b2 <= b1 . b4);
end;

:: YELLOW_6:dfs 10
definiens
  let a1 be non empty 1-sorted;
  let a2, a3 be non empty transitive directed NetStr over a1;
To prove
     a3 is subnet of a2
it is sufficient to prove
  thus ex b1 being Function-like quasi_total Relation of the carrier of a3,the carrier of a2 st
       the mapping of a3 = (the mapping of a2) * b1 &
        (for b2 being Element of the carrier of a2 holds
           ex b3 being Element of the carrier of a3 st
              for b4 being Element of the carrier of a3
                    st b3 <= b4
                 holds b2 <= b1 . b4);

:: YELLOW_6:def 12
theorem
for b1 being non empty 1-sorted
for b2, b3 being non empty transitive directed NetStr over b1 holds
   b3 is subnet of b2
iff
   ex b4 being Function-like quasi_total Relation of the carrier of b3,the carrier of b2 st
      the mapping of b3 = (the mapping of b2) * b4 &
       (for b5 being Element of the carrier of b2 holds
          ex b6 being Element of the carrier of b3 st
             for b7 being Element of the carrier of b3
                   st b6 <= b7
                holds b5 <= b4 . b7);

:: YELLOW_6:th 23
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1 holds
   b2 is subnet of b2;

:: YELLOW_6:th 24
theorem
for b1 being non empty 1-sorted
for b2, b3, b4 being non empty transitive directed NetStr over b1
      st b2 is subnet of b3 & b3 is subnet of b4
   holds b2 is subnet of b4;

:: YELLOW_6:th 25
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed constant NetStr over b1
for b3 being Element of the carrier of b2 holds
   b2 . b3 = the_value_of b2;

:: YELLOW_6:th 26
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3, b4 being set
      st b2 is_eventually_in b3 & b2 is_eventually_in b4
   holds b3 meets b4;

:: YELLOW_6:th 27
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being subnet of b2
for b4 being set
      st b3 is_often_in b4
   holds b2 is_often_in b4;

:: YELLOW_6:th 28
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being set
      st b2 is_eventually_in b3
   holds b2 is_often_in b3;

:: YELLOW_6:th 29
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1 holds
   b2 is_eventually_in the carrier of b1;

:: YELLOW_6:funcnot 6 => YELLOW_6:func 6
definition
  let a1 be 1-sorted;
  let a2 be NetStr over a1;
  let a3 be set;
  func A2 " A3 -> strict SubNetStr of a2 means
    it is full SubRelStr of a2 & the carrier of it = (the mapping of a2) " a3;
end;

:: YELLOW_6:def 13
theorem
for b1 being 1-sorted
for b2 being NetStr over b1
for b3 being set
for b4 being strict SubNetStr of b2 holds
      b4 = b2 " b3
   iff
      b4 is full SubRelStr of b2 & the carrier of b4 = (the mapping of b2) " b3;

:: YELLOW_6:funcreg 17
registration
  let a1 be 1-sorted;
  let a2 be transitive NetStr over a1;
  let a3 be set;
  cluster a2 " a3 -> transitive strict full;
end;

:: YELLOW_6:th 30
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being set
      st b2 is_often_in b3
   holds b2 " b3 is not empty & b2 " b3 is directed;

:: YELLOW_6:th 31
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being set
      st b2 is_often_in b3
   holds b2 " b3 is subnet of b2;

:: YELLOW_6:th 32
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being set
for b4 being subnet of b2
      st b4 = b2 " b3
   holds b4 is_eventually_in b3;

:: YELLOW_6:funcnot 7 => YELLOW_6:func 7
definition
  let a1 be non empty 1-sorted;
  func NetUniv A1 -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being non empty transitive strict directed NetStr over a1 st
             b2 = b1 & the carrier of b2 in the_universe_of the carrier of a1;
end;

:: YELLOW_6:def 14
theorem
for b1 being non empty 1-sorted
for b2 being set holds
      b2 = NetUniv b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            ex b4 being non empty transitive strict directed NetStr over b1 st
               b4 = b3 & the carrier of b4 in the_universe_of the carrier of b1;

:: YELLOW_6:funcreg 18
registration
  let a1 be non empty 1-sorted;
  cluster NetUniv a1 -> non empty;
end;

:: YELLOW_6:modenot 3 => YELLOW_6:mode 3
definition
  let a1 be set;
  let a2 be 1-sorted;
  mode net_set of A1,A2 -> ManySortedSet of a1 means
    for b1 being set
          st b1 in proj2 it
       holds b1 is non empty transitive directed NetStr over a2;
end;

:: YELLOW_6:dfs 13
definiens
  let a1 be set;
  let a2 be 1-sorted;
  let a3 be ManySortedSet of a1;
To prove
     a3 is net_set of a1,a2
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a3
       holds b1 is non empty transitive directed NetStr over a2;

:: YELLOW_6:def 15
theorem
for b1 being set
for b2 being 1-sorted
for b3 being ManySortedSet of b1 holds
      b3 is net_set of b1,b2
   iff
      for b4 being set
            st b4 in proj2 b3
         holds b4 is non empty transitive directed NetStr over b2;

:: YELLOW_6:th 33
theorem
for b1 being set
for b2 being 1-sorted
for b3 being ManySortedSet of b1 holds
      b3 is net_set of b1,b2
   iff
      for b4 being set
            st b4 in b1
         holds b3 . b4 is non empty transitive directed NetStr over b2;

:: YELLOW_6:funcnot 8 => YELLOW_6:func 8
definition
  let a1 be non empty set;
  let a2 be 1-sorted;
  let a3 be net_set of a1,a2;
  let a4 be Element of a1;
  redefine func a3 . a4 -> non empty transitive directed NetStr over a2;
end;

:: YELLOW_6:condreg 3
registration
  let a1 be set;
  let a2 be 1-sorted;
  cluster -> RelStr-yielding (net_set of a1,a2);
end;

:: YELLOW_6:condreg 4
registration
  let a1 be 1-sorted;
  let a2 be non empty transitive directed NetStr over a1;
  cluster -> non-Empty (net_set of the carrier of a2,a1);
end;

:: YELLOW_6:funcreg 19
registration
  let a1 be non empty 1-sorted;
  let a2 be non empty transitive directed NetStr over a1;
  let a3 be net_set of the carrier of a2,a1;
  cluster product a3 -> strict transitive directed;
end;

:: YELLOW_6:condreg 5
registration
  let a1 be set;
  let a2 be 1-sorted;
  cluster -> non-Empty (net_set of a1,a2);
end;

:: YELLOW_6:exreg 9
registration
  let a1 be set;
  let a2 be 1-sorted;
  cluster Relation-like Function-like 1-sorted-yielding RelStr-yielding non-Empty net_set of a1,a2;
end;

:: YELLOW_6:funcnot 9 => YELLOW_6:func 9
definition
  let a1 be non empty 1-sorted;
  let a2 be non empty transitive directed NetStr over a1;
  let a3 be net_set of the carrier of a2,a1;
  func Iterated A3 -> non empty transitive strict directed NetStr over a1 means
    RelStr(#the carrier of it,the InternalRel of it#) = [:a2,product a3:] &
     (for b1 being Element of the carrier of a2
     for b2 being Relation-like Function-like set
           st b1 in the carrier of a2 & b2 in the carrier of product a3
        holds (the mapping of it) .(b1,b2) = (the mapping of a3 . b1) . (b2 . b1));
end;

:: YELLOW_6:def 16
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being net_set of the carrier of b2,b1
for b4 being non empty transitive strict directed NetStr over b1 holds
      b4 = Iterated b3
   iff
      RelStr(#the carrier of b4,the InternalRel of b4#) = [:b2,product b3:] &
       (for b5 being Element of the carrier of b2
       for b6 being Relation-like Function-like set
             st b5 in the carrier of b2 & b6 in the carrier of product b3
          holds (the mapping of b4) .(b5,b6) = (the mapping of b3 . b5) . (b6 . b5));

:: YELLOW_6:th 34
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being net_set of the carrier of b2,b1
      st b2 in NetUniv b1 &
         (for b4 being Element of the carrier of b2 holds
            b3 . b4 in NetUniv b1)
   holds Iterated b3 in NetUniv b1;

:: YELLOW_6:th 35
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being net_set of the carrier of b2,b1 holds
   the carrier of Iterated b3 = [:the carrier of b2,product Carrier b3:];

:: YELLOW_6:th 36
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being net_set of the carrier of b2,b1
for b4 being Element of the carrier of b2
for b5 being Element of the carrier of product b3
for b6 being Element of the carrier of Iterated b3
      st b6 = [b4,b5]
   holds (Iterated b3) . b6 = (the mapping of b3 . b4) . (b5 . b4);

:: YELLOW_6:th 37
theorem
for b1 being non empty 1-sorted
for b2 being non empty transitive directed NetStr over b1
for b3 being net_set of the carrier of b2,b1 holds
   rng the mapping of Iterated b3 c= union {rng the mapping of b3 . b4 where b4 is Element of the carrier of b2: TRUE};

:: YELLOW_6:funcnot 10 => YELLOW_6:func 10
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  func OpenNeighborhoods A2 -> RelStr equals
    (InclPoset {b1 where b1 is Element of bool the carrier of a1: a2 in b1 & b1 is open(a1)}) ~;
end;

:: YELLOW_6:def 17
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1 holds
   OpenNeighborhoods b2 = (InclPoset {b3 where b3 is Element of bool the carrier of b1: b2 in b3 & b3 is open(b1)}) ~;

:: YELLOW_6:funcreg 20
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  cluster OpenNeighborhoods a2 -> non empty;
end;

:: YELLOW_6:th 38
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1
for b3 being Element of the carrier of OpenNeighborhoods b2 holds
   ex b4 being Element of bool the carrier of b1 st
      b4 = b3 & b2 in b4 & b4 is open(b1);

:: YELLOW_6:th 39
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b3 in the carrier of OpenNeighborhoods b2
   iff
      b2 in b3 & b3 is open(b1);

:: YELLOW_6:th 40
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of the carrier of b1
for b3, b4 being Element of the carrier of OpenNeighborhoods b2 holds
   b3 <= b4
iff
   b4 c= b3;

:: YELLOW_6:funcreg 21
registration
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Element of the carrier of a1;
  cluster OpenNeighborhoods a2 -> transitive directed;
end;

:: YELLOW_6:funcnot 11 => YELLOW_6:func 11
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non empty transitive directed NetStr over a1;
  func Lim A2 -> Element of bool the carrier of a1 means
    for b1 being Element of the carrier of a1 holds
          b1 in it
       iff
          for b2 being a_neighborhood of b1 holds
             a2 is_eventually_in b2;
end;

:: YELLOW_6:def 18
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1
for b3 being Element of bool the carrier of b1 holds
      b3 = Lim b2
   iff
      for b4 being Element of the carrier of b1 holds
            b4 in b3
         iff
            for b5 being a_neighborhood of b4 holds
               b2 is_eventually_in b5;

:: YELLOW_6:th 41
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1
for b3 being subnet of b2 holds
   Lim b2 c= Lim b3;

:: YELLOW_6:th 42
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed constant NetStr over b1 holds
   the_value_of b2 in Lim b2;

:: YELLOW_6:th 43
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1
for b3 being Element of the carrier of b1
   st b3 in Lim b2
for b4 being Element of the carrier of b2 holds
   ex b5 being Element of bool the carrier of b1 st
      b5 = {b2 . b6 where b6 is Element of the carrier of b2: b4 <= b6} &
       b3 in Cl b5;

:: YELLOW_6:th 44
theorem
for b1 being non empty TopSpace-like TopStruct holds
      b1 is being_T2
   iff
      for b2 being non empty transitive directed NetStr over b1
      for b3, b4 being Element of the carrier of b1
            st b3 in Lim b2 & b4 in Lim b2
         holds b3 = b4;

:: YELLOW_6:funcreg 22
registration
  let a1 be non empty TopSpace-like being_T2 TopStruct;
  let a2 be non empty transitive directed NetStr over a1;
  cluster Lim a2 -> trivial;
end;

:: YELLOW_6:attrnot 6 => YELLOW_6:attr 3
definition
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non empty transitive directed NetStr over a1;
  attr a2 is convergent means
    Lim a2 <> {};
end;

:: YELLOW_6:dfs 17
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be non empty transitive directed NetStr over a1;
To prove
     a2 is convergent
it is sufficient to prove
  thus Lim a2 <> {};

:: YELLOW_6:def 19
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1 holds
      b2 is convergent(b1)
   iff
      Lim b2 <> {};

:: YELLOW_6:condreg 6
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty transitive directed constant -> convergent (NetStr over a1);
end;

:: YELLOW_6:exreg 10
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster non empty transitive strict directed convergent NetStr over a1;
end;

:: YELLOW_6:funcnot 12 => YELLOW_6:func 12
definition
  let a1 be non empty TopSpace-like being_T2 TopStruct;
  let a2 be non empty transitive directed convergent NetStr over a1;
  func lim A2 -> Element of the carrier of a1 means
    it in Lim a2;
end;

:: YELLOW_6:def 20
theorem
for b1 being non empty TopSpace-like being_T2 TopStruct
for b2 being non empty transitive directed convergent NetStr over b1
for b3 being Element of the carrier of b1 holds
      b3 = lim b2
   iff
      b3 in Lim b2;

:: YELLOW_6:th 45
theorem
for b1 being non empty TopSpace-like being_T2 TopStruct
for b2 being non empty transitive directed constant NetStr over b1 holds
   lim b2 = the_value_of b2;

:: YELLOW_6:th 46
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1
for b3 being Element of the carrier of b1
      st not b3 in Lim b2
   holds ex b4 being subnet of b2 st
      for b5 being subnet of b4 holds
         not b3 in Lim b5;

:: YELLOW_6:th 47
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1
   st b2 in NetUniv b1
for b3 being Element of the carrier of b1
      st not b3 in Lim b2
   holds ex b4 being subnet of b2 st
      b4 in NetUniv b1 &
       (for b5 being subnet of b4 holds
          not b3 in Lim b5);

:: YELLOW_6:th 48
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being non empty transitive directed NetStr over b1
for b3 being Element of the carrier of b1
   st b3 in Lim b2
for b4 being net_set of the carrier of b2,b1
      st for b5 being Element of the carrier of b2 holds
           b2 . b5 in Lim (b4 . b5)
   holds b3 in Lim Iterated b4;

:: YELLOW_6:modenot 4 => YELLOW_6:mode 4
definition
  let a1 be non empty 1-sorted;
  mode Convergence-Class of A1 means
    it c= [:NetUniv a1,the carrier of a1:];
end;

:: YELLOW_6:dfs 19
definiens
  let a1 be non empty 1-sorted;
  let a2 be set;
To prove
     a2 is Convergence-Class of a1
it is sufficient to prove
  thus a2 c= [:NetUniv a1,the carrier of a1:];

:: YELLOW_6:def 21
theorem
for b1 being non empty 1-sorted
for b2 being set holds
      b2 is Convergence-Class of b1
   iff
      b2 c= [:NetUniv b1,the carrier of b1:];

:: YELLOW_6:condreg 7
registration
  let a1 be non empty 1-sorted;
  cluster -> Relation-like (Convergence-Class of a1);
end;

:: YELLOW_6:funcnot 13 => YELLOW_6:func 13
definition
  let a1 be non empty TopSpace-like TopStruct;
  func Convergence A1 -> Convergence-Class of a1 means
    for b1 being non empty transitive directed NetStr over a1
    for b2 being Element of the carrier of a1 holds
          [b1,b2] in it
       iff
          b1 in NetUniv a1 & b2 in Lim b1;
end;

:: YELLOW_6:def 22
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Convergence-Class of b1 holds
      b2 = Convergence b1
   iff
      for b3 being non empty transitive directed NetStr over b1
      for b4 being Element of the carrier of b1 holds
            [b3,b4] in b2
         iff
            b3 in NetUniv b1 & b4 in Lim b3;

:: YELLOW_6:attrnot 7 => YELLOW_6:attr 4
definition
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  attr a2 is (CONSTANTS) means
    for b1 being non empty transitive directed constant NetStr over a1
          st b1 in NetUniv a1
       holds [b1,the_value_of b1] in a2;
end;

:: YELLOW_6:dfs 21
definiens
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
To prove
     a2 is (CONSTANTS)
it is sufficient to prove
  thus for b1 being non empty transitive directed constant NetStr over a1
          st b1 in NetUniv a1
       holds [b1,the_value_of b1] in a2;

:: YELLOW_6:def 23
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
      b2 is (CONSTANTS)(b1)
   iff
      for b3 being non empty transitive directed constant NetStr over b1
            st b3 in NetUniv b1
         holds [b3,the_value_of b3] in b2;

:: YELLOW_6:attrnot 8 => YELLOW_6:attr 5
definition
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  attr a2 is (SUBNETS) means
    for b1 being non empty transitive directed NetStr over a1
    for b2 being subnet of b1
       st b2 in NetUniv a1
    for b3 being Element of the carrier of a1
          st [b1,b3] in a2
       holds [b2,b3] in a2;
end;

:: YELLOW_6:dfs 22
definiens
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
To prove
     a2 is (SUBNETS)
it is sufficient to prove
  thus for b1 being non empty transitive directed NetStr over a1
    for b2 being subnet of b1
       st b2 in NetUniv a1
    for b3 being Element of the carrier of a1
          st [b1,b3] in a2
       holds [b2,b3] in a2;

:: YELLOW_6:def 24
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
      b2 is (SUBNETS)(b1)
   iff
      for b3 being non empty transitive directed NetStr over b1
      for b4 being subnet of b3
         st b4 in NetUniv b1
      for b5 being Element of the carrier of b1
            st [b3,b5] in b2
         holds [b4,b5] in b2;

:: YELLOW_6:attrnot 9 => YELLOW_6:attr 6
definition
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  attr a2 is (DIVERGENCE) means
    for b1 being non empty transitive directed NetStr over a1
    for b2 being Element of the carrier of a1
          st b1 in NetUniv a1 & not [b1,b2] in a2
       holds ex b3 being subnet of b1 st
          b3 in NetUniv a1 &
           (for b4 being subnet of b3 holds
              not [b4,b2] in a2);
end;

:: YELLOW_6:dfs 23
definiens
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
To prove
     a2 is (DIVERGENCE)
it is sufficient to prove
  thus for b1 being non empty transitive directed NetStr over a1
    for b2 being Element of the carrier of a1
          st b1 in NetUniv a1 & not [b1,b2] in a2
       holds ex b3 being subnet of b1 st
          b3 in NetUniv a1 &
           (for b4 being subnet of b3 holds
              not [b4,b2] in a2);

:: YELLOW_6:def 25
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
      b2 is (DIVERGENCE)(b1)
   iff
      for b3 being non empty transitive directed NetStr over b1
      for b4 being Element of the carrier of b1
            st b3 in NetUniv b1 & not [b3,b4] in b2
         holds ex b5 being subnet of b3 st
            b5 in NetUniv b1 &
             (for b6 being subnet of b5 holds
                not [b6,b4] in b2);

:: YELLOW_6:attrnot 10 => YELLOW_6:attr 7
definition
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  attr a2 is (ITERATED_LIMITS) means
    for b1 being non empty transitive directed NetStr over a1
    for b2 being Element of the carrier of a1
       st [b1,b2] in a2
    for b3 being net_set of the carrier of b1,a1
          st for b4 being Element of the carrier of b1 holds
               [b3 . b4,b1 . b4] in a2
       holds [Iterated b3,b2] in a2;
end;

:: YELLOW_6:dfs 24
definiens
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
To prove
     a2 is (ITERATED_LIMITS)
it is sufficient to prove
  thus for b1 being non empty transitive directed NetStr over a1
    for b2 being Element of the carrier of a1
       st [b1,b2] in a2
    for b3 being net_set of the carrier of b1,a1
          st for b4 being Element of the carrier of b1 holds
               [b3 . b4,b1 . b4] in a2
       holds [Iterated b3,b2] in a2;

:: YELLOW_6:def 26
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
      b2 is (ITERATED_LIMITS)(b1)
   iff
      for b3 being non empty transitive directed NetStr over b1
      for b4 being Element of the carrier of b1
         st [b3,b4] in b2
      for b5 being net_set of the carrier of b3,b1
            st for b6 being Element of the carrier of b3 holds
                 [b5 . b6,b3 . b6] in b2
         holds [Iterated b5,b4] in b2;

:: YELLOW_6:funcreg 23
registration
  let a1 be non empty TopSpace-like TopStruct;
  cluster Convergence a1 -> (CONSTANTS) (SUBNETS) (DIVERGENCE) (ITERATED_LIMITS);
end;

:: YELLOW_6:funcnot 14 => YELLOW_6:func 14
definition
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  func ConvergenceSpace A2 -> strict TopStruct means
    the carrier of it = the carrier of a1 &
     the topology of it = {b1 where b1 is Element of bool the carrier of a1: for b2 being Element of the carrier of a1
        st b2 in b1
     for b3 being non empty transitive directed NetStr over a1
           st [b3,b2] in a2
        holds b3 is_eventually_in b1};
end;

:: YELLOW_6:def 27
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1
for b3 being strict TopStruct holds
      b3 = ConvergenceSpace b2
   iff
      the carrier of b3 = the carrier of b1 &
       the topology of b3 = {b4 where b4 is Element of bool the carrier of b1: for b5 being Element of the carrier of b1
          st b5 in b4
       for b6 being non empty transitive directed NetStr over b1
             st [b6,b5] in b2
          holds b6 is_eventually_in b4};

:: YELLOW_6:funcreg 24
registration
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  cluster ConvergenceSpace a2 -> non empty strict;
end;

:: YELLOW_6:funcreg 25
registration
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  cluster ConvergenceSpace a2 -> strict TopSpace-like;
end;

:: YELLOW_6:th 49
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
   b2 c= Convergence ConvergenceSpace b2;

:: YELLOW_6:attrnot 11 => YELLOW_6:attr 8
definition
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
  attr a2 is topological means
    a2 is (CONSTANTS)(a1) & a2 is (SUBNETS)(a1) & a2 is (DIVERGENCE)(a1) & a2 is (ITERATED_LIMITS)(a1);
end;

:: YELLOW_6:dfs 26
definiens
  let a1 be non empty 1-sorted;
  let a2 be Convergence-Class of a1;
To prove
     a2 is topological
it is sufficient to prove
  thus a2 is (CONSTANTS)(a1) & a2 is (SUBNETS)(a1) & a2 is (DIVERGENCE)(a1) & a2 is (ITERATED_LIMITS)(a1);

:: YELLOW_6:def 28
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
      b2 is topological(b1)
   iff
      b2 is (CONSTANTS)(b1) & b2 is (SUBNETS)(b1) & b2 is (DIVERGENCE)(b1) & b2 is (ITERATED_LIMITS)(b1);

:: YELLOW_6:exreg 11
registration
  let a1 be non empty 1-sorted;
  cluster Relation-like non empty topological Convergence-Class of a1;
end;

:: YELLOW_6:condreg 8
registration
  let a1 be non empty 1-sorted;
  cluster topological -> (CONSTANTS) (SUBNETS) (DIVERGENCE) (ITERATED_LIMITS) (Convergence-Class of a1);
end;

:: YELLOW_6:condreg 9
registration
  let a1 be non empty 1-sorted;
  cluster (CONSTANTS) (SUBNETS) (DIVERGENCE) (ITERATED_LIMITS) -> topological (Convergence-Class of a1);
end;

:: YELLOW_6:th 50
theorem
for b1 being non empty 1-sorted
for b2 being topological Convergence-Class of b1
for b3 being Element of bool the carrier of ConvergenceSpace b2 holds
      b3 is open(ConvergenceSpace b2)
   iff
      for b4 being Element of the carrier of b1
         st b4 in b3
      for b5 being non empty transitive directed NetStr over b1
            st [b5,b4] in b2
         holds b5 is_eventually_in b3;

:: YELLOW_6:th 51
theorem
for b1 being non empty 1-sorted
for b2 being topological Convergence-Class of b1
for b3 being Element of bool the carrier of ConvergenceSpace b2 holds
      b3 is closed(ConvergenceSpace b2)
   iff
      for b4 being Element of the carrier of b1
      for b5 being non empty transitive directed NetStr over b1
            st [b5,b4] in b2 & b5 is_often_in b3
         holds b4 in b3;

:: YELLOW_6:th 52
theorem
for b1 being non empty 1-sorted
for b2 being topological Convergence-Class of b1
for b3 being Element of bool the carrier of ConvergenceSpace b2
for b4 being Element of the carrier of ConvergenceSpace b2
      st b4 in Cl b3
   holds ex b5 being non empty transitive directed NetStr over ConvergenceSpace b2 st
      [b5,b4] in b2 & rng the mapping of b5 c= b3 & b4 in Lim b5;

:: YELLOW_6:th 53
theorem
for b1 being non empty 1-sorted
for b2 being Convergence-Class of b1 holds
      Convergence ConvergenceSpace b2 = b2
   iff
      b2 is topological(b1);