Article FILTER_0, MML version 4.99.1005

:: FILTER_0:th 1
theorem
for b1 being non empty join-commutative join-associative meet-commutative meet-absorbing join-absorbing LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3
   holds b4 "\/" b2 [= b4 "\/" b3;

:: FILTER_0:th 2
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3
   holds b2 "/\" b4 [= b3;

:: FILTER_0:th 3
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3
   holds b2 [= b4 "\/" b3;

:: FILTER_0:th 4
theorem
for b1 being non empty join-commutative join-associative join-absorbing LattStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2 [= b3 & b4 [= b5
   holds b2 "\/" b4 [= b3 "\/" b5;

:: FILTER_0:th 5
theorem
for b1 being non empty meet-commutative meet-associative meet-absorbing join-absorbing LattStr
for b2, b3, b4, b5 being Element of the carrier of b1
      st b2 [= b3 & b4 [= b5
   holds b2 "/\" b4 [= b3 "/\" b5;

:: FILTER_0:th 6
theorem
for b1 being non empty join-commutative join-associative meet-commutative meet-absorbing join-absorbing LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b4 & b3 [= b4
   holds b2 "\/" b3 [= b4;

:: FILTER_0:th 7
theorem
for b1 being non empty meet-commutative meet-associative meet-absorbing join-absorbing LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b3 & b2 [= b4
   holds b2 [= b3 "/\" b4;

:: FILTER_0:modenot 1 => FILTER_0:mode 1
definition
  let a1 be non empty Lattice-like LattStr;
  mode Filter of A1 -> non empty Element of bool the carrier 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_0:dfs 1
definiens
  let a1 be non empty Lattice-like LattStr;
  let a2 be non empty Element of bool the carrier of a1;
To prove
     a2 is Filter 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_0:def 1
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1 holds
      b2 is Filter 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_0:th 9
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1 holds
      b2 is Filter 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 & b3 [= b4
          holds b4 in b2);

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

:: FILTER_0:th 11
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
   ex b3 being Element of the carrier of b1 st
      b3 in b2;

:: FILTER_0:th 12
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like upper-bounded LattStr
   holds Top b1 in b2;

:: FILTER_0:th 13
theorem
for b1 being non empty Lattice-like LattStr
      st b1 is non empty Lattice-like upper-bounded LattStr
   holds {Top b1} is Filter of b1;

:: FILTER_0:th 14
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st {b2} is Filter of b1
   holds b1 is upper-bounded;

:: FILTER_0:th 15
theorem
for b1 being non empty Lattice-like LattStr holds
   the carrier of b1 is Filter of b1;

:: FILTER_0:funcnot 1 => FILTER_0:func 1
definition
  let a1 be non empty Lattice-like LattStr;
  func <.A1.) -> Filter of a1 equals
    the carrier of a1;
end;

:: FILTER_0:def 2
theorem
for b1 being non empty Lattice-like LattStr holds
   <.b1.) = the carrier of b1;

:: FILTER_0:funcnot 2 => FILTER_0:func 2
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Element of the carrier of a1;
  func <.A2.) -> Filter of a1 equals
    {b1 where b1 is Element of the carrier of a1: a2 [= b1};
end;

:: FILTER_0:def 3
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: b2 [= b3};

:: FILTER_0:th 18
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 in <.b3.)
iff
   b3 [= b2;

:: FILTER_0:th 19
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_0:th 20
theorem
for b1 being non empty Lattice-like LattStr
      st b1 is non empty Lattice-like lower-bounded LattStr
   holds <.b1.) = <.Bottom b1.);

:: FILTER_0:attrnot 1 => FILTER_0:attr 1
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  attr a2 is being_ultrafilter means
    a2 <> the carrier of a1 &
     (for b1 being Filter of a1
           st a2 c= b1 & b1 <> the carrier of a1
        holds a2 = b1);
end;

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

:: FILTER_0:def 4
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
      b2 is being_ultrafilter(b1)
   iff
      b2 <> the carrier of b1 &
       (for b3 being Filter of b1
             st b2 c= b3 & b3 <> the carrier of b1
          holds b2 = b3);

:: FILTER_0:prednot 1 => FILTER_0:attr 1
notation
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  synonym a2 is_ultrafilter for being_ultrafilter;
end;

:: FILTER_0:th 22
theorem
for b1 being non empty Lattice-like LattStr
   st b1 is lower-bounded
for b2 being Filter of b1
      st b2 <> the carrier of b1
   holds ex b3 being Filter of b1 st
      b2 c= b3 & b3 is being_ultrafilter(b1);

:: FILTER_0:th 23
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_0:th 24
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 lower-bounded LattStr & b2 <> Bottom b1
   holds ex b3 being Filter of b1 st
      b2 in b3 & b3 is being_ultrafilter(b1);

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

:: FILTER_0:def 5
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1
for b3 being Filter of b1 holds
      b3 = <.b2.)
   iff
      b2 c= b3 &
       (for b4 being Filter of b1
             st b2 c= b4
          holds b3 c= b4);

:: FILTER_0:th 26
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
   <.b2.) = b2;

:: FILTER_0:th 27
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being non empty Element of bool the carrier of b1
      st b2 c= b3
   holds <.b2.) c= <.b3.);

:: FILTER_0:th 29
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_0:th 30
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_0:th 31
theorem
for b1 being non empty Lattice-like LattStr
for b2 being non empty Element of bool the carrier of b1
      st b1 is non empty Lattice-like lower-bounded LattStr & Bottom b1 in b2
   holds <.b2.) = <.b1.) & <.b2.) = the carrier of b1;

:: FILTER_0:th 32
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like lower-bounded LattStr & Bottom b1 in b2
   holds b2 = <.b1.) & b2 = the carrier of b1;

:: FILTER_0:attrnot 2 => FILTER_0:attr 2
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter 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_0:dfs 6
definiens
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter 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_0:def 6
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter 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_0:th 34
theorem
for b1 being non empty Lattice-like LattStr
   st b1 is non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 "/\" (b2 ` "\/" b3) [= b3 &
 (for b4 being Element of the carrier of b1
       st b2 "/\" b4 [= b3
    holds b4 [= b2 ` "\/" b3);

:: FILTER_0:attrnot 3 => FILTER_0:attr 3
definition
  let a1 be non empty LattStr;
  attr a1 is implicative means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 "/\" b3 [= b2 &
        (for b4 being Element of the carrier of a1
              st b1 "/\" b4 [= b2
           holds b4 [= b3);
end;

:: FILTER_0:dfs 7
definiens
  let a1 be non empty LattStr;
To prove
     a1 is implicative
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being Element of the carrier of a1 st
       b1 "/\" b3 [= b2 &
        (for b4 being Element of the carrier of a1
              st b1 "/\" b4 [= b2
           holds b4 [= b3);

:: FILTER_0:def 7
theorem
for b1 being non empty LattStr holds
      b1 is implicative
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being Element of the carrier of b1 st
         b2 "/\" b4 [= b3 &
          (for b5 being Element of the carrier of b1
                st b2 "/\" b5 [= b3
             holds b5 [= b4);

:: FILTER_0:exreg 1
registration
  cluster non empty strict join-commutative join-associative meet-commutative meet-associative meet-absorbing join-absorbing Lattice-like implicative LattStr;
end;

:: FILTER_0:modenot 2
definition
  mode I_Lattice is non empty Lattice-like implicative LattStr;
end;

:: FILTER_0:funcnot 4 => FILTER_0:func 4
definition
  let a1 be non empty Lattice-like LattStr;
  let a2, a3 be Element of the carrier of a1;
  assume a1 is non empty Lattice-like implicative LattStr;
  func A2 => A3 -> Element of the carrier of a1 means
    a2 "/\" it [= a3 &
     (for b1 being Element of the carrier of a1
           st a2 "/\" b1 [= a3
        holds b1 [= it);
end;

:: FILTER_0:def 8
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 implicative LattStr
for b4 being Element of the carrier of b1 holds
      b4 = b2 => b3
   iff
      b2 "/\" b4 [= b3 &
       (for b5 being Element of the carrier of b1
             st b2 "/\" b5 [= b3
          holds b5 [= b4);

:: FILTER_0:th 37
theorem
for b1 being non empty Lattice-like implicative LattStr holds
   b1 is upper-bounded;

:: FILTER_0:th 38
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2 being Element of the carrier of b1 holds
   b2 => b2 = Top b1;

:: FILTER_0:th 39
theorem
for b1 being non empty Lattice-like implicative LattStr holds
   b1 is distributive;

:: FILTER_0:th 40
theorem
for b1 being non empty Lattice-like Boolean LattStr holds
   b1 is implicative;

:: FILTER_0:condreg 1
registration
  cluster non empty Lattice-like implicative -> distributive (LattStr);
end;

:: FILTER_0:th 41
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1
      st b2 in b4 & b2 => b3 in b4
   holds b3 in b4;

:: FILTER_0:th 42
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1
      st b2 in b4
   holds b3 => b2 in b4;

:: FILTER_0:funcnot 5 => FILTER_0:func 5
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_0:def 9
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_0:funcreg 1
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_0:th 44
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_0:th 45
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_0:th 46
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_0:funcnot 6 => FILTER_0:func 6
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_0:funcnot 7 => FILTER_0:func 7
definition
  let a1 be non empty Lattice-like Boolean LattStr;
  let a2, a3 be Filter of a1;
  redefine func a2 "/\" a3 -> Filter of a1;
end;

:: FILTER_0:th 47
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_0:th 48
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Filter 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
   b5 "/\" b6 [= b4 & b5 in b2 & b6 in b3};

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

:: FILTER_0:th 50
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Filter of b1 holds
<.b2 \/ b3.) = <.b2 "/\" b3.);

:: FILTER_0:th 51
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2, b3 being Filter of b1 holds
<.b2 \/ b3.) = b2 "/\" b3;

:: FILTER_0:th 52
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Filter of b1 holds
<.b2 \/ b3.) = b2 "/\" b3;

:: FILTER_0:th 53
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2, b3 being Element of the carrier of b1
for b4 being non empty Element of bool the carrier of b1
      st b2 in <.b4 \/ {b3}.)
   holds b3 => b2 in <.b4.);

:: FILTER_0:th 54
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2, b3, b4 being Element of the carrier of b1
for b5 being Filter of b1
      st b2 => b3 in b5 & b3 => b4 in b5
   holds b2 => b4 in b5;

:: FILTER_0:th 55
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 => b3 = b2 ` "\/" b3;

:: FILTER_0:th 56
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2, b3 being Element of the carrier of b1 holds
   b2 [= b3
iff
   b2 "/\" (b3 `) = Bottom b1;

:: FILTER_0:th 57
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Filter of b1 holds
      b2 is being_ultrafilter(b1)
   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_0:th 58
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Filter of b1 holds
      b2 <> <.b1.) & b2 is prime(b1)
   iff
      b2 is being_ultrafilter(b1);

:: FILTER_0:th 59
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Filter of b1
   st b2 is being_ultrafilter(b1)
for b3 being Element of the carrier of b1 holds
      b3 in b2
   iff
      not b3 ` in b2;

:: FILTER_0: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 Filter of b1 st
      b4 is being_ultrafilter(b1) &
       (b2 in b4 & not b3 in b4 or not b2 in b4 & b3 in b4);

:: FILTER_0:funcnot 8 => FILTER_0:func 8
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  func latt A2 -> non empty Lattice-like LattStr 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_0:def 10
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
for b3 being non empty Lattice-like LattStr holds
      b3 = latt 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_0:funcreg 2
registration
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  cluster latt a2 -> non empty strict Lattice-like;
end;

:: FILTER_0:th 62
theorem
for b1 being non empty strict Lattice-like LattStr holds
   latt <.b1.) = b1;

:: FILTER_0:th 63
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
   the carrier of latt b2 = b2 & the L_join of latt b2 = (the L_join of b1) || b2 & the L_meet of latt b2 = (the L_meet of b1) || b2;

:: FILTER_0:th 64
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1
for b5, b6 being Element of the carrier of latt b4
      st b2 = b5 & b3 = b6
   holds b2 "\/" b3 = b5 "\/" b6 & b2 "/\" b3 = b5 "/\" b6;

:: FILTER_0:th 65
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1
for b5, b6 being Element of the carrier of latt b4
      st b2 = b5 & b3 = b6
   holds    b2 [= b3
   iff
      b5 [= b6;

:: FILTER_0:th 66
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is upper-bounded
   holds latt b2 is upper-bounded;

:: FILTER_0:th 67
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is modular
   holds latt b2 is modular;

:: FILTER_0:th 68
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is distributive
   holds latt b2 is distributive;

:: FILTER_0:th 69
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like implicative LattStr
   holds latt b2 is implicative;

:: FILTER_0:th 70
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   latt <.b2.) is lower-bounded;

:: FILTER_0:th 71
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1 holds
   Bottom latt <.b2.) = b2;

:: FILTER_0:th 72
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Element of the carrier of b1
      st b1 is upper-bounded
   holds Top latt <.b2.) = Top b1;

:: FILTER_0:th 73
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 upper-bounded LattStr
   holds latt <.b2.) is bounded;

:: FILTER_0:th 74
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 non empty Lattice-like modular LattStr
   holds latt <.b2.) is non empty Lattice-like bounded complemented LattStr;

:: FILTER_0:th 75
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 Boolean LattStr
   holds latt <.b2.) is non empty Lattice-like Boolean LattStr;

:: FILTER_0:funcnot 9 => FILTER_0:func 9
definition
  let a1 be non empty Lattice-like LattStr;
  let a2, a3 be Element of the carrier of a1;
  func A2 <=> A3 -> Element of the carrier of a1 equals
    (a2 => a3) "/\" (a3 => a2);
end;

:: FILTER_0:def 11
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 <=> b3 = (b2 => b3) "/\" (b3 => b2);

:: FILTER_0:th 77
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1 holds
b2 <=> b3 = b3 <=> b2;

:: FILTER_0:th 78
theorem
for b1 being non empty Lattice-like implicative LattStr
for b2, b3, b4 being Element of the carrier of b1
for b5 being Filter of b1
      st b2 <=> b3 in b5 & b3 <=> b4 in b5
   holds b2 <=> b4 in b5;

:: FILTER_0:funcnot 10 => FILTER_0:func 10
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  func equivalence_wrt A2 -> Relation-like set means
    field it c= the carrier of a1 &
     (for b1, b2 being Element of the carrier of a1 holds
        [b1,b2] in it
     iff
        b1 <=> b2 in a2);
end;

:: FILTER_0:def 12
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
for b3 being Relation-like set holds
      b3 = equivalence_wrt b2
   iff
      field b3 c= the carrier of b1 &
       (for b4, b5 being Element of the carrier of b1 holds
          [b4,b5] in b3
       iff
          b4 <=> b5 in b2);

:: FILTER_0:th 80
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
   equivalence_wrt b2 is Relation of the carrier of b1,the carrier of b1;

:: FILTER_0:th 81
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like implicative LattStr
   holds equivalence_wrt b2 is_reflexive_in the carrier of b1;

:: FILTER_0:th 82
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1 holds
   equivalence_wrt b2 is_symmetric_in the carrier of b1;

:: FILTER_0:th 83
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like implicative LattStr
   holds equivalence_wrt b2 is_transitive_in the carrier of b1;

:: FILTER_0:th 84
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like implicative LattStr
   holds equivalence_wrt b2 is symmetric transitive total Relation of the carrier of b1,the carrier of b1;

:: FILTER_0:th 85
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
      st b1 is non empty Lattice-like implicative LattStr
   holds field equivalence_wrt b2 = the carrier of b1;

:: FILTER_0:funcnot 11 => FILTER_0:func 11
definition
  let a1 be non empty Lattice-like implicative LattStr;
  let a2 be Filter of a1;
  redefine func equivalence_wrt a2 -> symmetric transitive total Relation of the carrier of a1,the carrier of a1;
end;

:: FILTER_0:funcnot 12 => FILTER_0:func 12
definition
  let a1 be non empty Lattice-like Boolean LattStr;
  let a2 be Filter of a1;
  redefine func equivalence_wrt a2 -> symmetric transitive total Relation of the carrier of a1,the carrier of a1;
end;

:: FILTER_0:prednot 2 => FILTER_0:pred 1
definition
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  let a3, a4 be Element of the carrier of a1;
  pred A3,A4 are_equivalence_wrt A2 means
    a3 <=> a4 in a2;
end;

:: FILTER_0:dfs 13
definiens
  let a1 be non empty Lattice-like LattStr;
  let a2 be Filter of a1;
  let a3, a4 be Element of the carrier of a1;
To prove
     a3,a4 are_equivalence_wrt a2
it is sufficient to prove
  thus a3 <=> a4 in a2;

:: FILTER_0:def 13
theorem
for b1 being non empty Lattice-like LattStr
for b2 being Filter of b1
for b3, b4 being Element of the carrier of b1 holds
   b3,b4 are_equivalence_wrt b2
iff
   b3 <=> b4 in b2;

:: FILTER_0:th 87
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1 holds
      b2,b3 are_equivalence_wrt b4
   iff
      [b2,b3] in equivalence_wrt b4;

:: FILTER_0:th 88
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Filter of b1
for b3 being non empty Lattice-like implicative LattStr
for b4 being Element of the carrier of b3
for b5 being Filter of b3
for b6 being Element of the carrier of b1 holds
   b4,b4 are_equivalence_wrt b5 & b6,b6 are_equivalence_wrt b2;

:: FILTER_0:th 89
theorem
for b1 being non empty Lattice-like LattStr
for b2, b3 being Element of the carrier of b1
for b4 being Filter of b1
      st b2,b3 are_equivalence_wrt b4
   holds b3,b2 are_equivalence_wrt b4;

:: FILTER_0:th 90
theorem
for b1 being non empty Lattice-like Boolean LattStr
for b2 being Filter of b1
for b3 being non empty Lattice-like implicative LattStr
for b4, b5, b6 being Element of the carrier of b3
for b7 being Filter of b3
for b8, b9, b10 being Element of the carrier of b1 holds
(b4,b5 are_equivalence_wrt b7 & b5,b6 are_equivalence_wrt b7 implies b4,b6 are_equivalence_wrt b7) &
 (b8,b9 are_equivalence_wrt b2 & b9,b10 are_equivalence_wrt b2 implies b8,b10 are_equivalence_wrt b2);

:: FILTER_0:th 91
theorem
for b1 being non empty join-commutative meet-commutative meet-associative meet-absorbing join-absorbing LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b4 [= b2 &
         b4 [= b3 &
         (for b5 being Element of the carrier of b1
               st b5 [= b2 & b5 [= b3
            holds b5 [= b4)
   holds b4 = b2 "/\" b3;

:: FILTER_0:th 92
theorem
for b1 being non empty join-commutative join-associative meet-commutative meet-absorbing join-absorbing LattStr
for b2, b3, b4 being Element of the carrier of b1
      st b2 [= b4 &
         b3 [= b4 &
         (for b5 being Element of the carrier of b1
               st b2 [= b5 & b3 [= b5
            holds b4 [= b5)
   holds b4 = b2 "\/" b3;