Article FIB_NUM3, MML version 4.99.1005

:: FIB_NUM3:th 1
theorem
for b1 being real set
for b2 being Element of NAT
      st b1 to_power b2 = 0
   holds b1 = 0;

:: FIB_NUM3:th 2
theorem
for b1 being non negative real set holds
   (sqrt b1) * sqrt b1 = b1;

:: FIB_NUM3:th 3
theorem
for b1 being non empty real set holds
   b1 to_power 2 = (- b1) to_power 2;

:: FIB_NUM3:th 4
theorem
for b1 being non empty Element of NAT holds
   (b1 -' 1) + 2 = (b1 + 2) -' 1;

:: FIB_NUM3:th 5
theorem
for b1, b2 being Element of NAT holds
(b1 + b2) |^ 2 = (((b1 * b1) + (b1 * b2)) + (b1 * b2)) + (b2 * b2);

:: FIB_NUM3:th 6
theorem
for b1 being Element of NAT
for b2 being non empty real set holds
   (b2 to_power b1) to_power 2 = b2 to_power (2 * b1);

:: FIB_NUM3:th 7
theorem
for b1, b2 being real set holds
(b1 + b2) * (b1 - b2) = (b1 to_power 2) - (b2 to_power 2);

:: FIB_NUM3:th 8
theorem
for b1 being Element of NAT
for b2, b3 being non empty real set holds
(b2 * b3) to_power b1 = (b2 to_power b1) * (b3 to_power b1);

:: FIB_NUM3:funcreg 1
registration
  cluster tau -> positive real;
end;

:: FIB_NUM3:funcreg 2
registration
  cluster tau_bar -> negative real;
end;

:: FIB_NUM3:th 9
theorem
for b1 being Element of NAT holds
   (tau to_power b1) + (tau to_power (b1 + 1)) = tau to_power (b1 + 2);

:: FIB_NUM3:th 10
theorem
for b1 being Element of NAT holds
   (tau_bar to_power b1) + (tau_bar to_power (b1 + 1)) = tau_bar to_power (b1 + 2);

:: FIB_NUM3:funcnot 1 => FIB_NUM3:func 1
definition
  let a1 be Element of NAT;
  func Lucas A1 -> Element of NAT means
    ex b1 being Function-like quasi_total Relation of NAT,[:NAT,NAT:] st
       it = (b1 . a1) `1 &
        b1 . 0 = [2,1] &
        (for b2 being natural set holds
           b1 . (b2 + 1) = [(b1 . b2) `2,(b1 . b2) `1 + ((b1 . b2) `2)]);
end;

:: FIB_NUM3:def 1
theorem
for b1, b2 being Element of NAT holds
   b2 = Lucas b1
iff
   ex b3 being Function-like quasi_total Relation of NAT,[:NAT,NAT:] st
      b2 = (b3 . b1) `1 &
       b3 . 0 = [2,1] &
       (for b4 being natural set holds
          b3 . (b4 + 1) = [(b3 . b4) `2,(b3 . b4) `1 + ((b3 . b4) `2)]);

:: FIB_NUM3:th 11
theorem
Lucas 0 = 2 &
 Lucas 1 = 1 &
 (for b1 being Element of NAT holds
    Lucas ((b1 + 1) + 1) = (Lucas b1) + Lucas (b1 + 1));

:: FIB_NUM3:th 12
theorem
for b1 being Element of NAT holds
   Lucas (b1 + 2) = (Lucas b1) + Lucas (b1 + 1);

:: FIB_NUM3:th 13
theorem
for b1 being Element of NAT holds
   (Lucas (b1 + 1)) + Lucas (b1 + 2) = Lucas (b1 + 3);

:: FIB_NUM3:th 14
theorem
Lucas 2 = 3;

:: FIB_NUM3:th 15
theorem
Lucas 3 = 4;

:: FIB_NUM3:th 16
theorem
Lucas 4 = 7;

:: FIB_NUM3:th 17
theorem
for b1 being Element of NAT holds
   b1 <= Lucas b1;

:: FIB_NUM3:th 18
theorem
for b1 being non empty Element of NAT holds
   Lucas b1 <= Lucas (b1 + 1);

:: FIB_NUM3:funcreg 3
registration
  let a1 be Element of NAT;
  cluster Lucas a1 -> positive;
end;

:: FIB_NUM3:th 19
theorem
for b1 being Element of NAT holds
   2 * Lucas (b1 + 2) = (Lucas b1) + Lucas (b1 + 3);

:: FIB_NUM3:th 20
theorem
for b1 being Element of NAT holds
   Lucas (b1 + 1) = (Fib b1) + Fib (b1 + 2);

:: FIB_NUM3:th 21
theorem
for b1 being Element of NAT holds
   Lucas b1 = (tau to_power b1) + (tau_bar to_power b1);

:: FIB_NUM3:th 22
theorem
for b1 being Element of NAT holds
   (2 * Lucas b1) + Lucas (b1 + 1) = 5 * Fib (b1 + 1);

:: FIB_NUM3:th 23
theorem
for b1 being Element of NAT holds
   (Lucas (b1 + 3)) - (2 * Lucas b1) = 5 * Fib b1;

:: FIB_NUM3:th 24
theorem
for b1 being Element of NAT holds
   (Lucas b1) + Fib b1 = 2 * Fib (b1 + 1);

:: FIB_NUM3:th 25
theorem
for b1 being Element of NAT holds
   (3 * Fib b1) + Lucas b1 = 2 * Fib (b1 + 2);

:: FIB_NUM3:th 26
theorem
for b1, b2 being Element of NAT holds
2 * Lucas (b1 + b2) = ((Lucas b1) * Lucas b2) + ((5 * Fib b1) * Fib b2);

:: FIB_NUM3:th 27
theorem
for b1 being Element of NAT holds
   (Lucas (b1 + 3)) * Lucas b1 = ((Lucas (b1 + 2)) |^ 2) - ((Lucas (b1 + 1)) |^ 2);

:: FIB_NUM3:th 28
theorem
for b1 being Element of NAT holds
   Fib (2 * b1) = (Fib b1) * Lucas b1;

:: FIB_NUM3:th 29
theorem
for b1 being Element of NAT holds
   2 * Fib ((2 * b1) + 1) = ((Lucas (b1 + 1)) * Fib b1) + ((Lucas b1) * Fib (b1 + 1));

:: FIB_NUM3:th 30
theorem
for b1 being Element of NAT holds
   (5 * ((Fib b1) |^ 2)) - ((Lucas b1) |^ 2) = 4 * ((- 1) to_power (b1 + 1));

:: FIB_NUM3:th 31
theorem
for b1 being Element of NAT holds
   Fib ((2 * b1) + 1) = ((Fib (b1 + 1)) * Lucas (b1 + 1)) - ((Fib b1) * Lucas b1);

:: FIB_NUM3:funcnot 2 => FIB_NUM3:func 2
definition
  let a1, a2, a3 be Element of NAT;
  func GenFib(A1,A2,A3) -> Element of NAT means
    ex b1 being Function-like quasi_total Relation of NAT,[:NAT,NAT:] st
       it = (b1 . a3) `1 &
        b1 . 0 = [a1,a2] &
        (for b2 being natural set holds
           b1 . (b2 + 1) = [(b1 . b2) `2,(b1 . b2) `1 + ((b1 . b2) `2)]);
end;

:: FIB_NUM3:def 2
theorem
for b1, b2, b3, b4 being Element of NAT holds
   b4 = GenFib(b1,b2,b3)
iff
   ex b5 being Function-like quasi_total Relation of NAT,[:NAT,NAT:] st
      b4 = (b5 . b3) `1 &
       b5 . 0 = [b1,b2] &
       (for b6 being natural set holds
          b5 . (b6 + 1) = [(b5 . b6) `2,(b5 . b6) `1 + ((b5 . b6) `2)]);

:: FIB_NUM3:th 32
theorem
for b1, b2 being Element of NAT holds
GenFib(b1,b2,0) = b1 &
 GenFib(b1,b2,1) = b2 &
 (for b3 being Element of NAT holds
    GenFib(b1,b2,(b3 + 1) + 1) = (GenFib(b1,b2,b3)) + GenFib(b1,b2,b3 + 1));

:: FIB_NUM3:th 33
theorem
for b1, b2, b3 being Element of NAT holds
((GenFib(b1,b2,b3 + 1)) + GenFib(b1,b2,(b3 + 1) + 1)) |^ 2 = (((GenFib(b1,b2,b3 + 1)) |^ 2) + ((2 * GenFib(b1,b2,b3 + 1)) * GenFib(b1,b2,(b3 + 1) + 1))) + ((GenFib(b1,b2,(b3 + 1) + 1)) |^ 2);

:: FIB_NUM3:th 34
theorem
for b1, b2, b3 being Element of NAT holds
(GenFib(b1,b2,b3)) + GenFib(b1,b2,b3 + 1) = GenFib(b1,b2,b3 + 2);

:: FIB_NUM3:th 35
theorem
for b1, b2, b3 being Element of NAT holds
(GenFib(b1,b2,b3 + 1)) + GenFib(b1,b2,b3 + 2) = GenFib(b1,b2,b3 + 3);

:: FIB_NUM3:th 36
theorem
for b1, b2, b3 being Element of NAT holds
(GenFib(b1,b2,b3 + 2)) + GenFib(b1,b2,b3 + 3) = GenFib(b1,b2,b3 + 4);

:: FIB_NUM3:th 37
theorem
for b1 being Element of NAT holds
   GenFib(0,1,b1) = Fib b1;

:: FIB_NUM3:th 38
theorem
for b1 being Element of NAT holds
   GenFib(2,1,b1) = Lucas b1;

:: FIB_NUM3:th 39
theorem
for b1, b2, b3 being Element of NAT holds
(GenFib(b1,b2,b3)) + GenFib(b1,b2,b3 + 3) = 2 * GenFib(b1,b2,b3 + 2);

:: FIB_NUM3:th 40
theorem
for b1, b2, b3 being Element of NAT holds
(GenFib(b1,b2,b3)) + GenFib(b1,b2,b3 + 4) = 3 * GenFib(b1,b2,b3 + 2);

:: FIB_NUM3:th 41
theorem
for b1, b2, b3 being Element of NAT holds
(GenFib(b1,b2,b3 + 3)) - GenFib(b1,b2,b3) = 2 * GenFib(b1,b2,b3 + 1);

:: FIB_NUM3:th 42
theorem
for b1, b2, b3 being non empty Element of NAT holds
GenFib(b1,b2,b3) = ((GenFib(b1,b2,0)) * Fib (b3 -' 1)) + ((GenFib(b1,b2,1)) * Fib b3);

:: FIB_NUM3:th 43
theorem
for b1, b2 being Element of NAT holds
((Fib b2) * Lucas b1) + ((Lucas b2) * Fib b1) = GenFib(Fib 0,Lucas 0,b1 + b2);

:: FIB_NUM3:th 44
theorem
for b1 being Element of NAT holds
   (Lucas b1) + Lucas (b1 + 3) = 2 * Lucas (b1 + 2);

:: FIB_NUM3:th 45
theorem
for b1, b2 being Element of NAT holds
GenFib(b1,b1,b2) = ((GenFib(b1,b1,0)) / 2) * ((Fib b2) + Lucas b2);

:: FIB_NUM3:th 46
theorem
for b1, b2, b3 being Element of NAT holds
GenFib(b2,b1 + b2,b3) = GenFib(b1,b2,b3 + 1);

:: FIB_NUM3:th 47
theorem
for b1, b2, b3 being Element of NAT holds
((GenFib(b1,b2,b3 + 2)) * GenFib(b1,b2,b3)) - ((GenFib(b1,b2,b3 + 1)) |^ 2) = ((- 1) to_power b3) * (((GenFib(b1,b2,2)) |^ 2) - ((GenFib(b1,b2,1)) * GenFib(b1,b2,3)));

:: FIB_NUM3:th 48
theorem
for b1, b2, b3, b4 being Element of NAT holds
GenFib(GenFib(b1,b2,b3),GenFib(b1,b2,b3 + 1),b4) = GenFib(b1,b2,b4 + b3);

:: FIB_NUM3:th 49
theorem
for b1, b2, b3 being Element of NAT holds
GenFib(b1,b2,b3 + 1) = (b1 * Fib b3) + (b2 * Fib (b3 + 1));

:: FIB_NUM3:th 50
theorem
for b1, b2 being Element of NAT holds
GenFib(0,b1,b2) = b1 * Fib b2;

:: FIB_NUM3:th 51
theorem
for b1, b2 being Element of NAT holds
GenFib(b1,0,b2 + 1) = b1 * Fib b2;

:: FIB_NUM3:th 52
theorem
for b1, b2, b3, b4, b5 being Element of NAT holds
(GenFib(b1,b2,b5)) + GenFib(b3,b4,b5) = GenFib(b1 + b3,b2 + b4,b5);

:: FIB_NUM3:th 53
theorem
for b1, b2, b3, b4 being Element of NAT holds
GenFib(b3 * b1,b3 * b2,b4) = b3 * GenFib(b1,b2,b4);

:: FIB_NUM3:th 54
theorem
for b1, b2, b3 being Element of NAT holds
GenFib(b1,b2,b3) = ((((b1 * - tau_bar) + b2) * (tau to_power b3)) + (((b1 * tau) - b2) * (tau_bar to_power b3))) / sqrt 5;

:: FIB_NUM3:th 55
theorem
for b1, b2 being Element of NAT holds
GenFib((2 * b1) + 1,(2 * b1) + 1,b2 + 1) = ((2 * b1) + 1) * Fib (b2 + 2);