Article CLOSURE3, MML version 4.99.1005

:: CLOSURE3:funcreg 1
registration
  let a1 be non empty 1-sorted;
  cluster 1-sorted(#the carrier of a1#) -> strict non empty;
end;

:: CLOSURE3:th 1
theorem
for b1 being non empty set
for b2, b3 being ManySortedSet of b1 holds
b2 +* b3 = b3;

:: CLOSURE3:th 2
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 meet |:b4:| c= b3;

:: CLOSURE3:th 3
theorem
for b1 being non empty non void ManySortedSign
for b2 being strict non-empty MSAlgebra over b1
for b3 being Element of bool Bool the Sorts of b2
   st b3 c= SubSort b2
for b4 being ManySortedSubset of the Sorts of b2
      st b4 = meet |:b3:|
   holds b4 is opers_closed(b1, b2);

:: CLOSURE3:prednot 1 => CLOSURE3:pred 1
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Element of bool Bool a2;
  pred A4 is_finer_than A3 means
    for b1 being set
          st b1 in a4
       holds ex b2 being set st
          b2 in a3 & b1 c= b2;
  reflexivity;
::  for a1 being set
::  for a2 being ManySortedSet of a1
::  for a3 being Element of bool Bool a2 holds
::     a3 is_finer_than a3;
end;

:: CLOSURE3:dfs 1
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Element of bool Bool a2;
To prove
     a4 is_finer_than a3
it is sufficient to prove
  thus for b1 being set
          st b1 in a4
       holds ex b2 being set st
          b2 in a3 & b1 c= b2;

:: CLOSURE3:def 1
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
   b4 is_finer_than b3
iff
   for b5 being set
         st b5 in b4
      holds ex b6 being set st
         b6 in b3 & b5 c= b6;

:: CLOSURE3:prednot 2 => CLOSURE3:pred 2
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Element of bool Bool a2;
  pred A3 is_coarser_than A4 means
    for b1 being set
          st b1 in a3
       holds ex b2 being set st
          b2 in a4 & b2 c= b1;
  reflexivity;
::  for a1 being set
::  for a2 being ManySortedSet of a1
::  for a3 being Element of bool Bool a2 holds
::     a3 is_coarser_than a3;
end;

:: CLOSURE3:dfs 2
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Element of bool Bool a2;
To prove
     a3 is_coarser_than a4
it is sufficient to prove
  thus for b1 being set
          st b1 in a3
       holds ex b2 being set st
          b2 in a4 & b2 c= b1;

:: CLOSURE3:def 2
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
   b3 is_coarser_than b4
iff
   for b5 being set
         st b5 in b3
      holds ex b6 being set st
         b6 in b4 & b6 c= b5;

:: CLOSURE3:th 4
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4, b5 being Element of bool Bool b2
      st b3 is_finer_than b4 & b4 is_finer_than b5
   holds b3 is_finer_than b5;

:: CLOSURE3:th 5
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4, b5 being Element of bool Bool b2
      st b3 is_coarser_than b4 & b4 is_coarser_than b5
   holds b3 is_coarser_than b5;

:: CLOSURE3:funcnot 1 => CLOSURE3:func 1
definition
  let a1 be non empty set;
  let a2 be ManySortedSet of a1;
  func supp A2 -> set means
    it = {b1 where b1 is Element of a1: a2 . b1 <> {}};
end;

:: CLOSURE3:def 3
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3 being set holds
      b3 = supp b2
   iff
      b3 = {b4 where b4 is Element of b1: b2 . b4 <> {}};

:: CLOSURE3:th 6
theorem
for b1 being non empty set
for b2 being non-empty ManySortedSet of b1 holds
   b2 = ([0] b1) +* (b2 | supp b2);

:: CLOSURE3:th 7
theorem
for b1 being non empty set
for b2, b3 being non-empty ManySortedSet of b1
      st supp b2 = supp b3 & b2 | supp b2 = b3 | supp b3
   holds b2 = b3;

:: CLOSURE3:th 8
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3 being Element of b1
      st not b3 in supp b2
   holds b2 . b3 = {};

:: CLOSURE3:th 9
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3 being Element of Bool b2
for b4 being Element of b1
for b5 being set
      st b5 in b3 . b4
   holds ex b6 being Element of Bool b2 st
      b5 in b6 . b4 & b6 is finite-yielding & supp b6 is finite & b6 c= b3;

:: CLOSURE3:funcnot 2 => CLOSURE3:func 2
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be Element of bool Bool a2;
  func MSUnion A3 -> ManySortedSubset of a2 means
    for b1 being set
          st b1 in a1
       holds it . b1 = union {b2 . b1 where b2 is Element of Bool a2: b2 in a3};
end;

:: CLOSURE3:def 4
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 holds
      b4 = MSUnion b3
   iff
      for b5 being set
            st b5 in b1
         holds b4 . b5 = union {b6 . b5 where b6 is Element of Bool b2: b6 in b3};

:: CLOSURE3:modenot 1 => CLOSURE3: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 -> ManySortedSet of a1;
end;

:: CLOSURE3:funcreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3 be empty Element of bool Bool a2;
  cluster MSUnion a3 -> empty-yielding;
end;

:: CLOSURE3:th 10
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being Element of bool Bool b2 holds
   MSUnion b3 = union |:b3:|;

:: CLOSURE3:funcnot 3 => CLOSURE3:func 3
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Element of bool Bool a2;
  redefine func a3 \/ a4 -> Element of bool Bool a2;
  commutativity;
::  for a1 being set
::  for a2 being ManySortedSet of a1
::  for a3, a4 being Element of bool Bool a2 holds
::  a3 \/ a4 = a4 \/ a3;
  idempotence;
::  for a1 being set
::  for a2 being ManySortedSet of a1
::  for a3 being Element of bool Bool a2 holds
::     a3 \/ a3 = a3;
end;

:: CLOSURE3:th 11
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
MSUnion (b3 \/ b4) = (MSUnion b3) \/ MSUnion b4;

:: CLOSURE3:th 12
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2
      st b3 c= b4
   holds MSUnion b3 c= MSUnion b4;

:: CLOSURE3:funcnot 4 => CLOSURE3:func 4
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  let a3, a4 be Element of bool Bool a2;
  redefine func a3 /\ a4 -> Element of bool Bool a2;
  commutativity;
::  for a1 being set
::  for a2 being ManySortedSet of a1
::  for a3, a4 being Element of bool Bool a2 holds
::  a3 /\ a4 = a4 /\ a3;
  idempotence;
::  for a1 being set
::  for a2 being ManySortedSet of a1
::  for a3 being Element of bool Bool a2 holds
::     a3 /\ a3 = a3;
end;

:: CLOSURE3:th 13
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3, b4 being Element of bool Bool b2 holds
MSUnion (b3 /\ b4) c= (MSUnion b3) /\ MSUnion b4;

:: CLOSURE3:th 14
theorem
for b1 being set
for b2 being ManySortedSet of b1
for b3 being set
   st for b4 being set
           st b4 in b3
        holds b4 is Element of bool Bool b2
for b4, b5 being Element of bool Bool b2
      st b5 = {MSUnion b6 where b6 is Element of bool Bool b2: b6 in b3} &
         b4 = union b3
   holds MSUnion b5 = MSUnion b4;

:: CLOSURE3:attrnot 1 => CLOSURE3:attr 1
definition
  let a1 be non empty set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation of Bool a2,Bool a2;
  attr a3 is algebraic means
    for b1 being Element of Bool a2
          st b1 = a3 . b1
       holds ex b2 being Element of bool Bool a2 st
          b2 = {a3 . b3 where b3 is Element of Bool a2: b3 is finite-yielding & supp b3 is finite & b3 c= b1} &
           b1 = MSUnion b2;
end;

:: CLOSURE3:dfs 5
definiens
  let a1 be non empty set;
  let a2 be ManySortedSet of a1;
  let a3 be Function-like quasi_total Relation of Bool a2,Bool a2;
To prove
     a3 is algebraic
it is sufficient to prove
  thus for b1 being Element of Bool a2
          st b1 = a3 . b1
       holds ex b2 being Element of bool Bool a2 st
          b2 = {a3 . b3 where b3 is Element of Bool a2: b3 is finite-yielding & supp b3 is finite & b3 c= b1} &
           b1 = MSUnion b2;

:: CLOSURE3:def 5
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3 being Function-like quasi_total Relation of Bool b2,Bool b2 holds
      b3 is algebraic(b1, b2)
   iff
      for b4 being Element of Bool b2
            st b4 = b3 . b4
         holds ex b5 being Element of bool Bool b2 st
            b5 = {b3 . b6 where b6 is Element of Bool b2: b6 is finite-yielding & supp b6 is finite & b6 c= b4} &
             b4 = MSUnion b5;

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

:: CLOSURE3:attrnot 2 => CLOSURE3:attr 2
definition
  let a1 be non empty 1-sorted;
  let a2 be absolutely-multiplicative ClosureStr over a1;
  attr a2 is algebraic means
    ClSys->ClOp a2 is algebraic(the carrier of a1, the Sorts of a2);
end;

:: CLOSURE3:dfs 6
definiens
  let a1 be non empty 1-sorted;
  let a2 be absolutely-multiplicative ClosureStr over a1;
To prove
     a2 is algebraic
it is sufficient to prove
  thus ClSys->ClOp a2 is algebraic(the carrier of a1, the Sorts of a2);

:: CLOSURE3:def 6
theorem
for b1 being non empty 1-sorted
for b2 being absolutely-multiplicative ClosureStr over b1 holds
      b2 is algebraic(b1)
   iff
      ClSys->ClOp b2 is algebraic(the carrier of b1, the Sorts of b2);

:: CLOSURE3:funcnot 5 => CLOSURE3:func 5
definition
  let a1 be non empty non void ManySortedSign;
  let a2 be non-empty MSAlgebra over a1;
  func SubAlgCl A2 -> strict ClosureStr over 1-sorted(#the carrier of a1#) means
    the Sorts of it = the Sorts of a2 & the Family of it = SubSort a2;
end;

:: CLOSURE3:def 7
theorem
for b1 being non empty non void ManySortedSign
for b2 being non-empty MSAlgebra over b1
for b3 being strict ClosureStr over 1-sorted(#the carrier of b1#) holds
      b3 = SubAlgCl b2
   iff
      the Sorts of b3 = the Sorts of b2 & the Family of b3 = SubSort b2;

:: CLOSURE3:th 16
theorem
for b1 being non empty non void ManySortedSign
for b2 being strict non-empty MSAlgebra over b1 holds
   SubSort b2 is absolutely-multiplicative Element of bool Bool the Sorts of b2;

:: CLOSURE3:funcreg 3
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be strict non-empty MSAlgebra over a1;
  cluster SubAlgCl a2 -> strict absolutely-multiplicative;
end;

:: CLOSURE3:funcreg 4
registration
  let a1 be non empty non void ManySortedSign;
  let a2 be strict non-empty MSAlgebra over a1;
  cluster SubAlgCl a2 -> strict algebraic;
end;