Article HILBERT2, MML version 4.99.1005

:: HILBERT2:th 1
theorem
for b1 being set
for b2 being ManySortedSet of b1
   st for b3 being set
           st b3 in b1
        holds b2 . b3 is ManySortedSet of b3
for b3 being Relation-like Function-like set
      st b3 = Union b2
   holds proj1 b3 = union b1;

:: HILBERT2:th 2
theorem
for b1, b2 being set
for b3, b4 being Relation-like Function-like FinSequence-like set
      st <*b1*> ^ b3 = <*b2*> ^ b4
   holds b3 = b4;

:: HILBERT2:th 3
theorem
for b1, b2 being set
      st <*b1*> is FinSequence of b2
   holds b1 in b2;

:: HILBERT2:th 4
theorem
for b1 being set
for b2 being FinSequence of b1
      st b2 <> {}
   holds ex b3 being FinSequence of b1 st
      ex b4 being Element of b1 st
         b2 = b3 ^ <*b4*>;

:: HILBERT2:th 5
theorem
for b1 being set
for b2, b3 being non empty Tree-like set holds
   <*b1*> in tree(b2,b3)
iff
   (b1 = 0 or b1 = 1);

:: HILBERT2:funcreg 1
registration
  cluster {} -> Tree-yielding;
end;

:: HILBERT2:sch 1
scheme HILBERT2:sch 1
{F1 -> non empty Tree-like set}:
for b1 being Element of F1() holds
   P1[b1]
provided
   P1[<*> NAT]
and
   for b1 being Element of F1()
      st P1[b1]
   for b2 being Element of NAT
         st b1 ^ <*b2*> in F1()
      holds P1[b1 ^ <*b2*>];


:: HILBERT2:th 6
theorem
for b1 being set
for b2, b3 being Relation-like Function-like DecoratedTree-like set holds
(b1 -tree(b2,b3)) . {} = b1;

:: HILBERT2:th 7
theorem
for b1 being set
for b2, b3 being Relation-like Function-like DecoratedTree-like set holds
(b1 -tree(b2,b3)) . <*0*> = b2 . {} &
 (b1 -tree(b2,b3)) . <*1*> = b3 . {};

:: HILBERT2:th 8
theorem
for b1 being set
for b2, b3 being Relation-like Function-like DecoratedTree-like set holds
(b1 -tree(b2,b3)) | <*0*> = b2 &
 (b1 -tree(b2,b3)) | <*1*> = b3;

:: HILBERT2:funcreg 2
registration
  let a1 be set;
  let a2 be Relation-like Function-like non empty FinSequence-like DTree-yielding set;
  cluster a1 -tree a2 -> Relation-like Function-like DecoratedTree-like non root;
end;

:: HILBERT2:funcreg 3
registration
  let a1 be set;
  let a2 be Relation-like Function-like DecoratedTree-like set;
  cluster a1 -tree a2 -> Relation-like Function-like DecoratedTree-like non root;
end;

:: HILBERT2:funcreg 4
registration
  let a1 be set;
  let a2, a3 be Relation-like Function-like DecoratedTree-like set;
  cluster a1 -tree(a2,a3) -> Relation-like Function-like DecoratedTree-like non root;
end;

:: HILBERT2:funcnot 1 => HILBERT2:func 1
definition
  let a1 be Element of NAT;
  func prop A1 -> Element of HP-WFF equals
    <*3 + a1*>;
end;

:: HILBERT2:def 1
theorem
for b1 being Element of NAT holds
   prop b1 = <*3 + b1*>;

:: HILBERT2:attrnot 1 => HILBERT1:attr 1
definition
  let a1 be set;
  attr a1 is with_VERUM means
    VERUM in a1;
end;

:: HILBERT2:dfs 2
definiens
  let a1 be set;
To prove
     a1 is with_VERUM
it is sufficient to prove
  thus VERUM in a1;

:: HILBERT2:def 2
theorem
for b1 being set holds
      b1 is with_VERUM
   iff
      VERUM in b1;

:: HILBERT2:attrnot 2 => HILBERT1:attr 4
definition
  let a1 be set;
  attr a1 is with_propositional_variables means
    for b1 being Element of NAT holds
       prop b1 in a1;
end;

:: HILBERT2:dfs 3
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
       prop b1 in a1;

:: HILBERT2:def 3
theorem
for b1 being set holds
      b1 is with_propositional_variables
   iff
      for b2 being Element of NAT holds
         prop b2 in b1;

:: HILBERT2:attrnot 3 => HILBERT1:attr 2
definition
  let a1 be set;
  attr a1 is with_implication means
    for b1, b2 being Element of HP-WFF
          st b1 in a1 & b2 in a1
       holds b1 => b2 in a1;
end;

:: HILBERT2:dfs 4
definiens
  let a1 be Element of bool HP-WFF;
To prove
     a1 is with_implication
it is sufficient to prove
  thus for b1, b2 being Element of HP-WFF
          st b1 in a1 & b2 in a1
       holds b1 => b2 in a1;

:: HILBERT2:def 4
theorem
for b1 being Element of bool HP-WFF holds
      b1 is with_implication
   iff
      for b2, b3 being Element of HP-WFF
            st b2 in b1 & b3 in b1
         holds b2 => b3 in b1;

:: HILBERT2:attrnot 4 => HILBERT1:attr 3
definition
  let a1 be set;
  attr a1 is with_conjunction means
    for b1, b2 being Element of HP-WFF
          st b1 in a1 & b2 in a1
       holds b1 '&' b2 in a1;
end;

:: HILBERT2:dfs 5
definiens
  let a1 be Element of bool HP-WFF;
To prove
     a1 is with_conjunction
it is sufficient to prove
  thus for b1, b2 being Element of HP-WFF
          st b1 in a1 & b2 in a1
       holds b1 '&' b2 in a1;

:: HILBERT2:def 5
theorem
for b1 being Element of bool HP-WFF holds
      b1 is with_conjunction
   iff
      for b2, b3 being Element of HP-WFF
            st b2 in b1 & b3 in b1
         holds b2 '&' b3 in b1;

:: HILBERT2:attrnot 5 => HILBERT2:attr 1
definition
  let a1 be Element of HP-WFF;
  attr a1 is conjunctive means
    ex b1, b2 being Element of HP-WFF st
       a1 = b1 '&' b2;
end;

:: HILBERT2:dfs 6
definiens
  let a1 be Element of HP-WFF;
To prove
     a1 is conjunctive
it is sufficient to prove
  thus ex b1, b2 being Element of HP-WFF st
       a1 = b1 '&' b2;

:: HILBERT2:def 6
theorem
for b1 being Element of HP-WFF holds
      b1 is conjunctive
   iff
      ex b2, b3 being Element of HP-WFF st
         b1 = b2 '&' b3;

:: HILBERT2:attrnot 6 => HILBERT2:attr 2
definition
  let a1 be Element of HP-WFF;
  attr a1 is conditional means
    ex b1, b2 being Element of HP-WFF st
       a1 = b1 => b2;
end;

:: HILBERT2:dfs 7
definiens
  let a1 be Element of HP-WFF;
To prove
     a1 is conditional
it is sufficient to prove
  thus ex b1, b2 being Element of HP-WFF st
       a1 = b1 => b2;

:: HILBERT2:def 7
theorem
for b1 being Element of HP-WFF holds
      b1 is conditional
   iff
      ex b2, b3 being Element of HP-WFF st
         b1 = b2 => b3;

:: HILBERT2:attrnot 7 => HILBERT2:attr 3
definition
  let a1 be Element of HP-WFF;
  attr a1 is simple means
    ex b1 being Element of NAT st
       a1 = prop b1;
end;

:: HILBERT2:dfs 8
definiens
  let a1 be Element of HP-WFF;
To prove
     a1 is simple
it is sufficient to prove
  thus ex b1 being Element of NAT st
       a1 = prop b1;

:: HILBERT2:def 8
theorem
for b1 being Element of HP-WFF holds
      b1 is simple
   iff
      ex b2 being Element of NAT st
         b1 = prop b2;

:: HILBERT2:sch 2
scheme HILBERT2:sch 2
for b1 being Element of HP-WFF holds
   P1[b1]
provided
   P1[VERUM]
and
   for b1 being Element of NAT holds
      P1[prop b1]
and
   for b1, b2 being Element of HP-WFF
         st P1[b1] & P1[b2]
      holds P1[b1 '&' b2] & P1[b1 => b2];


:: HILBERT2:th 9
theorem
for b1 being Element of HP-WFF
      st b1 is not conjunctive & b1 is not conditional & b1 is not simple
   holds b1 = VERUM;

:: HILBERT2:th 10
theorem
for b1 being Element of HP-WFF holds
   1 <= len b1;

:: HILBERT2:th 11
theorem
for b1 being Element of HP-WFF
      st b1 . 1 = 1
   holds b1 is conditional;

:: HILBERT2:th 12
theorem
for b1 being Element of HP-WFF
      st b1 . 1 = 2
   holds b1 is conjunctive;

:: HILBERT2:th 13
theorem
for b1 being Element of NAT
for b2 being Element of HP-WFF
      st b2 . 1 = 3 + b1
   holds b2 is simple;

:: HILBERT2:th 14
theorem
for b1 being Element of HP-WFF
      st b1 . 1 = 0
   holds b1 = VERUM;

:: HILBERT2:th 15
theorem
for b1, b2 being Element of HP-WFF holds
len b1 < len (b1 '&' b2) & len b2 < len (b1 '&' b2);

:: HILBERT2:th 16
theorem
for b1, b2 being Element of HP-WFF holds
len b1 < len (b1 => b2) & len b2 < len (b1 => b2);

:: HILBERT2:th 17
theorem
for b1, b2 being Element of HP-WFF
for b3 being Relation-like Function-like FinSequence-like set
      st b1 = b2 ^ b3
   holds b1 = b2;

:: HILBERT2:th 18
theorem
for b1, b2, b3, b4 being Element of HP-WFF
      st b1 ^ b2 = b3 ^ b4
   holds b1 = b3 & b2 = b4;

:: HILBERT2:th 19
theorem
for b1, b2, b3, b4 being Element of HP-WFF
      st b1 '&' b2 = b3 '&' b4
   holds b1 = b3 & b4 = b2;

:: HILBERT2:th 20
theorem
for b1, b2, b3, b4 being Element of HP-WFF
      st b1 => b2 = b3 => b4
   holds b1 = b3 & b4 = b2;

:: HILBERT2:th 21
theorem
for b1, b2 being Element of NAT
      st prop b1 = prop b2
   holds b1 = b2;

:: HILBERT2:th 22
theorem
for b1, b2, b3, b4 being Element of HP-WFF holds
b1 '&' b2 <> b3 => b4;

:: HILBERT2:th 23
theorem
for b1, b2 being Element of HP-WFF holds
b1 '&' b2 <> VERUM;

:: HILBERT2:th 24
theorem
for b1 being Element of NAT
for b2, b3 being Element of HP-WFF holds
b2 '&' b3 <> prop b1;

:: HILBERT2:th 25
theorem
for b1, b2 being Element of HP-WFF holds
b1 => b2 <> VERUM;

:: HILBERT2:th 26
theorem
for b1 being Element of NAT
for b2, b3 being Element of HP-WFF holds
b2 => b3 <> prop b1;

:: HILBERT2:th 27
theorem
for b1, b2 being Element of HP-WFF holds
b1 '&' b2 <> b1 & b1 '&' b2 <> b2;

:: HILBERT2:th 28
theorem
for b1, b2 being Element of HP-WFF holds
b1 => b2 <> b1 & b1 => b2 <> b2;

:: HILBERT2:th 29
theorem
for b1 being Element of NAT holds
   VERUM <> prop b1;

:: HILBERT2:sch 3
scheme HILBERT2:sch 3
{F1 -> set,
  F2 -> set}:
ex b1 being ManySortedSet of HP-WFF st
   b1 . VERUM = F1() &
    (for b2 being Element of NAT holds
       b1 . prop b2 = F2(b2)) &
    (for b2, b3 being Element of HP-WFF holds
    P1[b2, b3, b1 . b2, b1 . b3, b1 . (b2 '&' b3)] &
     P2[b2, b3, b1 . b2, b1 . b3, b1 . (b2 => b3)])
provided
   for b1, b2 being Element of HP-WFF
   for b3, b4 being set holds
   ex b5 being set st
      P1[b1, b2, b3, b4, b5]
and
   for b1, b2 being Element of HP-WFF
   for b3, b4 being set holds
   ex b5 being set st
      P2[b1, b2, b3, b4, b5]
and
   for b1, b2 being Element of HP-WFF
   for b3, b4, b5, b6 being set
         st P1[b1, b2, b3, b4, b5] & P1[b1, b2, b3, b4, b6]
      holds b5 = b6
and
   for b1, b2 being Element of HP-WFF
   for b3, b4, b5, b6 being set
         st P2[b1, b2, b3, b4, b5] & P2[b1, b2, b3, b4, b6]
      holds b5 = b6;


:: HILBERT2:sch 4
scheme HILBERT2:sch 4
{F1 -> set,
  F2 -> set,
  F3 -> set,
  F4 -> set}:
ex b1 being ManySortedSet of HP-WFF st
   b1 . VERUM = F1() &
    (for b2 being Element of NAT holds
       b1 . prop b2 = F2(b2)) &
    (for b2, b3 being Element of HP-WFF holds
    b1 . (b2 '&' b3) = F3(b1 . b2, b1 . b3) &
     b1 . (b2 => b3) = F4(b1 . b2, b1 . b3))


:: HILBERT2:funcnot 2 => HILBERT2:func 2
definition
  func HP-Subformulae -> ManySortedSet of HP-WFF means
    it . VERUM = root-tree VERUM &
     (for b1 being Element of NAT holds
        it . prop b1 = root-tree prop b1) &
     (for b1, b2 being Element of HP-WFF holds
     ex b3, b4 being Function-like DecoratedTree-like ParametrizedSubset of HP-WFF st
        b3 = it . b1 &
         b4 = it . b2 &
         it . (b1 '&' b2) = (b1 '&' b2) -tree(b3,b4) &
         it . (b1 => b2) = (b1 => b2) -tree(b3,b4));
end;

:: HILBERT2:def 9
theorem
for b1 being ManySortedSet of HP-WFF holds
      b1 = HP-Subformulae
   iff
      b1 . VERUM = root-tree VERUM &
       (for b2 being Element of NAT holds
          b1 . prop b2 = root-tree prop b2) &
       (for b2, b3 being Element of HP-WFF holds
       ex b4, b5 being Function-like DecoratedTree-like ParametrizedSubset of HP-WFF st
          b4 = b1 . b2 &
           b5 = b1 . b3 &
           b1 . (b2 '&' b3) = (b2 '&' b3) -tree(b4,b5) &
           b1 . (b2 => b3) = (b2 => b3) -tree(b4,b5));

:: HILBERT2:funcnot 3 => HILBERT2:func 3
definition
  let a1 be Element of HP-WFF;
  func Subformulae A1 -> Function-like DecoratedTree-like ParametrizedSubset of HP-WFF equals
    HP-Subformulae . a1;
end;

:: HILBERT2:def 10
theorem
for b1 being Element of HP-WFF holds
   Subformulae b1 = HP-Subformulae . b1;

:: HILBERT2:th 30
theorem
Subformulae VERUM = root-tree VERUM;

:: HILBERT2:th 31
theorem
for b1 being Element of NAT holds
   Subformulae prop b1 = root-tree prop b1;

:: HILBERT2:th 32
theorem
for b1, b2 being Element of HP-WFF holds
Subformulae (b1 '&' b2) = (b1 '&' b2) -tree(Subformulae b1,Subformulae b2);

:: HILBERT2:th 33
theorem
for b1, b2 being Element of HP-WFF holds
Subformulae (b1 => b2) = (b1 => b2) -tree(Subformulae b1,Subformulae b2);

:: HILBERT2:th 34
theorem
for b1 being Element of HP-WFF holds
   (Subformulae b1) . {} = b1;

:: HILBERT2:th 35
theorem
for b1 being Element of HP-WFF
for b2 being Element of proj1 Subformulae b1 holds
   (Subformulae b1) | b2 = Subformulae ((Subformulae b1) . b2);

:: HILBERT2:th 36
theorem
for b1, b2 being Element of HP-WFF
      st b1 in Leaves Subformulae b2 & b1 <> VERUM
   holds b1 is simple;