Article NORMFORM, MML version 4.99.1005

:: NORMFORM:prednot 1 => NORMFORM:pred 1
definition
  let a1, a2 be non empty preBoolean set;
  let a3, a4 be Element of [:a1,a2:];
  pred A3 c= A4 means
    a3 `1 c= a4 `1 & a3 `2 c= a4 `2;
  reflexivity;
::  for a1, a2 being non empty preBoolean set
::  for a3 being Element of [:a1,a2:] holds
::     a3 c= a3;
end;

:: NORMFORM:dfs 1
definiens
  let a1, a2 be non empty preBoolean set;
  let a3, a4 be Element of [:a1,a2:];
To prove
     a3 c= a4
it is sufficient to prove
  thus a3 `1 c= a4 `1 & a3 `2 c= a4 `2;

:: NORMFORM:def 1
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
   b3 c= b4
iff
   b3 `1 c= b4 `1 & b3 `2 c= b4 `2;

:: NORMFORM:funcnot 1 => NORMFORM:func 1
definition
  let a1, a2 be non empty preBoolean set;
  let a3, a4 be Element of [:a1,a2:];
  func A3 \/ A4 -> Element of [:a1,a2:] equals
    [a3 `1 \/ (a4 `1),a3 `2 \/ (a4 `2)];
  commutativity;
::  for a1, a2 being non empty preBoolean set
::  for a3, a4 being Element of [:a1,a2:] holds
::  a3 \/ a4 = a4 \/ a3;
  idempotence;
::  for a1, a2 being non empty preBoolean set
::  for a3 being Element of [:a1,a2:] holds
::     a3 \/ a3 = a3;
end;

:: NORMFORM:def 2
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 \/ b4 = [b3 `1 \/ (b4 `1),b3 `2 \/ (b4 `2)];

:: NORMFORM:funcnot 2 => NORMFORM:func 2
definition
  let a1, a2 be non empty preBoolean set;
  let a3, a4 be Element of [:a1,a2:];
  func A3 /\ A4 -> Element of [:a1,a2:] equals
    [a3 `1 /\ (a4 `1),a3 `2 /\ (a4 `2)];
  commutativity;
::  for a1, a2 being non empty preBoolean set
::  for a3, a4 being Element of [:a1,a2:] holds
::  a3 /\ a4 = a4 /\ a3;
  idempotence;
::  for a1, a2 being non empty preBoolean set
::  for a3 being Element of [:a1,a2:] holds
::     a3 /\ a3 = a3;
end;

:: NORMFORM:def 3
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 /\ b4 = [b3 `1 /\ (b4 `1),b3 `2 /\ (b4 `2)];

:: NORMFORM:funcnot 3 => NORMFORM:func 3
definition
  let a1, a2 be non empty preBoolean set;
  let a3, a4 be Element of [:a1,a2:];
  func A3 \ A4 -> Element of [:a1,a2:] equals
    [a3 `1 \ (a4 `1),a3 `2 \ (a4 `2)];
end;

:: NORMFORM:def 4
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 \ b4 = [b3 `1 \ (b4 `1),b3 `2 \ (b4 `2)];

:: NORMFORM:funcnot 4 => NORMFORM:func 4
definition
  let a1, a2 be non empty preBoolean set;
  let a3, a4 be Element of [:a1,a2:];
  func A3 \+\ A4 -> Element of [:a1,a2:] equals
    [a3 `1 \+\ (a4 `1),a3 `2 \+\ (a4 `2)];
  commutativity;
::  for a1, a2 being non empty preBoolean set
::  for a3, a4 being Element of [:a1,a2:] holds
::  a3 \+\ a4 = a4 \+\ a3;
end;

:: NORMFORM:def 5
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 \+\ b4 = [b3 `1 \+\ (b4 `1),b3 `2 \+\ (b4 `2)];

:: NORMFORM:th 4
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:]
      st b3 c= b4 & b4 c= b3
   holds b3 = b4;

:: NORMFORM:th 5
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:]
      st b3 c= b4 & b4 c= b5
   holds b3 c= b5;

:: NORMFORM:th 16
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:] holds
(b3 \/ b4) \/ b5 = b3 \/ (b4 \/ b5);

:: NORMFORM:th 19
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:] holds
(b3 /\ b4) /\ b5 = b3 /\ (b4 /\ b5);

:: NORMFORM:th 20
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:] holds
b3 /\ (b4 \/ b5) = (b3 /\ b4) \/ (b3 /\ b5);

:: NORMFORM:th 21
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 \/ (b4 /\ b3) = b3;

:: NORMFORM:th 22
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 /\ (b4 \/ b3) = b3;

:: NORMFORM:th 24
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:] holds
b3 \/ (b4 /\ b5) = (b3 \/ b4) /\ (b3 \/ b5);

:: NORMFORM:th 25
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:]
      st b3 c= b4 & b5 c= b4
   holds b3 \/ b5 c= b4;

:: NORMFORM:th 26
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
b3 c= b3 \/ b4 & b4 c= b3 \/ b4;

:: NORMFORM:th 27
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:]
      st b3 = b3 \/ b4
   holds b4 c= b3;

:: NORMFORM:th 28
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:]
      st b3 c= b4
   holds b5 \/ b3 c= b5 \/ b4 & b3 \/ b5 c= b4 \/ b5;

:: NORMFORM:th 29
theorem
for b1, b2 being non empty preBoolean set
for b3, b4 being Element of [:b1,b2:] holds
(b3 \ b4) \/ b4 = b3 \/ b4;

:: NORMFORM:th 30
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:]
      st b3 \ b4 c= b5
   holds b3 c= b4 \/ b5;

:: NORMFORM:th 31
theorem
for b1, b2 being non empty preBoolean set
for b3, b4, b5 being Element of [:b1,b2:]
      st b3 c= b4 \/ b5
   holds b3 \ b5 c= b4;

:: NORMFORM:funcnot 5 => NORMFORM:func 5
definition
  let a1 be set;
  func FinPairUnion A1 -> Function-like quasi_total Relation of [:[:Fin a1,Fin a1:],[:Fin a1,Fin a1:]:],[:Fin a1,Fin a1:] means
    for b1, b2 being Element of [:Fin a1,Fin a1:] holds
    it .(b1,b2) = b1 \/ b2;
end;

:: NORMFORM:def 6
theorem
for b1 being set
for b2 being Function-like quasi_total Relation of [:[:Fin b1,Fin b1:],[:Fin b1,Fin b1:]:],[:Fin b1,Fin b1:] holds
      b2 = FinPairUnion b1
   iff
      for b3, b4 being Element of [:Fin b1,Fin b1:] holds
      b2 .(b3,b4) = b3 \/ b4;

:: NORMFORM:funcnot 6 => NORMFORM:func 6
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be Element of Fin a1;
  let a4 be Function-like quasi_total Relation of a1,[:Fin a2,Fin a2:];
  func FinPairUnion(A3,A4) -> Element of [:Fin a2,Fin a2:] equals
    (FinPairUnion a2) $$(a3,a4);
end;

:: NORMFORM:def 7
theorem
for b1 being non empty set
for b2 being set
for b3 being Element of Fin b1
for b4 being Function-like quasi_total Relation of b1,[:Fin b2,Fin b2:] holds
   FinPairUnion(b3,b4) = (FinPairUnion b2) $$(b3,b4);

:: NORMFORM:funcreg 1
registration
  let a1 be set;
  cluster FinPairUnion a1 -> Function-like quasi_total commutative associative idempotent;
end;

:: NORMFORM:th 35
theorem
for b1 being set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b2,[:Fin b1,Fin b1:]
for b4 being Element of Fin b2
for b5 being Element of b2
      st b5 in b4
   holds b3 . b5 c= FinPairUnion(b4,b3);

:: NORMFORM:th 36
theorem
for b1 being set holds
   [{}. b1,{}. b1] is_a_unity_wrt FinPairUnion b1;

:: NORMFORM:th 37
theorem
for b1 being set holds
   FinPairUnion b1 is having_a_unity([:Fin b1,Fin b1:]);

:: NORMFORM:th 38
theorem
for b1 being set holds
   the_unity_wrt FinPairUnion b1 = [{}. b1,{}. b1];

:: NORMFORM:th 39
theorem
for b1 being set
for b2 being Element of [:Fin b1,Fin b1:] holds
   the_unity_wrt FinPairUnion b1 c= b2;

:: NORMFORM:th 40
theorem
for b1 being set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b2,[:Fin b1,Fin b1:]
for b4 being Element of Fin b2
for b5 being Element of [:Fin b1,Fin b1:]
      st for b6 being Element of b2
              st b6 in b4
           holds b3 . b6 c= b5
   holds FinPairUnion(b4,b3) c= b5;

:: NORMFORM:th 41
theorem
for b1 being set
for b2 being non empty set
for b3 being Element of Fin b2
for b4, b5 being Function-like quasi_total Relation of b2,[:Fin b1,Fin b1:]
      st b4 | b3 = b5 | b3
   holds FinPairUnion(b3,b4) = FinPairUnion(b3,b5);

:: NORMFORM:funcnot 7 => NORMFORM:func 7
definition
  let a1 be set;
  func DISJOINT_PAIRS A1 -> Element of bool [:Fin a1,Fin a1:] equals
    {b1 where b1 is Element of [:Fin a1,Fin a1:]: b1 `1 misses b1 `2};
end;

:: NORMFORM:def 8
theorem
for b1 being set holds
   DISJOINT_PAIRS b1 = {b2 where b2 is Element of [:Fin b1,Fin b1:]: b2 `1 misses b2 `2};

:: NORMFORM:funcreg 2
registration
  let a1 be set;
  cluster DISJOINT_PAIRS a1 -> non empty;
end;

:: NORMFORM:th 42
theorem
for b1 being set
for b2 being Element of [:Fin b1,Fin b1:] holds
      b2 in DISJOINT_PAIRS b1
   iff
      b2 `1 misses b2 `2;

:: NORMFORM:th 43
theorem
for b1 being set
for b2, b3 being Element of [:Fin b1,Fin b1:]
      st b2 in DISJOINT_PAIRS b1 & b3 in DISJOINT_PAIRS b1
   holds    b2 \/ b3 in DISJOINT_PAIRS b1
   iff
      (b2 `1 /\ (b3 `2)) \/ (b3 `1 /\ (b2 `2)) = {};

:: NORMFORM:th 44
theorem
for b1 being set
for b2 being Element of DISJOINT_PAIRS b1 holds
   b2 `1 misses b2 `2;

:: NORMFORM:th 45
theorem
for b1 being set
for b2 being Element of [:Fin b1,Fin b1:]
for b3 being Element of DISJOINT_PAIRS b1
      st b2 c= b3
   holds b2 is Element of DISJOINT_PAIRS b1;

:: NORMFORM:th 46
theorem
for b1 being set
for b2 being Element of DISJOINT_PAIRS b1
for b3 being set
      st b3 in b2 `1
   holds not b3 in b2 `2;

:: NORMFORM:th 47
theorem
for b1 being set
for b2, b3 being Element of DISJOINT_PAIRS b1
      st not b2 \/ b3 in DISJOINT_PAIRS b1
   holds ex b4 being Element of b1 st
      (b4 in b2 `1 & b4 in b3 `2 or b4 in b3 `1 & b4 in b2 `2);

:: NORMFORM:th 49
theorem
for b1 being set
for b2 being Element of [:Fin b1,Fin b1:]
      st b2 `1 misses b2 `2
   holds b2 is Element of DISJOINT_PAIRS b1;

:: NORMFORM:th 50
theorem
for b1 being set
for b2 being Element of DISJOINT_PAIRS b1
for b3, b4 being set
      st b3 c= b2 `1 & b4 c= b2 `2
   holds [b3,b4] is Element of DISJOINT_PAIRS b1;

:: NORMFORM:funcnot 8 => NORMFORM:func 8
definition
  let a1 be set;
  func Normal_forms_on A1 -> Element of bool Fin DISJOINT_PAIRS a1 equals
    {b1 where b1 is Element of Fin DISJOINT_PAIRS a1: for b2, b3 being Element of DISJOINT_PAIRS a1
          st b2 in b1 & b3 in b1 & b2 c= b3
       holds b2 = b3};
end;

:: NORMFORM:def 9
theorem
for b1 being set holds
   Normal_forms_on b1 = {b2 where b2 is Element of Fin DISJOINT_PAIRS b1: for b3, b4 being Element of DISJOINT_PAIRS b1
         st b3 in b2 & b4 in b2 & b3 c= b4
      holds b3 = b4};

:: NORMFORM:funcreg 3
registration
  let a1 be set;
  cluster Normal_forms_on a1 -> non empty;
end;

:: NORMFORM:th 51
theorem
for b1 being set holds
   {} in Normal_forms_on b1;

:: NORMFORM:th 52
theorem
for b1 being set
for b2, b3 being Element of DISJOINT_PAIRS b1
for b4 being Element of Fin DISJOINT_PAIRS b1
      st b4 in Normal_forms_on b1 & b2 in b4 & b3 in b4 & b2 c= b3
   holds b2 = b3;

:: NORMFORM:th 53
theorem
for b1 being set
for b2 being Element of Fin DISJOINT_PAIRS b1
      st for b3, b4 being Element of DISJOINT_PAIRS b1
              st b3 in b2 & b4 in b2 & b3 c= b4
           holds b3 = b4
   holds b2 in Normal_forms_on b1;

:: NORMFORM:funcnot 9 => NORMFORM:func 9
definition
  let a1 be set;
  let a2 be Element of Fin DISJOINT_PAIRS a1;
  func mi A2 -> Element of Normal_forms_on a1 equals
    {b1 where b1 is Element of DISJOINT_PAIRS a1: for b2 being Element of DISJOINT_PAIRS a1 holds
          b2 in a2 & b2 c= b1
       iff
          b2 = b1};
end;

:: NORMFORM:def 10
theorem
for b1 being set
for b2 being Element of Fin DISJOINT_PAIRS b1 holds
   mi b2 = {b3 where b3 is Element of DISJOINT_PAIRS b1: for b4 being Element of DISJOINT_PAIRS b1 holds
         b4 in b2 & b4 c= b3
      iff
         b4 = b3};

:: NORMFORM:funcnot 10 => NORMFORM:func 10
definition
  let a1 be set;
  let a2, a3 be Element of Fin DISJOINT_PAIRS a1;
  func A2 ^ A3 -> Element of Fin DISJOINT_PAIRS a1 equals
    (DISJOINT_PAIRS a1) /\ {b1 \/ b2 where b1 is Element of DISJOINT_PAIRS a1, b2 is Element of DISJOINT_PAIRS a1: b1 in a2 & b2 in a3};
end;

:: NORMFORM:def 11
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
b2 ^ b3 = (DISJOINT_PAIRS b1) /\ {b4 \/ b5 where b4 is Element of DISJOINT_PAIRS b1, b5 is Element of DISJOINT_PAIRS b1: b4 in b2 & b5 in b3};

:: NORMFORM:th 55
theorem
for b1 being set
for b2 being Element of [:Fin b1,Fin b1:]
for b3, b4 being Element of Fin DISJOINT_PAIRS b1
      st b2 in b3 ^ b4
   holds ex b5, b6 being Element of DISJOINT_PAIRS b1 st
      b5 in b3 & b6 in b4 & b2 = b5 \/ b6;

:: NORMFORM:th 56
theorem
for b1 being set
for b2, b3 being Element of DISJOINT_PAIRS b1
for b4, b5 being Element of Fin DISJOINT_PAIRS b1
      st b2 in b4 & b3 in b5 & b2 \/ b3 in DISJOINT_PAIRS b1
   holds b2 \/ b3 in b4 ^ b5;

:: NORMFORM:th 58
theorem
for b1 being set
for b2, b3 being Element of DISJOINT_PAIRS b1
for b4 being Element of Fin DISJOINT_PAIRS b1
      st b2 in mi b4
   holds b2 in b4 & (b3 in b4 & b3 c= b2 implies b3 = b2);

:: NORMFORM:th 59
theorem
for b1 being set
for b2 being Element of DISJOINT_PAIRS b1
for b3 being Element of Fin DISJOINT_PAIRS b1
      st b2 in mi b3
   holds b2 in b3;

:: NORMFORM:th 60
theorem
for b1 being set
for b2, b3 being Element of DISJOINT_PAIRS b1
for b4 being Element of Fin DISJOINT_PAIRS b1
      st b2 in mi b4 & b3 in b4 & b3 c= b2
   holds b3 = b2;

:: NORMFORM:th 61
theorem
for b1 being set
for b2 being Element of DISJOINT_PAIRS b1
for b3 being Element of Fin DISJOINT_PAIRS b1
      st b2 in b3 &
         (for b4 being Element of DISJOINT_PAIRS b1
               st b4 in b3 & b4 c= b2
            holds b4 = b2)
   holds b2 in mi b3;

:: NORMFORM:funcnot 11 => NORMFORM:func 11
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  let a3 be Function-like quasi_total Relation of [:a2,a2:],a2;
  let a4, a5 be Element of a2;
  redefine func a3 .(a4,a5) -> Element of a2;
end;

:: NORMFORM:th 64
theorem
for b1 being set
for b2 being Element of Fin DISJOINT_PAIRS b1 holds
   mi b2 c= b2;

:: NORMFORM:th 65
theorem
for b1 being set
for b2 being Element of DISJOINT_PAIRS b1
for b3 being Element of Fin DISJOINT_PAIRS b1
      st b2 in b3
   holds ex b4 being Element of DISJOINT_PAIRS b1 st
      b4 c= b2 & b4 in mi b3;

:: NORMFORM:th 66
theorem
for b1 being set
for b2 being Element of Normal_forms_on b1 holds
   mi b2 = b2;

:: NORMFORM:th 67
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
mi (b2 \/ b3) c= (mi b2) \/ b3;

:: NORMFORM:th 68
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
mi ((mi b2) \/ b3) = mi (b2 \/ b3);

:: NORMFORM:th 69
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
mi (b2 \/ mi b3) = mi (b2 \/ b3);

:: NORMFORM:th 70
theorem
for b1 being set
for b2, b3, b4 being Element of Fin DISJOINT_PAIRS b1
      st b2 c= b3
   holds b2 ^ b4 c= b3 ^ b4;

:: NORMFORM:th 71
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
mi (b2 ^ b3) c= (mi b2) ^ b3;

:: NORMFORM:th 72
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
b2 ^ b3 = b3 ^ b2;

:: NORMFORM:th 73
theorem
for b1 being set
for b2, b3, b4 being Element of Fin DISJOINT_PAIRS b1
      st b2 c= b3
   holds b4 ^ b2 c= b4 ^ b3;

:: NORMFORM:th 74
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
mi ((mi b2) ^ b3) = mi (b2 ^ b3);

:: NORMFORM:th 75
theorem
for b1 being set
for b2, b3 being Element of Fin DISJOINT_PAIRS b1 holds
mi (b2 ^ mi b3) = mi (b2 ^ b3);

:: NORMFORM:th 76
theorem
for b1 being set
for b2, b3, b4 being Element of Normal_forms_on b1 holds
b2 ^ (b3 ^ b4) = (b2 ^ b3) ^ b4;

:: NORMFORM:th 77
theorem
for b1 being set
for b2, b3, b4 being Element of Normal_forms_on b1 holds
b2 ^ (b3 \/ b4) = (b2 ^ b3) \/ (b2 ^ b4);

:: NORMFORM:th 78
theorem
for b1 being set
for b2 being Element of Fin DISJOINT_PAIRS b1 holds
   b2 c= b2 ^ b2;

:: NORMFORM:th 79
theorem
for b1 being set
for b2 being Element of Normal_forms_on b1 holds
   mi (b2 ^ b2) = mi b2;

:: NORMFORM:funcnot 12 => NORMFORM:func 12
definition
  let a1 be set;
  func NormForm A1 -> strict LattStr means
    the carrier of it = Normal_forms_on a1 &
     (for b1, b2 being Element of Normal_forms_on a1 holds
     (the L_join of it) .(b1,b2) = mi (b1 \/ b2) &
      (the L_meet of it) .(b1,b2) = mi (b1 ^ b2));
end;

:: NORMFORM:def 14
theorem
for b1 being set
for b2 being strict LattStr holds
      b2 = NormForm b1
   iff
      the carrier of b2 = Normal_forms_on b1 &
       (for b3, b4 being Element of Normal_forms_on b1 holds
       (the L_join of b2) .(b3,b4) = mi (b3 \/ b4) &
        (the L_meet of b2) .(b3,b4) = mi (b3 ^ b4));

:: NORMFORM:funcreg 4
registration
  let a1 be set;
  cluster NormForm a1 -> non empty strict;
end;

:: NORMFORM:funcreg 5
registration
  let a1 be set;
  cluster NormForm a1 -> strict Lattice-like;
end;

:: NORMFORM:funcreg 6
registration
  let a1 be set;
  cluster NormForm a1 -> strict distributive lower-bounded;
end;

:: NORMFORM:th 85
theorem
for b1 being set holds
   {} is Element of the carrier of NormForm b1;

:: NORMFORM:th 86
theorem
for b1 being set holds
   Bottom NormForm b1 = {};