possible OEIS party Boston Apr 30?

[N. J. A. Sloane]

I have a nontrivial upper bound on the next element of this sequence
(which has the "more" keyword),
a(16) < 288310406533
and some considerations which I won't put on the OEIS but which might
be of interest for those who need.

If  p  is of class 16+, then one of the factors of p+1 must be of class 15+.
However, since this factor is odd and p+1 is even,  p+1 must be an
even multiple of a class 15+ number, i.e.  p  must be in the set
 { p = 2*k*q -1 ;  q  of class 15+ , k=1,2,3... such that p is prime }
which is in fact the complete set of ALL 16+ numbers.

So we have immediately that  a(16) >= 2*a(15)-1 = 47738922361, which
is not prime, thus a(16) > 2 a(15).
But also  a(16) <= 2*k*a(15)-1  where k is the least integer s.th.
this is prime,
i.e. k=9, which gives a "trivial" upper bound 429650301257.

Now, if we had a sufficiently complete list of class 15+ primes, we
would easily find a(16) by checking small even multiples -1 of these,
using the following algorithm
which stops when one is found with k=1:

findnextlowest( a /* sorted list of class n primes */,p=0,k0=99,s)={
  print1("looking for primes of class ");/* guess the class (n+/n-)
from the list a */
  if( class(a[1]) & class(a[1])==class(a[2]),
    s= 1;print(class(a[1])+1,"+"),/*else*/ s=-1;print(class(a[1],-1)+1,"-"));
  for(i=1,#a,
   for(k=1,k0-1, if(p & k>p/2/a[i], break);/* no chance to find lower
with this k */
    if( isprime( 2*k*a[i]-s ),
     print("Found prime p = 2*a*k+s, [p,a,k,s]=",[p=2*k*a[i]-s,a[i],k0=k,-s]);
     if( k==1,
      print("This is the smallest prime of this class if the given
list is complete up to ",a[i]);
      return(p);
     );break;/* no need to try bigger k */
  )));print("Not sure if the last prime found is really the smallest
of this class.");
}

using (only for the guess) the function

class(n,s=+1) = { if( ! isprime(n), 0,/*else*/ if( n=factor(n+s)[,1] & n[#n]>3,
 vecsort(vector(#n,i,class(n[i],s)))[#n]+1 ,/*else: factorset c {2,3} */ 1))}

Unfortunately, this list does not yet exist on OEIS. (Please tell me
if you have it !)
However, using the same ideas, we can construct a (maybe incomplete) list
from a list of 14+ primes, using the following algorithm:

nextclass( a /*list of primes of the lower class*/,
      lim=0 /*limit above which we stop testing multiples*/,p,b=[],s)={
  print1("looking for primes of class "); if( class(a[1]) &
class(a[1])==class(a[2]),
    s= 1;print(class(a[1])+1,"+"),/*else*/ s=-1;print(class(a[1],-1)+1,"-");
  );
 for( i=1,#a, p=-s; until( p>=lim, until( isprime(p), p += 2*a[i] );
   b=concat(b,p); if( !lim, lim=p)/* if none given, use the first
prime found as limit */)
 ); vecsort(b)
}

Unfortunately, even a list of 14+ primes is still missing on OEIS, but
we have a list of 13+ primes:
{A090468/* 		Class 13+ primes. 		+20 2*/=[
	545587687, 852480757, 1048438561, 1150849009, 1323457987, 1745980517,
	1756123441, 1785398401, 1798736161, 1892507347, 1937020021, 2002155601,
	2136716521, 2150905573, 2229004913, 2548101601, 2671514917, 2838761021
]}

thus:

> c14p = nextclass(A090468,10^12) \\ yields a list of class 14+ primes
...
> c15p = nextclass(c14p,10^12) \\ yields a list of class 15+ primes
time = 78 ms.
%206 = [23869461181, 64788537493, 79681330633, 91658731403,
143216767091, 144155203267, 153446536169, ...]
...
> a16upperlimit = findnextlowest( c15p ) \\ yields an upper limit for a(16)
looking for primes of class 16+
Found prime p = 2*a*k+s, [p,a,k,s]=[429650301257, 23869461181, 9, -1]
Found prime p = 2*a*k+s, [p,a,k,s]=[288310406533, 144155203267, 1, -1]
This is the smallest prime of this class if the given list is complete
up to 144155203267
time = 0 ms.
%207 = 288310406533
> _

This explains the limit I gave on top of the message, a(16) <= 288310406533,
and we can be sure that this is the true value if the calculated list
c15p is complete up to the 6th element. (Which in turn is true if the
list c14p is complete up to the biggest element which had been used to
calculate c15p[1]...c15p[6], etc.)

Also, you might have noticed that the above algorithms also work for
class n- primes.

Maximilian