Article HILBERT1, MML version 4.99.1005

:: HILBERT1:attrnot 1 => HILBERT1:attr 1
definition
  let a1 be set;
  attr a1 is with_VERUM means
    <*0*> in a1;
end;

:: HILBERT1:dfs 1
definiens
  let a1 be set;
To prove
     a1 is with_VERUM
it is sufficient to prove
  thus <*0*> in a1;

:: HILBERT1:def 1
theorem
for b1 being set holds
      b1 is with_VERUM
   iff
      <*0*> in b1;

:: HILBERT1:attrnot 2 => HILBERT1:attr 2
definition
  let a1 be set;
  attr a1 is with_implication means
    for b1, b2 being Relation-like Function-like FinSequence-like set
          st b1 in a1 & b2 in a1
       holds (<*1*> ^ b1) ^ b2 in a1;
end;

:: HILBERT1:dfs 2
definiens
  let a1 be set;
To prove
     a1 is with_implication
it is sufficient to prove
  thus for b1, b2 being Relation-like Function-like FinSequence-like set
          st b1 in a1 & b2 in a1
       holds (<*1*> ^ b1) ^ b2 in a1;

:: HILBERT1:def 2
theorem
for b1 being set holds
      b1 is with_implication
   iff
      for b2, b3 being Relation-like Function-like FinSequence-like set
            st b2 in b1 & b3 in b1
         holds (<*1*> ^ b2) ^ b3 in b1;

:: HILBERT1:attrnot 3 => HILBERT1:attr 3
definition
  let a1 be set;
  attr a1 is with_conjunction means
    for b1, b2 being Relation-like Function-like FinSequence-like set
          st b1 in a1 & b2 in a1
       holds (<*2*> ^ b1) ^ b2 in a1;
end;

:: HILBERT1:dfs 3
definiens
  let a1 be set;
To prove
     a1 is with_conjunction
it is sufficient to prove
  thus for b1, b2 being Relation-like Function-like FinSequence-like set
          st b1 in a1 & b2 in a1
       holds (<*2*> ^ b1) ^ b2 in a1;

:: HILBERT1:def 3
theorem
for b1 being set holds
      b1 is with_conjunction
   iff
      for b2, b3 being Relation-like Function-like FinSequence-like set
            st b2 in b1 & b3 in b1
         holds (<*2*> ^ b2) ^ b3 in b1;

:: HILBERT1:attrnot 4 => HILBERT1:attr 4
definition
  let a1 be set;
  attr a1 is with_propositional_variables means
    for b1 being Element of NAT holds
       <*3 + b1*> in a1;
end;

:: HILBERT1:dfs 4
definiens
  let a1 be set;
To prove
     a1 is with_propositional_variables
it is sufficient to prove
  thus for b1 being Element of NAT holds
       <*3 + b1*> in a1;

:: HILBERT1:def 4
theorem
for b1 being set holds
      b1 is with_propositional_variables
   iff
      for b2 being Element of NAT holds
         <*3 + b2*> in b1;

:: HILBERT1:attrnot 5 => HILBERT1:attr 5
definition
  let a1 be set;
  attr a1 is HP-closed means
    a1 c= NAT * & a1 is with_VERUM & a1 is with_implication & a1 is with_conjunction & a1 is with_propositional_variables;
end;

:: HILBERT1:dfs 5
definiens
  let a1 be set;
To prove
     a1 is HP-closed
it is sufficient to prove
  thus a1 c= NAT * & a1 is with_VERUM & a1 is with_implication & a1 is with_conjunction & a1 is with_propositional_variables;

:: HILBERT1:def 5
theorem
for b1 being set holds
      b1 is HP-closed
   iff
      b1 c= NAT * & b1 is with_VERUM & b1 is with_implication & b1 is with_conjunction & b1 is with_propositional_variables;

:: HILBERT1:condreg 1
registration
  cluster HP-closed -> non empty with_VERUM with_implication with_conjunction with_propositional_variables (set);
end;

:: HILBERT1:condreg 2
registration
  cluster with_VERUM with_implication with_conjunction with_propositional_variables -> HP-closed (Element of bool (NAT *));
end;

:: HILBERT1:funcnot 1 => HILBERT1:func 1
definition
  func HP-WFF -> set means
    it is HP-closed &
     (for b1 being set
           st b1 is HP-closed
        holds it c= b1);
end;

:: HILBERT1:def 6
theorem
for b1 being set holds
      b1 = HP-WFF
   iff
      b1 is HP-closed &
       (for b2 being set
             st b2 is HP-closed
          holds b1 c= b2);

:: HILBERT1:funcreg 1
registration
  cluster HP-WFF -> HP-closed;
end;

:: HILBERT1:exreg 1
registration
  cluster non empty HP-closed set;
end;

:: HILBERT1:funcreg 2
registration
  cluster HP-WFF -> functional;
end;

:: HILBERT1:condreg 3
registration
  cluster -> FinSequence-like (Element of HP-WFF);
end;

:: HILBERT1:modenot 1
definition
  mode HP-formula is Element of HP-WFF;
end;

:: HILBERT1:funcnot 2 => HILBERT1:func 2
definition
  func VERUM -> Element of HP-WFF equals
    <*0*>;
end;

:: HILBERT1:def 7
theorem
VERUM = <*0*>;

:: HILBERT1:funcnot 3 => HILBERT1:func 3
definition
  let a1, a2 be Element of HP-WFF;
  func A1 => A2 -> Element of HP-WFF equals
    (<*1*> ^ a1) ^ a2;
end;

:: HILBERT1:def 8
theorem
for b1, b2 being Element of HP-WFF holds
b1 => b2 = (<*1*> ^ b1) ^ b2;

:: HILBERT1:funcnot 4 => HILBERT1:func 4
definition
  let a1, a2 be Element of HP-WFF;
  func A1 '&' A2 -> Element of HP-WFF equals
    (<*2*> ^ a1) ^ a2;
end;

:: HILBERT1:def 9
theorem
for b1, b2 being Element of HP-WFF holds
b1 '&' b2 = (<*2*> ^ b1) ^ b2;

:: HILBERT1:attrnot 6 => HILBERT1:attr 6
definition
  let a1 be Element of bool HP-WFF;
  attr a1 is Hilbert_theory means
    VERUM in a1 &
     (for b1, b2, b3 being Element of HP-WFF holds
     b1 => (b2 => b1) in a1 &
      (b1 => (b2 => b3)) => ((b1 => b2) => (b1 => b3)) in a1 &
      (b1 '&' b2) => b1 in a1 &
      (b1 '&' b2) => b2 in a1 &
      b1 => (b2 => (b1 '&' b2)) in a1 &
      (b1 in a1 & b1 => b2 in a1 implies b2 in a1));
end;

:: HILBERT1:dfs 10
definiens
  let a1 be Element of bool HP-WFF;
To prove
     a1 is Hilbert_theory
it is sufficient to prove
  thus VERUM in a1 &
     (for b1, b2, b3 being Element of HP-WFF holds
     b1 => (b2 => b1) in a1 &
      (b1 => (b2 => b3)) => ((b1 => b2) => (b1 => b3)) in a1 &
      (b1 '&' b2) => b1 in a1 &
      (b1 '&' b2) => b2 in a1 &
      b1 => (b2 => (b1 '&' b2)) in a1 &
      (b1 in a1 & b1 => b2 in a1 implies b2 in a1));

:: HILBERT1:def 10
theorem
for b1 being Element of bool HP-WFF holds
      b1 is Hilbert_theory
   iff
      VERUM in b1 &
       (for b2, b3, b4 being Element of HP-WFF holds
       b2 => (b3 => b2) in b1 &
        (b2 => (b3 => b4)) => ((b2 => b3) => (b2 => b4)) in b1 &
        (b2 '&' b3) => b2 in b1 &
        (b2 '&' b3) => b3 in b1 &
        b2 => (b3 => (b2 '&' b3)) in b1 &
        (b2 in b1 & b2 => b3 in b1 implies b3 in b1));

:: HILBERT1:funcnot 5 => HILBERT1:func 5
definition
  let a1 be Element of bool HP-WFF;
  func CnPos A1 -> Element of bool HP-WFF means
    for b1 being Element of HP-WFF holds
          b1 in it
       iff
          for b2 being Element of bool HP-WFF
                st b2 is Hilbert_theory & a1 c= b2
             holds b1 in b2;
end;

:: HILBERT1:def 11
theorem
for b1, b2 being Element of bool HP-WFF holds
   b2 = CnPos b1
iff
   for b3 being Element of HP-WFF holds
         b3 in b2
      iff
         for b4 being Element of bool HP-WFF
               st b4 is Hilbert_theory & b1 c= b4
            holds b3 in b4;

:: HILBERT1:funcnot 6 => HILBERT1:func 6
definition
  func HP_TAUT -> Element of bool HP-WFF equals
    CnPos {} HP-WFF;
end;

:: HILBERT1:def 12
theorem
HP_TAUT = CnPos {} HP-WFF;

:: HILBERT1:th 1
theorem
for b1 being Element of bool HP-WFF holds
   VERUM in CnPos b1;

:: HILBERT1:th 2
theorem
for b1 being Element of bool HP-WFF
for b2, b3 being Element of HP-WFF holds
b2 => (b3 => (b2 '&' b3)) in CnPos b1;

:: HILBERT1:th 3
theorem
for b1 being Element of bool HP-WFF
for b2, b3, b4 being Element of HP-WFF holds
(b2 => (b3 => b4)) => ((b2 => b3) => (b2 => b4)) in CnPos b1;

:: HILBERT1:th 4
theorem
for b1 being Element of bool HP-WFF
for b2, b3 being Element of HP-WFF holds
b2 => (b3 => b2) in CnPos b1;

:: HILBERT1:th 5
theorem
for b1 being Element of bool HP-WFF
for b2, b3 being Element of HP-WFF holds
(b2 '&' b3) => b2 in CnPos b1;

:: HILBERT1:th 6
theorem
for b1 being Element of bool HP-WFF
for b2, b3 being Element of HP-WFF holds
(b2 '&' b3) => b3 in CnPos b1;

:: HILBERT1:th 7
theorem
for b1 being Element of bool HP-WFF
for b2, b3 being Element of HP-WFF
      st b2 in CnPos b1 & b2 => b3 in CnPos b1
   holds b3 in CnPos b1;

:: HILBERT1:th 8
theorem
for b1, b2 being Element of bool HP-WFF
      st b1 is Hilbert_theory & b2 c= b1
   holds CnPos b2 c= b1;

:: HILBERT1:th 9
theorem
for b1 being Element of bool HP-WFF holds
   b1 c= CnPos b1;

:: HILBERT1:th 10
theorem
for b1, b2 being Element of bool HP-WFF
      st b1 c= b2
   holds CnPos b1 c= CnPos b2;

:: HILBERT1:th 11
theorem
for b1 being Element of bool HP-WFF holds
   CnPos CnPos b1 = CnPos b1;

:: HILBERT1:funcreg 3
registration
  let a1 be Element of bool HP-WFF;
  cluster CnPos a1 -> Hilbert_theory;
end;

:: HILBERT1:th 12
theorem
for b1 being Element of bool HP-WFF holds
      b1 is Hilbert_theory
   iff
      CnPos b1 = b1;

:: HILBERT1:th 13
theorem
for b1 being Element of bool HP-WFF
      st b1 is Hilbert_theory
   holds HP_TAUT c= b1;

:: HILBERT1:funcreg 4
registration
  cluster HP_TAUT -> Hilbert_theory;
end;

:: HILBERT1:th 14
theorem
for b1 being Element of HP-WFF holds
   b1 => b1 in HP_TAUT;

:: HILBERT1:th 15
theorem
for b1, b2 being Element of HP-WFF
      st b1 in HP_TAUT
   holds b2 => b1 in HP_TAUT;

:: HILBERT1:th 16
theorem
for b1 being Element of HP-WFF holds
   b1 => VERUM in HP_TAUT;

:: HILBERT1:th 17
theorem
for b1, b2 being Element of HP-WFF holds
(b1 => b2) => (b1 => b1) in HP_TAUT;

:: HILBERT1:th 18
theorem
for b1, b2 being Element of HP-WFF holds
(b1 => b2) => (b2 => b2) in HP_TAUT;

:: HILBERT1:th 19
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b3 => b1) => (b3 => b2)) in HP_TAUT;

:: HILBERT1:th 20
theorem
for b1, b2, b3 being Element of HP-WFF
      st b1 => (b2 => b3) in HP_TAUT
   holds b2 => (b1 => b3) in HP_TAUT;

:: HILBERT1:th 21
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b2 => b3) => (b1 => b3)) in HP_TAUT;

:: HILBERT1:th 22
theorem
for b1, b2, b3 being Element of HP-WFF
      st b1 => b2 in HP_TAUT
   holds (b2 => b3) => (b1 => b3) in HP_TAUT;

:: HILBERT1:th 23
theorem
for b1, b2, b3 being Element of HP-WFF
      st b1 => b2 in HP_TAUT & b2 => b3 in HP_TAUT
   holds b1 => b3 in HP_TAUT;

:: HILBERT1:th 24
theorem
for b1, b2, b3, b4 being Element of HP-WFF holds
(b1 => (b2 => b3)) => ((b4 => b2) => (b1 => (b4 => b3))) in HP_TAUT;

:: HILBERT1:th 25
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 => b2) => b3) => (b2 => b3) in HP_TAUT;

:: HILBERT1:th 26
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => (b2 => b3)) => (b2 => (b1 => b3)) in HP_TAUT;

:: HILBERT1:th 27
theorem
for b1, b2 being Element of HP-WFF holds
(b1 => (b1 => b2)) => (b1 => b2) in HP_TAUT;

:: HILBERT1:th 28
theorem
for b1, b2 being Element of HP-WFF holds
b1 => ((b1 => b2) => b2) in HP_TAUT;

:: HILBERT1:th 29
theorem
for b1, b2, b3 being Element of HP-WFF
      st b1 => (b2 => b3) in HP_TAUT & b2 in HP_TAUT
   holds b1 => b3 in HP_TAUT;

:: HILBERT1:th 30
theorem
for b1 being Element of HP-WFF holds
   b1 => (b1 '&' b1) in HP_TAUT;

:: HILBERT1:th 31
theorem
for b1, b2 being Element of HP-WFF holds
   b1 '&' b2 in HP_TAUT
iff
   b1 in HP_TAUT & b2 in HP_TAUT;

:: HILBERT1:th 32
theorem
for b1, b2 being Element of HP-WFF holds
   b1 '&' b2 in HP_TAUT
iff
   b2 '&' b1 in HP_TAUT;

:: HILBERT1:th 33
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 '&' b2) => b3) => (b1 => (b2 => b3)) in HP_TAUT;

:: HILBERT1:th 34
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => (b2 => b3)) => ((b1 '&' b2) => b3) in HP_TAUT;

:: HILBERT1:th 35
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b1 => b3) => (b1 => (b2 '&' b3))) in HP_TAUT;

:: HILBERT1:th 36
theorem
for b1, b2 being Element of HP-WFF holds
((b1 => b2) '&' b1) => b2 in HP_TAUT;

:: HILBERT1:th 37
theorem
for b1, b2, b3 being Element of HP-WFF holds
(((b1 => b2) '&' b1) '&' b3) => b2 in HP_TAUT;

:: HILBERT1:th 38
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b3 '&' b1) => b2) in HP_TAUT;

:: HILBERT1:th 39
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b1 '&' b3) => b2) in HP_TAUT;

:: HILBERT1:th 40
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 '&' b2) => b3) => ((b1 '&' b2) => (b3 '&' b2)) in HP_TAUT;

:: HILBERT1:th 41
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b1 '&' b3) => (b2 '&' b3)) in HP_TAUT;

:: HILBERT1:th 42
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 => b2) '&' (b1 '&' b3)) => (b2 '&' b3) in HP_TAUT;

:: HILBERT1:th 43
theorem
for b1, b2 being Element of HP-WFF holds
(b1 '&' b2) => (b2 '&' b1) in HP_TAUT;

:: HILBERT1:th 44
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 => b2) '&' (b1 '&' b3)) => (b3 '&' b2) in HP_TAUT;

:: HILBERT1:th 45
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b1 '&' b3) => (b3 '&' b2)) in HP_TAUT;

:: HILBERT1:th 46
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 => b2) => ((b3 '&' b1) => (b3 '&' b2)) in HP_TAUT;

:: HILBERT1:th 47
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 '&' (b2 '&' b3)) => (b1 '&' (b3 '&' b2)) in HP_TAUT;

:: HILBERT1:th 48
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 => b2) '&' (b1 => b3)) => (b1 => (b2 '&' b3)) in HP_TAUT;

:: HILBERT1:th 49
theorem
for b1, b2, b3 being Element of HP-WFF holds
((b1 '&' b2) '&' b3) => (b1 '&' (b2 '&' b3)) in HP_TAUT;

:: HILBERT1:th 50
theorem
for b1, b2, b3 being Element of HP-WFF holds
(b1 '&' (b2 '&' b3)) => ((b1 '&' b2) '&' b3) in HP_TAUT;