Return to Answer

=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=

C++

int OROURKE(int i)
{
  int joe = 1;

  int p = 2;
  int temp = i;
  if (temp < 0 )
  {
    temp *= -1;

  }


  if ( temp > 1)
  {
    int primefac = 0;
    while( temp > 1 && p * p <= temp)
    {
      if (temp % p == 0)
      {
        ++primefac;
      
        temp /= p;
        int exponent = 1;
        while (temp % p == 0)
        {
          temp /= p;
          ++exponent;
        } // while p is fac
        if ( exponent > 1)
        {
       
          joe *= exponent ;
        }
      }  // if p is factor
      ++p;
    } // while p
 
  } // temp > 1
  return joe;
} // OROURKE



int main()
{

     cout << endl;
     double luge = 0.0;
  double luge_a = 0.0, luge_b = 0.0, luge_c = 0.0, luge_d = 0.0, luge_e = 0.0, luge_f = 0.0, luge_g = 0.0, luge_h = 0.0;

     for( int a = 2; a <= 100 &&  a * log(2.0) < 37.0; ++a){

       luge_a =  a * log(2.0);
       luge = luge_a;

     for (int b = 0; b <= a && luge_a + b * log(3.0) < 37.0; ++b){
        luge_b = luge_a + b * log(3.0) ;
         luge = luge_b;

     for( int c = 0; c <= b && luge_b + c * log(5.0) < 37.0; ++c){
       luge_c = luge_b + c * log(5.0) ;
         luge = luge_c;

     for(int d = 0; d <= c && luge_c + d * log(7.0) < 37.0; ++d) {
          luge_d = luge_c + d * log(7.0) ;
         luge = luge_d;

     for(int e = 0; e <= d && luge_d + e * log(11.0)  < 37.0; ++e){
               luge_e = luge_d + e * log(11.0) ;
         luge = luge_e;

     for(int f = 0; f <= e && luge_e + f * log(13.0) < 37.0; ++f){
              luge_f = luge_e + f * log(13.0) ;
         luge = luge_f;

     for(int g = 0; g <= f && luge_f + g * log(17.0) < 37.0; ++g) {
            luge_g = luge_f + g * log(17.0) ;
         luge = luge_g;

     for(int h = 0; h <= g && luge_g + h * log(19.0) < 37.0; ++h){
            luge_h = luge_g + h * log(19.0) ;
         luge = luge_h;
 
        int oro = 1;
        if ( a > 1) oro *= a; 
       if ( b > 1) oro *= b; 
       if ( c > 1) oro *= c; 
       if ( d > 1) oro *= d; 
       if ( e > 1) oro *= e; 
       if ( f > 1) oro *= f;   
     if ( g > 1) oro *= g; 
       if ( h > 1) oro *= h; 
       if (  OROURKE(OROURKE(OROURKE(oro))) != 1 &&   OROURKE(OROURKE(OROURKE(OROURKE(oro)))) == 1  && luge < 37.0  )       cout << setw(12) << luge << setw(12) << oro << setw(13) << a  << setw(3) << b << setw(3) << c << setw(3) << d << setw(3) << e << setw(3) << f << setw(3) << g << setw(3) << h << endl;
     
     }}}}}}}}  // abcdefgh




    return 0 ;
}

MUCH more careful computer run. No specific bounds on the exponents, just the requirement that the resulting product $n < e^{37},$ done using the logarithms. My original guess that $6$ was a reasonable upper bound on the exponents was just that, a guess, and not a good one. Mostly, you don't get enough benefit from extra large exponents on 2, and you don't get enough benefit out of $p(n)$ moving from 1296 to 2304 or 3600

MUCH more careful computer run. No specific bounds on the exponents, just the requirement that the resulting product $n < e^{37},$ done using the logarithms. My original guess that $6$ was a reasonable upper bound on the exponents was just that, a guess, and not a good one. Mostly, you don't get enough benefit from extra large (or extra small) exponents on 2, and you don't get enough benefit out of $p(n)$ moving from 1296 to 2304 or 3600

So, I am not entirely convinced that $p(m(5)) = 1296.$ Maybe, maybe not. However, i am convinced that if you go up to eight primes, $$ n = 2^a 3^b 5^c 7^d 11^e 13^f 17^g 19^h $$ with $a \geq b \geq c \geq d \geq e \geq f \geq g \geq h \geq 0$ and none exactly 1, say $a \leq 6,$ say, and loops with built-in bounds reflecting $n > 2 \cdot 10^8,$ you will find the winner.

MUCH more careful computer run. Mostly, you don't get enough benefit from extra large exponents on 2, and you don't get enough benefit out of $p(n)$ moving from 1296 to 2304 or 3600

So, I am not entirely convinced that $p(m(5)) = 1296.$ Maybe, maybe not. However, i am convinced that if you go up to eight primes, $$ n = 2^a 3^b 5^c 7^d 11^e 13^f 17^g 19^h $$ with $a \geq b \geq c \geq d \geq e \geq f \geq g \geq h \geq 0$ and none exactly 1, and loops with built-in bounds reflecting $n > 2 \cdot 10^8,$ you will find the winner. NOTE: it turns out that this was true: since $$(2 \cdot 3 \cdot 5 \cdot 7 \cdot 11 \cdot 13 \cdot 17 \cdot 19)^2 \approx 9.4 \cdot 10^{13}$$ and we found out we could do slightly better than $10^{13},$ and any prime we use has an exponent at least $2,$ it follows that we do not need to use any prime bigger than $17.$

NOTE: I see no hope of finding $m(6)$ unless we can prove that $p(m(6)) = m(5),$ and it is still a stretch in that case.

MUCH more careful computer run. No specific bounds on the exponents, just the requirement that the resulting product $n < e^{37},$ done using the logarithms. My original guess that $6$ was a reasonable upper bound on the exponents was just that, a guess, and not a good one. Mostly, you don't get enough benefit from extra large exponents on 2, and you don't get enough benefit out of $p(n)$ moving from 1296 to 2304 or 3600