Article FILTER_2, MML version 4.99.1005

:: FILTER_2:th 1
theorem
for b1 being non empty set
for b2 being non empty Element of bool b1
for b3 being Function-like quasi_total Relation of [:b1,b1:],b1
for b4 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b4 = b3 || b2
   holds (b3 is commutative(b1) implies b4 is commutative(b2)) & (b3 is idempotent(b1) implies b4 is idempotent(b2)) & (b3 is associative(b1) implies b4 is associative(b2));

:: FILTER_2:th 2
theorem
for b1 being non empty set
for b2 being non empty Element of bool b1
for b3 being Function-like quasi_total Relation of [:b1,b1:],b1
for b4 being Function-like quasi_total Relation of [:b2,b2:],b2
for b5 being Element of b1
for b6 being Element of b2
      st b4 = b3 || b2 & b6 = b5
   holds (b5 is_a_left_unity_wrt b3 implies b6 is_a_left_unity_wrt b4) & (b5 is_a_right_unity_wrt b3 implies b6 is_a_right_unity_wrt b4) & (b5 is_a_unity_wrt b3 implies b6 is_a_unity_wrt b4);

:: FILTER_2:th 3
theorem
for b1 being non empty set
for b2 being non empty Element of bool b1
for b3, b4 being Function-like quasi_total Relation of [:b1,b1:],b1
for b5, b6 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b5 = b3 || b2 & b6 = b4 || b2
   holds (b3 is_left_distributive_wrt b4 implies b5 is_left_distributive_wrt b6) & (b3 is_right_distributive_wrt b4 implies b5 is_right_distributive_wrt b6);

:: FILTER_2:th 4
theorem
for b1 being non empty set
for b2 being non empty Element of bool b1
for b3, b4 being Function-like quasi_total Relation of [:b1,b1:],b1
for b5, b6 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b5 = b3 || b2 & b6 = b4 || b2 & b3 is_distributive_wrt b4
   holds b5 is_distributive_wrt b6;

:: FILTER_2:th 5
theorem
for b1 being non empty set
for b2 being non empty Element of bool b1
for b3, b4 being Function-like quasi_total Relation of [:b1,b1:],b1
for b5, b6 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b5 = b3 || b2 & b6 = b4 || b2 & b3 absorbs b4
   holds b5 absorbs b6;

:: FILTER_2:prednot 1 => FILTER_2:pred 1
definition
  let a1 be non empty set;
  let a2, a3 be Element of bool a1;
  redefine pred A2 = A3 means
    for b1 being Element of a1 holds
          b1 in a2
       iff
          b1 in a3;
  symmetry;
::  for a1 being non empty set
::  for a2, a3 being Element of bool a1
::        st a2 = a3
::     holds a3 = a2;
  reflexivity;
::  for a1 being non empty set
::  for a2 being Element of bool a1 holds
::     a2 = a2;
end;

:: FILTER_2:dfs 1
definiens
  let a1 be non empty set;
  let a2, a3 be Element of bool a1;
To prove
     a2 = a3
it is sufficient to prove
  thus for b1 being Element of a1 holds
          b1 in a2
       iff
          b1 in a3;

:: FILTER_2:def 1
theorem
for b1 being non empty set
for b2, b3 being Element of bool b1 holds
   b2 = b3
iff
   for b4 being Element of b1 holds
         b4 in b2
      iff
         b4 in b3;

:: FILTER_2:th 6
theorem
for b1, b2 being LattStr
      st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
   holds b1 .: = b2 .:;

:: FILTER_2:th 7
theorem
for b1 being non empty Lattice-like LattStr holds
   b1 .: .: = LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#);

:: FILTER_2:th 8
theorem
for b1, b2 being non empty LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b3 = b5 & b4 = b6
   holds b3 "\/" b4 = b5 "\/" b6 & b3 "/\" b4 = b5 "/\" b6 & (b3 [= b4 implies b5 [= b6) & (b5 [= b6 implies b3 [= b4);

:: FILTER_2:th 9
theorem
for b1, b2 being non empty Lattice-like lower-bounded LattStr
      st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
   holds Bottom b1 = Bottom b2;

:: FILTER_2:th 10
theorem
for b1, b2 being non empty Lattice-like upper-bounded LattStr
      st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
   holds Top b1 = Top b2;

:: FILTER_2:th 11
theorem
for b1, b2 being non empty Lattice-like bounded complemented LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of b2
      st b3 = b5 & b4 = b6 & b3 is_a_complement_of b4
   holds b5 is_a_complement_of b6;

:: FILTER_2:th 12
theorem
for b1, b2 being non empty Lattice-like Boolean LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3 being Element of the carrier of b1
for b4 being Element of the carrier of b2
      st b3 = b4
   holds b3 ` = b4 `;

:: FILTER_2:th 13
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of bool the carrier of b1
      st for b3, b4 being Element of the carrier of b1 holds
           b3 in b2 & b4 in b2
        iff
           b3 "/\" b4 in b2
   holds b2 is ClosedSubset of b1;

:: FILTER_2:th 14
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of bool the carrier of b1
      st for b3, b4 being Element of the carrier of b1 holds
           b3 in b2 & b4 in b2
        iff
           b3 "\/" b4 in b2
   holds b2 is ClosedSubset of b1;

:: FILTER_2:modenot 1 => FILTER_2:mode 1
definition
  let a1 be non empty Lattice-like LattStr;
  redefine mode Filter of a1 -> non empty ClosedSubset of a1;
end;

:: FILTER_2:funcnot 1 => FILTER_2:func 1
definition
  let a1 be non empty Lattice-like LattStr;
  redefine func <.a1.) -> Filter of a1;
end;

:: FILTER_2:funcnot 2 => FILTER_2:func 2
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of a1;
  redefine func <.a2.) -> Filter of a1;
end;

:: FILTER_2:funcnot 3 => FILTER_2:func 3
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty Element of bool the carrier of a1;
  redefine func <.a2.) -> Filter of a1;
end;

:: FILTER_2:funcnot 4 => FILTER_2:func 4
definition
  let a1 be non empty Lattice-like distributive LattStr;
  let a2, a3 be Filter of a1;
  redefine func a2 "/\" a3 -> Filter of a1;
end;

:: FILTER_2:modenot 2 => FILTER_2:mode 2
definition
  let a1 be non empty Lattice-like LattStr;
  mode Ideal of A1 -> non empty ClosedSubset of a1 means
    for b1, b2 being Element of the carrier of a1 holds
       b1 in it & b2 in it
    iff
       b1 "\/" b2 in it;
end;

:: FILTER_2:dfs 2
definiens
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty ClosedSubset of a1;
To prove
     a2 is Ideal of a1
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
       b1 in a2 & b2 in a2
    iff
       b1 "\/" b2 in a2;

:: FILTER_2:def 3
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1 holds
      b2 is Ideal of b1
   iff
      for b3, b4 being Element of the carrier of b1 holds
         b3 in b2 & b4 in b2
      iff
         b3 "\/" b4 in b2;

:: FILTER_2:th 15
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1
      st for b3, b4 being Element of the carrier of b1 holds
           b3 in b2 & b4 in b2
        iff
           b3 "\/" b4 in b2
   holds b2 is Ideal of b1;

:: FILTER_2:th 16
theorem
for b1, b2 being non empty Lattice-like LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3 being set
      st b3 is Filter of b1
   holds b3 is Filter of b2;

:: FILTER_2:th 17
theorem
for b1, b2 being non empty Lattice-like LattStr
   st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#)
for b3 being set
      st b3 is Ideal of b1
   holds b3 is Ideal of b2;

:: FILTER_2:funcnot 5 => FILTER_2:func 5
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of a1;
  func A2 .: -> Element of the carrier of a1 .: equals
    a2;
end;

:: FILTER_2:def 4
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   b2 .: = b2;

:: FILTER_2:funcnot 6 => FILTER_2:func 6
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of a1 .:;
  func .: A2 -> Element of the carrier of a1 equals
    a2;
end;

:: FILTER_2:def 5
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 .: holds
   .: b2 = b2;

:: FILTER_2:th 18
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
for b3 being Element of the carrier of b1 .: holds
   .: (b2 .:) = b2 & (.: b3) .: = b3;

:: FILTER_2:th 19
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of b1 .: holds
b2 "/\" b3 = b2 .: "\/" (b3 .:) & b2 "\/" b3 = b2 .: "/\" (b3 .:) & b4 "/\" b5 = (.: b4) "\/" .: b5 & b4 "\/" b5 = (.: b4) "/\" .: b5;

:: FILTER_2:th 20
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of b1 .: holds
(b2 [= b3 implies b3 .: [= b2 .:) & (b3 .: [= b2 .: implies b2 [= b3) & (b4 [= b5 implies .: b5 [= .: b4) & (.: b5 [= .: b4 implies b4 [= b5);

:: FILTER_2:th 21
theorem
for b1 being non empty Lattice-like LattStr
for b2 being set holds
      b2 is Ideal of b1
   iff
      b2 is Filter of b1 .:;

:: FILTER_2:funcnot 7 => FILTER_2:func 7
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of bool the carrier of a1;
  func A2 .: -> Element of bool the carrier of a1 .: equals
    a2;
end;

:: FILTER_2:def 6
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of bool the carrier of b1 holds
   b2 .: = b2;

:: FILTER_2:funcnot 8 => FILTER_2:func 8
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of bool the carrier of a1 .:;
  func .: A2 -> Element of bool the carrier of a1 equals
    a2;
end;

:: FILTER_2:def 7
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of bool the carrier of b1 .: holds
   .: b2 = b2;

:: FILTER_2:funcreg 1
registration
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty Element of bool the carrier of a1;
  cluster a2 .: -> non empty;
end;

:: FILTER_2:funcreg 2
registration
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty Element of bool the carrier of a1 .:;
  cluster .: a2 -> non empty;
end;

:: FILTER_2:funcnot 9 => FILTER_2:func 9
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be ClosedSubset of a1;
  redefine func a2 .: -> ClosedSubset of a1 .:;
end;

:: FILTER_2:funcnot 10 => FILTER_2:func 10
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty ClosedSubset of a1;
  redefine func a2 .: -> non empty ClosedSubset of a1 .:;
end;

:: FILTER_2:funcnot 11 => FILTER_2:func 11
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be ClosedSubset of a1 .:;
  redefine func .: a2 -> ClosedSubset of a1;
end;

:: FILTER_2:funcnot 12 => FILTER_2:func 12
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty ClosedSubset of a1 .:;
  redefine func .: a2 -> non empty ClosedSubset of a1;
end;

:: FILTER_2:funcnot 13 => FILTER_2:func 13
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  redefine func a2 .: -> Ideal of a1 .:;
end;

:: FILTER_2:funcnot 14 => FILTER_2:func 14
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1 .:;
  redefine func .: a2 -> Ideal of a1;
end;

:: FILTER_2:funcnot 15 => FILTER_2:func 15
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Ideal of a1;
  redefine func a2 .: -> Filter of a1 .:;
end;

:: FILTER_2:funcnot 16 => FILTER_2:func 16
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Ideal of a1 .:;
  redefine func .: a2 -> Filter of a1;
end;

:: FILTER_2:th 22
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1 holds
      b2 is Ideal of b1
   iff
      (for b3, b4 being Element of the carrier of b1
             st b3 in b2 & b4 in b2
          holds b3 "\/" b4 in b2) &
       (for b3, b4 being Element of the carrier of b1
             st b3 in b2 & b4 [= b3
          holds b4 in b2);

:: FILTER_2:th 23
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Ideal of b1
      st b2 in b4
   holds b2 "/\" b3 in b4 & b3 "/\" b2 in b4;

:: FILTER_2:th 24
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1 holds
   ex b3 being Element of the carrier of b1 st
      b3 in b2;

:: FILTER_2:th 25
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1
      st b1 is lower-bounded
   holds Bottom b1 in b2;

:: FILTER_2:th 26
theorem
for b1 being non empty Lattice-like LattStr
      st b1 is lower-bounded
   holds {Bottom b1} is Ideal of b1;

:: FILTER_2:th 27
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st {b2} is Ideal of b1
   holds b1 is lower-bounded;

:: FILTER_2:th 28
theorem
for b1 being non empty Lattice-like LattStr holds
   the carrier of b1 is Ideal of b1;

:: FILTER_2:funcnot 17 => FILTER_2:func 17
definition
  let a1 be non empty Lattice-like LattStr;
  func (.A1.> -> Ideal of a1 equals
    the carrier of a1;
end;

:: FILTER_2:def 8
theorem
for b1 being non empty Lattice-like LattStr holds
   (.b1.> = the carrier of b1;

:: FILTER_2:funcnot 18 => FILTER_2:func 18
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of a1;
  func (.A2.> -> Ideal of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 [= a2};
end;

:: FILTER_2:def 9
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   (.b2.> = {b3 where b3 is Element of the carrier of b1: b3 [= b2};

:: FILTER_2:th 29
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 in (.b3.>
iff
   b2 [= b3;

:: FILTER_2:th 30
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   (.b2.> = <.b2 .:.) &
    (.b2 .:.> = <.b2.);

:: FILTER_2:th 31
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 in (.b2.> & b2 "/\" b3 in (.b2.> & b3 "/\" b2 in (.b2.>;

:: FILTER_2:th 32
theorem
for b1 being non empty Lattice-like LattStr
      st b1 is upper-bounded
   holds (.b1.> = (.Top b1.>;

:: FILTER_2:prednot 2 => FILTER_2:pred 2
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Ideal of a1;
  pred A2 is_max-ideal means
    a2 <> the carrier of a1 &
     (for b1 being Ideal of a1
           st a2 c= b1 & b1 <> the carrier of a1
        holds a2 = b1);
end;

:: FILTER_2:dfs 9
definiens
  let a1 be non empty Lattice-like LattStr;
  let a2 be Ideal of a1;
To prove
     a2 is_max-ideal
it is sufficient to prove
  thus a2 <> the carrier of a1 &
     (for b1 being Ideal of a1
           st a2 c= b1 & b1 <> the carrier of a1
        holds a2 = b1);

:: FILTER_2:def 10
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1 holds
      b2 is_max-ideal
   iff
      b2 <> the carrier of b1 &
       (for b3 being Ideal of b1
             st b2 c= b3 & b3 <> the carrier of b1
          holds b2 = b3);

:: FILTER_2:th 33
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1 holds
      b2 is_max-ideal
   iff
      b2 .: is being_ultrafilter(b1 .:);

:: FILTER_2:th 34
theorem
for b1 being non empty Lattice-like LattStr
   st b1 is upper-bounded
for b2 being Ideal of b1
      st b2 <> the carrier of b1
   holds ex b3 being Ideal of b1 st
      b2 c= b3 & b3 is_max-ideal;

:: FILTER_2:th 35
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st ex b3 being Element of the carrier of b1 st
           b2 "\/" b3 <> b2
   holds (.b2.> <> the carrier of b1;

:: FILTER_2:th 36
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is upper-bounded & b2 <> Top b1
   holds ex b3 being Ideal of b1 st
      b2 in b3 & b3 is_max-ideal;

:: FILTER_2:funcnot 19 => FILTER_2:func 19
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty Element of bool the carrier of a1;
  func (.A2.> -> Ideal of a1 means
    a2 c= it &
     (for b1 being Ideal of a1
           st a2 c= b1
        holds it c= b1);
end;

:: FILTER_2:def 11
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Ideal of b1 holds
      b3 = (.b2.>
   iff
      b2 c= b3 &
       (for b4 being Ideal of b1
             st b2 c= b4
          holds b3 c= b4);

:: FILTER_2:th 37
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1
for b3 being non empty Element of bool the carrier of b1 .: holds
   <.b2 .:.) = (.b2.> &
    <.b2.) = (.b2 .:.> &
    <..: b3.) = (.b3.> &
    <.b3.) = (..: b3.>;

:: FILTER_2:th 38
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1 holds
   (.b2.> = b2;

:: FILTER_2:th 39
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3, b4 being non empty Element of bool the carrier of b1 holds
(b3 c= b4 implies (.b3.> c= (.b4.>) &
 (.(.b2.>.> c= (.b2.>;

:: FILTER_2:th 40
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
for b3 being non empty Element of bool the carrier of b1
      st b2 in b3
   holds (.b2.> c= (.b3.>;

:: FILTER_2:th 41
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
for b3 being non empty Element of bool the carrier of b1
      st b3 = {b2}
   holds (.b3.> = (.b2.>;

:: FILTER_2:th 42
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1
      st b1 is upper-bounded & Top b1 in b2
   holds (.b2.> = (.b1.> & (.b2.> = the carrier of b1;

:: FILTER_2:th 43
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1
      st b1 is upper-bounded & Top b1 in b2
   holds b2 = (.b1.> & b2 = the carrier of b1;

:: FILTER_2:attrnot 1 => FILTER_2:attr 1
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Ideal of a1;
  attr a2 is prime means
    for b1, b2 being Element of the carrier of a1 holds
       b1 "/\" b2 in a2
    iff
       (b1 in a2 or b2 in a2);
end;

:: FILTER_2:dfs 11
definiens
  let a1 be non empty Lattice-like LattStr;
  let a2 be Ideal of a1;
To prove
     a2 is prime
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
       b1 "/\" b2 in a2
    iff
       (b1 in a2 or b2 in a2);

:: FILTER_2:def 12
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1 holds
      b2 is prime(b1)
   iff
      for b3, b4 being Element of the carrier of b1 holds
         b3 "/\" b4 in b2
      iff
         (b3 in b2 or b4 in b2);

:: FILTER_2:th 44
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1 holds
      b2 is prime(b1)
   iff
      b2 .: is prime(b1 .:);

:: FILTER_2:funcnot 20 => FILTER_2:func 20
definition
  let a1 be non empty Lattice-like LattStr;
  let a2, a3 be non empty Element of bool the carrier of a1;
  func A2 "\/" A3 -> Element of bool the carrier of a1 equals
    {b1 "\/" b2 where b1 is Element of the carrier of a1, b2 is Element of the carrier of a1: b1 in a2 & b2 in a3};
end;

:: FILTER_2:def 13
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being non empty Element of bool the carrier of b1 holds
b2 "\/" b3 = {b4 "\/" b5 where b4 is Element of the carrier of b1, b5 is Element of the carrier of b1: b4 in b2 & b5 in b3};

:: FILTER_2:funcreg 3
registration
  let a1 be non empty Lattice-like LattStr;
  let a2, a3 be non empty Element of bool the carrier of a1;
  cluster a2 "\/" a3 -> non empty;
end;

:: FILTER_2:th 45
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being non empty Element of bool the carrier of b1
for b4, b5 being non empty Element of bool the carrier of b1 .: holds
b2 "\/" b3 = b2 .: "/\" (b3 .:) & b2 .: "\/" (b3 .:) = b2 "/\" b3 & b4 "\/" b5 = (.: b4) "/\" .: b5 & (.: b4) "\/" .: b5 = b4 "/\" b5;

:: FILTER_2:th 46
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being non empty Element of bool the carrier of b1
      st b2 in b4 & b3 in b5
   holds b2 "\/" b3 in b4 "\/" b5 & b3 "\/" b2 in b4 "\/" b5;

:: FILTER_2:th 47
theorem
for b1 being non empty Lattice-like LattStr
for b2 being set
for b3, b4 being non empty Element of bool the carrier of b1
      st b2 in b3 "\/" b4
   holds ex b5, b6 being Element of the carrier of b1 st
      b2 = b5 "\/" b6 & b5 in b3 & b6 in b4;

:: FILTER_2:th 48
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being non empty Element of bool the carrier of b1 holds
b2 "\/" b3 = b3 "\/" b2;

:: FILTER_2:funcnot 21 => FILTER_2:func 21
definition
  let a1 be non empty Lattice-like distributive LattStr;
  let a2, a3 be Ideal of a1;
  redefine func a2 "\/" a3 -> Ideal of a1;
end;

:: FILTER_2:th 49
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being non empty Element of bool the carrier of b1 holds
(.b2 \/ b3.> = (.(.b2.> \/ b3.> &
 (.b2 \/ b3.> = (.b2 \/ (.b3.>.>;

:: FILTER_2:th 50
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Ideal of b1 holds
(.b2 \/ b3.> = {b4 where b4 is Element of the carrier of b1: ex b5, b6 being Element of the carrier of b1 st
   b4 [= b5 "\/" b6 & b5 in b2 & b6 in b3};

:: FILTER_2:th 51
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Ideal of b1 holds
b2 c= b2 "\/" b3 & b3 c= b2 "\/" b3;

:: FILTER_2:th 52
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Ideal of b1 holds
(.b2 \/ b3.> = (.b2 "\/" b3.>;

:: FILTER_2:th 53
theorem
for b1 being non empty Lattice-like LattStr holds
      b1 is non empty Lattice-like bounded complemented LattStr
   iff
      b1 .: is non empty Lattice-like bounded complemented LattStr;

:: FILTER_2:th 54
theorem
for b1 being non empty Lattice-like LattStr holds
      b1 is non empty Lattice-like Boolean LattStr
   iff
      b1 .: is non empty Lattice-like Boolean LattStr;

:: FILTER_2:funcreg 4
registration
  let a1 be non empty Lattice-like Boolean LattStr;
  cluster a1 .: -> strict Lattice-like Boolean;
end;

:: FILTER_2:th 55
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Element of the carrier of b1
for b3 being Element of the carrier of b1 .: holds
   b2 .: ` = b2 ` & (.: b3) ` = b3 `;

:: FILTER_2:th 56
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Ideal of b1 holds
(.b2 \/ b3.> = b2 "\/" b3;

:: FILTER_2:th 57
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Ideal of b1 holds
      b2 is_max-ideal
   iff
      b2 <> the carrier of b1 &
       (for b3 being Element of the carrier of b1
             st not b3 in b2
          holds b3 ` in b2);

:: FILTER_2:th 58
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Ideal of b1 holds
      b2 <> (.b1.> & b2 is prime(b1)
   iff
      b2 is_max-ideal;

:: FILTER_2:th 59
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Ideal of b1
   st b2 is_max-ideal
for b3 being Element of the carrier of b1 holds
      b3 in b2
   iff
      not b3 ` in b2;

:: FILTER_2:th 60
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1
      st b2 <> b3
   holds ex b4 being Ideal of b1 st
      b4 is_max-ideal &
       (b2 in b4 & not b3 in b4 or not b2 in b4 & b3 in b4);

:: FILTER_2:th 61
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1 holds
   (the L_join of b1) || b2 is Function-like quasi_total Relation of [:b2,b2:],b2 &
    (the L_meet of b1) || b2 is Function-like quasi_total Relation of [:b2,b2:],b2;

:: FILTER_2:th 62
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1
for b3, b4 being Function-like quasi_total Relation of [:b2,b2:],b2
      st b3 = (the L_join of b1) || b2 & b4 = (the L_meet of b1) || b2
   holds b3 is commutative(b2) & b3 is associative(b2) & b4 is commutative(b2) & b4 is associative(b2) & b3 absorbs b4 & b4 absorbs b3;

:: FILTER_2:funcnot 22 => FILTER_2:func 22
definition
  let a1 be non empty Lattice-like LattStr;
  let a2, a3 be Element of the carrier of a1;
  assume a2 [= a3;
  func [#A2,A3#] -> non empty ClosedSubset of a1 equals
    {b1 where b1 is Element of the carrier of a1: a2 [= b1 & b1 [= a3};
end;

:: FILTER_2:def 14
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
      st b2 [= b3
   holds [#b2,b3#] = {b4 where b4 is Element of the carrier of b1: b2 [= b4 & b4 [= b3};

:: FILTER_2:th 63
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3
   holds    b4 in [#b2,b3#]
   iff
      b2 [= b4 & b4 [= b3;

:: FILTER_2:th 64
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
      st b2 [= b3
   holds b2 in [#b2,b3#] & b3 in [#b2,b3#];

:: FILTER_2:th 65
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   [#b2,b2#] = {b2};

:: FILTER_2:th 66
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is upper-bounded
   holds <.b2.) = [#b2,Top b1#];

:: FILTER_2:th 67
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is lower-bounded
   holds (.b2.> = [#Bottom b1,b2#];

:: FILTER_2:th 68
theorem
for b1, b2 being non empty Lattice-like LattStr
for b3 being Filter of b1
for b4 being Filter of b2
      st LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) = LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#) &
         b3 = b4
   holds latt b3 = latt b4;

:: FILTER_2:modenot 3 => NAT_LAT:mode 2
notation
  let a1 be non empty Lattice-like LattStr;
  synonym Sublattice of a1 for SubLattice of a1;
end;

:: FILTER_2:modenot 4 => NAT_LAT:mode 2
definition
  let a1 be non empty Lattice-like LattStr;
  mode Sublattice of A1 -> non empty Lattice-like LattStr means
    ex b1 being non empty ClosedSubset of a1 st
       ex b2, b3 being Function-like quasi_total Relation of [:b1,b1:],b1 st
          b2 = (the L_join of a1) || b1 &
           b3 = (the L_meet of a1) || b1 &
           LattStr(#the carrier of it,the L_join of it,the L_meet of it#) = LattStr(#b1,b2,b3#);
end;

:: FILTER_2:dfs 14
definiens
  let a1, a2 be non empty Lattice-like LattStr;
To prove
     a2 is SubLattice of a1
it is sufficient to prove
  thus ex b1 being non empty ClosedSubset of a1 st
       ex b2, b3 being Function-like quasi_total Relation of [:b1,b1:],b1 st
          b2 = (the L_join of a1) || b1 &
           b3 = (the L_meet of a1) || b1 &
           LattStr(#the carrier of a2,the L_join of a2,the L_meet of a2#) = LattStr(#b1,b2,b3#);

:: FILTER_2:def 15
theorem
for b1, b2 being non empty Lattice-like LattStr holds
   b2 is SubLattice of b1
iff
   ex b3 being non empty ClosedSubset of b1 st
      ex b4, b5 being Function-like quasi_total Relation of [:b3,b3:],b3 st
         b4 = (the L_join of b1) || b3 &
          b5 = (the L_meet of b1) || b3 &
          LattStr(#the carrier of b2,the L_join of b2,the L_meet of b2#) = LattStr(#b3,b4,b5#);

:: FILTER_2:th 69
theorem
for b1 being non empty Lattice-like LattStr
for b2 being SubLattice of b1
for b3 being Element of the carrier of b2 holds
   b3 is Element of the carrier of b1;

:: FILTER_2:funcnot 23 => FILTER_2:func 23
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty ClosedSubset of a1;
  func latt(A1,A2) -> SubLattice of a1 means
    ex b1, b2 being Function-like quasi_total Relation of [:a2,a2:],a2 st
       b1 = (the L_join of a1) || a2 & b2 = (the L_meet of a1) || a2 & it = LattStr(#a2,b1,b2#);
end;

:: FILTER_2:def 16
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1
for b3 being SubLattice of b1 holds
      b3 = latt(b1,b2)
   iff
      ex b4, b5 being Function-like quasi_total Relation of [:b2,b2:],b2 st
         b4 = (the L_join of b1) || b2 & b5 = (the L_meet of b1) || b2 & b3 = LattStr(#b2,b4,b5#);

:: FILTER_2:funcreg 5
registration
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty ClosedSubset of a1;
  cluster latt(a1,a2) -> strict;
end;

:: FILTER_2:funcnot 24 => FILTER_2:func 24
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be SubLattice of a1;
  redefine func a2 .: -> strict SubLattice of a1 .:;
end;

:: FILTER_2:th 70
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
   latt b2 = latt(b1,b2);

:: FILTER_2:th 71
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1 holds
   latt(b1,b2) = (latt(b1 .:,b2 .:)) .:;

:: FILTER_2:th 72
theorem
for b1 being non empty Lattice-like LattStr holds
   latt(b1,(.b1.>) = LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#) &
    latt(b1,<.b1.)) = LattStr(#the carrier of b1,the L_join of b1,the L_meet of b1#);

:: FILTER_2:th 73
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1 holds
   the carrier of latt(b1,b2) = b2 &
    the L_join of latt(b1,b2) = (the L_join of b1) || b2 &
    the L_meet of latt(b1,b2) = (the L_meet of b1) || b2;

:: FILTER_2:th 74
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of latt(b1,b2)
      st b3 = b5 & b4 = b6
   holds b3 "\/" b4 = b5 "\/" b6 & b3 "/\" b4 = b5 "/\" b6;

:: FILTER_2:th 75
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1
for b3, b4 being Element of the carrier of b1
for b5, b6 being Element of the carrier of latt(b1,b2)
      st b3 = b5 & b4 = b6
   holds    b3 [= b4
   iff
      b5 [= b6;

:: FILTER_2:th 76
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Ideal of b1
      st b1 is lower-bounded
   holds latt(b1,b2) is lower-bounded;

:: FILTER_2:th 77
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1
      st b1 is modular
   holds latt(b1,b2) is modular;

:: FILTER_2:th 78
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty ClosedSubset of b1
      st b1 is distributive
   holds latt(b1,b2) is distributive;

:: FILTER_2:th 79
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
      st b1 is implicative & b2 [= b3
   holds latt(b1,[#b2,b3#]) is implicative;

:: FILTER_2:th 80
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   latt(b1,(.b2.>) is upper-bounded;

:: FILTER_2:th 81
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   Top latt(b1,(.b2.>) = b2;

:: FILTER_2:th 82
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is lower-bounded
   holds latt(b1,(.b2.>) is lower-bounded &
    Bottom latt(b1,(.b2.>) = Bottom b1;

:: FILTER_2:th 83
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is lower-bounded
   holds latt(b1,(.b2.>) is bounded;

:: FILTER_2:th 84
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
      st b2 [= b3
   holds latt(b1,[#b2,b3#]) is bounded & Top latt(b1,[#b2,b3#]) = b3 & Bottom latt(b1,[#b2,b3#]) = b2;

:: FILTER_2:th 85
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is non empty Lattice-like bounded complemented LattStr &
         b1 is modular
   holds latt(b1,(.b2.>) is non empty Lattice-like bounded complemented LattStr;

:: FILTER_2:th 86
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
      st b1 is non empty Lattice-like bounded complemented LattStr &
         b1 is modular &
         b2 [= b3
   holds latt(b1,[#b2,b3#]) is non empty Lattice-like bounded complemented LattStr;

:: FILTER_2:th 87
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
      st b1 is non empty Lattice-like Boolean LattStr & b2 [= b3
   holds latt(b1,[#b2,b3#]) is non empty Lattice-like Boolean LattStr;