PARI's commands

[3.14159]

Originally Posted by Charles

Right. That's too big, though -- it double-counts 4 residues mod 108, for example, making it too large by at least 4/108 = 3.7...%.

Right..

Originally Posted by Charles

That will be too large, since it's only removing one congruence class mod H (the huge product). You removed 1 mod H, but you also need to remove 1 + 4*27, 1 + 2*4*27, ... mod H.

109, 217, 325, 433, 541, 649, 757, ... ?

[3.14159]

Also: Here is the number, such that nⁿ = 2 :

1.559610469462369349970388768765002993284883511843...

Any simple way to compute that? I had to do trial and error to get the first 10 or so digits.

[CRGreathouse]

It's log(2)/W(log(2)). I can calculate it with

\p 1000
log(2)/LambertW(log(2))

using my program

LambertW(x)={
	my(e,t,w,ep);
	if(x <= 0,
		if (x == 0, return (0));
		if (x == -exp(-1), return (-1));
		if (x < -exp(-1), error("LambertW: "x" is out of range, exiting."))
	);

	\\ Initial approximation for iteration
	if (x < 1,
		ep = sqrt(2*exp(1)*x+2);	\\ Using ep as a temporary variable
		w = ep * (1 - ep * (1/3 + 11/72*ep)) - 1
	,	w = log(x));
	if (x>3, w = w - log(w));

	t = 1;
	ep = eps() * (1 + abs(w));	\\ ep = epsilon

	while (abs(t) > ep, \\ Main (Halley) loop, cubic convergence
		e = exp(w);
		t = w*e - x;
		t = t/(e*(w+1) - .5*(w+2)*t/(w+1));
		w = w - t
	);
	w
};
addhelp(LambertW,"Primary branch of Lambert's W function. Finds an L >= -1 such that L * exp(L) = x, where x >= -1/e.");

\\ 2 ^ -(decimal_precision * lg(10) - 1)
eps()={
	precision(2.>>(32 * ceil(precision(1.) * 0.103810252965230073370947482)), 9)
};

Be careful, though; you'll want some guard digits. If you want 10,000 digits I'd calculate it with \p 10100 just in case.

[3.14159]

Excellent. I have turned it into the basis of my program, wroot. (Finds x such that x^x = n.)

Based on w(n) being nⁿ.

[CRGreathouse]

Originally Posted by 3.14159

Excellent. I have turned it into the basis of my program, wroot. (Finds x such that x^x = n.)

Presumably wroot(n)=log(n)/LambertW(log(n)). This can be calculated directly slightly more quickly by other means, but I'm sure for your purposes very little speed is needed.

[3.14159]

Originally Posted by CRGreathouse

Presumably wroot(n)=log(n)/LambertW(log(n)). This can be calculated directly slightly more quickly by other means, but I'm sure for your purposes very little speed is needed.

This is for when I wish to find an n-digit k-b-b, and it will show what the value of b is.

[CRGreathouse]

Originally Posted by 3.14159

This is for when I wish to find an n-digit k-b-b, and it will show what the value of b is.

I gathered as much.

You might also consider writing a script that, given b and a max-k value, estimates the number of primes.

[3.14159]

Originally Posted by CRGreathouse

You might also consider writing a script that, given b and a max-k value, estimates the number of primes.

Step 1. log(x)
Step 2. Divide by prime factors. (p)/(p-1)
Step 3. Divide result by number of candidates
Step 4. These are the amount of primes expected.
Step 5. Divide step 2 number by sieve efficiency to learn chances of finding a prime after sieving to x.

[axn]

Originally Posted by 3.14159

Step 1. log(x)
Step 2. Divide by prime factors. (p)/(p-1)
Step 3. Divide result by number of candidates
Step 4. These are the amount of primes expected.
Step 5. Divide step 2 number by sieve efficiency to learn chances of finding a prime after sieving to x.

Step 1: log(N)
Step 2: Divide step 1 by (1.781*log(x)) to learn chances of finding a prime after sieving to x.

[3.14159]

Originally Posted by Axn

Step 1: log(N)
Step 2: Divide step 1 by (1.781*log(x)) to learn chances of finding a prime after sieving to x.

Something about something else comes to mind at this point..

Oh, I know!

Sieving for k * 28657²⁸⁶⁵⁷ + 1 and k * 2³²⁸⁷⁵⁰ + 1.

(Approx. 127700 and 98900 digits, respectively.)

So, that'll register for items 1 and 15. If I prove them prime using Proth.exe, add item 20 to the list as well.

[CRGreathouse]

Back to the restricted sequence A180362:

Not that it's worth calculating -- checking bases is surely faster for tractable values -- but as a curios, the restriction is