The Relationships Between Prime Number And Fibonacci Number

[theodorenghiem]

Hello all,

 

Thank you very much for your discussion. CraigD gave me a hard to solve problem :-). Among his 49 numbers, currently I only solved 28 cases. They fall into the second case: Integer = Prime - Fibonacci

 

In detail:

 

1045 = 3525623 – 3524578

1351 = 14931703 -14930352

1851 = 26791617 – 267914296

2463 = 834503 – 832040

3749 = 835789 – 832040

3901 = 3528479 – 3524578

4469 = 836509 – 832040

4573 = 4807531549 – 4807526976

5125 = 3529703 – 3524578

5185 = 4807532161 – 4807526976

5215 = 267919511 – 267914296

5319 = 837359 – 832040

5761 = 14936113 – 14930352

5949 = 1134909119 – 1134903170

6929 = 838969 – 832040

6987 = 20365018061 – 20365011074

7969 = 14938321 – 14930352

7981 = 3532559 – 3524578

8349 = 86267579621 – 86267571272

8491 = 14938843 – 14930352

8557 = 14938909 – 14930352

9121 = 14939473 – 14930352

9267 = 841307 – 832040

9359 = 14939711 – 14930352

9361 = 3533939 – 3524578

9527 = 14939879 – 14930352

9569 = 1134912739 – 1134903170

9945 = 365435306107 - 365435296162

 

So there are 21 remaining cases unsolved. I was running too far up to 12 digits values and out of ranges. So I must stop, 21 exception in total 10,000 numbers is not too bad, is that right?

 

But even if I can solve of them, we cannot give out any conclusion here. Since the number range is unlimited, there may be who knows, a number greater than 10,000 which breaks my rule. We can declare my conjecture is right only when we prove it in general case. This requires a person who is much more talent than me. That's the reason I post here for your help.

 

Once again, thank for your contribution.

[CraigD]

My first check just used quickly generated lists of the primes up to 212369 and the Fibonaccis up to 7540113804746346429. I rewrote it to use a prime number check (the Rabin-Miller) and Fibonaccis up to 7540113804746346429.

 

I found solutions for some, but not all, from the first list of failures. 1651 is the lowest number that fails my latest check.

 

7540113804746346429 is the largest Fibonacci my built-in calculator can handle. I’ll rewrite my program to use an effectively unlimited (about 3,000,000 digit) precision calculator, and see if it finds a solution for 1651.

 

As we’ve noted, no brute-force checker proves there isn’t a solution to 1651 = some prime – some Fibonacci. Some number theory and mathematical proof will be needed.

 

The conjecture has some similarities to a famous one, Goldbach’s strong and weak conjectures, which state:

(the strong, or binary) every even integer greater than 2 can be expressed as the sum of two primes;

(the weak, or ternary) every odd number greater than 5 can be expressed as the sum of three primes.

 

I’ve read that G’s weak conjecture was proven in 2013, here, and gather that the proof is accepted by most Math pros, though I’ve not tried reading it, and fear it’s difficult. These kinds of proofs can be hard – G’s weak took over 250 years.

[A-wal]

I remember reading that it's been mathematically proven that there are an infinite amount of double primes (not sure if that's the correct term, 11/13, 17/19, etc). How could you prove something like that? I know the full answer will be highly technical but is there a simple way to explain how it's done?

[theodorenghiem]

Hi CraigD,

 

I know the GoldBacj conjectures, they referred to prime number only.

 

Currently prime number and Fibonacci number are researched independently, nobody thinks that they have relationship to each other.

 

That's the reason I was so surprise to find out my rule unexpectedly. Bu all of you are right. We need either to prove it in general case or look for a very powerful computer to run  for extremely great number like 1,000,000 or 1,000,000,000

[CraigD]

I finally got a chance to rewrite my program to use practically unlimited precision arithmetic, and turned it lose to test the conjecture for its first apparent failure, 1651

 

After about 40 minutes, it’s tested for up to the 1500th Fibonacci number, the 314 decimal digit

35477307586119343358323040573458324336272973070096320561743110836633224414869683457397230159251404953822275198639462583960142202354300086972011354285518390373499681038514586463959047864164321612181071558172491921736663200292652809821361709977085584058494975879142255340544810237718983215278836358201318619034847001

, and not found a prime number p=F+1651.

 

Running on a single processor on my laptop, it’s taking about 10 seconds to check each new F, so it’s not going to do much better than this any time soon.

 

It was a fun bit of programming, and lead me to discover that there was a bug in one of my old primacy testers. Here’s the MUMPS code I used:

f  r R q:'$l(R)  s I=$p($p(R,";",$l(R,";")),":") i $l(I) s @I=R ;XRX: read xecute code
n (XCKFPC3,XMHI,XRMPT,XMMEXP,R) x XCKFPC3(0) f TC=1:1 q:TC>NT&NT  s R=N x XCKFPC3(3),XCKFPC3(2) q:R  x XCKFPC3(1) q:R  ;XCKFPC3: check conjecture R=P+F or P-F
s N=$p(R,","),F1=$p(R,",",2),F2=$p(R,",",3),NT=$p(R,",",4),RWF=$p(R,",",5) s:'$e(F2) F1=0,F2=1 ;XCKFPC3(0): get optional R=R,fib#1,fib#2,#tries before failing,show fib# checked flag
s R(1)=N,R(2)=FC x XMHI("+") s PC=R(3) k R s R=PC x XRMPT s:R R=N_","_PC_",-"_FC ;XCKFPC3(1):  N=PC-FC
s R(1)=N,R(2)=FC x XMHI(">") i R x XMHI("-") s PC=R(3) k R s R=PC x XRMPT s:R R=N_","_PC_","_FC ;XCKFPC3(2): N=PC+FC
n R s (F1(1),R(1))=F1,R(2)=F2 x XMHI("+") s F1=F2,(F2,FC)=R(3) w:RWF TC," ",$l(FC)," ",$s($g(RWF=2:$e(FC)_"..."_$e(FC,$l(FC)),1:FC),! ;XCKFPC3(3):generate Fibonacci #s

s R="1651,,,,1" x XCKFPC3

and here’s the code it uses, which other than looking at the comments to see what it does, is interesting only to someone with an interest in writing high-precision decimal integer math and primacy testers:

f  r R q:'$l(R)  s I=$p($p(R,";",$l(R,";")),":") i $l(I) s @I=R ;XRX: read xecute code
s L3=$s(L1>L2:L1,1:L2)+1,C=$tr($j(C,L3)," ",0) f I=0:16:L3-1 s J=$e(A,L1-I-15,L1-I)+$e(B,L2-I-15,L2-I)+$e(C,L3-I),$e(C,L3-I-$L(J)+1,L3-I)=J ;XMHI(0,2)
f I=0:8:L1-1 s K=$e(A,L1-I-7,L1-I) f J=0:8:L2-1 s M=K*$e(B,L2-J-7,L2-J)+$e(C,L3-I-J-15,L3-I-J),LM=$l(M),D=$e(M,LM-16),$e(C,L3-I-J-$L(M)+1,L3-I-J)=$e(M,LM-15,LM) w ?L3-I-J-$l(M)-1,M," ",D," ",K,"*",$e(B,L2-J-7,L2-J),! ;XMHI(0,3)
f I=0:8:L1-1 s K=$e(A,L1-I-7,L1-I) f J=0:8:L2-1 s M=K*$e(B,L2-J-7,L2-J)+$e(C,L3-I-J-15,L3-I-J)+D,LM=$l(M),D=$e(M,LM-16)_"00000000",M=$e(M,LM-15,LM),$e(C,L3-I-J-$l(M)+1,L3-I-J)=M ;XMHI(0,3)
x XMHI(0,4,1) i $e(P,LP-LD+1,LP)=D s P=0,C=1 f I=$l(Q)-5:-6:1 q:'C  s C=$e(Q,I,I+5)+C,L=$l(C),$e(Q,I,I+5)=$tr($j($e(C,L-5,L),6)," ",0),C=$e(C,L-6) ;XMHI(0,4)
f I=0:6:LP-LD s M=$e(P,I-5,I+12)\D1,$e(Q,I+1,I+12)=$tr($j($e(Q,I+1,I+12)*1000000+M,12)," ",0),A=0,C=1 f J=LD-5:-6:-5 s K=I+J s:K>0 B=$e(D,J,J+5)*M+A,L=$l(B),A=$e(B,1,L-6),B=$tr($j($e(B,L-5,L),6),"1234567890 ",87654321099)+$e(P,K,K+5)+C,L=$l(B),$e(P,K,K+5)=$tr($j($e(B,L-5,L),6)," ",0),C=$e(B,L-6) ;XMHI(0,4,1)
n (XMHI,R) s A=R(1),$e(A,1,$f($tr(A_1,23456789,11111111),1)-2)="",L1=$l(A),B=R(2),$e(B,1,$f($tr(B_1,23456789,11111111),1)-2)="",L2=$l(B),C=0 x XMHI(0,2) s $e(C,1,$f($tr(C_1,23456789,11111111),1)-2)="",R(3)=$s($l(C):C,1:0) ;XMHI("+"): R(3)=R(1)+R(2)
n (XMHI,R) s A=R(1),$e(A,1,$f($tr(A_1,23456789,11111111),1)-2)="",L1=$l(A),B=R(2),$e(B,1,$f($tr(B_1,23456789,11111111),1)-2)="",B=$tr($j(B,L1),"1234567890 ",87654321099),L2=L1,C=1 x XMHI(0,2) s $e(C)="",$e(C,1,$f($tr(C_1,23456789,11111111),1)-2)="",R(3)=$s($l(C):C,1:0) ;XMHI("-"): R(3)=R(1)-R(2)
n (XMHI,R) s A=R(1),$e(A,1,$f($tr(A_1,23456789,11111111),1)-2)="",L1=$l(A),B=R(2),$e(B,1,$f($tr(B_1,23456789,11111111),1)-2)="",L2=$l(B),R=$s(L1<L2:1,L1>L2:0,1:B]A)  ;XMHI("<"): returns R true iff R(1)<R(2)
n (XMHI,R) s A=R(2),$e(A,1,$f($tr(A_1,23456789,11111111),1)-2)="",L1=$l(A),B=R(1),$e(B,1,$f($tr(B_1,23456789,11111111),1)-2)="",L2=$l(B),R=$s(L1<L2:1,L1>L2:0,1:B]A)  ;XMHI(">"): returns R true iff R(1)>R(2)
n (XMHI,R) s A=R(1),$e(A,1,$f($tr(A_1,23456789,11111111),1)-2)="",L1=$l(A),B=R(2),$e(B,1,$f($tr(B_1,23456789,11111111),1)-2)="",L2=$l(B),L3=L1+L2,C=$tr($j(0,L3)," ",0),D=0 x XMHI(0,3) s $e(C,1,$f($tr(C_1,23456789,11111111),1)-2)="",R(3)=$s($l(C):C,1:0) ;XMHI("*"): R(3)=R(1)*R(2)
n (XMHI,R) s P=R(1),$e(P,1,$f($tr(P_1,23456789,11111111),1)-2)="",LP=$l(P),D=R(2),$e(D,1,$f($tr(D_1,23456789,11111111),1)-2)="",LD=$l(D),JX=LD<7*6+(-LD#6),K="000000000000",I=$e(K,1,JX),P=P_I,D=D_I,LP=LP+JX,LD=LD+JX,J=-LP#6,P=$e(K,1,J)_P,LP=LP+J,D1=$e(D,1,12)+1,Q="" x XMHI(0,4) s $e(Q,1,$f($tr(Q_1,23456789,11111111),1)-2)="",L=$l(P),$e(P,L+1-JX,L)="",$e(P,1,$f($tr(P_1,23456789,11111111),1)-2)="",R(3)=$s($l(Q):Q,1:0),R(4)=$s($l(P):P,1:0) ;XMHI("/"): R(3)=R(1)\R(2),R(4)=R(1)#R(2)
n (XMMEXP,XMHI,R) S X=$p(R,","),B=$P(R,",",2),N=$P(R,",",3),(R,Y)=1 i $e(B)>0 f  x XMMEXP(1),XMMEXP(2):F,XMMEXP(3) s R=Y q:'B  ;XMMEXP: R=A^B#N using binary exponentiation
n R s R(1)=B,R(2)=2 x XMHI("/") s B=R(3),F=$s(R(4)'="0":1,1:B="0") ;XMMEXP(1): F=B#2!'B
n R s R(1)=X,R(2)=Y x XMHI("*") s R(1)=R(3),R(2)=N x XMHI("/") s Y=R(4) ;XMMEXP(2): Y=X*Y#N
n R s (R(1),R(2))=X x XMHI("*") s R(1)=R(3),R(2)=N x XMHI("/") s X=R(4) ;XMMEXP(3): X=X*X#N
n (R) s A=R,(R,F)="" f I=1:16:$l(A) s E=$e(A,I,I+15),V=$r($s(F:$e(10000000000000000,1,$l(E)+1),1:I+15'>$l(A)+E)),R=R_$s(I=1:V,1:$tr($j(V,$l(E))," ",0)) s:V-E F=1 ;XMHI("R"): R=$r(R)
n (XRMPT,XMMEXP,XMHI,R) s N=$p(R,","),K=$p(R,",",2),R=N="2" s:K<1 K=32 i $e(N,1,2)>2,$e(N,$l(N))#2 x XRMPT(1) f K=1:1:K x XRMPT(2) s R=F q:'F  ;XRMPT: Rabin-Miller primacy test - if R prime, returns R=1, chance of false R=1 4^$p(R,",",2) (default 32)
n R s R(1)=N,R(2)=1 x XMHI("-") s (N1,D,R(1))=R(3) x XMHI("-") s N2=R(3),R(2)=2 f S=0:1 s R(1)=D x XMHI("/") q:R(4)  s D=R(3) ;XRMPT(1): find D,S st N-1=2^S*D
n R s R=N2 x XMHI("R") s R(1)=R,R(2)=2 x XMHI("+") s R=R(3)_","_D_","_N f I=0:1:S x XMMEXP s F=$s(R="1":1,R=N1:1,1:0) q:F  s R=R_",2,"_N ;XRMPT(2): check if some A^(2^(0 to S)D#N=1 or N1

PS: An implementation of the MUMPS language used above, called “Cache” or “Cache Object Script”, can be downloaded for free (registration, but no payment or committment, required) at here. Edited December 17, 2016 by CraigD
Neated code

[sanctus]

Was playing a bit (not expecting to be able to prove anything but just see where this type of proof I forgot the name about leads to, induction ? I mean test it for a low n, then say assume it is true for n, so develop for n+1) with the cases and found a speed up for your code CraigD:

\Foreach n there exists a p and an f such that n=p+f or n=p-f

Case n=p+f
n+1=p'+f'<=>p+f+1=p'+f'==>p'-p=f+1-f'==> 
OR
n+1=p'-f'<=>p+f+1=p'-f'==>p'-p=f'+1+f==>p'>p  #fibonacci are always >0

Case n=p-f
n+1=p'+f'<=>p-f+1=p'+f'==>p'-p=-f'-f+1==>p'-p<0==>p'<p #fibonacci are always >0
OR
n+1=p'-f'<=>p-f+1=p'-f'==>p'-p=f'-f+1

A speed up because if a given n was n=p+f then for checking whther n+1=p'-f' only p'>p need to be checked (for n+1=p'+f' still full bruteforce needed)

The other speedup is for the case when n was n=p-f then to check whether n+1=p'+f' only p'<p need to be checked.

[theodorenghiem]

Hi CraigD,

 

I am doing the prgramming of my own. It's unlucky that I use Java, which is limited in expressing large number. So with 1651 it shows minus value.

 

Another guy is using C which is much better than Java in this issue. But I am not good in C. I am asking for help from other expert.

 

Thanks very much for your feedback

[CraigD]

I am doing the prgramming of my own. It's unlucky that I use Java, which is limited in expressing large number. So with 1651 it shows minus value.

You should be able to do arithmetic in much higher precision than your computer can do in a reasonable amount of time by using Java’s java.math.BigInteger class.

 

The largest positive integer BigInteger can handle is about 2^{32*Integer.MAX_VALUE} = 66571993088 bits, about 20,000,000,000 decimal digits, better than the 6,000,000 the XMHI MUMPS execute code tool I wrote (see my previous post) to give my MUMPS program high-precision arithmetic can do.

 

One of the advantages to using a very popular, well-managed language like Java is that you often don’t have to write your own code to extend its abilities. That can also be a disadvantage, as you may not deeply understand the code you’re using, especially if it’s purposefully made hard to read, as Java library code is. My hand-written XMHI, though it took me hours to write and debug, is understandable by anyone who learns the terse, procedural MUMPS language and understands simple arithmetic, and is only 2584 bytes of code (including comments :) ).

 

Another guy is using C which is much better than Java in this issue. But I am not good in C. I am asking for help from other expert.

C++ also has high-precision arithmetic libraries, and because of its operator overloading feature, code that uses instances of the classes they implement is more readable than Java or MUMPS. Compiled C programs are much faster-running than Java or MUMPS equivalents. I recommend “protoyping” programs in easy-to-use languages like Python or MUMPS, then translating them to high-performance ones like C.

 

Was playing a bit (not expecting to be able to prove anything but just see where this type of proof I forgot the name about leads to, induction ? I mean test it for a low n, then say assume it is true for n, so develop for n+1)

Since for the small number N = 1651 we’re focusing on you can quickly check to see if N = f + p for all Fibonacci numbers F < 1651, we can ignore checking if p is prime for the N = f + p case, and just check for the N = p – f.

 

That part of the program I posted looks like this in pseudocode:

Given number to test N

Initialize F to first Fibonacci number

Begin Loop

Check if N+F is prime, if it is, quit

Set F to next Fibonacci number

End loop

So an induction proof would look like

Give N + F_n is not prime

x = N + F_n+1 is not prime because … (then a miracle occurs ;) ) … Q.E.D.

The miraculous/hard part of such a proof is due to there not being a know way to prove

Given y, If x is not prime, x + y is not prime

Except for the trivial case where x and y are not relatively prime (ie: have a factor in common, like 6 and 3, so we know that if 6 is not prime, 9 is not, 12 is not, etc). For our proof, we’d have to get it to work for y is any Fibonacci number.

 

I’ve some hunches about how to approach such a proof, but they’re mind-boggling deep and difficult, likely too difficult for my 2nd or worse-rate mathematical mind. I love ‘em. :)

[sanctus]

But I was saying that if:
N=1650 was equal to p+f

then for N=1651 only p'>p needs to be checked for seeing whether there exists p' and f' such that 1651=p'-f'

Equivalently if 1650=p-f then for N=1651 only p'<p needs to be checked for p'+f'


So there are in total 4 cases:
1)1650=p+f
1.1) 1651 =^? p'-f' only check p'>p--> a tiny speedup since 1651 quite small
1.2) 1651=^? p'+f' brute force, but since 1651 is small there are not sooo many primes and fibonacci combos having smaller sum then 1651

 

2)1650=p-f
2.1) 1651=^? p'+f' only check p'<p--> again a tiny speedup since 1651 quite small
2.2) 1651=^? p'-f' brute force

Writing this I notice the speed up might not be very substantial, but what you can see is that case 2.2 is the killer, the rest is all quick.

[CraigD]

But I was saying that if:

N=1650 was equal to p+f

then for N=1651 only p'>p needs to be checked for seeing whether there exists p' and f' such that 1651=p'-f'

I think I understand what you’re suggesting, but since my program is just checking the primality of p = f + 1651 for consecutive Fibonacci numbers f, knowing that p’ > p doesn’t help.

 

It might help to think of question being checked as “Is there any Fibonacci number f for which f+1651 is prime?” Knowing that f+1651 isn’t prime for a given f doesn’t help in finding if f’+1651 is or not.

 

My program is using the Rabin-Miller primality test using exponentiation by repeated squaring, which has complexity O(k log³ n), and the xth Fibonacci number [math]f_x \dot= k \varphi^x[/math], so a little calculus give that to check for f₁ to f_x will take about k x⁴, so since it took about 1 hr to check through f₂₀₀₀, it’ll take over 16 hrs to check through f₄₀₀₀ 256 to check through f₈₀₀₀, etc.

 

So I’m not much inclined to run it any more. Brute force is fun, but has its limits ;)

[theodorenghiem]

Hello all,

 

I come back !!!

 

Sorry for my being invisible few days ago. I focused in programming, and with the help of programming community, now I have proved my theory with the first 10,000,000 (ten millions) whole number from 1 to 10,000,000. My program was written in Java.

 

I can test more with greater number, but currently ten millions is enough.

 

I put my data in an microsoft access file Data.accdb, share it in ggole drive with link

 

https://drive.google.com/drive/u/0/folders/0BzAetX6K_uyALUc2ZnkzV2xaTkE

 

I shared full access for everyone. So please com there, open this file and see table data1. They're there.

 

Look at column four 'Sum or Difference' in this table. For cases which belong to the second rule Integer = Prime - Fibonacci, I put comment 'Difference'. Otherwise it's NULL.

 

Please enjoy.

 

 

 

I

[CraigD]

Good to see you back, Thinh, and with 245 MB of output the share! :) :thumbs_up

 

I doesn’t demonstrates that your conjecture that every positive integer n= p + f or p - f where p is prime and f is a Fibonacci number, though.

 

Looking at this line from Data.txt

2971216724 2971215073 1651 Difference

I see 2971216724-2971215073=1651, but while 2971215073 is the 47th Fibonacci number, 2971216724 is not prime.

 

I count 4744683 lines showing where the program appears to have given up trying to find a p and f pair for an n, and output a line ending “ Difference”. It seems to have checked only for the first 51 Fibonacci numbers (up to 20365011074).

 

Using the program in this post,, I checked for prime number for n=1651 up to the 2552th Fibonacci number (

97044944451457817379368505883647677831280152046360405677817589793430560697799425585411735769896781424700950972141688183054468510256380227649515066442371230683106204992650332004103580552970556466850693605054267763396495636570692208317713974747832515879032996259580137524231585102648042657310952345839756063972389513274753517342772738544772837165187478842528683147080856413929434800485794614327153978732848967327526950385204829219450575526863247517072744309205223768225024509166420498382397465351568447693479588099591352120368564191349

), without finding a p and f pair that supported the conjecture.

 

1651 seems to be the magic number where the conjecture fails. If you want to try brute force computing, I recommend running the fastest unlimited precision program you have on the fastest and as many processors as you have free, looking for a solution for this number.

 

For any program similar to mine, it’s easy to split into many threads that can be run in parallel, because its easy to generate Fibonacci numbers. What takes most of the time is checking to see if f + 1651 is prime (XRMPT in my code).

[theodorenghiem]

Hello all,

 

CraigD is correct. Please ignore my output file since it has so many incorrect calculation. 1651 is one of them, as CraigD said.

 

Thank you CraigD. I must fix issue in my program. 

[theodorenghiem]

Hello all,

 

I checked my data. Thanks to CraigD to find out my mistake. All of the incorrect records belong to Prime numbers which are greater than 2.1 billions. it results from the limit of Java in huge number processing.

 

I use the same algorithm to rewrite the program in C. It solve a number of missing records found by CraigD, but not all of them

 

For example 1651 has been expressed successfully as 

18446744073709550683  2584  1651.That means the prime number found is over 18 billions billions (Terrible !!!)

 

Finally, there are 9,335,421 numbers from 1 to 10,000,000 are analyzed successfuly. The number of failure is 664,579 records ~ 6.6%.

 

There may be two cases:

 

1. Either the calculation is out of C language capability so it had to break out.

 

2. Or my conjecture fails for these records. That means there is no pair of Prime/Fibonacci to fulfill the rules stated by me.

 

New data has  been updated into the same sahring location in Google drive (Data.txt and Data.accdb)

 

The source code of C language can be found in

https://drive.google.com/drive/u/0/folders/0BzAetX6K_uyAb0k1Q0h2ekJmT0E

 

Thank you and merry christmas to all of you

Edited December 16, 2016 by theodorenghiem

[OceanBreeze]

 

 

Finally, there are 9,335,421 numbers from 1 to 10,000,000 are analyzed successfuly. The number of failure is 664,579 records ~ 6.6%.

 

 

Thank you and merry christmas to all of you

 

What failure? Look at it this way; you’ve found an entire new class of numbers that cannot be expressed as a sum or difference between a Prime and a Fibonacci.  

 

Congratulations, and Merry Christmas!

[Turtle]

Hello all,

 

I checked my data. Thanks to CraigD to find out my mistake. All of the incorrect records belong to Prime numbers which are greater than 2.1 billions. it results from the limit of Java in huge number processing.

 

I use the same algorithm to rewrite the program in C. It solve a number of missing records found by CraigD, but not all of them

 

For example 1651 has been expressed successfully as 

18446744073709550683  2584  1651.That means the prime number found is over 18 billions billions (Terrible !!!)

... 

Thank you and merry christmas to all of you

I find the output for 1651 unsatisfying inasmuch as it appears truncated and we -apparently- can't read the Fibonacci subtrahend.

If 18446744073709550683 is supposed to be the Prime, it is wrong as its prime factorization is 7^2×71×5302312179853277 (factorization courtesy Wolfram Alpha)

 

Merry Christmas back! :xmas_tree:

 

Edit: A few lines down from the above entry in you data.txt file is this anomalous entry:

18446744073709550713 2584 1681

Again the mysterious 2584, and 18446744073709550713 is not Prime as it factors to 23×802032351030850031

Edited December 16, 2016 by Turtle

[Turtle]

So, in searching for the difference 1651 we can narrow our choices. I'll outline just the cases for Primes ending in 1 and leave the cases of Primes ending in 3, 7, or 9 aside for the time being.

 

Now to get 1651 as a difference between a Prime ending in 1 and a Fibonacci, the Fibonacci must end in 0. Ending digits of Fibonaccis have a cycle of 60, and ending digits of 0 have a sub-cycle of 15. To get P¹-F⁰=1651 you need only check Fibonaccis of form F_(15n) for n={1,2,3,...}

 

Here's the cycle 60 list:

 

Fibonacci ending digit cycle

index/end digit

1 1

2 1

3 2

4 3

5 5

6 8

7 3

8 1

9 4

10 5

11 9

12 4

13 3

14 7

15 0

16 7

17 7

18 4

19 1

20 5

21 6

22 1

23 7

24 8

25 5

26 3

27 8

28 1

29 9

30 0

31 9

32 9

33 8

34 7

35 5

36 2

37 7

38 9

39 6

40 5

41 1

42 6

43 7

44 3

45 0

46 3

47 3

48 6

49 9

50 5

51 4

52 9

53 3

54 2

55 5

56 7

57 2

58 9

59 1

60 0

 

 

Have at it programmers! :computerkeys:

 

Addendum:

For a difference end digit of 1 and a Prime ending in 3.

3: for difference of 1, minuend must be 2: F_(60n+3);F_((60n+36);F_((60n+54);F_((60n+57):n={0,1,2,3...}

 

For a difference end digit of 1 and a Prime ending in 7.

7: for difference of 1, minuend must be 6 F_(60n+21);F_(60n+39);F_(60n+42);F_(60n+48):n={0,1,2,3...}

 

For a difference end digit of 1 and a Prime ending in 9.

9: for difference of 1, minuend must be 8 F_(60n+6);F_(60n+24);F_(60n+27);F_(60n+33):n={0,1,2,3...}

 

PS Here is a grand page on patterns in Fibonacci numbers: >> The Mathematical Magic of the Fibonacci Numbers

Edited December 17, 2016 by Turtle