Estudo sobre numeros primos, teoremas e axiomas

Vejo outros teoremas. Exemplo:

Se os axiomas são 2 primos, então teremos teoremas que são multiplos desses 2 primos na forma A^n * B^m = Z.

Se for pedido o numero na posição P tal que 3^n * 5^m = Z:
Quais os valores de 'n', 'm' e Z?

Nesse estudo, tentaremos encontrar um algoritmo de busca de um numero com base no seu numero de primos e a posição P (cardinalidade) tal que A^n * B^m = Z.

Se por hipotese 3 e 5 sao as bases que compoem os teoremas:
1,

3,
5,

3*3,
3*5,
5*5,

3*3*3,
3*3*5,
3*5*5,
5*5*5,

3*3*3*3,
3*3*3*5,
3*3*5*5,
3*5*5*5,
5*5*5*5,

3*3*3*3*3,
3*3*3*3*5,
3*3*3*5*5,
3*3*5*5*5,
3*5*5*5*5,
5*5*5*5*5,

3*3*3*3*3*3,
3*3*3*3*3*5,
3*3*3*3*5*5,
3*3*3*5*5*5,
3*3*5*5*5*5,
3*5*5*5*5*5,
5*5*5*5*5*5,...

Como foi observado, existe uma relação entre a quantidade de digitos utilizado 'k' e o numero de numeros possiveis de se contruir 'k+1'.

Note que podemos ter teoremas tais que

1) A^m * B^0 >  A^0 * B^n
Exemplo: 3*3*3*3 < 5*5*5

2) A^m * B^0  <  A^0 * B^n
Exemplo: 3*3*3 > 5*5

Portanto deve existir um numero de virada 'k' tal que 3^k = 5^(k-1). Buscando 'k':
k * ln(3) = (k-1) * ln(5)
k * ln(3) - (k-1) * ln(5) = 0
supondo que ln(5) = v*ln(3) temos:
k * ln(3) - (k-1) * v*ln(3) = 0
(k-vk+v)ln(3)=0
(k-vk+v)=0
k(1-v)+v=0
k=v/(v-1) tal que v = ln(5)/ln(3) temos:
o ponto de virada seria:
k=3.150660103087125


teste:
k * ln(3) = (k - 1) * ln(5)
3.150660103087125 *  ln(3) = 2.150660103087125 * ln(5)

se k=3.150660103087125
    3.461353906667849 =  3.461353906667849

se k<3.150660103087125 : exemplo k=3.1506601030871
    3.4613539066678216 > 3.461353906667809

se k<3.150660103087125 : exemplo  k=3.15066010308713
    3.4613539066679313 < 3.46135390666797
 
script para verificação:
//===================================================
    <script>
    var v = Math.log(5) / Math.log(3)

    var k=v/(v-1);
    document.write( "para k = "+k +"</br>")
    document.write( (k * Math.log(3)) +" = "+ ((k-1) * Math.log(5)) +"</br></br>")

    var k1= k - 0.0000000000001
    document.write( "para k = "+k1 +"</br>")
    document.write( (k1 * Math.log(3)) +" > "+ ((k1-1) * Math.log(5)) +"</br></br>")

    var k2= k + 0.0000000000001
    document.write( "para k = "+k2 +"</br>")
    document.write( (k2 * Math.log(3)) +" < "+ ((k2-1) * Math.log(5)) +"</br></br>")
    </script>
//============================================

Encontramos um 'k' que não é inteiro, e precisamos estabelecer um limite na inteiro para dizermos se ou 3^k < 5^(k-1) ou 3^k > 5^(k-1)

Isso divide nosso seguimento de buisca em 3 partes tal que nossas funções f1, f2 e f3 devem ser:

f1(n) se nº digitos < k-1
f2(n) se nº digitos > k-1 e nº digitos < k+1 <= região crítica.
f3(n) se nº digitos > k+1

   f1(n)      f2(n)       f3(n)
-----------o----------o-------------
         (k-1)      (k+1)

Script que mostra os numeros que estão fora de posição:
//===================================================   
    <script>

    // ponto de virada
    var virada = Math.log(5) / Math.log(3) ;

    // esta função é para mudança de base.
    function logVirada(v)
    {
        return Math.log(v) / Math.log( virada ) ;
    }

    // mudaremos as bases de 5 e 3 para que possamos colocar os numeros sob uma mesma base.
    var k = logVirada(5)/logVirada(3)

    // maior numero escrito será guardado nesta variavel.
    var maiorNumero=0;

    // inicio do laço de repetição que coloca cada linha no triangulo.
    // de linha i indo de zero a 10 com incremento de 1 em cada passo.
    for(var i=0; i<10; i+=1)
    {
        document.write( i+ " digitos: ") ;

        // inicio do laço de repetição que coloca cada elemento da linha.
        // da posicao j indo de zero a i com incremento de 1 em cada passo.
        for(var j=0; j<=i; j++)
        {
            // n é o valor que eleva 3
            n=i-j;

            // m é o valor que eleva 5
            m=j;

            // Math.pow( base, potencia );
            resp = Math.round( Math.pow( virada, (m*k + n)*logVirada(3) ) )  ;

            // verificando as cores
            //se esse for o maior numero escrito guarda e finalmente escreve
            if( maiorNumero < resp)
            {
                maiorNumero = resp;
                document.write(  " "+resp ) ;
            }
            else // se não escreve de vermelho
            {
                document.write( "<font color='ff0000'>"+ resp +"</font> ") ;
            }
        }
        document.write( "</br></br>") ;
    }
    </script>
//============================================


Imagem obtida e comentada: