Article BVFUNC_1, MML version 4.99.1005

:: BVFUNC_1:prednot 1 => XXREAL_0:pred 1
notation
  let a1, a2 be boolean set;
  synonym a1 '<' a2 for a1 <= a2;
end;

:: BVFUNC_1:prednot 2 => XXREAL_0:pred 1
definition
  let a1, a2 be ext-real set;
  pred A1 '<' A2 means
    a1 => a2 = TRUE;
  reflexivity;
::  for a1 being ext-real set holds
::     a1 <= a1;
  connectedness;
::  for a1, a2 being ext-real set
::        st a2 < a1
::     holds a2 <= a1;
end;

:: BVFUNC_1:dfs 1
definiens
  let a1, a2 be boolean set;
To prove
     a1 <= a2
it is sufficient to prove
  thus a1 => a2 = TRUE;

:: BVFUNC_1:def 3
theorem
for b1, b2 being boolean set holds
   b1 <= b2
iff
   b1 => b2 = TRUE;

:: BVFUNC_1:funcnot 1 => BVFUNC_1:func 1
definition
  let a1 be set;
  func BVF A1 -> set equals
    Funcs(a1,BOOLEAN);
end;

:: BVFUNC_1:def 4
theorem
for b1 being set holds
   BVF b1 = Funcs(b1,BOOLEAN);

:: BVFUNC_1:funcreg 1
registration
  let a1 be set;
  cluster BVF a1 -> non empty functional;
end;

:: BVFUNC_1:condreg 1
registration
  let a1 be set;
  cluster -> boolean-valued (Element of BVF a1);
end;

:: BVFUNC_1:sch 1
scheme BVFUNC_1:sch 1
{F1 -> non empty set,
  F2 -> set}:
for b1, b2 being Element of Funcs(F1(),BOOLEAN)
      st (for b3 being Element of F1() holds
            b1 . b3 = F2(b3)) &
         (for b3 being Element of F1() holds
            b2 . b3 = F2(b3))
   holds b1 = b2


:: BVFUNC_1:funcnot 2 => BVFUNC_1:func 2
definition
  let a1 be non empty set;
  let a2 be Element of BVF a1;
  redefine func 'not' a2 -> Element of BVF a1;
  involutiveness;
::  for a1 being non empty set
::  for a2 being Element of BVF a1 holds
::     'not' 'not' a2 = a2;
end;

:: BVFUNC_1:funcnot 3 => BVFUNC_1:func 3
definition
  let a1 be non empty set;
  let a2, a3 be Element of BVF a1;
  redefine func a2 '&' a3 -> Element of BVF a1;
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of BVF a1 holds
::  a2 '&' a3 = a3 '&' a2;
  idempotence;
::  for a1 being non empty set
::  for a2 being Element of BVF a1 holds
::     a2 '&' a2 = a2;
end;

:: BVFUNC_1:funcnot 4 => BVFUNC_1:func 4
definition
  let a1, a2 be Relation-like Function-like boolean-valued set;
  func A1 'or' A2 -> Relation-like Function-like boolean-valued set means
    proj1 it = (proj1 a1) /\ proj1 a2 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) 'or' (a2 . b1));
  commutativity;
::  for a1, a2 being Relation-like Function-like boolean-valued set holds
::  a1 'or' a2 = a2 'or' a1;
  idempotence;
::  for a1 being Relation-like Function-like boolean-valued set holds
::     a1 'or' a1 = a1;
end;

:: BVFUNC_1:def 5
theorem
for b1, b2, b3 being Relation-like Function-like boolean-valued set holds
   b3 = b1 'or' b2
iff
   proj1 b3 = (proj1 b1) /\ proj1 b2 &
    (for b4 being set
          st b4 in proj1 b3
       holds b3 . b4 = (b1 . b4) 'or' (b2 . b4));

:: BVFUNC_1:funcnot 5 => BVFUNC_1:func 5
definition
  let a1, a2 be Relation-like Function-like boolean-valued set;
  func A1 'xor' A2 -> Relation-like Function-like set means
    proj1 it = (proj1 a1) /\ proj1 a2 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) 'xor' (a2 . b1));
  commutativity;
::  for a1, a2 being Relation-like Function-like boolean-valued set holds
::  a1 'xor' a2 = a2 'xor' a1;
end;

:: BVFUNC_1:def 6
theorem
for b1, b2 being Relation-like Function-like boolean-valued set
for b3 being Relation-like Function-like set holds
      b3 = b1 'xor' b2
   iff
      proj1 b3 = (proj1 b1) /\ proj1 b2 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = (b1 . b4) 'xor' (b2 . b4));

:: BVFUNC_1:funcreg 2
registration
  let a1, a2 be Relation-like Function-like boolean-valued set;
  cluster a1 'xor' a2 -> Relation-like Function-like boolean-valued;
end;

:: BVFUNC_1:funcnot 6 => BVFUNC_1:func 6
definition
  let a1 be non empty set;
  let a2, a3 be Element of Funcs(a1,BOOLEAN);
  redefine func A2 'or' A3 -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       it . b1 = (a2 . b1) 'or' (a3 . b1);
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of Funcs(a1,BOOLEAN) holds
::  a2 'or' a3 = a3 'or' a2;
  idempotence;
::  for a1 being non empty set
::  for a2 being Element of Funcs(a1,BOOLEAN) holds
::     a2 'or' a2 = a2;
end;

:: BVFUNC_1:def 7
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
   b4 = b2 'or' b3
iff
   for b5 being Element of b1 holds
      b4 . b5 = (b2 . b5) 'or' (b3 . b5);

:: BVFUNC_1:funcnot 7 => BVFUNC_1:func 7
definition
  let a1 be non empty set;
  let a2, a3 be Element of Funcs(a1,BOOLEAN);
  redefine func A2 'xor' A3 -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       it . b1 = (a2 . b1) 'xor' (a3 . b1);
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of Funcs(a1,BOOLEAN) holds
::  a2 'xor' a3 = a3 'xor' a2;
end;

:: BVFUNC_1:def 8
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
   b4 = b2 'xor' b3
iff
   for b5 being Element of b1 holds
      b4 . b5 = (b2 . b5) 'xor' (b3 . b5);

:: BVFUNC_1:funcnot 8 => BVFUNC_1:func 8
definition
  let a1 be non empty set;
  let a2, a3 be Element of BVF a1;
  redefine func a2 'or' a3 -> Element of BVF a1;
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of BVF a1 holds
::  a2 'or' a3 = a3 'or' a2;
  idempotence;
::  for a1 being non empty set
::  for a2 being Element of BVF a1 holds
::     a2 'or' a2 = a2;
end;

:: BVFUNC_1:funcnot 9 => BVFUNC_1:func 9
definition
  let a1 be non empty set;
  let a2, a3 be Element of BVF a1;
  redefine func a2 'xor' a3 -> Element of BVF a1;
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of BVF a1 holds
::  a2 'xor' a3 = a3 'xor' a2;
end;

:: BVFUNC_1:funcnot 10 => BVFUNC_1:func 10
definition
  let a1, a2 be Relation-like Function-like boolean-valued set;
  func A1 'imp' A2 -> Relation-like Function-like set means
    proj1 it = (proj1 a1) /\ proj1 a2 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) => (a2 . b1));
end;

:: BVFUNC_1:def 9
theorem
for b1, b2 being Relation-like Function-like boolean-valued set
for b3 being Relation-like Function-like set holds
      b3 = b1 'imp' b2
   iff
      proj1 b3 = (proj1 b1) /\ proj1 b2 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = (b1 . b4) => (b2 . b4));

:: BVFUNC_1:funcnot 11 => BVFUNC_1:func 11
definition
  let a1, a2 be Relation-like Function-like boolean-valued set;
  func A1 'eqv' A2 -> Relation-like Function-like set means
    proj1 it = (proj1 a1) /\ proj1 a2 &
     (for b1 being set
           st b1 in proj1 it
        holds it . b1 = (a1 . b1) <=> (a2 . b1));
  commutativity;
::  for a1, a2 being Relation-like Function-like boolean-valued set holds
::  a1 'eqv' a2 = a2 'eqv' a1;
end;

:: BVFUNC_1:def 10
theorem
for b1, b2 being Relation-like Function-like boolean-valued set
for b3 being Relation-like Function-like set holds
      b3 = b1 'eqv' b2
   iff
      proj1 b3 = (proj1 b1) /\ proj1 b2 &
       (for b4 being set
             st b4 in proj1 b3
          holds b3 . b4 = (b1 . b4) <=> (b2 . b4));

:: BVFUNC_1:funcreg 3
registration
  let a1, a2 be Relation-like Function-like boolean-valued set;
  cluster a1 'imp' a2 -> Relation-like Function-like boolean-valued;
end;

:: BVFUNC_1:funcreg 4
registration
  let a1, a2 be Relation-like Function-like boolean-valued set;
  cluster a1 'eqv' a2 -> Relation-like Function-like boolean-valued;
end;

:: BVFUNC_1:funcnot 12 => BVFUNC_1:func 12
definition
  let a1 be non empty set;
  let a2, a3 be Element of Funcs(a1,BOOLEAN);
  redefine func A2 'imp' A3 -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       it . b1 = ('not' (a2 . b1)) 'or' (a3 . b1);
end;

:: BVFUNC_1:def 11
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
   b4 = b2 'imp' b3
iff
   for b5 being Element of b1 holds
      b4 . b5 = ('not' (b2 . b5)) 'or' (b3 . b5);

:: BVFUNC_1:funcnot 13 => BVFUNC_1:func 13
definition
  let a1 be non empty set;
  let a2, a3 be Element of Funcs(a1,BOOLEAN);
  redefine func A2 'eqv' A3 -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       it . b1 = 'not' ((a2 . b1) 'xor' (a3 . b1));
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of Funcs(a1,BOOLEAN) holds
::  a2 'eqv' a3 = a3 'eqv' a2;
end;

:: BVFUNC_1:def 12
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
   b4 = b2 'eqv' b3
iff
   for b5 being Element of b1 holds
      b4 . b5 = 'not' ((b2 . b5) 'xor' (b3 . b5));

:: BVFUNC_1:funcnot 14 => BVFUNC_1:func 14
definition
  let a1 be non empty set;
  let a2, a3 be Element of BVF a1;
  redefine func a2 'imp' a3 -> Element of BVF a1;
end;

:: BVFUNC_1:funcnot 15 => BVFUNC_1:func 15
definition
  let a1 be non empty set;
  let a2, a3 be Element of BVF a1;
  redefine func a2 'eqv' a3 -> Element of BVF a1;
  commutativity;
::  for a1 being non empty set
::  for a2, a3 being Element of BVF a1 holds
::  a2 'eqv' a3 = a3 'eqv' a2;
end;

:: BVFUNC_1:funcnot 16 => BVFUNC_1:func 16
definition
  let a1 be non empty set;
  func O_el A1 -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       it . b1 = FALSE;
end;

:: BVFUNC_1:def 13
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
      b2 = O_el b1
   iff
      for b3 being Element of b1 holds
         b2 . b3 = FALSE;

:: BVFUNC_1:funcnot 17 => BVFUNC_1:func 17
definition
  let a1 be non empty set;
  func I_el A1 -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       it . b1 = TRUE;
end;

:: BVFUNC_1:def 14
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
      b2 = I_el b1
   iff
      for b3 being Element of b1 holds
         b2 . b3 = TRUE;

:: BVFUNC_1:th 4
theorem
for b1 being Relation-like Function-like boolean-valued set holds
   'not' 'not' b1 = b1;

:: BVFUNC_1:th 5
theorem
for b1 being non empty set holds
   'not' I_el b1 = O_el b1 & 'not' O_el b1 = I_el b1;

:: BVFUNC_1:th 6
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
b2 '&' b2 = b2;

:: BVFUNC_1:th 7
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
(b2 '&' b3) '&' b4 = b2 '&' (b3 '&' b4);

:: BVFUNC_1:th 8
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 '&' O_el b1 = O_el b1;

:: BVFUNC_1:th 9
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 '&' I_el b1 = b2;

:: BVFUNC_1:th 10
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 'or' b2 = b2;

:: BVFUNC_1:th 11
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
(b2 'or' b3) 'or' b4 = b2 'or' (b3 'or' b4);

:: BVFUNC_1:th 12
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 'or' O_el b1 = b2;

:: BVFUNC_1:th 13
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 'or' I_el b1 = I_el b1;

:: BVFUNC_1:th 14
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
(b2 '&' b3) 'or' b4 = (b2 'or' b4) '&' (b3 'or' b4);

:: BVFUNC_1:th 15
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
(b2 'or' b3) '&' b4 = (b2 '&' b4) 'or' (b3 '&' b4);

:: BVFUNC_1:th 16
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
'not' (b2 'or' b3) = ('not' b2) '&' 'not' b3;

:: BVFUNC_1:th 17
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
'not' (b2 '&' b3) = ('not' b2) 'or' 'not' b3;

:: BVFUNC_1:prednot 3 => BVFUNC_1:pred 1
definition
  let a1 be non empty set;
  let a2, a3 be Element of Funcs(a1,BOOLEAN);
  pred A2 '<' A3 means
    for b1 being Element of a1
          st a2 . b1 = TRUE
       holds a3 . b1 = TRUE;
  reflexivity;
::  for a1 being non empty set
::  for a2 being Element of Funcs(a1,BOOLEAN) holds
::     a2 '<' a2;
end;

:: BVFUNC_1:dfs 13
definiens
  let a1 be non empty set;
  let a2, a3 be Element of Funcs(a1,BOOLEAN);
To prove
     a2 '<' a3
it is sufficient to prove
  thus for b1 being Element of a1
          st a2 . b1 = TRUE
       holds a3 . b1 = TRUE;

:: BVFUNC_1:def 15
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
   b2 '<' b3
iff
   for b4 being Element of b1
         st b2 . b4 = TRUE
      holds b3 . b4 = TRUE;

:: BVFUNC_1:th 18
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,BOOLEAN) holds
(b2 '<' b3 & b3 '<' b2 implies b2 = b3) & (b2 '<' b3 & b3 '<' b4 implies b2 '<' b4);

:: BVFUNC_1:th 19
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
   b2 'imp' b3 = I_el b1
iff
   b2 '<' b3;

:: BVFUNC_1:th 20
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
   b2 'eqv' b3 = I_el b1
iff
   b2 = b3;

:: BVFUNC_1:th 21
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   O_el b1 '<' b2 & b2 '<' I_el b1;

:: BVFUNC_1:funcnot 18 => BVFUNC_1:func 18
definition
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  func B_INF A2 -> Element of Funcs(a1,BOOLEAN) means
    it = I_el a1
    if for b1 being Element of a1 holds
       a2 . b1 = TRUE
    otherwise it = O_el a1;
end;

:: BVFUNC_1:def 16
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
(for b4 being Element of b1 holds
    b2 . b4 = TRUE implies    (b3 = B_INF b2
 iff
    b3 = I_el b1)) &
 (for b4 being Element of b1 holds
    b2 . b4 = TRUE or    (b3 = B_INF b2
 iff
    b3 = O_el b1));

:: BVFUNC_1:funcnot 19 => BVFUNC_1:func 19
definition
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  func B_SUP A2 -> Element of Funcs(a1,BOOLEAN) means
    it = O_el a1
    if for b1 being Element of a1 holds
       a2 . b1 = FALSE
    otherwise it = I_el a1;
end;

:: BVFUNC_1:def 17
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
(for b4 being Element of b1 holds
    b2 . b4 = FALSE implies    (b3 = B_SUP b2
 iff
    b3 = O_el b1)) &
 (for b4 being Element of b1 holds
    b2 . b4 = FALSE or    (b3 = B_SUP b2
 iff
    b3 = I_el b1));

:: BVFUNC_1:th 22
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   'not' B_INF b2 = B_SUP 'not' b2 & 'not' B_SUP b2 = B_INF 'not' b2;

:: BVFUNC_1:th 23
theorem
for b1 being non empty set holds
   B_INF O_el b1 = O_el b1 & B_INF I_el b1 = I_el b1 & B_SUP O_el b1 = O_el b1 & B_SUP I_el b1 = I_el b1;

:: BVFUNC_1:funcreg 5
registration
  let a1 be non empty set;
  cluster O_el a1 -> constant;
end;

:: BVFUNC_1:funcreg 6
registration
  let a1 be non empty set;
  cluster I_el a1 -> constant;
end;

:: BVFUNC_1:exreg 1
registration
  let a1 be non empty set;
  cluster Relation-like Function-like constant quasi_total boolean-valued Element of Funcs(a1,BOOLEAN);
end;

:: BVFUNC_1:th 24
theorem
for b1 being non empty set
for b2 being constant Element of Funcs(b1,BOOLEAN)
      st not b2 = O_el b1
   holds b2 = I_el b1;

:: BVFUNC_1:th 25
theorem
for b1 being non empty set
for b2 being constant Element of Funcs(b1,BOOLEAN) holds
   B_INF b2 = b2 & B_SUP b2 = b2;

:: BVFUNC_1:th 26
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN) holds
B_INF (b2 '&' b3) = (B_INF b2) '&' B_INF b3 &
 B_SUP (b2 'or' b3) = (B_SUP b2) 'or' B_SUP b3;

:: BVFUNC_1:th 27
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being constant Element of Funcs(b1,BOOLEAN) holds
   B_INF (b3 'imp' b2) = b3 'imp' B_INF b2 &
    B_INF (b2 'imp' b3) = (B_SUP b2) 'imp' b3;

:: BVFUNC_1:th 28
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being constant Element of Funcs(b1,BOOLEAN) holds
   B_INF (b3 'or' b2) = b3 'or' B_INF b2 &
    B_SUP (b3 '&' b2) = b3 '&' B_SUP b2 &
    B_SUP (b2 '&' b3) = (B_SUP b2) '&' b3;

:: BVFUNC_1:th 29
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being Element of b1 holds
   (B_INF b2) . b3 <= b2 . b3;

:: BVFUNC_1:th 30
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being Element of b1 holds
   b2 . b3 <= (B_SUP b2) . b3;

:: BVFUNC_1:prednot 4 => BVFUNC_1:pred 2
definition
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  let a3 be a_partition of a1;
  pred A2 is_dependent_of A3 means
    for b1 being set
       st b1 in a3
    for b2, b3 being set
          st b2 in b1 & b3 in b1
       holds a2 . b2 = a2 . b3;
end;

:: BVFUNC_1:dfs 16
definiens
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  let a3 be a_partition of a1;
To prove
     a2 is_dependent_of a3
it is sufficient to prove
  thus for b1 being set
       st b1 in a3
    for b2, b3 being set
          st b2 in b1 & b3 in b1
       holds a2 . b2 = a2 . b3;

:: BVFUNC_1:def 18
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1 holds
      b2 is_dependent_of b3
   iff
      for b4 being set
         st b4 in b3
      for b5, b6 being set
            st b5 in b4 & b6 in b4
         holds b2 . b5 = b2 . b6;

:: BVFUNC_1:th 31
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 is_dependent_of SmallestPartition b1;

:: BVFUNC_1:th 32
theorem
for b1 being non empty set
for b2 being constant Element of Funcs(b1,BOOLEAN) holds
   b2 is_dependent_of %O b1;

:: BVFUNC_1:modenot 1 => BVFUNC_1:mode 1
definition
  let a1 be non empty set;
  let a2 be a_partition of a1;
  redefine mode Element of a2 -> Element of bool a1;
end;

:: BVFUNC_1:funcnot 20 => BVFUNC_1:func 20
definition
  let a1 be non empty set;
  let a2 be Element of a1;
  let a3 be a_partition of a1;
  redefine func EqClass(a2,a3) -> Element of a3;
end;

:: BVFUNC_1:funcnot 21 => BVFUNC_1:func 21
definition
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  let a3 be a_partition of a1;
  func B_INF(A2,A3) -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       (for b2 being Element of a1
              st b2 in EqClass(b1,a3)
           holds a2 . b2 = TRUE implies it . b1 = TRUE) &
        (for b2 being Element of a1
              st b2 in EqClass(b1,a3)
           holds a2 . b2 = TRUE or it . b1 = FALSE);
end;

:: BVFUNC_1:def 19
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1
for b4 being Element of Funcs(b1,BOOLEAN) holds
      b4 = B_INF(b2,b3)
   iff
      for b5 being Element of b1 holds
         (for b6 being Element of b1
                st b6 in EqClass(b5,b3)
             holds b2 . b6 = TRUE implies b4 . b5 = TRUE) &
          (for b6 being Element of b1
                st b6 in EqClass(b5,b3)
             holds b2 . b6 = TRUE or b4 . b5 = FALSE);

:: BVFUNC_1:funcnot 22 => BVFUNC_1:func 22
definition
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  let a3 be a_partition of a1;
  func B_SUP(A2,A3) -> Element of Funcs(a1,BOOLEAN) means
    for b1 being Element of a1 holds
       (for b2 being Element of a1
              st b2 in EqClass(b1,a3)
           holds a2 . b2 <> TRUE or it . b1 = TRUE) &
        (for b2 being Element of a1
              st b2 in EqClass(b1,a3)
           holds a2 . b2 <> TRUE implies it . b1 = FALSE);
end;

:: BVFUNC_1:def 20
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1
for b4 being Element of Funcs(b1,BOOLEAN) holds
      b4 = B_SUP(b2,b3)
   iff
      for b5 being Element of b1 holds
         (for b6 being Element of b1
                st b6 in EqClass(b5,b3)
             holds b2 . b6 <> TRUE or b4 . b5 = TRUE) &
          (for b6 being Element of b1
                st b6 in EqClass(b5,b3)
             holds b2 . b6 <> TRUE implies b4 . b5 = FALSE);

:: BVFUNC_1:th 33
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1 holds
   B_INF(b2,b3) is_dependent_of b3;

:: BVFUNC_1:th 34
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1 holds
   B_SUP(b2,b3) is_dependent_of b3;

:: BVFUNC_1:th 35
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1 holds
   B_INF(b2,b3) '<' b2;

:: BVFUNC_1:th 36
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1 holds
   b2 '<' B_SUP(b2,b3);

:: BVFUNC_1:th 37
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1 holds
   'not' B_INF(b2,b3) = B_SUP('not' b2,b3);

:: BVFUNC_1:th 38
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   B_INF(b2,%O b1) = B_INF b2;

:: BVFUNC_1:th 39
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   B_SUP(b2,%O b1) = B_SUP b2;

:: BVFUNC_1:th 40
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   B_INF(b2,SmallestPartition b1) = b2;

:: BVFUNC_1:th 41
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   B_SUP(b2,SmallestPartition b1) = b2;

:: BVFUNC_1:th 42
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN)
for b4 being a_partition of b1 holds
   B_INF(b2 '&' b3,b4) = (B_INF(b2,b4)) '&' B_INF(b3,b4);

:: BVFUNC_1:th 43
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,BOOLEAN)
for b4 being a_partition of b1 holds
   B_SUP(b2 'or' b3,b4) = (B_SUP(b2,b4)) 'or' B_SUP(b3,b4);

:: BVFUNC_1:funcnot 23 => BVFUNC_1:func 23
definition
  let a1 be non empty set;
  let a2 be Element of Funcs(a1,BOOLEAN);
  func GPart A2 -> a_partition of a1 equals
    {{b1 where b1 is Element of a1: a2 . b1 = TRUE},{b1 where b1 is Element of a1: a2 . b1 = FALSE}} \ {{}};
end;

:: BVFUNC_1:def 21
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   GPart b2 = {{b3 where b3 is Element of b1: b2 . b3 = TRUE},{b3 where b3 is Element of b1: b2 . b3 = FALSE}} \ {{}};

:: BVFUNC_1:th 44
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN) holds
   b2 is_dependent_of GPart b2;

:: BVFUNC_1:th 45
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,BOOLEAN)
for b3 being a_partition of b1
      st b2 is_dependent_of b3
   holds b3 is_finer_than GPart b2;