- You write: My conjecture is that, the number of required iterations of this algorithm to convert a composite number to prime one, is finite,

Here is my easier algorithm to "make primes" which I (and you) can prove only takes a finite number of steps:

Pick any positive integer n.

(a) Increment n (replace n by n+1).

(b) If this n is prime, output n. Otherwise go to step (a).

My point is there are many such algorithms. You should explain why we should care about yours. When you first put it on stack exchange, it allowed infinite loops. Can you at least prove that problem is solved? Do you know you numbers do not grow to the point it is hard to factor them?

There are many true mathematical statements, few are actually interesting.

CC

-----Original Message-----

From: primenumbers@yahoogroups.com [mailto:primenumbers@yahoogroups.com] On Behalf Of Mohsen Afshin

Sent: Friday, April 05, 2013 1:37 PM

To: primenumbers@yahoogroups.com

Subject: [PrimeNumbers] Prime Maker Conjecture

I asked about any proof for my conjecture in Math.StackExchange<http://math.stackexchange.com/questions/318412/proof-of-prime-maker-conjecture>a

month ago with no answer, so I ask it again here.

I'm not sure if it is new, so tell me if it had been stated by someone else already.

"*Prime Maker Conjecture*"

I call a number n *factor-resistant* to q if q∤n. Considering n as a composite number, the idea is to make n factor-resistant to all of its

(prime) factors. When we multiply a number minus or plus 1 with one of its

(prime) factor and then add or subtract 1, the number would become factor-resistant to that (prime) factor.

The Algorithm:

1.

Let n=m∓1 (m is even).

2.

Perform a primility test on n, if n is prime output Prime and exit.

3.

Find the smallest prime factor d0 of n

4.

Set m=d0×m.

5.

Set n=m±1

6.

Go to Step 2

*Example*

We choose m=541# (# is primorial sign) and positive side (+1).

1.

n=541#+1

2.

IsPrime(n) ? n is composite

3.

d0=2879

4.

m=2879×541#

5.

n=m+1

6.

IsPrime(n)?n is composite

7.

d0=342085039

8.

m=342085039×2879×541#

9.

n=m+1

10.

IsPrime(n)?n is prime.

Of course the most time consuming step in the algorithm is finding the

(smallest) factor, sometimes it makes the algorithm impractical but for a math proof we can think of it as a fast operation.

My conjecture is that, the number of required iterations of this algorithm to convert a composite number to prime one, is finite, but I have no idea how to prove it or even approach it ...

*More Samples*

- n=1549×57179×102932777×67118797×718049×8466769×4261711×1444603×100!+1

- n=18593×3119#+1 is a 1327 digits prime

- n=1732043×142981×97787×376001×7933#+1 is a 3423 digits prime

--

"Mathematics is the queen of the sciences and number theory is the queen of mathematics."

--Gauss

[Non-text portions of this message have been removed]

------------------------------------

Unsubscribe by an email to: primenumbers-unsubscribe@yahoogroups.com

The Prime Pages : http://primes.utm.edu/

Yahoo! Groups Links - --- In primenumbers@yahoogroups.com,

Mohsen Afshin <mafshin89@...> wrote:

> http://math.stackexchange.com/questions/318412/proof-of-prime-maker-conjecture

For similar series that demand impractical factorization, see:

> ... makes the algorithm impractical ...

http://oeis.org/search?q=Mullin> 113 results found

David

- --- In primenumbers@yahoogroups.com,

"djbroadhurst" <d.broadhurst@...> wrote:

> For similar series that demand impractical factorization, see:

For example,

> http://oeis.org/search?q=Mullin

http://oeis.org/A051334/b051334.txt

with the small seed 8191, currently leads to a

328-digit impasse, at step 60, with no conclusion

achieved in Mohsen Afshin's use of Euler-Mullin:

{mf(n)=local(f=factor(n,mp)[,1]);f[1];}

{g(m)=local(n=m+1,z,t=m,k=1);

while(!isprime(n),k++;z=mf(n);if(!isprime(z),

print("With seed "m" at step "k", C"#Str(z)" is unfactorized.");

break());t*=z;n=t+1);n;}

{help=[16293787,16639867,26945441,90670999,1340659787,

1406593120897,1193114397863177,34417238589462247,

280460690293140589,17797975387733759209,

11946702618236600549201000463124069,

54540542259000816707816058313971443];}

{mp=10^7;default(primelimit,mp);

for(k=1,#help,p=help[k];if(isprime(p),addprimes(p)));

g(8191);}

With seed 8191 at step 60, C328 is unfactorized.

David