Article NAT_1, MML version 4.99.1005

:: NAT_1:modenot 1
definition
  mode Nat is natural set;
end;

:: NAT_1:th 1
theorem
for b1 being Element of bool REAL
   st 0 in b1 &
      (for b2 being Element of REAL
            st b2 in b1
         holds b2 + 1 in b1)
for b2 being natural set holds
   b2 in b1;

:: NAT_1:funcreg 1
registration
  let a1, a2 be natural set;
  cluster a1 + a2 -> natural;
end;

:: NAT_1:funcnot 1 => NAT_1:func 1
definition
  let a1 be natural set;
  let a2 be Element of NAT;
  redefine func a1 + a2 -> Element of NAT;
  commutativity;
::  for a1 being natural set
::  for a2 being Element of NAT holds
::     a1 + a2 = a2 + a1;
end;

:: NAT_1:funcnot 2 => NAT_1:func 2
definition
  let a1 be Element of NAT;
  let a2 be natural set;
  redefine func a1 + a2 -> Element of NAT;
  commutativity;
::  for a1 being Element of NAT
::  for a2 being natural set holds
::     a1 + a2 = a2 + a1;
end;

:: NAT_1:sch 1
scheme NAT_1:sch 1
for b1 being Element of NAT holds
   P1[b1]
provided
   P1[0]
and
   for b1 being Element of NAT
         st P1[b1]
      holds P1[b1 + 1];


:: NAT_1:sch 2
scheme NAT_1:sch 2
for b1 being natural set holds
   P1[b1]
provided
   P1[0]
and
   for b1 being natural set
         st P1[b1]
      holds P1[b1 + 1];


:: NAT_1:funcreg 2
registration
  let a1, a2 be natural set;
  cluster a1 * a2 -> natural;
end;

:: NAT_1:funcnot 3 => NAT_1:func 3
definition
  let a1 be natural set;
  let a2 be Element of NAT;
  redefine func a1 * a2 -> Element of NAT;
  commutativity;
::  for a1 being natural set
::  for a2 being Element of NAT holds
::     a1 * a2 = a2 * a1;
end;

:: NAT_1:funcnot 4 => NAT_1:func 4
definition
  let a1 be Element of NAT;
  let a2 be natural set;
  redefine func a1 * a2 -> Element of NAT;
  commutativity;
::  for a1 being Element of NAT
::  for a2 being natural set holds
::     a1 * a2 = a2 * a1;
end;

:: NAT_1:th 2
theorem
for b1 being natural set holds
   0 <= b1;

:: NAT_1:th 3
theorem
for b1 being natural set
      st 0 <> b1
   holds 0 < b1;

:: NAT_1:th 4
theorem
for b1, b2, b3 being natural set
      st b1 <= b2
   holds b1 * b3 <= b2 * b3;

:: NAT_1:th 5
theorem
for b1 being natural set holds
   0 < b1 + 1;

:: NAT_1:th 6
theorem
for b1 being natural set
      st b1 <> 0
   holds ex b2 being natural set st
      b1 = b2 + 1;

:: NAT_1:th 7
theorem
for b1, b2 being natural set
      st b1 + b2 = 0
   holds b1 = 0 & b2 = 0;

:: NAT_1:exreg 1
registration
  cluster non empty epsilon-transitive epsilon-connected ordinal natural complex ext-real real finite cardinal set;
end;

:: NAT_1:funcreg 3
registration
  let a1 be natural set;
  let a2 be non empty natural set;
  cluster a1 + a2 -> non empty;
end;

:: NAT_1:funcreg 4
registration
  let a1 be natural set;
  let a2 be non empty natural set;
  cluster a2 + a1 -> non empty;
end;

:: NAT_1:sch 3
scheme NAT_1:sch 3
{F1 -> natural set,
  F2 -> natural set}:
(for b1 being natural set holds
    ex b2 being natural set st
       P1[b1, b2]) &
 (for b1, b2, b3 being natural set
       st P1[b1, b2] & P1[b1, b3]
    holds b2 = b3)
provided
   for b1, b2 being natural set holds
      P1[b1, b2]
   iff
      ((b1 = 0 implies b2 <> F1()) implies ex b3, b4 being natural set st
         b1 = b3 + 1 & P1[b3, b4] & b2 = F2(b1, b4));


:: NAT_1:th 8
theorem
for b1, b2 being natural set
      st b1 <= b2 + 1 & b2 < b1
   holds b1 = b2 + 1;

:: NAT_1:th 9
theorem
for b1, b2 being natural set
      st b1 <= b2 & b2 <= b1 + 1 & b1 <> b2
   holds b2 = b1 + 1;

:: NAT_1:th 10
theorem
for b1, b2 being natural set
      st b1 <= b2
   holds ex b3 being natural set st
      b2 = b1 + b3;

:: NAT_1:th 11
theorem
for b1, b2 being natural set holds
b1 <= b1 + b2;

:: NAT_1:sch 4
scheme NAT_1:sch 4
for b1 being natural set holds
   P1[b1]
provided
   for b1 being natural set
         st for b2 being natural set
                 st b2 < b1
              holds P1[b2]
      holds P1[b1];


:: NAT_1:sch 5
scheme NAT_1:sch 5
ex b1 being natural set st
   P1[b1] &
    (for b2 being natural set
          st P1[b2]
       holds b1 <= b2)
provided
   ex b1 being natural set st
      P1[b1];


:: NAT_1:sch 6
scheme NAT_1:sch 6
{F1 -> natural set}:
ex b1 being natural set st
   P1[b1] &
    (for b2 being natural set
          st P1[b2]
       holds b2 <= b1)
provided
   for b1 being natural set
         st P1[b1]
      holds b1 <= F1()
and
   ex b1 being natural set st
      P1[b1];


:: NAT_1:th 12
theorem
for b1, b2, b3 being natural set
      st b1 <= b2
   holds b1 <= b2 + b3;

:: NAT_1:th 13
theorem
for b1, b2 being natural set holds
   b1 < b2 + 1
iff
   b1 <= b2;

:: NAT_1:th 14
theorem
for b1 being natural set
      st b1 < 1
   holds b1 = 0;

:: NAT_1:th 15
theorem
for b1, b2 being natural set
      st b1 * b2 = 1
   holds b1 = 1;

:: NAT_1:th 16
theorem
for b1, b2 being natural set
      st b1 <> 0
   holds b2 < b2 + b1;

:: NAT_1:sch 7
scheme NAT_1:sch 7
P1[0]
provided
   ex b1 being natural set st
      P1[b1]
and
   for b1 being natural set
         st b1 <> 0 & P1[b1]
      holds ex b2 being natural set st
         b2 < b1 & P1[b2];


:: NAT_1:th 17
theorem
for b1 being natural set
   st 0 < b1
for b2 being natural set holds
   ex b3, b4 being natural set st
      b2 = (b1 * b3) + b4 & b4 < b1;

:: NAT_1:th 18
theorem
for b1, b2, b3, b4, b5, b6 being natural set
      st b1 = (b2 * b3) + b4 & b4 < b2 & b1 = (b2 * b5) + b6 & b6 < b2
   holds b3 = b5 & b4 = b6;

:: NAT_1:condreg 1
registration
  cluster natural -> ordinal (set);
end;

:: NAT_1:exreg 2
registration
  cluster non empty ordinal Element of bool REAL;
end;

:: NAT_1:th 19
theorem
for b1, b2 being natural set holds
   b1 < b1 + b2
iff
   1 <= b2;

:: NAT_1:th 20
theorem
for b1, b2 being natural set
      st b1 < b2
   holds b2 - 1 is Element of NAT;

:: NAT_1:th 21
theorem
for b1, b2 being natural set
      st b1 <= b2
   holds b2 - b1 is Element of NAT;

:: NAT_1:th 22
theorem
for b1, b2 being natural set
      st b1 < b2 + 1 & b2 <= b1
   holds b1 = b2;

:: NAT_1:th 23
theorem
for b1 being natural set
      st b1 < 2 & b1 <> 0
   holds b1 = 1;

:: NAT_1:exreg 3
registration
  cluster non empty epsilon-transitive epsilon-connected ordinal natural complex ext-real real finite cardinal Element of NAT;
end;

:: NAT_1:condreg 2
registration
  cluster -> non negative (Element of NAT);
end;

:: NAT_1:condreg 3
registration
  cluster natural -> non negative (set);
end;

:: NAT_1:th 24
theorem
for b1, b2, b3 being natural set
      st b1 <> 0 & b2 = b3 * b1
   holds b3 <= b2;

:: NAT_1:sch 8
scheme NAT_1:sch 8
{F1 -> natural set}:
for b1 being natural set
      st F1() <= b1
   holds P1[b1]
provided
   P1[F1()]
and
   for b1 being natural set
         st F1() <= b1 & P1[b1]
      holds P1[b1 + 1];


:: NAT_1:sch 9
scheme NAT_1:sch 9
{F1 -> natural set}:
for b1 being natural set
      st F1() <= b1
   holds P1[b1]
provided
   for b1 being natural set
         st F1() <= b1 &
            (for b2 being natural set
                  st F1() <= b2 & b2 < b1
               holds P1[b2])
      holds P1[b1];


:: NAT_1:th 26
theorem
for b1 being natural set
      st b1 <= 1 & b1 <> 0
   holds b1 = 1;

:: NAT_1:th 27
theorem
for b1 being natural set
      st b1 <= 2 & b1 <> 0 & b1 <> 1
   holds b1 = 2;

:: NAT_1:th 28
theorem
for b1 being natural set
      st b1 <= 3 & b1 <> 0 & b1 <> 1 & b1 <> 2
   holds b1 = 3;

:: NAT_1:th 29
theorem
for b1 being natural set
      st b1 <= 4 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3
   holds b1 = 4;

:: NAT_1:th 30
theorem
for b1 being natural set
      st b1 <= 5 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4
   holds b1 = 5;

:: NAT_1:th 31
theorem
for b1 being natural set
      st b1 <= 6 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5
   holds b1 = 6;

:: NAT_1:th 32
theorem
for b1 being natural set
      st b1 <= 7 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6
   holds b1 = 7;

:: NAT_1:th 33
theorem
for b1 being natural set
      st b1 <= 8 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6 & b1 <> 7
   holds b1 = 8;

:: NAT_1:th 34
theorem
for b1 being natural set
      st b1 <= 9 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6 & b1 <> 7 & b1 <> 8
   holds b1 = 9;

:: NAT_1:th 35
theorem
for b1 being natural set
      st b1 <= 10 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6 & b1 <> 7 & b1 <> 8 & b1 <> 9
   holds b1 = 10;

:: NAT_1:th 36
theorem
for b1 being natural set
      st b1 <= 11 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6 & b1 <> 7 & b1 <> 8 & b1 <> 9 & b1 <> 10
   holds b1 = 11;

:: NAT_1:th 37
theorem
for b1 being natural set
      st b1 <= 12 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6 & b1 <> 7 & b1 <> 8 & b1 <> 9 & b1 <> 10 & b1 <> 11
   holds b1 = 12;

:: NAT_1:th 38
theorem
for b1 being natural set
      st b1 <= 13 & b1 <> 0 & b1 <> 1 & b1 <> 2 & b1 <> 3 & b1 <> 4 & b1 <> 5 & b1 <> 6 & b1 <> 7 & b1 <> 8 & b1 <> 9 & b1 <> 10 & b1 <> 11 & b1 <> 12
   holds b1 = 13;

:: NAT_1:sch 10
scheme NAT_1:sch 10
for b1 being non empty natural set holds
   P1[b1]
provided
   P1[1]
and
   for b1 being non empty natural set
         st P1[b1]
      holds P1[b1 + 1];


:: NAT_1:funcnot 5 => NAT_1:func 5
definition
  let a1 be set;
  func min* A1 -> Element of NAT means
    it in a1 &
     (for b1 being natural set
           st b1 in a1
        holds it <= b1)
    if a1 is non empty Element of bool NAT
    otherwise it = 0;
end;

:: NAT_1:def 1
theorem
for b1 being set
for b2 being Element of NAT holds
   (b1 is non empty Element of bool NAT implies    (b2 = min* b1
    iff
       b2 in b1 &
        (for b3 being natural set
              st b3 in b1
           holds b2 <= b3))) &
    (b1 is non empty Element of bool NAT or    (b2 = min* b1
    iff
       b2 = 0));

:: NAT_1:th 39
theorem
for b1 being natural set holds
   succ b1 = b1 + 1;

:: NAT_1:th 40
theorem
for b1, b2 being natural set holds
   b1 <= b2
iff
   b1 c= b2;

:: NAT_1:th 41
theorem
for b1, b2 being natural set holds
   Card b1 c= Card b2
iff
   b1 <= b2;

:: NAT_1:th 42
theorem
for b1, b2 being natural set holds
   Card b1 in Card b2
iff
   b1 < b2;

:: NAT_1:th 43
theorem
for b1 being natural set holds
   nextcard Card b1 = Card (b1 + 1);

:: NAT_1:funcnot 6 => ORDINAL1:func 1
definition
  let a1 be set;
  func succ A1 -> set equals
    a1 + 1;
end;

:: NAT_1:def 2
theorem
for b1 being natural set holds
   succ b1 = b1 + 1;

:: NAT_1:th 44
theorem
for b1, b2 being finite set
      st b1 c= b2
   holds card b1 <= card b2;

:: NAT_1:th 45
theorem
for b1, b2 being natural set holds
   b1 in b2
iff
   b1 < b2;

:: NAT_1:th 46
theorem
for b1 being natural set holds
   b1 in b1 + 1;

:: NAT_1:th 47
theorem
for b1, b2 being natural set
      st b1 <= b2
   holds b1 = b1 /\ b2;

:: NAT_1:sch 11
scheme NAT_1:sch 11
{F1 -> set,
  F2 -> set}:
ex b1 being Relation-like Function-like set st
   proj1 b1 = NAT &
    b1 . 0 = F1() &
    (for b2 being natural set holds
       b1 . (b2 + 1) = F2(b2, b1 . b2))


:: NAT_1:sch 12
scheme NAT_1:sch 12
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1()}:
ex b1 being Function-like quasi_total Relation of NAT,F1() st
   b1 . 0 = F2() &
    (for b2 being natural set holds
       b1 . (b2 + 1) = F3(b2, b1 . b2))


:: NAT_1:sch 13
scheme NAT_1:sch 13
{F1 -> set,
  F2 -> Relation-like Function-like set,
  F3 -> Relation-like Function-like set}:
F2() = F3()
provided
   proj1 F2() = NAT
and
   F2() . 0 = F1()
and
   for b1 being natural set holds
      P1[b1, F2() . b1, F2() . (b1 + 1)]
and
   proj1 F3() = NAT
and
   F3() . 0 = F1()
and
   for b1 being natural set holds
      P1[b1, F3() . b1, F3() . (b1 + 1)]
and
   for b1 being natural set
   for b2, b3, b4 being set
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4;


:: NAT_1:sch 14
scheme NAT_1:sch 14
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Function-like quasi_total Relation of NAT,F1(),
  F4 -> Function-like quasi_total Relation of NAT,F1()}:
F3() = F4()
provided
   F3() . 0 = F2()
and
   for b1 being natural set holds
      P1[b1, F3() . b1, F3() . (b1 + 1)]
and
   F4() . 0 = F2()
and
   for b1 being natural set holds
      P1[b1, F4() . b1, F4() . (b1 + 1)]
and
   for b1 being natural set
   for b2, b3, b4 being Element of F1()
         st P1[b1, b2, b3] & P1[b1, b2, b4]
      holds b3 = b4;


:: NAT_1:sch 15
scheme NAT_1:sch 15
{F1 -> set,
  F2 -> set,
  F3 -> Relation-like Function-like set,
  F4 -> Relation-like Function-like set}:
F3() = F4()
provided
   proj1 F3() = NAT
and
   F3() . 0 = F1()
and
   for b1 being natural set holds
      F3() . (b1 + 1) = F2(b1, F3() . b1)
and
   proj1 F4() = NAT
and
   F4() . 0 = F1()
and
   for b1 being natural set holds
      F4() . (b1 + 1) = F2(b1, F4() . b1);


:: NAT_1:sch 16
scheme NAT_1:sch 16
{F1 -> non empty set,
  F2 -> Element of F1(),
  F3 -> Element of F1(),
  F4 -> Function-like quasi_total Relation of NAT,F1(),
  F5 -> Function-like quasi_total Relation of NAT,F1()}:
F4() = F5()
provided
   F4() . 0 = F2()
and
   for b1 being natural set holds
      F4() . (b1 + 1) = F3(b1, F4() . b1)
and
   F5() . 0 = F2()
and
   for b1 being natural set holds
      F5() . (b1 + 1) = F3(b1, F5() . b1);


:: NAT_1:funcreg 5
registration
  let a1, a2 be natural set;
  cluster min(a1,a2) -> natural;
end;

:: NAT_1:funcreg 6
registration
  let a1, a2 be natural set;
  cluster max(a1,a2) -> natural;
end;

:: NAT_1:sch 17
scheme NAT_1:sch 17
{F1 -> natural set}:
ex b1 being natural set st
   F1(b1) = 0 &
    (for b2 being natural set
          st F1(b2) = 0
       holds b1 <= b2)
provided
   for b1 being natural set
         st F1(b1) <= F1(b1 + 1)
      holds F1(b1) = 0;