Article HILBERT3, MML version 4.99.1005

:: HILBERT3:th 1
theorem
for b1 being integer set holds
      b1 is even
   iff
      b1 - 1 is odd;

:: HILBERT3:th 2
theorem
for b1 being integer set holds
      b1 is odd
   iff
      b1 - 1 is even;

:: HILBERT3:th 3
theorem
for b1 being trivial set
for b2 being set
   st b2 in b1
for b3 being Function-like quasi_total Relation of b1,b1 holds
   b2 is_a_fixpoint_of b3;

:: HILBERT3:condreg 1
registration
  let a1, a2, a3 be set;
  cluster Function-like quasi_total -> Function-yielding (Relation of a1,Funcs(a2,a3));
end;

:: HILBERT3:th 4
theorem
for b1 being Relation-like Function-like Function-yielding set holds
   SubFuncs proj2 b1 = proj2 b1;

:: HILBERT3:th 5
theorem
for b1, b2, b3 being set
for b4 being Relation-like Function-like set
      st b3 in b1 & b4 in Funcs(b1,b2)
   holds b4 . b3 in b2;

:: HILBERT3:th 6
theorem
for b1, b2, b3 being set
   st (b3 = {} & b2 <> {} implies b1 = {})
for b4 being Function-like quasi_total Relation of b1,Funcs(b2,b3) holds
   doms b4 = b1 --> b2;

:: HILBERT3:funcreg 1
registration
  cluster {} -> Function-yielding;
end;

:: HILBERT3:th 7
theorem
for b1 being set holds
   {} . b1 = {};

:: HILBERT3:condreg 2
registration
  let a1 be set;
  let a2 be functional set;
  cluster Function-like quasi_total -> Function-yielding (Relation of a1,a2);
end;

:: HILBERT3:th 8
theorem
for b1 being set
for b2 being Element of bool b1 holds
   ((0,1)-->(1,0)) * chi(b2,b1) = chi(b2 `,b1);

:: HILBERT3:th 9
theorem
for b1 being set
for b2 being Element of bool b1 holds
   ((0,1)-->(1,0)) * chi(b2 `,b1) = chi(b2,b1);

:: HILBERT3:th 10
theorem
for b1, b2, b3, b4, b5, b6 being set
      st b1 <> b2 & (b1,b2)-->(b3,b4) = (b1,b2)-->(b5,b6)
   holds b3 = b5 & b4 = b6;

:: HILBERT3:th 11
theorem
for b1, b2, b3, b4, b5, b6 being set
      st b1 <> b2 & b3 in b5 & b4 in b6
   holds (b1,b2)-->(b3,b4) in product ((b1,b2)-->(b5,b6));

:: HILBERT3:th 12
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of 2,b1 holds
   ex b3, b4 being Element of b1 st
      b2 = (0,1)-->(b3,b4);

:: HILBERT3:th 13
theorem
for b1, b2, b3, b4 being set
      st b1 <> b2
   holds ((b1,b2)-->(b2,b1)) * ((b1,b2)-->(b3,b4)) = (b1,b2)-->(b4,b3);

:: HILBERT3:th 14
theorem
for b1, b2, b3, b4 being set
for b5 being Relation-like Function-like set
      st b1 <> b2 & b3 in proj1 b5 & b4 in proj1 b5
   holds ((b1,b2)-->(b3,b4)) * b5 = (b1,b2)-->(b5 . b3,b5 . b4);

:: HILBERT3:funcreg 2
registration
  let a1, a2 be Relation-like Function-like one-to-one set;
  cluster [:a1,a2:] -> Relation-like Function-like one-to-one;
end;

:: HILBERT3:th 15
theorem
for b1, b2 being non empty set
for b3, b4 being set
for b5 being Function-like quasi_total Relation of b3,b1
for b6 being Function-like quasi_total Relation of b4,b2 holds
   (pr1(b1,b2)) * [:b5,b6:] = b5 * pr1(b3,b4);

:: HILBERT3:th 16
theorem
for b1, b2 being non empty set
for b3, b4 being set
for b5 being Function-like quasi_total Relation of b3,b1
for b6 being Function-like quasi_total Relation of b4,b2 holds
   (pr2(b1,b2)) * [:b5,b6:] = b6 * pr2(b3,b4);

:: HILBERT3:th 17
theorem
for b1 being Relation-like Function-like set holds
   {} .. b1 = {};

:: HILBERT3:th 18
theorem
for b1 being Relation-like Function-like Function-yielding set
for b2, b3 being Relation-like Function-like set holds
b3 * (b1 .. b2) = (b3 * b1) .. (b3 * b2);

:: HILBERT3:th 19
theorem
for b1 being set
for b2 being non empty set
for b3 being Function-like quasi_total Relation of b2,Funcs({},b1)
for b4 being Function-like quasi_total Relation of b2,{} holds
   proj2 (b3 .. b4) = {{}};

:: HILBERT3:th 20
theorem
for b1, b2, b3 being set
   st (b2 = {} implies b1 = {})
for b4 being Function-like quasi_total Relation of b1,Funcs(b2,b3)
for b5 being Function-like quasi_total Relation of b1,b2 holds
   proj2 (b4 .. b5) c= b3;

:: HILBERT3:th 21
theorem
for b1, b2, b3 being set
   st (b3 = {} & b2 <> {} implies b1 = {})
for b4 being Function-like quasi_total Relation of b1,Funcs(b2,b3) holds
   proj1 Frege b4 = Funcs(b1,b2);

:: HILBERT3:th 23
theorem
for b1, b2, b3 being set
   st (b3 = {} & b2 <> {} implies b1 = {})
for b4 being Function-like quasi_total Relation of b1,Funcs(b2,b3) holds
   proj2 Frege b4 c= Funcs(b1,b3);

:: HILBERT3:th 24
theorem
for b1, b2, b3 being set
   st (b3 = {} & b2 <> {} implies b1 = {})
for b4 being Function-like quasi_total Relation of b1,Funcs(b2,b3) holds
   Frege b4 is Function-like quasi_total Relation of Funcs(b1,b2),Funcs(b1,b3);

:: HILBERT3:th 25
theorem
for b1, b2 being set
for b3 being Function-like quasi_total bijective Relation of b1,b1
for b4 being Function-like quasi_total bijective Relation of b2,b2 holds
   [:b3,b4:] is bijective([:b1,b2:], [:b1,b2:]);

:: HILBERT3:funcnot 1 => HILBERT3:func 1
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total bijective Relation of a1,a1;
  let a4 be Function-like quasi_total Relation of a2,a2;
  func A3 => A4 -> Function-like quasi_total Relation of Funcs(a1,a2),Funcs(a1,a2) means
    for b1 being Function-like quasi_total Relation of a1,a2 holds
       it . b1 = (a4 * b1) * (a3 ");
end;

:: HILBERT3:def 1
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total bijective Relation of b1,b1
for b4 being Function-like quasi_total Relation of b2,b2
for b5 being Function-like quasi_total Relation of Funcs(b1,b2),Funcs(b1,b2) holds
      b5 = b3 => b4
   iff
      for b6 being Function-like quasi_total Relation of b1,b2 holds
         b5 . b6 = (b4 * b6) * (b3 ");

:: HILBERT3:funcreg 3
registration
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total bijective Relation of a1,a1;
  let a4 be Function-like quasi_total bijective Relation of a2,a2;
  cluster a3 => a4 -> Function-like quasi_total bijective;
end;

:: HILBERT3:th 26
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total bijective Relation of b1,b1
for b4 being Function-like quasi_total bijective Relation of b2,b2
for b5 being Function-like quasi_total Relation of b1,b2 holds
   (b3 => b4) " . b5 = (b4 " * b5) * b3;

:: HILBERT3:th 27
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total bijective Relation of b1,b1
for b4 being Function-like quasi_total bijective Relation of b2,b2 holds
   (b3 => b4) " = b3 " => (b4 ");

:: HILBERT3:th 28
theorem
for b1, b2, b3 being non empty set
for b4 being Function-like quasi_total Relation of b1,Funcs(b2,b3)
for b5 being Function-like quasi_total Relation of b1,b2
for b6 being Function-like quasi_total bijective Relation of b2,b2
for b7 being Function-like quasi_total bijective Relation of b3,b3 holds
   ((b6 => b7) * b4) .. (b6 * b5) = (b4 .. b5) * b7;

:: HILBERT3:modenot 1
definition
  mode SetValuation is non-empty ManySortedSet of NAT;
end;

:: HILBERT3:funcnot 2 => HILBERT3:func 2
definition
  let a1 be non-empty ManySortedSet of NAT;
  func SetVal A1 -> ManySortedSet of HP-WFF means
    it . VERUM = 1 &
     (for b1 being Element of NAT holds
        it . prop b1 = a1 . b1) &
     (for b1, b2 being Element of HP-WFF holds
     it . (b1 '&' b2) = [:it . b1,it . b2:] &
      it . (b1 => b2) = Funcs(it . b1,it . b2));
end;

:: HILBERT3:def 2
theorem
for b1 being non-empty ManySortedSet of NAT
for b2 being ManySortedSet of HP-WFF holds
      b2 = SetVal b1
   iff
      b2 . VERUM = 1 &
       (for b3 being Element of NAT holds
          b2 . prop b3 = b1 . b3) &
       (for b3, b4 being Element of HP-WFF holds
       b2 . (b3 '&' b4) = [:b2 . b3,b2 . b4:] &
        b2 . (b3 => b4) = Funcs(b2 . b3,b2 . b4));

:: HILBERT3:funcnot 3 => HILBERT3:func 3
definition
  let a1 be non-empty ManySortedSet of NAT;
  let a2 be Element of HP-WFF;
  func SetVal(A1,A2) -> set equals
    (SetVal a1) . a2;
end;

:: HILBERT3:def 3
theorem
for b1 being non-empty ManySortedSet of NAT
for b2 being Element of HP-WFF holds
   SetVal(b1,b2) = (SetVal b1) . b2;

:: HILBERT3:funcreg 4
registration
  let a1 be non-empty ManySortedSet of NAT;
  let a2 be Element of HP-WFF;
  cluster SetVal(a1,a2) -> non empty;
end;

:: HILBERT3:th 29
theorem
for b1 being non-empty ManySortedSet of NAT holds
   SetVal(b1,VERUM) = 1;

:: HILBERT3:th 30
theorem
for b1 being Element of NAT
for b2 being non-empty ManySortedSet of NAT holds
   SetVal(b2,prop b1) = b2 . b1;

:: HILBERT3:th 31
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT holds
   SetVal(b3,b1 '&' b2) = [:SetVal(b3,b1),SetVal(b3,b2):];

:: HILBERT3:th 32
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT holds
   SetVal(b3,b1 => b2) = Funcs(SetVal(b3,b1),SetVal(b3,b2));

:: HILBERT3:funcreg 5
registration
  let a1 be non-empty ManySortedSet of NAT;
  let a2, a3 be Element of HP-WFF;
  cluster SetVal(a1,a2 => a3) -> functional;
end;

:: HILBERT3:condreg 3
registration
  let a1 be non-empty ManySortedSet of NAT;
  let a2, a3, a4 be Element of HP-WFF;
  cluster -> Function-yielding (Element of SetVal(a1,a2 => (a3 => a4)));
end;

:: HILBERT3:exreg 1
registration
  let a1 be non-empty ManySortedSet of NAT;
  let a2, a3, a4 be Element of HP-WFF;
  cluster Relation-like Function-like non empty quasi_total Function-yielding total Relation of SetVal(a1,a2 => a3),SetVal(a1,a2 => a4);
end;

:: HILBERT3:exreg 2
registration
  let a1 be non-empty ManySortedSet of NAT;
  let a2, a3, a4 be Element of HP-WFF;
  cluster Relation-like Function-like Function-yielding Element of SetVal(a1,a2 => (a3 => a4));
end;

:: HILBERT3:modenot 2 => HILBERT3:mode 1
definition
  let a1 be non-empty ManySortedSet of NAT;
  mode Permutation of A1 -> Relation-like Function-like set means
    proj1 it = NAT &
     (for b1 being Element of NAT holds
        it . b1 is Function-like quasi_total bijective Relation of a1 . b1,a1 . b1);
end;

:: HILBERT3:dfs 4
definiens
  let a1 be non-empty ManySortedSet of NAT;
  let a2 be Relation-like Function-like set;
To prove
     a2 is Permutation of a1
it is sufficient to prove
  thus proj1 a2 = NAT &
     (for b1 being Element of NAT holds
        a2 . b1 is Function-like quasi_total bijective Relation of a1 . b1,a1 . b1);

:: HILBERT3:def 4
theorem
for b1 being non-empty ManySortedSet of NAT
for b2 being Relation-like Function-like set holds
      b2 is Permutation of b1
   iff
      proj1 b2 = NAT &
       (for b3 being Element of NAT holds
          b2 . b3 is Function-like quasi_total bijective Relation of b1 . b3,b1 . b3);

:: HILBERT3:funcnot 4 => HILBERT3:func 4
definition
  let a1 be non-empty ManySortedSet of NAT;
  let a2 be Permutation of a1;
  func Perm A2 -> ManySortedFunction of SetVal a1,SetVal a1 means
    it . VERUM = id 1 &
     (for b1 being Element of NAT holds
        it . prop b1 = a2 . b1) &
     (for b1, b2 being Element of HP-WFF holds
     ex b3 being Function-like quasi_total bijective Relation of SetVal(a1,b1),SetVal(a1,b1) st
        ex b4 being Function-like quasi_total bijective Relation of SetVal(a1,b2),SetVal(a1,b2) st
           b3 = it . b1 & b4 = it . b2 & it . (b1 '&' b2) = [:b3,b4:] & it . (b1 => b2) = b3 => b4);
end;

:: HILBERT3:def 5
theorem
for b1 being non-empty ManySortedSet of NAT
for b2 being Permutation of b1
for b3 being ManySortedFunction of SetVal b1,SetVal b1 holds
      b3 = Perm b2
   iff
      b3 . VERUM = id 1 &
       (for b4 being Element of NAT holds
          b3 . prop b4 = b2 . b4) &
       (for b4, b5 being Element of HP-WFF holds
       ex b6 being Function-like quasi_total bijective Relation of SetVal(b1,b4),SetVal(b1,b4) st
          ex b7 being Function-like quasi_total bijective Relation of SetVal(b1,b5),SetVal(b1,b5) st
             b6 = b3 . b4 & b7 = b3 . b5 & b3 . (b4 '&' b5) = [:b6,b7:] & b3 . (b4 => b5) = b6 => b7);

:: HILBERT3:funcnot 5 => HILBERT3:func 5
definition
  let a1 be non-empty ManySortedSet of NAT;
  let a2 be Permutation of a1;
  let a3 be Element of HP-WFF;
  func Perm(A2,A3) -> Function-like quasi_total Relation of SetVal(a1,a3),SetVal(a1,a3) equals
    (Perm a2) . a3;
end;

:: HILBERT3:def 6
theorem
for b1 being non-empty ManySortedSet of NAT
for b2 being Permutation of b1
for b3 being Element of HP-WFF holds
   Perm(b2,b3) = (Perm b2) . b3;

:: HILBERT3:th 33
theorem
for b1 being non-empty ManySortedSet of NAT
for b2 being Permutation of b1 holds
   Perm(b2,VERUM) = id SetVal(b1,VERUM);

:: HILBERT3:th 34
theorem
for b1 being Element of NAT
for b2 being non-empty ManySortedSet of NAT
for b3 being Permutation of b2 holds
   Perm(b3,prop b1) = b3 . b1;

:: HILBERT3:th 35
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3 holds
   Perm(b4,b1 '&' b2) = [:Perm(b4,b1),Perm(b4,b2):];

:: HILBERT3:th 36
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3
for b5 being Function-like quasi_total bijective Relation of SetVal(b3,b1),SetVal(b3,b1)
for b6 being Function-like quasi_total bijective Relation of SetVal(b3,b2),SetVal(b3,b2)
      st b5 = Perm(b4,b1) & b6 = Perm(b4,b2)
   holds Perm(b4,b1 => b2) = b5 => b6;

:: HILBERT3:funcreg 6
registration
  let a1 be non-empty ManySortedSet of NAT;
  let a2 be Permutation of a1;
  let a3 be Element of HP-WFF;
  cluster Perm(a2,a3) -> Function-like quasi_total bijective;
end;

:: HILBERT3:th 37
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3
for b5 being Function-like quasi_total Relation of SetVal(b3,b1),SetVal(b3,b2) holds
   (Perm(b4,b1 => b2)) . b5 = ((Perm(b4,b2)) * b5) * ((Perm(b4,b1)) ");

:: HILBERT3:th 38
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3
for b5 being Function-like quasi_total Relation of SetVal(b3,b1),SetVal(b3,b2) holds
   (Perm(b4,b1 => b2)) " . b5 = ((Perm(b4,b2)) " * b5) * Perm(b4,b1);

:: HILBERT3:th 39
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3
for b5, b6 being Function-like quasi_total Relation of SetVal(b3,b1),SetVal(b3,b2)
      st b5 = (Perm(b4,b1 => b2)) . b6
   holds (Perm(b4,b2)) * b6 = b5 * Perm(b4,b1);

:: HILBERT3:th 40
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3
for b5 being set
   st b5 is_a_fixpoint_of Perm(b4,b1)
for b6 being Relation-like Function-like set
      st b6 is_a_fixpoint_of Perm(b4,b1 => b2)
   holds b6 . b5 is_a_fixpoint_of Perm(b4,b2);

:: HILBERT3:attrnot 1 => HILBERT3:attr 1
definition
  let a1 be Element of HP-WFF;
  attr a1 is canonical means
    for b1 being non-empty ManySortedSet of NAT holds
       ex b2 being set st
          for b3 being Permutation of b1 holds
             b2 is_a_fixpoint_of Perm(b3,a1);
end;

:: HILBERT3:dfs 7
definiens
  let a1 be Element of HP-WFF;
To prove
     a1 is canonical
it is sufficient to prove
  thus for b1 being non-empty ManySortedSet of NAT holds
       ex b2 being set st
          for b3 being Permutation of b1 holds
             b2 is_a_fixpoint_of Perm(b3,a1);

:: HILBERT3:def 7
theorem
for b1 being Element of HP-WFF holds
      b1 is canonical
   iff
      for b2 being non-empty ManySortedSet of NAT holds
         ex b3 being set st
            for b4 being Permutation of b2 holds
               b3 is_a_fixpoint_of Perm(b4,b1);

:: HILBERT3:funcreg 7
registration
  cluster VERUM -> canonical;
end;

:: HILBERT3:th 41
theorem
for b1, b2 being Element of HP-WFF holds
b1 => (b2 => b1) is canonical;

:: HILBERT3:th 42
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => (b2 => b3)) => ((b1 => b2) => (b1 => b3)) is canonical;

:: HILBERT3:th 43
theorem
for b1, b2 being Element of HP-WFF holds
(b1 '&' b2) => b1 is canonical;

:: HILBERT3:th 44
theorem
for b1, b2 being Element of HP-WFF holds
(b1 '&' b2) => b2 is canonical;

:: HILBERT3:th 45
theorem
for b1, b2 being Element of HP-WFF holds
b1 => (b2 => (b1 '&' b2)) is canonical;

:: HILBERT3:th 46
theorem
for b1, b2 being Element of HP-WFF
      st b1 is canonical & b1 => b2 is canonical
   holds b2 is canonical;

:: HILBERT3:th 47
theorem
for b1 being Element of HP-WFF
      st b1 in HP_TAUT
   holds b1 is canonical;

:: HILBERT3:exreg 3
registration
  cluster Relation-like Function-like FinSequence-like canonical Element of HP-WFF;
end;

:: HILBERT3:attrnot 2 => HILBERT3:attr 2
definition
  let a1 be Element of HP-WFF;
  attr a1 is pseudo-canonical means
    for b1 being non-empty ManySortedSet of NAT
    for b2 being Permutation of b1 holds
       ex b3 being set st
          b3 is_a_fixpoint_of Perm(b2,a1);
end;

:: HILBERT3:dfs 8
definiens
  let a1 be Element of HP-WFF;
To prove
     a1 is pseudo-canonical
it is sufficient to prove
  thus for b1 being non-empty ManySortedSet of NAT
    for b2 being Permutation of b1 holds
       ex b3 being set st
          b3 is_a_fixpoint_of Perm(b2,a1);

:: HILBERT3:def 8
theorem
for b1 being Element of HP-WFF holds
      b1 is pseudo-canonical
   iff
      for b2 being non-empty ManySortedSet of NAT
      for b3 being Permutation of b2 holds
         ex b4 being set st
            b4 is_a_fixpoint_of Perm(b3,b1);

:: HILBERT3:condreg 4
registration
  cluster canonical -> pseudo-canonical (Element of HP-WFF);
end;

:: HILBERT3:th 48
theorem
for b1, b2 being Element of HP-WFF holds
b1 => (b2 => b1) is pseudo-canonical;

:: HILBERT3:th 49
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => (b2 => b3)) => ((b1 => b2) => (b1 => b3)) is pseudo-canonical;

:: HILBERT3:th 50
theorem
for b1, b2 being Element of HP-WFF holds
(b1 '&' b2) => b1 is pseudo-canonical;

:: HILBERT3:th 51
theorem
for b1, b2 being Element of HP-WFF holds
(b1 '&' b2) => b2 is pseudo-canonical;

:: HILBERT3:th 52
theorem
for b1, b2 being Element of HP-WFF holds
b1 => (b2 => (b1 '&' b2)) is pseudo-canonical;

:: HILBERT3:th 53
theorem
for b1, b2 being Element of HP-WFF
      st b1 is pseudo-canonical & b1 => b2 is pseudo-canonical
   holds b2 is pseudo-canonical;

:: HILBERT3:th 54
theorem
for b1, b2 being Element of HP-WFF
for b3 being non-empty ManySortedSet of NAT
for b4 being Permutation of b3
      st (ex b5 being set st
            b5 is_a_fixpoint_of Perm(b4,b1)) &
         (for b5 being set holds
            not b5 is_a_fixpoint_of Perm(b4,b2))
   holds b1 => b2 is not pseudo-canonical;

:: HILBERT3:th 55
theorem
(((prop 0) => prop 1) => prop 0) => prop 0 is not pseudo-canonical;