Article CLOSURE2, MML version 4.99.1005

:: CLOSURE2:prednot 1 => PBOOLE:pred 1
notation
  let a1 be set;
  let a2, a3 be ManySortedSet of a1;
  synonym a2 in' a3 for a2 in a3;
end;

:: CLOSURE2:prednot 2 => PBOOLE:pred 2
notation
  let a1 be set;
  let a2, a3 be ManySortedSet of a1;
  synonym a2 c=' a3 for a2 c= a3;
end;

:: CLOSURE2:th 1
theorem
for b1 being non empty set
for b2, b3 being Element of b1
      st b2 c= b3
   holds (id b1) . b2 c= (id b1) . b3;

:: CLOSURE2:th 3
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3 being ManySortedSubset of b2 holds
   proj2 b3 c= union proj2 bool b2;

:: CLOSURE2:condreg 1
registration
  cluster empty -> functional (set);
end;

:: CLOSURE2:exreg 1
registration
  cluster empty functional set;
end;

:: CLOSURE2:funcreg 1
registration
  let a1, a2 be Relation-like Function-like set;
  cluster {a1,a2} -> functional;
end;

:: CLOSURE2:funcnot 1 => CLOSURE2:func 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  func Bool A2 -> set means
    for b1 being set holds
          b1 in it
       iff
          b1 is ManySortedSubset of a2;
end;

:: CLOSURE2:def 1
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being set holds
      b3 = Bool b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is ManySortedSubset of b2;

:: CLOSURE2:funcreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster Bool a2 -> non empty functional with_common_domain;
end;

:: CLOSURE2:modenot 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  mode SubsetFamily of a2 is Element of bool Bool a2;
end;

:: CLOSURE2:funcnot 2 => CLOSURE2:func 2
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  redefine func Bool a2 -> Element of bool Bool a2;
end;

:: CLOSURE2:exreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster non empty functional with_common_domain Element of bool Bool a2;
end;

:: CLOSURE2:exreg 3
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster empty finite functional Element of bool Bool a2;
end;

:: CLOSURE2:modenot 2 => CLOSURE2:mode 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be non empty Element of bool Bool a2;
  redefine mode Element of a3 -> ManySortedSubset of a2;
end;

:: CLOSURE2:th 4
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
b3 \/ b4 is Element of bool Bool b2;

:: CLOSURE2:th 5
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
b3 /\ b4 is Element of bool Bool b2;

:: CLOSURE2:th 6
theorem
for b1, b2 being set
for b3 being ManySortedSet of b1
for b4 being Element of bool Bool b3 holds
   b4 \ b2 is Element of bool Bool b3;

:: CLOSURE2:th 7
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
b3 \+\ b4 is Element of bool Bool b2;

:: CLOSURE2:th 8
theorem
for b1 being set
for b2, b3 being ManySortedSet of b1
      st b2 c= b3
   holds {b2} is Element of bool Bool b3;

:: CLOSURE2:th 9
theorem
for b1 being set
for b2, b3, b4 being ManySortedSet of b1
      st b2 c= b3 & b4 c= b3
   holds {b2,b4} is Element of bool Bool b3;

:: CLOSURE2:th 10
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of Bool b2 holds
b3 /\ b4 in Bool b2;

:: CLOSURE2:th 11
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of Bool b2 holds
b3 \/ b4 in Bool b2;

:: CLOSURE2:th 12
theorem
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being Element of Bool b3 holds
   b4 \ b2 in Bool b3;

:: CLOSURE2:th 13
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of Bool b2 holds
b3 \+\ b4 in Bool b2;

:: CLOSURE2:funcnot 3 => CLOSURE2:func 3
definition
  let a1 be functional set;
  func |.A1.| -> Relation-like Function-like set means
    ex b1 being non empty functional set st
       b1 = a1 &
        proj1 it = meet {proj1 b2 where b2 is Element of b1: TRUE} &
        (for b2 being set
              st b2 in proj1 it
           holds it . b2 = {b3 . b2 where b3 is Element of b1: TRUE})
    if a1 <> {}
    otherwise it = {};
end;

:: CLOSURE2:def 3
theorem
for b1 being functional set
for b2 being Relation-like Function-like set holds
   (b1 = {} or    (b2 = |.b1.|
    iff
       ex b3 being non empty functional set st
          b3 = b1 &
           proj1 b2 = meet {proj1 b4 where b4 is Element of b3: TRUE} &
           (for b4 being set
                 st b4 in proj1 b2
              holds b2 . b4 = {b5 . b4 where b5 is Element of b3: TRUE}))) &
    (b1 = {} implies    (b2 = |.b1.|
    iff
       b2 = {}));

:: CLOSURE2:th 14
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being non empty Element of bool Bool b2 holds
   proj1 |.b3.| = b1;

:: CLOSURE2:funcreg 3
registration
  let a1 be empty functional set;
  cluster |.a1.| -> empty Relation-like Function-like;
end;

:: CLOSURE2:funcnot 4 => CLOSURE2:func 4
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  func |:A3:| -> ManySortedSet of a1 equals
    |.a3.|
    if a3 <> {}
    otherwise [0] a1;
end;

:: CLOSURE2:def 4
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
   (b3 = {} or |:b3:| = |.b3.|) &
    (b3 = {} implies |:b3:| = [0] b1);

:: CLOSURE2:funcreg 4
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be empty Element of bool Bool a2;
  cluster |:a3:| -> empty-yielding;
end;

:: CLOSURE2:th 15
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2
   st b3 is not empty
for b4 being set
      st b4 in b1
   holds |:b3:| . b4 = {b5 . b4 where b5 is Element of Bool b2: b5 in b3};

:: CLOSURE2:funcreg 5
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be non empty Element of bool Bool a2;
  cluster |:a3:| -> non-empty;
end;

:: CLOSURE2:th 16
theorem
for b1 being Relation-like Function-like set holds
   proj1 |.{b1}.| = proj1 b1;

:: CLOSURE2:th 17
theorem
for b1, b2 being Relation-like Function-like set holds
proj1 |.{b1,b2}.| = (proj1 b1) /\ proj1 b2;

:: CLOSURE2:th 18
theorem
for b1 being set
for b2 being Relation-like Function-like set
      st b1 in proj1 b2
   holds |.{b2}.| . b1 = {b2 . b1};

:: CLOSURE2:th 19
theorem
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4 being Relation-like Function-like set
for b5 being Element of bool Bool b3
      st b1 in b2 & b5 = {b4}
   holds |:b5:| . b1 = {b4 . b1};

:: CLOSURE2:th 20
theorem
for b1 being set
for b2, b3 being Relation-like Function-like set
      st b1 in proj1 |.{b2,b3}.|
   holds |.{b2,b3}.| . b1 = {b2 . b1,b3 . b1};

:: CLOSURE2:th 21
theorem
for b1, b2 being set
for b3 being ManySortedSet of b2
for b4, b5 being Relation-like Function-like set
for b6 being Element of bool Bool b3
      st b1 in b2 & b6 = {b4,b5}
   holds |:b6:| . b1 = {b4 . b1,b5 . b1};

:: CLOSURE2:funcnot 5 => CLOSURE2:func 5
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  redefine func |:a3:| -> ManySortedSubset of bool a2;
end;

:: CLOSURE2:th 22
theorem
for b1 being set
for b2, b3 being ManySortedSet of b1
for b4 being Element of bool Bool b2
      st b3 in b4
   holds b3 in |:b4:|;

:: CLOSURE2:th 23
theorem
for b1 being set
for b2, b3, b4 being ManySortedSet of b1
for b5 being Element of bool Bool b2
      st b5 = {b3,b4}
   holds union |:b5:| = b3 \/ b4;

:: CLOSURE2:th 24
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2
for b4, b5 being Element of Bool b2
      st b3 = {b4,b5}
   holds meet |:b3:| = b4 /\ b5;

:: CLOSURE2:th 25
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2
for b4 being ManySortedSubset of b2
      st for b5 being ManySortedSet of b1
              st b5 in b3
           holds b4 c= b5
   holds b4 c= meet |:b3:|;

:: CLOSURE2:th 26
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   |:Bool b2:| = bool b2;

:: CLOSURE2:attrnot 1 => CLOSURE2:attr 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  attr a3 is additive means
    for b1, b2 being ManySortedSet of a1
          st b1 in a3 & b2 in a3
       holds b1 \/ b2 in a3;
end;

:: CLOSURE2:dfs 4
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
To prove
     a3 is additive
it is sufficient to prove
  thus for b1, b2 being ManySortedSet of a1
          st b1 in a3 & b2 in a3
       holds b1 \/ b2 in a3;

:: CLOSURE2:def 5
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
      b3 is additive(b1, b2)
   iff
      for b4, b5 being ManySortedSet of b1
            st b4 in b3 & b5 in b3
         holds b4 \/ b5 in b3;

:: CLOSURE2:attrnot 2 => CLOSURE2:attr 2
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  attr a3 is absolutely-additive means
    for b1 being Element of bool Bool a2
          st b1 c= a3
       holds union |:b1:| in a3;
end;

:: CLOSURE2:dfs 5
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
To prove
     a3 is absolutely-additive
it is sufficient to prove
  thus for b1 being Element of bool Bool a2
          st b1 c= a3
       holds union |:b1:| in a3;

:: CLOSURE2:def 6
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
      b3 is absolutely-additive(b1, b2)
   iff
      for b4 being Element of bool Bool b2
            st b4 c= b3
         holds union |:b4:| in b3;

:: CLOSURE2:attrnot 3 => CLOSURE2:attr 3
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  attr a3 is multiplicative means
    for b1, b2 being ManySortedSet of a1
          st b1 in a3 & b2 in a3
       holds b1 /\ b2 in a3;
end;

:: CLOSURE2:dfs 6
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
To prove
     a3 is multiplicative
it is sufficient to prove
  thus for b1, b2 being ManySortedSet of a1
          st b1 in a3 & b2 in a3
       holds b1 /\ b2 in a3;

:: CLOSURE2:def 7
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
      b3 is multiplicative(b1, b2)
   iff
      for b4, b5 being ManySortedSet of b1
            st b4 in b3 & b5 in b3
         holds b4 /\ b5 in b3;

:: CLOSURE2:attrnot 4 => CLOSURE2:attr 4
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  attr a3 is absolutely-multiplicative means
    for b1 being Element of bool Bool a2
          st b1 c= a3
       holds meet |:b1:| in a3;
end;

:: CLOSURE2:dfs 7
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
To prove
     a3 is absolutely-multiplicative
it is sufficient to prove
  thus for b1 being Element of bool Bool a2
          st b1 c= a3
       holds meet |:b1:| in a3;

:: CLOSURE2:def 8
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
      b3 is absolutely-multiplicative(b1, b2)
   iff
      for b4 being Element of bool Bool b2
            st b4 c= b3
         holds meet |:b4:| in b3;

:: CLOSURE2:attrnot 5 => CLOSURE2:attr 5
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  attr a3 is properly-upper-bound means
    a2 in a3;
end;

:: CLOSURE2:dfs 8
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
To prove
     a3 is properly-upper-bound
it is sufficient to prove
  thus a2 in a3;

:: CLOSURE2:def 9
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
      b3 is properly-upper-bound(b1, b2)
   iff
      b2 in b3;

:: CLOSURE2:attrnot 6 => CLOSURE2:attr 6
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  attr a3 is properly-lower-bound means
    [0] a1 in a3;
end;

:: CLOSURE2:dfs 9
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
To prove
     a3 is properly-lower-bound
it is sufficient to prove
  thus [0] a1 in a3;

:: CLOSURE2:def 10
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
      b3 is properly-lower-bound(b1, b2)
   iff
      [0] b1 in b3;

:: CLOSURE2:exreg 4
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster non empty functional with_common_domain additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound Element of bool Bool a2;
end;

:: CLOSURE2:funcnot 6 => CLOSURE2:func 6
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  redefine func Bool a2 -> additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound Element of bool Bool a2;
end;

:: CLOSURE2:condreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster absolutely-additive -> additive (Element of bool Bool a2);
end;

:: CLOSURE2:condreg 3
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster absolutely-multiplicative -> multiplicative (Element of bool Bool a2);
end;

:: CLOSURE2:condreg 4
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster absolutely-multiplicative -> properly-upper-bound (Element of bool Bool a2);
end;

:: CLOSURE2:condreg 5
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster properly-upper-bound -> non empty (Element of bool Bool a2);
end;

:: CLOSURE2:condreg 6
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster absolutely-additive -> properly-lower-bound (Element of bool Bool a2);
end;

:: CLOSURE2:condreg 7
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster properly-lower-bound -> non empty (Element of bool Bool a2);
end;

:: CLOSURE2:modenot 3
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  mode SetOp of a2 is Function-like quasi_total Relation of Bool a2,Bool a2;
end;

:: CLOSURE2:funcnot 7 => CLOSURE2:func 7
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation of Bool a2,Bool a2;
  let a4 be Element of Bool a2;
  redefine func a3 . a4 -> Element of Bool a2;
end;

:: CLOSURE2:attrnot 7 => CLOSURE2:attr 7
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation of Bool a2,Bool a2;
  attr a3 is reflexive means
    for b1 being Element of Bool a2 holds
       b1 c= a3 . b1;
end;

:: CLOSURE2:dfs 10
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation 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;

:: CLOSURE2:def 12
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Function-like quasi_total Relation of Bool b2,Bool b2 holds
      b3 is reflexive(b1, b2)
   iff
      for b4 being Element of Bool b2 holds
         b4 c= b3 . b4;

:: CLOSURE2:attrnot 8 => CLOSURE2:attr 8
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation 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;

:: CLOSURE2:dfs 11
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation 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;

:: CLOSURE2:def 13
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Function-like quasi_total Relation 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;

:: CLOSURE2:attrnot 9 => CLOSURE2:attr 9
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation of Bool a2,Bool a2;
  attr a3 is idempotent means
    for b1 being Element of Bool a2 holds
       a3 . b1 = a3 . (a3 . b1);
end;

:: CLOSURE2:dfs 12
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation 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);

:: CLOSURE2:def 14
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Function-like quasi_total Relation 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);

:: CLOSURE2:attrnot 10 => CLOSURE2:attr 10
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation 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;

:: CLOSURE2:dfs 13
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation 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);

:: CLOSURE2:def 15
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Function-like quasi_total Relation 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);

:: CLOSURE2:exreg 5
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster non empty Relation-like Function-like quasi_total total reflexive monotonic idempotent topological Relation of Bool a2,Bool a2;
end;

:: CLOSURE2:th 27
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id Bool b2 is Function-like quasi_total reflexive Relation of Bool b2,Bool b2;

:: CLOSURE2:th 28
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id Bool b2 is Function-like quasi_total monotonic Relation of Bool b2,Bool b2;

:: CLOSURE2:th 29
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id Bool b2 is Function-like quasi_total idempotent Relation of Bool b2,Bool b2;

:: CLOSURE2:th 30
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
   id Bool b2 is Function-like quasi_total topological Relation of Bool b2,Bool b2;

:: CLOSURE2:th 31
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of Bool b2
for b4 being Function-like quasi_total Relation of Bool b2,Bool b2
      st b3 = b2 & b4 is reflexive(b1, b2)
   holds b3 = b4 . b3;

:: CLOSURE2:th 32
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Function-like quasi_total Relation 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);

:: CLOSURE2:th 33
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of Bool b2
for b5 being Function-like quasi_total Relation of Bool b2,Bool b2
for b6 being Element of Bool b2
      st b6 = b3 /\ b4 & b5 is monotonic(b1, b2)
   holds b5 . b6 c= (b5 . b3) /\ (b5 . b4);

:: CLOSURE2:condreg 8
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster Function-like quasi_total topological -> monotonic (Relation of Bool a2,Bool a2);
end;

:: CLOSURE2:th 34
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of Bool b2
for b5 being Function-like quasi_total Relation of Bool b2,Bool b2
for b6 being Element of Bool b2
      st b6 = b3 \ b4 & b5 is topological(b1, b2)
   holds (b5 . b3) \ (b5 . b4) c= b5 . b6;

:: CLOSURE2:funcnot 8 => CLOSURE2:func 8
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Function-like quasi_total Relation of Bool a2,Bool a2;
  redefine func a4 * a3 -> Function-like quasi_total Relation of Bool a2,Bool a2;
end;

:: CLOSURE2:th 35
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Function-like quasi_total Relation of Bool b2,Bool b2
      st b3 is reflexive(b1, b2) & b4 is reflexive(b1, b2)
   holds b3 * b4 is reflexive(b1, b2);

:: CLOSURE2:th 36
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Function-like quasi_total Relation of Bool b2,Bool b2
      st b3 is monotonic(b1, b2) & b4 is monotonic(b1, b2)
   holds b3 * b4 is monotonic(b1, b2);

:: CLOSURE2:th 37
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Function-like quasi_total Relation 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);

:: CLOSURE2:th 38
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Function-like quasi_total Relation of Bool b2,Bool b2
      st b3 is topological(b1, b2) & b4 is topological(b1, b2)
   holds b3 * b4 is topological(b1, b2);

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

:: CLOSURE2:attrnot 11 => CLOSURE2:attr 11
definition
  let a1 be 1-sorted;
  let a2 be ClosureStr over a1;
  attr a2 is strict;
end;

:: CLOSURE2:exreg 6
registration
  let a1 be 1-sorted;
  cluster strict ClosureStr over a1;
end;

:: CLOSURE2:aggrnot 1 => CLOSURE2:aggr 1
definition
  let a1 be 1-sorted;
  let a2 be ManySortedSet of the carrier of a1;
  let a3 be Element of bool Bool a2;
  aggr ClosureStr(#a2,a3#) -> strict ClosureStr over a1;
end;

:: CLOSURE2:selnot 1 => CLOSURE2:sel 1
definition
  let a1 be 1-sorted;
  let a2 be ClosureStr over a1;
  sel the Family of a2 -> Element of bool Bool the Sorts of a2;
end;

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

:: CLOSURE2:dfs 14
definiens
  let a1 be 1-sorted;
  let a2 be ClosureStr 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);

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

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

:: CLOSURE2:dfs 15
definiens
  let a1 be 1-sorted;
  let a2 be ClosureStr 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);

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

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

:: CLOSURE2:dfs 16
definiens
  let a1 be 1-sorted;
  let a2 be ClosureStr 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);

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

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

:: CLOSURE2:dfs 17
definiens
  let a1 be 1-sorted;
  let a2 be ClosureStr 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);

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

:: CLOSURE2:attrnot 16 => CLOSURE2:attr 16
definition
  let a1 be 1-sorted;
  let a2 be ClosureStr 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;

:: CLOSURE2:dfs 18
definiens
  let a1 be 1-sorted;
  let a2 be ClosureStr 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);

:: CLOSURE2:def 20
theorem
for b1 being 1-sorted
for b2 being ClosureStr 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);

:: CLOSURE2:attrnot 17 => CLOSURE2:attr 17
definition
  let a1 be 1-sorted;
  let a2 be ClosureStr 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;

:: CLOSURE2:dfs 19
definiens
  let a1 be 1-sorted;
  let a2 be ClosureStr 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);

:: CLOSURE2:def 21
theorem
for b1 being 1-sorted
for b2 being ClosureStr 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);

:: CLOSURE2:funcnot 9 => CLOSURE2:func 9
definition
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  func Full A2 -> ClosureStr over a1 equals
    ClosureStr(#the Sorts of a2,Bool the Sorts of a2#);
end;

:: CLOSURE2:def 22
theorem
for b1 being 1-sorted
for b2 being many-sorted over b1 holds
   Full b2 = ClosureStr(#the Sorts of b2,Bool the Sorts of b2#);

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

:: CLOSURE2:funcreg 7
registration
  let a1 be 1-sorted;
  let a2 be non-empty many-sorted over a1;
  cluster Full a2 -> non-empty;
end;

:: CLOSURE2:exreg 7
registration
  let a1 be 1-sorted;
  cluster non-empty strict additive absolutely-additive multiplicative absolutely-multiplicative properly-upper-bound properly-lower-bound ClosureStr over a1;
end;

:: CLOSURE2:funcreg 8
registration
  let a1 be 1-sorted;
  let a2 be additive ClosureStr over a1;
  cluster the Family of a2 -> additive;
end;

:: CLOSURE2:funcreg 9
registration
  let a1 be 1-sorted;
  let a2 be absolutely-additive ClosureStr over a1;
  cluster the Family of a2 -> absolutely-additive;
end;

:: CLOSURE2:funcreg 10
registration
  let a1 be 1-sorted;
  let a2 be multiplicative ClosureStr over a1;
  cluster the Family of a2 -> multiplicative;
end;

:: CLOSURE2:funcreg 11
registration
  let a1 be 1-sorted;
  let a2 be absolutely-multiplicative ClosureStr over a1;
  cluster the Family of a2 -> absolutely-multiplicative;
end;

:: CLOSURE2:funcreg 12
registration
  let a1 be 1-sorted;
  let a2 be properly-upper-bound ClosureStr over a1;
  cluster the Family of a2 -> properly-upper-bound;
end;

:: CLOSURE2:funcreg 13
registration
  let a1 be 1-sorted;
  let a2 be properly-lower-bound ClosureStr over a1;
  cluster the Family of a2 -> properly-lower-bound;
end;

:: CLOSURE2:funcreg 14
registration
  let a1 be 1-sorted;
  let a2 be non-empty ManySortedSet of the carrier of a1;
  let a3 be Element of bool Bool a2;
  cluster ClosureStr(#a2,a3#) -> non-empty strict;
end;

:: CLOSURE2:funcreg 15
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be additive Element of bool Bool the Sorts of a2;
  cluster ClosureStr(#the Sorts of a2,a3#) -> strict additive;
end;

:: CLOSURE2:funcreg 16
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be absolutely-additive Element of bool Bool the Sorts of a2;
  cluster ClosureStr(#the Sorts of a2,a3#) -> strict absolutely-additive;
end;

:: CLOSURE2:funcreg 17
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be multiplicative Element of bool Bool the Sorts of a2;
  cluster ClosureStr(#the Sorts of a2,a3#) -> strict multiplicative;
end;

:: CLOSURE2:funcreg 18
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be absolutely-multiplicative Element of bool Bool the Sorts of a2;
  cluster ClosureStr(#the Sorts of a2,a3#) -> strict absolutely-multiplicative;
end;

:: CLOSURE2:funcreg 19
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be properly-upper-bound Element of bool Bool the Sorts of a2;
  cluster ClosureStr(#the Sorts of a2,a3#) -> strict properly-upper-bound;
end;

:: CLOSURE2:funcreg 20
registration
  let a1 be 1-sorted;
  let a2 be many-sorted over a1;
  let a3 be properly-lower-bound Element of bool Bool the Sorts of a2;
  cluster ClosureStr(#the Sorts of a2,a3#) -> strict properly-lower-bound;
end;

:: CLOSURE2:condreg 9
registration
  let a1 be 1-sorted;
  cluster absolutely-additive -> additive (ClosureStr over a1);
end;

:: CLOSURE2:condreg 10
registration
  let a1 be 1-sorted;
  cluster absolutely-multiplicative -> multiplicative (ClosureStr over a1);
end;

:: CLOSURE2:condreg 11
registration
  let a1 be 1-sorted;
  cluster absolutely-multiplicative -> properly-upper-bound (ClosureStr over a1);
end;

:: CLOSURE2:condreg 12
registration
  let a1 be 1-sorted;
  cluster absolutely-additive -> properly-lower-bound (ClosureStr over a1);
end;

:: CLOSURE2:modenot 4
definition
  let a1 be 1-sorted;
  mode ClosureSystem of a1 is absolutely-multiplicative ClosureStr over a1;
end;

:: CLOSURE2:modenot 5
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  mode ClosureOperator of a2 is Function-like quasi_total reflexive monotonic idempotent Relation of Bool a2,Bool a2;
end;

:: CLOSURE2:th 39
theorem
for b1 being 1-sorted
for b2 being ManySortedSet of the carrier of b1
for b3 being Function-like quasi_total reflexive monotonic Relation of Bool b2,Bool b2
for b4 being Element of bool Bool b2
      st b4 = {b5 where b5 is Element of Bool b2: b3 . b5 = b5}
   holds ClosureStr(#b2,b4#) is absolutely-multiplicative ClosureStr over b1;

:: CLOSURE2:funcnot 10 => CLOSURE2:func 10
definition
  let a1 be 1-sorted;
  let a2 be ManySortedSet of the carrier of a1;
  let a3 be Function-like quasi_total reflexive monotonic idempotent Relation of Bool a2,Bool a2;
  func ClOp->ClSys A3 -> strict absolutely-multiplicative ClosureStr over a1 means
    the Sorts of it = a2 &
     the Family of it = {b1 where b1 is Element of Bool a2: a3 . b1 = b1};
end;

:: CLOSURE2:def 23
theorem
for b1 being 1-sorted
for b2 being ManySortedSet of the carrier of b1
for b3 being Function-like quasi_total reflexive monotonic idempotent Relation of Bool b2,Bool b2
for b4 being strict absolutely-multiplicative ClosureStr over b1 holds
      b4 = ClOp->ClSys b3
   iff
      the Sorts of b4 = b2 &
       the Family of b4 = {b5 where b5 is Element of Bool b2: b3 . b5 = b5};

:: CLOSURE2:funcnot 11 => CLOSURE2:func 11
definition
  let a1 be 1-sorted;
  let a2 be absolutely-multiplicative ClosureStr over a1;
  let a3 be ManySortedSubset of the Sorts of a2;
  func Cl A3 -> Element of Bool the Sorts of a2 means
    ex b1 being Element of bool Bool the Sorts of a2 st
       it = meet |:b1:| &
        b1 = {b2 where b2 is Element of Bool the Sorts of a2: a3 c= b2 & b2 in the Family of a2};
end;

:: CLOSURE2:def 24
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative ClosureStr over b1
for b3 being ManySortedSubset of the Sorts of b2
for b4 being Element of Bool the Sorts of b2 holds
      b4 = Cl b3
   iff
      ex b5 being Element of bool Bool the Sorts of b2 st
         b4 = meet |:b5:| &
          b5 = {b6 where b6 is Element of Bool the Sorts of b2: b3 c= b6 & b6 in the Family of b2};

:: CLOSURE2:th 40
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative ClosureStr over b1
for b3 being Element of Bool the Sorts of b2
for b4 being Function-like quasi_total Relation of Bool the Sorts of b2,Bool the Sorts of b2
      st b3 in the Family of b2 &
         (for b5 being Element of Bool the Sorts of b2 holds
            b4 . b5 = Cl b5)
   holds b4 . b3 = b3;

:: CLOSURE2:th 41
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative ClosureStr over b1
for b3 being Element of Bool the Sorts of b2
for b4 being Function-like quasi_total Relation of Bool the Sorts of b2,Bool the Sorts of b2
      st b4 . b3 = b3 &
         (for b5 being Element of Bool the Sorts of b2 holds
            b4 . b5 = Cl b5)
   holds b3 in the Family of b2;

:: CLOSURE2:th 42
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative ClosureStr over b1
for b3 being Function-like quasi_total Relation of Bool the Sorts of b2,Bool the Sorts of b2
      st for b4 being Element of Bool the Sorts of b2 holds
           b3 . b4 = Cl b4
   holds b3 is reflexive(the carrier of b1, the Sorts of b2) & b3 is monotonic(the carrier of b1, the Sorts of b2) & b3 is idempotent(the carrier of b1, the Sorts of b2);

:: CLOSURE2:funcnot 12 => CLOSURE2:func 12
definition
  let a1 be 1-sorted;
  let a2 be absolutely-multiplicative ClosureStr over a1;
  func ClSys->ClOp A2 -> Function-like quasi_total reflexive monotonic idempotent Relation of Bool the Sorts of a2,Bool the Sorts of a2 means
    for b1 being Element of Bool the Sorts of a2 holds
       it . b1 = Cl b1;
end;

:: CLOSURE2:def 25
theorem
for b1 being 1-sorted
for b2 being absolutely-multiplicative ClosureStr over b1
for b3 being Function-like quasi_total reflexive monotonic idempotent Relation 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 holds
         b3 . b4 = Cl b4;

:: CLOSURE2:th 43
theorem
for b1 being 1-sorted
for b2 being ManySortedSet of the carrier of b1
for b3 being Function-like quasi_total reflexive monotonic idempotent Relation of Bool b2,Bool b2 holds
   ClSys->ClOp ClOp->ClSys b3 = b3;

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