Article FIB_NUM2, MML version 4.99.1005

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

:: FIB_NUM2:th 2
theorem
for b1 being integer odd set
for b2 being non empty real set holds
   (- b2) to_power b1 = - (b2 to_power b1);

:: FIB_NUM2:th 3
theorem
for b1 being integer odd set holds
   (- 1) to_power b1 = - 1;

:: FIB_NUM2:th 4
theorem
for b1 being integer even set
for b2 being non empty real set holds
   (- b2) to_power b1 = b2 to_power b1;

:: FIB_NUM2:th 5
theorem
for b1 being integer even set holds
   (- 1) to_power b1 = 1;

:: FIB_NUM2:th 6
theorem
for b1 being non empty real set
for b2 being integer set holds
   ((- 1) * b1) to_power b2 = ((- 1) to_power b2) * (b1 to_power b2);

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

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

:: FIB_NUM2:th 9
theorem
for b1 being Element of NAT holds
   ((- 1) to_power - b1) ^2 = 1;

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

:: FIB_NUM2:th 11
theorem
for b1 being Element of NAT holds
   (- 1) to_power - (2 * b1) = 1;

:: FIB_NUM2:th 12
theorem
for b1 being Element of NAT
for b2 being non empty real set holds
   (b2 to_power b1) * (b2 to_power - b1) = 1;

:: FIB_NUM2:funcreg 1
registration
  let a1 be integer odd set;
  cluster - a1 -> complex odd;
end;

:: FIB_NUM2:funcreg 2
registration
  let a1 be integer even set;
  cluster - a1 -> complex even;
end;

:: FIB_NUM2:th 13
theorem
for b1 being Element of NAT holds
   (- 1) to_power - b1 = (- 1) to_power b1;

:: FIB_NUM2:th 14
theorem
for b1, b2, b3, b4, b5 being Element of NAT
      st b2 divides b3 & b2 divides b1
   holds b2 divides (b3 * b4) + (b1 * b5);

:: FIB_NUM2:exreg 1
registration
  cluster non empty with_non-empty_elements finite natural-membered set;
end;

:: FIB_NUM2:funcreg 3
registration
  let a1 be Function-like quasi_total Relation of NAT,NAT;
  let a2 be with_non-empty_elements finite natural-membered set;
  cluster a1 | a2 -> Relation-like FinSubsequence-like;
end;

:: FIB_NUM2:th 15
theorem
for b1 being Relation-like Function-like FinSubsequence-like set holds
   proj2 Seq b1 c= proj2 b1;

:: FIB_NUM2:funcnot 1 => FIB_NUM2:func 1
definition
  let a1 be Function-like quasi_total Relation of NAT,NAT;
  let a2 be with_non-empty_elements finite natural-membered set;
  func Prefix(A1,A2) -> FinSequence of NAT equals
    Seq (a1 | a2);
end;

:: FIB_NUM2:def 1
theorem
for b1 being Function-like quasi_total Relation of NAT,NAT
for b2 being with_non-empty_elements finite natural-membered set holds
   Prefix(b1,b2) = Seq (b1 | b2);

:: FIB_NUM2:th 16
theorem
for b1, b2, b3 being Element of NAT
      st b3 <> 0 & b3 + b1 <= b2
   holds b1 < b2;

:: FIB_NUM2:funcreg 4
registration
  cluster omega -> bounded_below;
end;

:: FIB_NUM2:th 17
theorem
for b1, b2 being Element of NAT
for b3, b4 being set
      st 0 < b1 & b1 < b2
   holds {[b1,b3],[b2,b4]} is Relation-like Function-like FinSubsequence-like set;

:: FIB_NUM2:th 18
theorem
for b1, b2 being Element of NAT
for b3, b4 being set
for b5 being Relation-like Function-like FinSubsequence-like set
      st b1 < b2 &
         b5 = {[b1,b3],[b2,b4]}
   holds Seq b5 = <*b3,b4*>;

:: FIB_NUM2:funcreg 5
registration
  let a1 be Element of NAT;
  cluster Seg a1 -> with_non-empty_elements;
end;

:: FIB_NUM2:condreg 1
registration
  let a1 be with_non-empty_elements set;
  cluster -> with_non-empty_elements (Element of bool a1);
end;

:: FIB_NUM2:funcreg 6
registration
  let a1 be with_non-empty_elements set;
  let a2 be set;
  cluster a1 /\ a2 -> with_non-empty_elements;
end;

:: FIB_NUM2:funcreg 7
registration
  let a1 be with_non-empty_elements set;
  let a2 be set;
  cluster a2 /\ a1 -> with_non-empty_elements;
end;

:: FIB_NUM2:th 19
theorem
for b1 being Element of NAT
for b2 being set
      st 1 <= b1
   holds {[b1,b2]} is Relation-like Function-like FinSubsequence-like set;

:: FIB_NUM2:th 20
theorem
for b1 being Element of NAT
for b2 being set
for b3 being Relation-like Function-like FinSubsequence-like set
      st b3 = {[1,b2]}
   holds b1 Shift b3 = {[1 + b1,b2]};

:: FIB_NUM2:th 21
theorem
for b1 being Relation-like Function-like FinSubsequence-like set
for b2, b3 being Element of NAT
      st proj1 b1 c= Seg b2 & b2 < b3
   holds ex b4 being Relation-like Function-like FinSequence-like set st
      b1 c= b4 & dom b4 = Seg b3;

:: FIB_NUM2:th 22
theorem
for b1 being Relation-like Function-like FinSubsequence-like set holds
   ex b2 being Relation-like Function-like FinSequence-like set st
      b1 c= b2;

:: FIB_NUM2:sch 1
scheme FIB_NUM2:sch 1
for b1 being non empty Element of NAT holds
   P1[b1]
provided
   P1[1]
and
   P1[2]
and
   for b1 being non empty Element of NAT
         st P1[b1] & P1[b1 + 1]
      holds P1[b1 + 2];


:: FIB_NUM2:sch 2
scheme FIB_NUM2:sch 2
for b1 being non trivial Element of NAT holds
   P1[b1]
provided
   P1[2]
and
   P1[3]
and
   for b1 being non trivial Element of NAT
         st P1[b1] & P1[b1 + 1]
      holds P1[b1 + 2];


:: FIB_NUM2:th 23
theorem
Fib 2 = 1;

:: FIB_NUM2:th 24
theorem
Fib 3 = 2;

:: FIB_NUM2:th 25
theorem
Fib 4 = 3;

:: FIB_NUM2:th 26
theorem
for b1 being Element of NAT holds
   Fib (b1 + 2) = (Fib b1) + Fib (b1 + 1);

:: FIB_NUM2:th 27
theorem
for b1 being Element of NAT holds
   Fib (b1 + 3) = (Fib (b1 + 2)) + Fib (b1 + 1);

:: FIB_NUM2:th 28
theorem
for b1 being Element of NAT holds
   Fib (b1 + 4) = (Fib (b1 + 2)) + Fib (b1 + 3);

:: FIB_NUM2:th 29
theorem
for b1 being Element of NAT holds
   Fib (b1 + 5) = (Fib (b1 + 3)) + Fib (b1 + 4);

:: FIB_NUM2:th 30
theorem
for b1 being Element of NAT holds
   Fib (b1 + 2) = (Fib (b1 + 3)) - Fib (b1 + 1);

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

:: FIB_NUM2:th 32
theorem
for b1 being Element of NAT holds
   Fib b1 = (Fib (b1 + 2)) - Fib (b1 + 1);

:: FIB_NUM2:th 33
theorem
for b1 being Element of NAT holds
   ((Fib b1) * Fib (b1 + 2)) - ((Fib (b1 + 1)) ^2) = (- 1) |^ (b1 + 1);

:: FIB_NUM2:th 34
theorem
for b1 being non empty Element of NAT holds
   ((Fib (b1 -' 1)) * Fib (b1 + 1)) - ((Fib b1) ^2) = (- 1) |^ b1;

:: FIB_NUM2:th 35
theorem
0 < tau;

:: FIB_NUM2:th 36
theorem
tau_bar = (- tau) to_power - 1;

:: FIB_NUM2:th 37
theorem
for b1 being Element of NAT holds
   (- tau) to_power ((- 1) * b1) = ((- tau) to_power - 1) to_power b1;

:: FIB_NUM2:th 38
theorem
- (1 / tau) = tau_bar;

:: FIB_NUM2:th 39
theorem
for b1 being Element of NAT holds
   ((tau to_power b1) ^2 - (2 * ((- 1) to_power b1))) + ((tau to_power - b1) ^2) = ((tau to_power b1) - (tau_bar to_power b1)) ^2;

:: FIB_NUM2:th 40
theorem
for b1, b2 being non empty Element of NAT
      st b2 <= b1
   holds (Fib b1) ^2 - ((Fib (b1 + b2)) * Fib (b1 -' b2)) = ((- 1) |^ (b1 -' b2)) * ((Fib b2) ^2);

:: FIB_NUM2:th 41
theorem
for b1 being Element of NAT holds
   (Fib b1) ^2 + ((Fib (b1 + 1)) ^2) = Fib ((2 * b1) + 1);

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

:: FIB_NUM2:th 43
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT holds
   Fib b2 divides Fib (b2 * b1);

:: FIB_NUM2:th 44
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
      st b2 divides b1
   holds Fib b2 divides Fib b1;

:: FIB_NUM2:th 45
theorem
for b1 being Element of NAT holds
   Fib b1 <= Fib (b1 + 1);

:: FIB_NUM2:th 46
theorem
for b1 being Element of NAT
      st 1 < b1
   holds Fib b1 < Fib (b1 + 1);

:: FIB_NUM2:th 47
theorem
for b1, b2 being Element of NAT
      st b2 <= b1
   holds Fib b2 <= Fib b1;

:: FIB_NUM2:th 48
theorem
for b1, b2 being Element of NAT
      st 1 < b2 & b2 < b1
   holds Fib b2 < Fib b1;

:: FIB_NUM2:th 49
theorem
for b1 being Element of NAT holds
      Fib b1 = 1
   iff
      (b1 = 1 or b1 = 2);

:: FIB_NUM2:th 50
theorem
for b1, b2 being Element of NAT
      st 1 < b2 &
         b1 <> 0 &
         b1 <> 1 &
         (b1 <> 1 & b2 <> 2 or b1 <> 2 & b2 <> 1)
   holds    Fib b1 = Fib b2
   iff
      b1 = b2;

:: FIB_NUM2:th 51
theorem
for b1 being Element of NAT
      st 1 < b1 & b1 <> 4 & b1 is not prime
   holds ex b2 being non empty Element of NAT st
      b2 <> 1 & b2 <> 2 & b2 <> b1 & b2 divides b1;

:: FIB_NUM2:th 52
theorem
for b1 being Element of NAT
      st 1 < b1 & b1 <> 4 & Fib b1 is prime
   holds b1 is prime;

:: FIB_NUM2:funcnot 2 => FIB_NUM2:func 2
definition
  func FIB -> Function-like quasi_total Relation of NAT,NAT means
    for b1 being Element of NAT holds
       it . b1 = Fib b1;
end;

:: FIB_NUM2:def 2
theorem
for b1 being Function-like quasi_total Relation of NAT,NAT holds
      b1 = FIB
   iff
      for b2 being Element of NAT holds
         b1 . b2 = Fib b2;

:: FIB_NUM2:funcnot 3 => FIB_NUM2:func 3
definition
  func EvenNAT -> Element of bool NAT equals
    {2 * b1 where b1 is Element of NAT: TRUE};
end;

:: FIB_NUM2:def 3
theorem
EvenNAT = {2 * b1 where b1 is Element of NAT: TRUE};

:: FIB_NUM2:funcnot 4 => FIB_NUM2:func 4
definition
  func OddNAT -> Element of bool NAT equals
    {(2 * b1) + 1 where b1 is Element of NAT: TRUE};
end;

:: FIB_NUM2:def 4
theorem
OddNAT = {(2 * b1) + 1 where b1 is Element of NAT: TRUE};

:: FIB_NUM2:th 53
theorem
for b1 being Element of NAT holds
   2 * b1 in EvenNAT & not (2 * b1) + 1 in EvenNAT;

:: FIB_NUM2:th 54
theorem
for b1 being Element of NAT holds
   (2 * b1) + 1 in OddNAT & not 2 * b1 in OddNAT;

:: FIB_NUM2:funcnot 5 => FIB_NUM2:func 5
definition
  let a1 be Element of NAT;
  func EvenFibs A1 -> FinSequence of NAT equals
    Prefix(FIB,EvenNAT /\ Seg a1);
end;

:: FIB_NUM2:def 5
theorem
for b1 being Element of NAT holds
   EvenFibs b1 = Prefix(FIB,EvenNAT /\ Seg b1);

:: FIB_NUM2:funcnot 6 => FIB_NUM2:func 6
definition
  let a1 be Element of NAT;
  func OddFibs A1 -> FinSequence of NAT equals
    Prefix(FIB,OddNAT /\ Seg a1);
end;

:: FIB_NUM2:def 6
theorem
for b1 being Element of NAT holds
   OddFibs b1 = Prefix(FIB,OddNAT /\ Seg b1);

:: FIB_NUM2:th 55
theorem
EvenFibs 0 = {};

:: FIB_NUM2:th 56
theorem
Seq (FIB | {2}) = <*1*>;

:: FIB_NUM2:th 57
theorem
EvenFibs 2 = <*1*>;

:: FIB_NUM2:th 58
theorem
EvenFibs 4 = <*1,3*>;

:: FIB_NUM2:th 59
theorem
for b1 being Element of NAT holds
   (EvenNAT /\ Seg ((2 * b1) + 2)) \/ {(2 * b1) + 4} = EvenNAT /\ Seg ((2 * b1) + 4);

:: FIB_NUM2:th 60
theorem
for b1 being Element of NAT holds
   (FIB | (EvenNAT /\ Seg ((2 * b1) + 2))) \/ {[(2 * b1) + 4,FIB . ((2 * b1) + 4)]} = FIB | (EvenNAT /\ Seg ((2 * b1) + 4));

:: FIB_NUM2:th 61
theorem
for b1 being Element of NAT holds
   EvenFibs ((2 * b1) + 2) = (EvenFibs (2 * b1)) ^ <*Fib ((2 * b1) + 2)*>;

:: FIB_NUM2:th 62
theorem
OddFibs 1 = <*1*>;

:: FIB_NUM2:th 63
theorem
OddFibs 3 = <*1,2*>;

:: FIB_NUM2:th 64
theorem
for b1 being Element of NAT holds
   (OddNAT /\ Seg ((2 * b1) + 3)) \/ {(2 * b1) + 5} = OddNAT /\ Seg ((2 * b1) + 5);

:: FIB_NUM2:th 65
theorem
for b1 being Element of NAT holds
   (FIB | (OddNAT /\ Seg ((2 * b1) + 3))) \/ {[(2 * b1) + 5,FIB . ((2 * b1) + 5)]} = FIB | (OddNAT /\ Seg ((2 * b1) + 5));

:: FIB_NUM2:th 66
theorem
for b1 being Element of NAT holds
   OddFibs ((2 * b1) + 3) = (OddFibs ((2 * b1) + 1)) ^ <*Fib ((2 * b1) + 3)*>;

:: FIB_NUM2:th 67
theorem
for b1 being Element of NAT holds
   Sum EvenFibs ((2 * b1) + 2) = (Fib ((2 * b1) + 3)) - 1;

:: FIB_NUM2:th 68
theorem
for b1 being Element of NAT holds
   Sum OddFibs ((2 * b1) + 1) = Fib ((2 * b1) + 2);

:: FIB_NUM2:th 69
theorem
for b1 being Element of NAT holds
   Fib b1,Fib (b1 + 1) are_relative_prime;

:: FIB_NUM2:th 70
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
      st b2 <> 1 & b2 divides Fib b1
   holds not b2 divides Fib (b1 -' 1);

:: FIB_NUM2:th 71
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
   st b1 is prime & b2 is prime & b1 divides Fib b2
for b3 being Element of NAT
      st b3 < b2 & b3 <> 0
   holds not b1 divides Fib b3;

:: FIB_NUM2:th 72
theorem
for b1 being non empty Element of NAT holds
   {(Fib b1) * Fib (b1 + 3),(2 * Fib (b1 + 1)) * Fib (b1 + 2),(Fib (b1 + 1)) ^2 + ((Fib (b1 + 2)) ^2)} is Pythagorean_triple;