Article CLOSURE1, MML version 4.99.1005

:: CLOSURE1:sch 1
scheme CLOSURE1:sch 1
{F1 -> set,
  F2 -> non-empty ManySortedSet of F1(),
  F3 -> ManySortedSet of F1()}:
(for b1 being ManySortedSet of F1() holds
      b1 in F2()
   iff
      b1 in F3() & P1[b1] implies F2() c= F3())


:: CLOSURE1:th 1
theorem
for b1 being non empty set
for b2, b3 being set
      st b2 c= b3
   holds {b4 where b4 is Element of b1: b3 c= b4} c= {b4 where b4 is Element of b1: b2 c= b4};

:: CLOSURE1:th 2
theorem
for b1 being set
for b2 being ManySortedSet of b1
      st ex b3 being ManySortedSet of b1 st
           b3 in b2
   holds b2 is non-empty;

:: CLOSURE1:funcnot 1 => CLOSURE1:func 1
definition
  let a1 be set;
  let a2 be Function-yielding ManySortedSet of a1;
  let a3 be ManySortedSet of a1;
  redefine func a2 .. a3 -> ManySortedSet of a1;
end;

:: CLOSURE1:funcnot 2 => CLOSURE1:func 2
definition
  let a1 be set;
  let a2, a3 be non-empty ManySortedSet of a1;
  let a4 be ManySortedFunction of a2,a3;
  let a5 be Element of a2;
  redefine func a4 .. a5 -> Element of a3;
end;

:: CLOSURE1:th 3
theorem
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being non-empty ManySortedSet of b1
for b5 being ManySortedFunction of b2,b4
      st b3 in b2
   holds b5 .. b3 in b4;

:: CLOSURE1:th 4
theorem
for b1 being set
for b2, b3 being Function-yielding ManySortedSet of b1
for b4 being ManySortedSet of b1
      st b4 in doms b3
   holds b2 .. (b3 .. b4) = (b2 ** b3) .. b4;

:: CLOSURE1:th 5
theorem
for b1 being set
for b2 being Function-yielding ManySortedSet of b1
   st b2 is "1-1"
for b3, b4 being ManySortedSet of b1
      st b3 in doms b2 & b4 in doms b2 & b2 .. b3 = b2 .. b4
   holds b3 = b4;

:: CLOSURE1:th 6
theorem
for b1 being set
for b2 being Function-yielding ManySortedSet of b1
      st doms b2 is non-empty &
         (for b3, b4 being ManySortedSet of b1
               st b3 in doms b2 & b4 in doms b2 & b2 .. b3 = b2 .. b4
            holds b3 = b4)
   holds b2 is "1-1";

:: CLOSURE1:th 7
theorem
for b1 being set
for b2, b3 being non-empty ManySortedSet of b1
for b4, b5 being ManySortedFunction of b2,b3
      st for b6 being ManySortedSet of b1
              st b6 in b2
           holds b4 .. b6 = b5 .. b6
   holds b4 = b5;

:: CLOSURE1:exreg 1
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster Relation-like empty-yielding Function-like finite-yielding Element of bool a2;
end;

:: CLOSURE1:modenot 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  mode MSSetOp of a2 is ManySortedFunction of bool a2,bool a2;
end;

:: CLOSURE1:funcnot 3 => CLOSURE1:func 3
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
  let a4 be Element of bool a2;
  redefine func a3 .. a4 -> Element of bool a2;
end;

:: CLOSURE1:attrnot 1 => CLOSURE1:attr 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
  attr a3 is reflexive means
    for b1 being Element of bool a2 holds
       b1 c= a3 .. b1;
end;

:: CLOSURE1:dfs 1
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
To prove
     a3 is reflexive
it is sufficient to prove
  thus for b1 being Element of bool a2 holds
       b1 c= a3 .. b1;

:: CLOSURE1:def 2
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2 holds
      b3 is reflexive(b1, b2)
   iff
      for b4 being Element of bool b2 holds
         b4 c= b3 .. b4;

:: CLOSURE1:attrnot 2 => CLOSURE1:attr 2
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
  attr a3 is monotonic means
    for b1, b2 being Element of bool a2
          st b1 c= b2
       holds a3 .. b1 c= a3 .. b2;
end;

:: CLOSURE1:dfs 2
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
To prove
     a3 is monotonic
it is sufficient to prove
  thus for b1, b2 being Element of bool a2
          st b1 c= b2
       holds a3 .. b1 c= a3 .. b2;

:: CLOSURE1:def 3
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2 holds
      b3 is monotonic(b1, b2)
   iff
      for b4, b5 being Element of bool b2
            st b4 c= b5
         holds b3 .. b4 c= b3 .. b5;

:: CLOSURE1:attrnot 3 => CLOSURE1:attr 3
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
  attr a3 is idempotent means
    for b1 being Element of bool a2 holds
       a3 .. b1 = a3 .. (a3 .. b1);
end;

:: CLOSURE1:dfs 3
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
To prove
     a3 is idempotent
it is sufficient to prove
  thus for b1 being Element of bool a2 holds
       a3 .. b1 = a3 .. (a3 .. b1);

:: CLOSURE1:def 4
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2 holds
      b3 is idempotent(b1, b2)
   iff
      for b4 being Element of bool b2 holds
         b3 .. b4 = b3 .. (b3 .. b4);

:: CLOSURE1:attrnot 4 => CLOSURE1:attr 4
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
  attr a3 is topological means
    for b1, b2 being Element of bool a2 holds
    a3 .. (b1 \/ b2) = (a3 .. b1) \/ (a3 .. b2);
end;

:: CLOSURE1:dfs 4
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of bool a2,bool a2;
To prove
     a3 is topological
it is sufficient to prove
  thus for b1, b2 being Element of bool a2 holds
    a3 .. (b1 \/ b2) = (a3 .. b1) \/ (a3 .. b2);

:: CLOSURE1:def 5
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2 holds
      b3 is topological(b1, b2)
   iff
      for b4, b5 being Element of bool b2 holds
      b3 .. (b4 \/ b5) = (b3 .. b4) \/ (b3 .. b5);

:: CLOSURE1:th 8
theorem
for b1 being set
for b2 being non-empty ManySortedSet of b1
for b3 being Element of b2 holds
   b3 = (id b2) .. b3;

:: CLOSURE1:th 9
theorem
for b1 being set
for b2 being non-empty ManySortedSet of b1
for b3, b4 being Element of b2
      st b3 c= b4
   holds (id b2) .. b3 c= (id b2) .. b4;

:: CLOSURE1:th 10
theorem
for b1 being set
for b2 being non-empty ManySortedSet of b1
for b3, b4 being Element of b2
      st b3 \/ b4 is Element of b2
   holds (id b2) .. (b3 \/ b4) = ((id b2) .. b3) \/ ((id b2) .. b4);

:: CLOSURE1:th 11
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool b2
for b4, b5 being set
      st b4 in b1 & b5 in ((id bool b2) .. b3) . b4
   holds ex b6 being finite-yielding Element of bool b2 st
      b6 c= b3 & b5 in ((id bool b2) .. b6) . b4;

:: CLOSURE1:exreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster Relation-like Function-like Function-yielding reflexive monotonic idempotent topological ManySortedFunction of bool a2,bool a2;
end;

:: CLOSURE1:th 12
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id bool b2 is reflexive ManySortedFunction of bool b2,bool b2;

:: CLOSURE1:th 13
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id bool b2 is monotonic ManySortedFunction of bool b2,bool b2;

:: CLOSURE1:th 14
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id bool b2 is idempotent ManySortedFunction of bool b2,bool b2;

:: CLOSURE1:th 15
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id bool b2 is topological ManySortedFunction of bool b2,bool b2;

:: CLOSURE1:th 16
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2
for b4 being Element of bool b2
      st b4 = b2 & b3 is reflexive(b1, b2)
   holds b4 = b3 .. b4;

:: CLOSURE1:th 17
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2
      st b3 is reflexive(b1, b2) &
         (for b4 being Element of bool b2 holds
            b3 .. b4 c= b4)
   holds b3 is idempotent(b1, b2);

:: CLOSURE1:th 18
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2
for b4, b5 being Element of bool b2
      st b3 is monotonic(b1, b2)
   holds b3 .. (b4 /\ b5) c= (b3 .. b4) /\ (b3 .. b5);

:: CLOSURE1:condreg 1
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster topological -> monotonic (ManySortedFunction of bool a2,bool a2);
end;

:: CLOSURE1:th 19
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of bool b2,bool b2
for b4, b5 being Element of bool b2
      st b3 is topological(b1, b2)
   holds (b3 .. b4) \ (b3 .. b5) c= b3 .. (b4 \ b5);

:: CLOSURE1:funcnot 4 => CLOSURE1:func 4
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be ManySortedFunction of bool a2,bool a2;
  redefine func a4 ** a3 -> ManySortedFunction of bool a2,bool a2;
end;

:: CLOSURE1:th 20
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being ManySortedFunction of bool b2,bool b2
      st b3 is reflexive(b1, b2) & b4 is reflexive(b1, b2)
   holds b3 ** b4 is reflexive(b1, b2);

:: CLOSURE1:th 21
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being ManySortedFunction of bool b2,bool b2
      st b3 is monotonic(b1, b2) & b4 is monotonic(b1, b2)
   holds b3 ** b4 is monotonic(b1, b2);

:: CLOSURE1:th 22
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being ManySortedFunction of bool b2,bool b2
      st b3 is idempotent(b1, b2) & b4 is idempotent(b1, b2) & b3 ** b4 = b4 ** b3
   holds b3 ** b4 is idempotent(b1, b2);

:: CLOSURE1:th 23
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being ManySortedFunction of bool b2,bool b2
      st b3 is topological(b1, b2) & b4 is topological(b1, b2)
   holds b3 ** b4 is topological(b1, b2);

:: CLOSURE1:th 24
theorem
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4 being Relation-like Function-like set
for b5 being ManySortedFunction of bool b3,bool b3
   st b5 is reflexive(b2, b3) & b1 in b2 & b4 = b5 . b1
for b6 being Element of bool (b3 . b1) holds
   b6 c= b4 . b6;

:: CLOSURE1:th 25
theorem
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4 being Relation-like Function-like set
for b5 being ManySortedFunction of bool b3,bool b3
   st b5 is monotonic(b2, b3) & b1 in b2 & b4 = b5 . b1
for b6, b7 being Element of bool (b3 . b1)
      st b6 c= b7
   holds b4 . b6 c= b4 . b7;

:: CLOSURE1:th 26
theorem
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4 being Relation-like Function-like set
for b5 being ManySortedFunction of bool b3,bool b3
   st b5 is idempotent(b2, b3) & b1 in b2 & b4 = b5 . b1
for b6 being Element of bool (b3 . b1) holds
   b4 . b6 = b4 . (b4 . b6);

:: CLOSURE1:th 27
theorem
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4 being Relation-like Function-like set
for b5 being ManySortedFunction of bool b3,bool b3
   st b5 is topological(b2, b3) & b1 in b2 & b4 = b5 . b1
for b6, b7 being Element of bool (b3 . b1) holds
b4 . (b6 \/ b7) = (b4 . b6) \/ (b4 . b7);

:: CLOSURE1:structnot 1 => CLOSURE1:struct 1
definition
  let a1 be 1-sorted;
  struct(many-sorted over a1) MSClosureStr(#
    Sorts -> ManySortedSet of the carrier of A1,
    Family -> ManySortedSubset of bool the Sorts of it
  #);
end;

:: CLOSURE1:attrnot 5 => CLOSURE1:attr 5
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is strict;
end;

:: CLOSURE1:exreg 3
registration
  let a1 be 1-sorted;
  cluster strict MSClosureStr over a1;
end;

:: CLOSURE1:aggrnot 1 => CLOSURE1:aggr 1
definition
  let a1 be 1-sorted;
  let a2 be ManySortedSet of the carrier of a1;
  let a3 be ManySortedSubset of bool a2;
  aggr MSClosureStr(#a2,a3#) -> strict MSClosureStr over a1;
end;

:: CLOSURE1:selnot 1 => CLOSURE1:sel 1
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  sel the Family of a2 -> ManySortedSubset of bool the Sorts of a2;
end;

:: CLOSURE1:attrnot 6 => CLOSURE1:attr 6
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is additive means
    the Family of a2 is additive(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE1:dfs 5
definiens
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
To prove
     a2 is additive
it is sufficient to prove
  thus the Family of a2 is additive(the carrier of a1, the Sorts of a2);

:: CLOSURE1:def 6
theorem
for b1 being 1-sorted
for b2 being MSClosureStr over b1 holds
      b2 is additive(b1)
   iff
      the Family of b2 is additive(the carrier of b1, the Sorts of b2);

:: CLOSURE1:attrnot 7 => CLOSURE1:attr 7
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is absolutely-additive means
    the Family of a2 is absolutely-additive(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE1:dfs 6
definiens
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
To prove
     a2 is absolutely-additive
it is sufficient to prove
  thus the Family of a2 is absolutely-additive(the carrier of a1, the Sorts of a2);

:: CLOSURE1:def 7
theorem
for b1 being 1-sorted
for b2 being MSClosureStr over b1 holds
      b2 is absolutely-additive(b1)
   iff
      the Family of b2 is absolutely-additive(the carrier of b1, the Sorts of b2);

:: CLOSURE1:attrnot 8 => CLOSURE1:attr 8
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is multiplicative means
    the Family of a2 is multiplicative(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE1:dfs 7
definiens
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
To prove
     a2 is multiplicative
it is sufficient to prove
  thus the Family of a2 is multiplicative(the carrier of a1, the Sorts of a2);

:: CLOSURE1:def 8
theorem
for b1 being 1-sorted
for b2 being MSClosureStr over b1 holds
      b2 is multiplicative(b1)
   iff
      the Family of b2 is multiplicative(the carrier of b1, the Sorts of b2);

:: CLOSURE1:attrnot 9 => CLOSURE1:attr 9
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is absolutely-multiplicative means
    the Family of a2 is absolutely-multiplicative(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE1:dfs 8
definiens
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
To prove
     a2 is absolutely-multiplicative
it is sufficient to prove
  thus the Family of a2 is absolutely-multiplicative(the carrier of a1, the Sorts of a2);

:: CLOSURE1:def 9
theorem
for b1 being 1-sorted
for b2 being MSClosureStr over b1 holds
      b2 is absolutely-multiplicative(b1)
   iff
      the Family of b2 is absolutely-multiplicative(the carrier of b1, the Sorts of b2);

:: CLOSURE1:attrnot 10 => CLOSURE1:attr 10
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is properly-upper-bound means
    the Family of a2 is properly-upper-bound(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE1:dfs 9
definiens
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
To prove
     a2 is properly-upper-bound
it is sufficient to prove
  thus the Family of a2 is properly-upper-bound(the carrier of a1, the Sorts of a2);

:: CLOSURE1:def 10
theorem
for b1 being 1-sorted
for b2 being MSClosureStr over b1 holds
      b2 is properly-upper-bound(b1)
   iff
      the Family of b2 is properly-upper-bound(the carrier of b1, the Sorts of b2);

:: CLOSURE1:attrnot 11 => CLOSURE1:attr 11
definition
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
  attr a2 is properly-lower-bound means
    the Family of a2 is properly-lower-bound(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE1:dfs 10
definiens
  let a1 be 1-sorted;
  let a2 be MSClosureStr over a1;
To prove
     a2 is properly-lower-bound
it is sufficient to prove
  thus the Family of a2 is properly-lower-bound(the carrier of a1, the Sorts of a2);

:: CLOSURE1:def 11
theorem
for b1 being 1-sorted
for b2 being MSClosureStr over b1 holds
      b2 is properly-lower-bound(b1)
   iff
      the Family of b2 is properly-lower-bound(the carrier of b1, the Sorts of b2);

:: CLOSURE1:funcnot 5 => CLOSURE1:func 5
definition
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  func MSFull A2 -> MSClosureStr over a1 equals
    MSClosureStr(#the Sorts of a2,bool the Sorts of a2#);
end;

:: CLOSURE1:def 12
theorem
for b1 being 1-sorted
for b2 being many-sorted over b1 holds
   MSFull b2 = MSClosureStr(#the Sorts of b2,bool the Sorts of b2#);

:: CLOSURE1:funcreg 1
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  cluster MSFull a2 -> strict additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound;
end;

:: CLOSURE1:funcreg 2
registration
  let a1 be 1-sorted;
  let a2 be non-empty many-sorted over a1;
  cluster MSFull a2 -> non-empty;
end;

:: CLOSURE1:exreg 4
registration
  let a1 be 1-sorted;
  cluster non-empty strict additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound MSClosureStr over a1;
end;

:: CLOSURE1:funcreg 3
registration
  let a1 be 1-sorted;
  let a2 be additive MSClosureStr over a1;
  cluster the Family of a2 -> additive;
end;

:: CLOSURE1:funcreg 4
registration
  let a1 be 1-sorted;
  let a2 be absolutely-additive MSClosureStr over a1;
  cluster the Family of a2 -> absolutely-additive;
end;

:: CLOSURE1:funcreg 5
registration
  let a1 be 1-sorted;
  let a2 be multiplicative MSClosureStr over a1;
  cluster the Family of a2 -> multiplicative;
end;

:: CLOSURE1:funcreg 6
registration
  let a1 be 1-sorted;
  let a2 be absolutely-multiplicative MSClosureStr over a1;
  cluster the Family of a2 -> absolutely-multiplicative;
end;

:: CLOSURE1:funcreg 7
registration
  let a1 be 1-sorted;
  let a2 be properly-upper-bound MSClosureStr over a1;
  cluster the Family of a2 -> properly-upper-bound;
end;

:: CLOSURE1:funcreg 8
registration
  let a1 be 1-sorted;
  let a2 be properly-lower-bound MSClosureStr over a1;
  cluster the Family of a2 -> properly-lower-bound;
end;

:: CLOSURE1:funcreg 9
registration
  let a1 be 1-sorted;
  let a2 be non-empty ManySortedSet of the carrier of a1;
  let a3 be ManySortedSubset of bool a2;
  cluster MSClosureStr(#a2,a3#) -> non-empty strict;
end;

:: CLOSURE1:funcreg 10
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be additive ManySortedSubset of bool the Sorts of a2;
  cluster MSClosureStr(#the Sorts of a2,a3#) -> strict additive;
end;

:: CLOSURE1:funcreg 11
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be absolutely-additive ManySortedSubset of bool the Sorts of a2;
  cluster MSClosureStr(#the Sorts of a2,a3#) -> strict absolutely-additive;
end;

:: CLOSURE1:funcreg 12
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be multiplicative ManySortedSubset of bool the Sorts of a2;
  cluster MSClosureStr(#the Sorts of a2,a3#) -> strict multiplicative;
end;

:: CLOSURE1:funcreg 13
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be absolutely-multiplicative ManySortedSubset of bool the Sorts of a2;
  cluster MSClosureStr(#the Sorts of a2,a3#) -> strict absolutely-multiplicative;
end;

:: CLOSURE1:funcreg 14
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be properly-upper-bound ManySortedSubset of bool the Sorts of a2;
  cluster MSClosureStr(#the Sorts of a2,a3#) -> strict properly-upper-bound;
end;

:: CLOSURE1:funcreg 15
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be properly-lower-bound ManySortedSubset of bool the Sorts of a2;
  cluster MSClosureStr(#the Sorts of a2,a3#) -> strict properly-lower-bound;
end;

:: CLOSURE1:condreg 2
registration
  let a1 be 1-sorted;
  cluster absolutely-additive -> additive (MSClosureStr over a1);
end;

:: CLOSURE1:condreg 3
registration
  let a1 be 1-sorted;
  cluster absolutely-multiplicative -> multiplicative (MSClosureStr over a1);
end;

:: CLOSURE1:condreg 4
registration
  let a1 be 1-sorted;
  cluster absolutely-multiplicative -> properly-upper-bound (MSClosureStr over a1);
end;

:: CLOSURE1:condreg 5
registration
  let a1 be 1-sorted;
  cluster absolutely-additive -> properly-lower-bound (MSClosureStr over a1);
end;

:: CLOSURE1:modenot 2
definition
  let a1 be 1-sorted;
  mode MSClosureSystem of a1 is absolutely-multiplicative MSClosureStr over a1;
end;

:: CLOSURE1:modenot 3
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  mode MSClosureOperator of a2 is reflexive monotonic idempotent ManySortedFunction of bool a2,bool a2;
end;

:: CLOSURE1:funcnot 6 => CLOSURE1:func 6
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be ManySortedFunction of a2,a2;
  func MSFixPoints A3 -> ManySortedSubset of a2 means
    for b1, b2 being set
          st b2 in a1
       holds    b1 in it . b2
       iff
          ex b3 being Relation-like Function-like set st
             b3 = a3 . b2 & b1 in proj1 b3 & b3 . b1 = b1;
end;

:: CLOSURE1:def 13
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being ManySortedFunction of b2,b2
for b4 being ManySortedSubset of b2 holds
      b4 = MSFixPoints b3
   iff
      for b5, b6 being set
            st b6 in b1
         holds    b5 in b4 . b6
         iff
            ex b7 being Relation-like Function-like set st
               b7 = b3 . b6 & b5 in proj1 b7 & b7 . b5 = b5;

:: CLOSURE1:funcreg 16
registration
  let a1 be set;
  let a2 be empty-yielding ManySortedSet of a1;
  let a3 be ManySortedFunction of a2,a2;
  cluster MSFixPoints a3 -> empty-yielding;
end;

:: CLOSURE1:th 28
theorem
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being ManySortedFunction of b2,b2 holds
      b3 in b2 & b4 .. b3 = b3
   iff
      b3 in MSFixPoints b4;

:: CLOSURE1:th 29
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   MSFixPoints id b2 = b2;

:: CLOSURE1:th 30
theorem
for b1 being 1-sorted
for b2 being ManySortedSet of the carrier of b1
for b3 being reflexive monotonic ManySortedFunction of bool b2,bool b2
for b4 being ManySortedSubset of bool b2
      st b4 = MSFixPoints b3
   holds MSClosureStr(#b2,b4#) is absolutely-multiplicative MSClosureStr over b1;

:: CLOSURE1:th 31
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being properly-upper-bound ManySortedSubset of bool b2
for b4 being Element of bool b2 holds
   ex b5 being non-empty ManySortedSubset of bool b2 st
      for b6 being ManySortedSet of b1 holds
            b6 in b5
         iff
            b6 in b3 & b4 c= b6;

:: CLOSURE1:th 32
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being properly-upper-bound ManySortedSubset of bool b2
for b4 being Element of bool b2
for b5 being non-empty ManySortedSubset of bool b2
   st for b6 being ManySortedSet of b1 holds
           b6 in b5
        iff
           b6 in b3 & b4 c= b6
for b6 being set
for b7 being non empty set
      st b6 in b1 & b7 = b3 . b6
   holds b5 . b6 = {b8 where b8 is Element of b7: b4 . b6 c= b8};

:: CLOSURE1:th 33
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being properly-upper-bound ManySortedSubset of bool b2 holds
   ex b4 being ManySortedFunction of bool b2,bool b2 st
      for b5 being Element of bool b2
      for b6 being non-empty ManySortedSubset of bool b2
            st for b7 being ManySortedSet of b1 holds
                    b7 in b6
                 iff
                    b7 in b3 & b5 c= b7
         holds b4 .. b5 = meet b6;

:: CLOSURE1:th 34
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being properly-upper-bound ManySortedSubset of bool b2
for b4 being Element of bool b2
for b5 being ManySortedFunction of bool b2,bool b2
      st b4 in b3 &
         (for b6 being Element of bool b2
         for b7 being non-empty ManySortedSubset of bool b2
               st for b8 being ManySortedSet of b1 holds
                       b8 in b7
                    iff
                       b8 in b3 & b6 c= b8
            holds b5 .. b6 = meet b7)
   holds b5 .. b4 = b4;

:: CLOSURE1:th 35
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being absolutely-multiplicative ManySortedSubset of bool b2
for b4 being Element of bool b2
for b5 being ManySortedFunction of bool b2,bool b2
      st b5 .. b4 = b4 &
         (for b6 being Element of bool b2
         for b7 being non-empty ManySortedSubset of bool b2
               st for b8 being ManySortedSet of b1 holds
                       b8 in b7
                    iff
                       b8 in b3 & b6 c= b8
            holds b5 .. b6 = meet b7)
   holds b4 in b3;

:: CLOSURE1:th 36
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being properly-upper-bound ManySortedSubset of bool b2
for b4 being ManySortedFunction of bool b2,bool b2
      st for b5 being Element of bool b2
        for b6 being non-empty ManySortedSubset of bool b2
              st for b7 being ManySortedSet of b1 holds
                      b7 in b6
                   iff
                      b7 in b3 & b5 c= b7
           holds b4 .. b5 = meet b6
   holds b4 is reflexive(b1, b2) & b4 is monotonic(b1, b2);

:: CLOSURE1:th 37
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being absolutely-multiplicative ManySortedSubset of bool b2
for b4 being ManySortedFunction of bool b2,bool b2
      st for b5 being Element of bool b2
        for b6 being non-empty ManySortedSubset of bool b2
              st for b7 being ManySortedSet of b1 holds
                      b7 in b6
                   iff
                      b7 in b3 & b5 c= b7
           holds b4 .. b5 = meet b6
   holds b4 is idempotent(b1, b2);

:: CLOSURE1:th 38
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative MSClosureStr over b1
for b3 being ManySortedFunction of bool the Sorts of b2,bool the Sorts of b2
      st for b4 being Element of bool the Sorts of b2
        for b5 being non-empty ManySortedSubset of bool the Sorts of b2
              st for b6 being ManySortedSet of the carrier of b1 holds
                      b6 in b5
                   iff
                      b6 in the Family of b2 & b4 c= b6
           holds b3 .. b4 = meet b5
   holds b3 is reflexive monotonic idempotent ManySortedFunction of bool the Sorts of b2,bool the Sorts of b2;

:: CLOSURE1:funcnot 7 => CLOSURE1:func 7
definition
  let a1 be 1-sorted;
  let a2 be ManySortedSet of the carrier of a1;
  let a3 be reflexive monotonic idempotent ManySortedFunction of bool a2,bool a2;
  func ClOp->ClSys A3 -> absolutely-multiplicative MSClosureStr over a1 means
    ex b1 being ManySortedSubset of bool a2 st
       b1 = MSFixPoints a3 & it = MSClosureStr(#a2,b1#);
end;

:: CLOSURE1:def 14
theorem
for b1 being 1-sorted
for b2 being ManySortedSet of the carrier of b1
for b3 being reflexive monotonic idempotent ManySortedFunction of bool b2,bool b2
for b4 being absolutely-multiplicative MSClosureStr over b1 holds
      b4 = ClOp->ClSys b3
   iff
      ex b5 being ManySortedSubset of bool b2 st
         b5 = MSFixPoints b3 & b4 = MSClosureStr(#b2,b5#);

:: CLOSURE1:funcreg 17
registration
  let a1 be 1-sorted;
  let a2 be ManySortedSet of the carrier of a1;
  let a3 be reflexive monotonic idempotent ManySortedFunction of bool a2,bool a2;
  cluster ClOp->ClSys a3 -> strict absolutely-multiplicative;
end;

:: CLOSURE1:funcreg 18
registration
  let a1 be 1-sorted;
  let a2 be non-empty ManySortedSet of the carrier of a1;
  let a3 be reflexive monotonic idempotent ManySortedFunction of bool a2,bool a2;
  cluster ClOp->ClSys a3 -> non-empty absolutely-multiplicative;
end;

:: CLOSURE1:funcnot 8 => CLOSURE1:func 8
definition
  let a1 be 1-sorted;
  let a2 be absolutely-multiplicative MSClosureStr over a1;
  func ClSys->ClOp A2 -> reflexive monotonic idempotent ManySortedFunction of bool the Sorts of a2,bool the Sorts of a2 means
    for b1 being Element of bool the Sorts of a2
    for b2 being non-empty ManySortedSubset of bool the Sorts of a2
          st for b3 being ManySortedSet of the carrier of a1 holds
                  b3 in b2
               iff
                  b3 in the Family of a2 & b1 c= b3
       holds it .. b1 = meet b2;
end;

:: CLOSURE1:def 15
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative MSClosureStr over b1
for b3 being reflexive monotonic idempotent ManySortedFunction of bool the Sorts of b2,bool the Sorts of b2 holds
      b3 = ClSys->ClOp b2
   iff
      for b4 being Element of bool the Sorts of b2
      for b5 being non-empty ManySortedSubset of bool the Sorts of b2
            st for b6 being ManySortedSet of the carrier of b1 holds
                    b6 in b5
                 iff
                    b6 in the Family of b2 & b4 c= b6
         holds b3 .. b4 = meet b5;

:: CLOSURE1:th 39
theorem
for b1 being 1-sorted
for b2 being ManySortedSet of the carrier of b1
for b3 being reflexive monotonic idempotent ManySortedFunction of bool b2,bool b2 holds
   ClSys->ClOp ClOp->ClSys b3 = b3;

:: CLOSURE1:th 40
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative MSClosureStr over b1 holds
   ClOp->ClSys ClSys->ClOp b2 = MSClosureStr(#the Sorts of b2,the Family of b2#);