Derivação Fórmula 6k+-1 Prováveis Primos com 12k+-(1, 5, 7, 11)
Artigo acadêmico que explora a eficácia de formulações matemáticas generalizadas para
encontrar números primos. O artigo se concentra na generalização da fórmula \(6k \pm 1\),
usando múltiplos de 6 e uma regra de multiplicação por 8 para obter novas constantes
multiplicativas. As formulações foram testadas computacionalmente e mostraram ser
eficazes na geração de candidatos a números primos.
### Novo Resumo com \(12k\)
#### Formulações Matemáticas
1. **Candidatos a Números Primos com \(12k\)**
\[
C = \bigcup_{s \in \{1, 5, 7, 11\}} \left\{ 12k + s, 12k - s \,|\, k = 0, 1, 2, \ldots,
\text{NumCandidates} - 1 \right\}
\]
Nesta formulação, \(C\) é o conjunto de todos os candidatos a números primos. Para cada
valor inicial \(s\) e para cada \(k\), dois candidatos são gerados: \(12k + s\) e \(12k - s\).
2. **Método de Diferença Constante**
\[
a_n = a_0 + n \times 12
\]
3. **Método Baseado em \(6k\)**
\[
p = 6k \pm 1
\]
#### Algoritmo em Python
O algoritmo em Python para gerar candidatos a números primos usando a fórmula \(12k \pm
s\) e para validar esses candidatos está disponível [aqui](https://cpad.io/s/bb58709e).
#### Testes de Validação
O algoritmo inclui testes de validação usando a biblioteca `sympy` para verificar se os
números gerados são realmente primos.
### Algoritmo em Python
Aqui está o algoritmo em Python que gera candidatos a números primos usando a fórmula
\(12k \pm s\) e realiza testes de validação para verificar se os números gerados são
realmente primos.
```python
from sympy import isprime
# Generate prime candidates using 12k ± s
initial_values = [1, 5, 7, 11]
num_candidates = 100
prime_candidates = []
for s in initial_values:
for k in range(num_candidates):
candidate1 = 12 * k + s
candidate2 = 12 * k - s
prime_candidates.extend([candidate1, candidate2])
# Validation tests
validated_primes = [x for x in prime_candidates if isprime(x)]
print('Generated Prime Candidates:', prime_candidates)
print('Validated Primes:', validated_primes)
```
### Formulações Matemáticas
1. **Candidatos a Números Primos com \(12k\)**
\[
C = \bigcup_{s \in \{1, 5, 7, 11\}} \left\{ 12k + s, 12k - s \,|\, k = 0, 1, 2, \ldots,
\text{NumCandidates} - 1 \right\}
\]
2. **Método de Diferença Constante**
\[
a_n = a_0 + n \times 12
\]
3. **Método Baseado em \(6k\)**
\[
p = 6k \pm 1
\]
Essas são todas as formulações matemáticas relevantes para o método atualizado com
\(12k\).
### Comparação com a Formulação \(6k \pm 1\)
A formulação \(6k \pm 1\) é uma forma clássica de gerar candidatos a números primos.
Todos os números primos maiores que 3 podem ser escritos na forma \(6k \pm 1\).
A nova formulação \(12k \pm s\), onde \(s \in \{1, 5, 7, 11\}\), é uma extensão dessa ideia.
Note que \(6k + 1\) e \(6k - 1\) são casos especiais de \(12k \pm s\) quando \(s = 1\) ou \(s =
5\).
### Flexibilidade e Escalabilidade
1. **Múltiplas Colunas**: A nova formulação permite que você explore diferentes "colunas"
de candidatos a números primos, cada uma iniciada por um dos valores \(s\). Isso oferece
mais flexibilidade na busca de números primos.
2. **Grandes Magnitudes**: Ao usar \(12k\) em vez de \(6k\), você efetivamente dobra o
intervalo de pesquisa, o que pode ser útil para encontrar números primos de grandes
magnitudes mais rapidamente.
3. **Paralelismo**: Cada coluna pode ser processada independentemente, permitindo a
implementação de algoritmos paralelos para acelerar a busca.
4. **Ajuste de Parâmetros**: A constante \(12\) e os valores iniciais \(s\) podem ser
ajustados para adaptar o método a diferentes cenários ou para otimizar a eficiência.
### Exemplo de Flexibilidade
Suponha que você esteja interessado em encontrar números primos entre \(10^6\) e
\(10^7\). Você pode ajustar o valor de \(k\) para começar de \(\frac{10^6}{12}\) e terminar em
\(\frac{10^7}{12}\), e então aplicar a formulação \(12k \pm s\) para gerar candidatos nesse
intervalo.
### Explicação Detalhada e Formulações Matemáticas
#### Comparação com \(6k \pm 1\)
A formulação \(6k \pm 1\) é uma forma eficiente de gerar candidatos a números primos
porque todos os números primos maiores que 3 podem ser escritos dessa forma. Isso
ocorre porque todos os números inteiros podem ser escritos como \(6k\), \(6k + 1\), \(6k +
2\), \(6k + 3\), \(6k + 4\), ou \(6k + 5\), e apenas \(6k + 1\) e \(6k - 1\) (ou \(6k + 5\)) têm a
possibilidade de serem primos.
#### Extensão para \(12k \pm s\)
A formulação \(12k \pm s\) é uma generalização dessa ideia. Aqui, \(s\) pode ser um dos
quatro valores: \(1, 5, 7, 11\). Isso permite que você explore diferentes "colunas" de
candidatos a números primos, cada uma iniciada por um dos valores \(s\).
##### Formulações Matemáticas
1. **Conjunto de Candidatos a Números Primos**
\[
C = \bigcup_{s \in \{1, 5, 7, 11\}} \left\{ 12k + s, 12k - s \,|\, k = 0, 1, 2, \ldots,
\text{NumCandidates} - 1 \right\}
\]
2. **Método de Diferença Constante**
\[
a_n = a_0 + n \times 12
\]
3. **Método Baseado em \(6k\)**
\[
p = 6k \pm 1
\]
4. **Intervalo de Busca para Grandes Magnitudes**
\[
k_{\text{start}} = \left\lceil \frac{N_{\text{min}}}{12} \right\rceil, \quad k_{\text{end}} =
\left\lfloor \frac{N_{\text{max}}}{12} \right\rfloor
\]
Aqui, \(N_{\text{min}}\) e \(N_{\text{max}}\) são os limites inferior e superior do intervalo de
números que você está interessado em explorar.
#### Lógica Envolvida
1. **Flexibilidade**: A escolha de diferentes valores de \(s\) permite que você explore
diferentes subconjuntos de candidatos a números primos.
2. **Escalabilidade**: O método é facilmente escalável para grandes magnitudes ao ajustar
o valor de \(k\).
3. **Paralelismo**: Cada "coluna" \(s\) pode ser processada em paralelo, permitindo uma
busca mais rápida.
4. **Ajuste de Parâmetros**: A constante \(12\) e os valores \(s\) podem ser ajustados para
diferentes cenários, permitindo uma busca mais eficiente.
Claro, vou explicar cada formulação matemática em detalhes:
### 1. Conjunto de Candidatos a Números Primos \( C \)
\[
C = \bigcup_{s \in \{1, 5, 7, 11\}} \left\{ 12k + s, 12k - s \,|\, k = 0, 1, 2, \ldots,
\text{NumCandidates} - 1 \right\}
\]
- **\( \bigcup \)**: Este símbolo representa a união de conjuntos. Estamos combinando
vários conjuntos menores para formar o conjunto \( C \), que contém todos os candidatos a
números primos.
- **\( s \in \{1, 5, 7, 11\} \)**: Aqui, \( s \) representa um dos valores iniciais \(1, 5, 7, 11\). Para
cada um desses valores, um conjunto de candidatos a números primos será gerado.
- **\( 12k + s, 12k - s \)**: Estas são as fórmulas para gerar candidatos a números primos.
Para cada valor de \( k \) e para cada valor inicial \( s \), dois candidatos são gerados: um
pela adição \( (12k + s) \) e outro pela subtração \( (12k - s) \).
- **\( k = 0, 1, 2, \ldots, \text{NumCandidates} - 1 \)**: \( k \) é um índice que começa em 0 e
vai até \( \text{NumCandidates} - 1 \), onde \( \text{NumCandidates} \) é o número total de
candidatos que você deseja gerar.
### 2. Método de Diferença Constante \( a_n \)
\[
a_n = a_0 + n \times 12
\]
- \( a_n \) é o \( n \)-ésimo candidato a número primo na sequência.
- \( a_0 \) é o valor inicial, que pode ser \( 1, 5, 7, 11 \).
- \( n \) é o índice do candidato na sequência.
- \( 12 \) é a diferença constante entre os candidatos na sequência.
### 3. Método Baseado em \( 6k \) \( p \)
\[
p = 6k \pm 1
\]
- \( p \) é um número primo da forma \( 6k \pm 1 \).
- \( k \) é um número inteiro positivo.
- \( \pm 1 \) indica que tanto \( 6k + 1 \) quanto \( 6k - 1 \) são candidatos a números primos.
### 4. Intervalo de Busca para Grandes Magnitudes
\[
k_{\text{start}} = \left\lceil \frac{N_{\text{min}}}{12} \right\rceil, \quad k_{\text{end}} = \left\lfloor
\frac{N_{\text{max}}}{12} \right\rfloor
\]
- \( k_{\text{start}} \) e \( k_{\text{end}} \) são os valores iniciais e finais de \( k \) para o
intervalo de números que você está interessado.
- \( N_{\text{min}} \) e \( N_{\text{max}} \) são os limites inferior e superior do intervalo de
números.
- \( \left\lceil \cdot \right\rceil \) e \( \left\lfloor \cdot \right\rfloor \) são as funções teto e chão,
respectivamente, que arredondam um número para o inteiro mais próximo.
\[
C = \bigcup_{s \in \{1, 5, 7, 11\}} \left\{ 48k + s, 48k - s \,|\, k = 0, 1, 2, \ldots,
\text{NumCandidates} - 1 \right\}
\]
1. **\( \bigcup \)**: Este símbolo representa a união de conjuntos. Estamos combinando
vários conjuntos menores para formar o conjunto \( C \), que contém todos os candidatos a
números primos.
2. **\( s \in \{1, 5, 7, 11\} \)**: Aqui, \( s \) representa um dos valores iniciais \(1, 5, 7, 11\).
Para cada um desses valores, um conjunto de candidatos a números primos será gerado.
3. **\( 48k + s, 48k - s \)**: Estas são as fórmulas para gerar candidatos a números primos.
Para cada valor de \( k \) e para cada valor inicial \( s \), dois candidatos são gerados: um
pela adição \( (48k + s) \) e outro pela subtração \( (48k - s) \).
4. **\( k = 0, 1, 2, \ldots, \text{NumCandidates} - 1 \)**: \( k \) é um índice que começa em 0 e
vai até \( \text{NumCandidates} - 1 \), onde \( \text{NumCandidates} \) é o número total de
candidatos que você deseja gerar.
Então, em resumo, para cada valor inicial \( s \) e para cada valor de \( k \), a fórmula gera
dois candidatos a números primos: \( 48k + s \) e \( 48k - s \). Todos esses candidatos são
então combinados para formar o conjunto \( C \), que contém todos os candidatos a
números primos.
### Resumo Revisado e Novas Formulações
#### Formulações Matemáticas
1. **Candidatos a Números Primos com \(48k\)**
\[
C = \bigcup_{s \in \{1, 5, 7, 11\}} \left\{ 48k + s, 48k - s \,|\, k = 0, 1, 2, \ldots,
\text{NumCandidates} - 1 \right\}
\]
Aqui, \(C\) é o conjunto de todos os candidatos a números primos. Para cada valor inicial
\(s\) e para cada \(k\), dois candidatos são gerados: \(48k + s\) e \(48k - s\).
2. **Método de Diferença Constante**
\[
a_n = a_0 + n \times 48
\]
\(a_n\) é o \(n\)-ésimo candidato a número primo na sequência, \(a_0\) é o valor inicial (\(1,
5, 7\) ou \(11\)), e \(n\) é o índice do candidato na sequência.
3. **Método de Frequência de Segmento**
\[
S_i = \{ x \,|\, x \in S, x \in i \times 100, (i+1) \times 100 - 1 \}
\]
\(S_i\) é o \(i\)-ésimo segmento de \(100\) termos na sequência \(S\), e \(i\) é o índice do
segmento.
4. **Método Baseado em \(6k\)**
\[
p = 6k \pm 1
\]
\(p\) é um número primo da forma \(6k \pm 1\), \(k\) é um número inteiro positivo.
#### Explicações
- O termo \( \pm \) foi incluído para gerar dois candidatos a números primos para cada valor
de \( k \) e cada valor inicial \( s \).
- O método de diferença constante gera uma sequência de candidatos a números primos
com uma diferença constante de \( 48 \) entre os elementos.
- O método de frequência de segmento divide os números em segmentos de \( 100 \)
termos e conta a frequência de números primos em cada segmento.
- O método baseado em \( 6k \) é um método bem conhecido para gerar números primos da
forma \( 6k \pm 1 \).
### Algoritmos e Formulações
O artigo apresenta várias formulações para gerar candidatos a números primos:
1. \(48k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
2. \(384k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
3. \(3072k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
4. \(24576k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
O código Python fornecido no artigo utiliza a biblioteca `sympy` para testar a primalidade e
define funções para gerar candidatos a números primos com base nas formulações acima.
### Código Python
Aqui está um resumo do código Python fornecido:
```python
from sympy import isprime
# Função para gerar candidatos a números primos para a formula 48k + 5 e 48k - 5
def generate_prime_candidates_48k5(num_candidates):
prime_candidates = []
for k in range(1, num_candidates + 1):
candidate1 = 48 * k + 5
candidate2 = 48 * k - 5
prime_candidates.extend([candidate1, candidate2])
return prime_candidates
# Filtrando os candidatos que são primos
filtered_prime_candidates_48k5 = [x for x in prime_candidates_48k5 if isprime(x)]
# Calculando as proporções
proportion_48k5 = len(filtered_prime_candidates_48k5) / len(prime_candidates_48k5)
```
### Metodologia
O artigo utiliza uma abordagem determinística para testar a primalidade, baseada em
divisão simples. Para cada formulação, 20.000 candidatos a números primos são gerados
(10.000 para cada lado do sinal \(\pm\)), e um teste de primalidade é aplicado.
### Resultados
- Para a formulação \(48k \pm 1\), foram encontrados 5016 números primos.
- Para a formulação \(48k \pm 5\), foram encontrados 5007 números primos.
- Para a formulação \(48k \pm 7\), foram encontrados 5010 números primos.
- Para a formulação \(48k \pm 11\), foram encontrados 5007 números primos.
### Discussão
As formulações testadas mostraram-se eficazes na geração de números primos, com cada
uma produzindo mais de 5000 primos nos primeiros 20.000 candidatos. Isso sugere que
essas formulações podem ser uma abordagem eficiente para a geração de números primos.
### Conclusão
As novas formulações provaram ser eficazes na geração de candidatos a números primos.
Mais estudos podem ser realizados para entender as propriedades matemáticas
subjacentes que tornam essas formulações eficazes.
### Código Python Adicional
O código Python também inclui uma função genérica para gerar e filtrar candidatos a
números primos usando o método determinístico de divisão simples.
```python
# Função para testar a primalidade usando um método determinístico de divisão simples
def is_prime_deterministic(n):
if n <= 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
# Função genérica para gerar candidatos a números primos
def generate_prime_candidates_formula(num_candidates):
prime_candidates = []
for k in range(1, num_candidates + 1):
candidate1 = formula(k, 1)
candidate2 = formula(k, -1)
prime_candidates.extend([candidate1, candidate2])
return prime_candidates
# Função genérica para gerar e filtrar candidatos a números primos
def generate_and_filter_prime_candidates_deterministic(formula, num_candidates):
prime_candidates = generate_prime_candidates_formula(num_candidates)
filtered_prime_candidates = [x for x in prime_candidates if is_prime_deterministic(x)]
return filtered_prime_candidates
```
### Formulações Matemáticas e Explicações
O artigo propõe uma generalização da fórmula \(6k \pm 1\) para a geração de candidatos a
números primos. As novas formulações são:
1. \(48k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
2. \(384k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
3. \(3072k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
4. \(24576k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)
#### Explicação
- **Multiplicação por 8**: O artigo sugere a multiplicação da base original (6) por 8 para
obter novas constantes multiplicativas (48, 384, 3072, 24576). Isso permite uma pesquisa
mais extensa e pode ser útil para encontrar primos maiores.
- **\(b \in \{1, 5, 7, 11\}\)**: Esses valores de \(b\) são usados para ajustar a formulação e
gerar diferentes conjuntos de candidatos a números primos.
#### Inovação na Formulação
Uma possível inovação seria considerar a combinação de múltiplos de 6 com outras
constantes além de \(b\). Por exemplo:
\[
a_n = 48k \pm b + c \cdot \cos(k)
\]
onde \(c\) é uma constante e \(\cos(k)\) é a função cosseno avaliada em \(k\).
#### Regras de \(6k \pm 1\)
A regra \(6k \pm 1\) é baseada no fato de que todo número primo maior que 3 pode ser
escrito na forma \(6k \pm 1\). Isso ocorre porque \(6k\) será sempre divisível por 6, \(6k + 2\)
e \(6k + 4\) serão sempre pares, \(6k + 3\) será sempre divisível por 3. Portanto, os únicos
candidatos possíveis para a primalidade são números da forma \(6k \pm 1\).
#### Código Python
### Formulações Matemáticas
1. **\(48k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)**
- Esta é uma generalização da fórmula \(6k \pm 1\), que é comumente usada para gerar
candidatos a números primos. Aqui, \(k\) é um número inteiro positivo e \(b\) é um dos
quatro valores possíveis: 1, 5, 7 ou 11.
2. **\(384k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)**
- Esta é uma extensão da primeira formulação, multiplicando a constante 48 por 8 para
obter 384.
3. **\(3072k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)**
- Similar à segunda formulação, mas com uma constante multiplicativa ainda maior
(3072).
4. **\(24576k \pm b\), onde \(b \in \{1, 5, 7, 11\}\)**
- Esta é a formulação mais generalizada, com a maior constante multiplicativa (24576).
### Explicação Detalhada
1. **\(48k \pm b\)**
- Esta formulação é uma generalização da fórmula \(6k \pm 1\). A ideia é que, ao usar
uma constante multiplicativa maior (48), você pode gerar um conjunto mais amplo de
candidatos a números primos. O valor de \(b\) serve para ajustar a formulação e gerar
diferentes conjuntos de candidatos.
2. **\(384k \pm b\)**
- Esta formulação é uma extensão da primeira, onde a constante multiplicativa é
aumentada para 384. Isso permite gerar um conjunto ainda mais amplo de candidatos a
números primos, mas com o custo de aumentar o espaço de pesquisa.
3. **\(3072k \pm b\)**
- Similar à segunda formulação, mas com uma constante multiplicativa ainda maior. Isso é
útil para quando você precisa de um conjunto muito grande de candidatos a números
primos e está disposto a comprometer a eficiência computacional.
4. **\(24576k \pm b\)**
- Esta é a formulação mais generalizada e é usada quando você precisa do conjunto mais
amplo possível de candidatos a números primos. No entanto, isso vem com o custo de uma
eficiência computacional significativamente reduzida.
### Aplicação em Python
No código Python, essas formulações são aplicadas para gerar candidatos a números
primos, que são então filtrados usando um teste de primalidade. A eficácia de cada
formulação é avaliada com base no número de primos gerados.
### Continuação das Formulações Matemáticas e Explicações
#### Formulações de Geração de Candidatos a Números Primos
1. \( \text{formula48k1}(k, \text{sign}) = 48k + \text{sign} \times 1 \)
2. \( \text{formula48k5}(k, \text{sign}) = 48k + \text{sign} \times 5 \)
3. \( \text{formula48k7}(k, \text{sign}) = 48k + \text{sign} \times 7 \)
4. \( \text{formula48k11}(k, \text{sign}) = 48k + \text{sign} \times 11 \)
#### Método de Teste de Primalidade
O método de teste de primalidade usado no código original para \(6k \pm 1\) é um método
baseado em divisão. Ele funciona da seguinte maneira:
1. Casos especiais para \( n \leq 3 \) são tratados separadamente.
2. Verifica-se se \( n \) é divisível por 2 ou 3.
3. Para todos os números \( i \) começando de 5 até \( \sqrt{n} \), verifica-se se \( n \) é
divisível por \( i \) ou \( i + 2 \).
Se qualquer um desses testes for verdadeiro, \( n \) não é primo. Incrementa-se \( i \) por 6
para o próximo ciclo, pois \( i \) e \( i+2 \) são da forma \( 6k \pm 1 \).
#### Resultados
Para cada formulação, foram gerados 20.000 candidatos a números primos (10.000 para
cada lado do sinal \( \pm \)) e aplicou-se um teste de primalidade determinístico baseado em
divisão simples.
- Para a formulação \( 48k \pm 1 \), foram encontrados 5016 números primos.
- Para a formulação \( 48k \pm 5 \), foram encontrados 5007 números primos.
- Para a formulação \( 48k \pm 7 \), foram encontrados 5010 números primos.
- Para a formulação \( 48k \pm 11 \), foram encontrados 5007 números primos.
#### Conclusão
As novas formulações \( 48k \pm 1 \), \( 48k \pm 5 \), \( 48k \pm 7 \), e \( 48k \pm 11 \)
provaram ser eficazes na geração de candidatos a números primos. Mais estudos podem
ser realizados para entender as propriedades matemáticas subjacentes que tornam essas
formulações eficazes.
### Continuação das Formulações Matemáticas e Explicações
#### Significado de "sign" nas Formulações
O termo "sign" nas formulações refere-se ao sinal \( \pm \), que significa que o número pode
ser tanto adicionado quanto subtraído. Isso é usado para gerar dois candidatos a números
primos para cada valor de \( k \).
#### Formulações Matemáticas Adicionais
5. \( \text{formula3072k}(k, \text{sign}, b) = 3072k + \text{sign} \times b \)
6. \( \text{formula24576k}(k, \text{sign}, b) = 24576k + \text{sign} \times b \)
#### Adaptação para Números Primos de Mersenne
A fórmula geral para um número primo de Mersenne \( M_p \) adaptada para esse método
seria:
\[
k = \left\lfloor \frac{p}{16} \right\rfloor, \quad c \times k + b
\]
onde \( c \) é uma das constantes multiplicativas \( 48, 384, 3072, 24576 \).
#### Algoritmo em Python para Números Primos de Mersenne
```python
def mersenne_to_ck_plus_b(p, b, c):
k = p // 16
return c * k + b
mersenne_primes_with_b = [(p, b), ...] # pares (p, b)
constants = [48, 384, 3072, 24576]
for c in constants:
for p, b in mersenne_primes_with_b:
result = mersenne_to_ck_plus_b(p, b, c)
print(f"2^{p} - 1 no formato c * k + b: k = {result // c}, b = {b}, c * k = {result}")
```
#### Observações
- O método é eficiente para representar esses números primos de Mersenne usando \( k \) e
\( b \) inteiros.
- No entanto, foi observado que os números primos de Mersenne não se encaixam no
formato \( 48k \pm b \) com \( k \) e \( b \) inteiros. As soluções encontradas para \( k \) e \( b
\) são fracionárias.
def mersenne_to_48k_plus_b(p, b):
k = (p - 1) // 6
return 48 * k + b
mersenne_primes = [
(2, 1), (3, 1), (5, 1), (7, 1), (13, 1), (17, 1), (19, 1), (31, 1),
(61, 1), (89, 1), (107, 1), (127, 1), (521, 1), (607, 1), (1279, 1), (2203, 1),
(2281, 1), (3217, 1), (4253, 1), (4423, 1), (9689, 1), (9941, 1), (11213, 1),
(19937, 1), (21701, 1), (23209, 1), (44497, 1), (86243, 1), (110503, 1), (132049, 1),
(216091, 1), (756839, 1), (859433, 1), (1257787, 1), (1398269, 1), (2976221, 1),
(3021377, 1), (6972593, 1), (13466917, 1), (20996011, 1), (24036583, 1), (25964951, 1),
(30402457, 1), (32582657, 1), (37156667, 1), (42643801, 1), (43112609, 1), (57885161,
1),
(74207281, 1), (77232917, 1)
]
for p, b in mersenne_primes:
result = mersenne_to_48k_plus_b(p, b)
print(f'2^{p} - 1 no formato 48k + b: k = {result // 48}, b = {result % 48}')
### Referências Bibliográficas
1. Cormen, T. H., Leiserson, C. E., Rivest, R. L., Stein, C. (2009). Introduction to Algorithms,
3rd ed. MIT Press.
2. Crandall, R., Pomerance, C. (2005). Prime Numbers: A Computational Perspective, 2nd
ed. Springer.
3. Marlon Fernando Polegato Padrões Números Primos
https://fermatslibrary.com/p/5dbb1f65
### Agradecimentos
Agradeço ao Grande Arquiteto do Universo, aos seus pais, Helvio Polegato e Fátima I. L.
Polegato a minha esposa Tayrine S. B. Polegato aos amigos e familiares que o apoiaram
em sua jornada.
### Contato
- Autor: Marlon Fernando Polegato
- Endereço de e-mail: marlonpolegato33@gmail.com
- Co-autor: Aurora Boreal Inteligência Artificial, OpenAI.com, GPT