Formulações e Provas Formais do M.F.P.
- Método de Fatoração por Padrão
Autor: Marlon Fernando Polegato
Resumo
Este artigo apresenta e formaliza o M.F.P. (Método de Fatoração por Padrão) para a
classificação de números primos e compostos. São discutidas duas implementações
complementares: uma sequencial baseada em `__int128` e outra paralela baseada em
`std::string` com OpenMP. Ambas identificam divisores reais com alta eficiência e tempo
médio reduzido, mesmo em números grandes como RSA-100 e Mersenne. Incluímos provas
formais, exemplos passo a passo e os resultados experimentais completos.
1. Introdução
A identificação eficiente de primos é essencial para criptografia e teoria dos números. O
M.F.P. visa classificar números com divisores reais detectáveis usando uma estrutura
decimal redistributiva sem projeções externas nem fatoração tradicional.
1. Definição Estrutural do Método
Dado n ∈ ℕ e multiplicadores fixos k ∈ {3, 7, 9, 11, 1}, calcula-se:
- nk = 10A + d, com A = ⌊nk / 10⌋ e d = nk mod 10.
- Em cada passo: A ← A - i e d ← d + 10i.
- Se d > 1, A mod d = 0 e n mod d = 0, então d é divisor real de n.
2. Formulação Geral do M.F.P.
Para cada k fixo, define-se:
n ∈ ℕ ⇒ nk = 10A + d
A = ⌊nk / 10⌋, d = nk % 10
Iterativamente: A_i = A - i, d_i = d + 10i
Critério de composição: ∃i ∈ ℕ tal que d_i > 1, d_i | A_i e d_i | n ⇒ n é composto.
3. Teorema de Correção do M.F.P.
Se n é composto e ∃ d real tal que d divide n, então existe k ∈ {3,7,9,11,1} e i ∈ ℕ tal que:
- A = dq
- nk = 10A + d
- A mod d = 0 e n mod d = 0 ⇒ d será identificado como divisor real dentro do laço
redistributivo.
Demonstração (Esboço):
Se A = dq, então:
nk = 10dq + d = d(10q + 1) ⇒ n = nk / k = d(10q + 1)/k.
Se k | (10q + 1), então n ∈ ℕ e d | n.
Como os valores de k são fixos, e a redistribuição é finita (limitada por d ≤ √nk),
o método encontrará d com no máximo √nk/10 iterações.
4. Exemplo 1: n = 57
Multiplicador k = 3 ⇒ nk = 171 ⇒ A = 17, d = 1
Iterações:
- (A=16, d=11), (A=15, d=21), ..., (A=9, d=71) até A < d.
Com k = 9 ⇒ nk = 513 ⇒ A = 51, d = 3 ⇒ 51 % 3 == 0 e 57 % 3 == 0 ⇒ 3 é divisor real.
5. Exemplo 2: n = 252097800621
k = 3 ⇒ nk = 756293401863 ⇒ A = 75629340186, d = 3
A % 3 == 0 e n % 3 == 0 ⇒ 3 é divisor real identificado na primeira iteração.
6. Propriedades Fundamentais
- Método completamente determinístico.
- Utiliza apenas estrutura decimal de nk, sem fatoração.
- Critério de parada embutido: A < d ou d > √nk.
- Se composto, retornará divisor real d com q = A / d > 1.
7. Observações sobre Eficiência
- Os testes experimentais mostram que o número de iterações é sempre limitado.
- O método evita listas de primos ou checagem de primalidade por tentativa.
- Pode ser paralelizado com OpenMP ou distribuído.
4. Códigos Fonte
As implementações completas em C++ (versão sequencial com `__int128` e versão paralela
com OpenMP) acompanham este artigo e estão disponíveis no anexo ou repositório
correspondente.
Untitled20.ipynb
Untitled20.ipynb_
[14]
12s
# 1. Salvar o código C++ completo em arquivo
Cpp_code = r’’’
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <chrono>
#include <cmath>
#include <limits>
#include <omp.h>
Using namespace std;
Using namespace std::chrono;
// --- Funções auxiliares ---
String multiply_string(const string &num, int k) {
Int carry = 0;
String res(num.size(), ‘0’);
For (int I = num.size() – 1; I >= 0; i--) {
Int d = num[i] – ‘0’;
Int prod = d * k + carry;
Res[i] = char(‘0’ + (prod % 10));
Carry = prod / 10;
}
While (carry > 0) {
Res.insert(res.begin(), char(‘0’ + (carry % 10)));
Carry /= 10;
}
Return res;
}
String subtract_string(const string &num, const string &sub_str) {
String res = num;
Int sub = stoi(sub_str);
Int I = res.size() – 1;
While (sub > 0 && I >= 0) {
Int d = res[i] – ‘0’;
Int sub_digit = sub % 10;
If (d < sub_digit) {
Int j = I – 1;
While (j >= 0 && res[j] == ‘0’) {
Res[j] = ‘9’;
j--;
}
If (j >= 0) res[j]--;
D += 10;
}
Res[i] = char(‘0’ + (d – sub_digit));
Sub /= 10;
i--;
}
Size_t pos = res.find_first_not_of(‘0’);
Return (pos != string::npos ? res.substr(pos) : “0”);
}
String divide_string(const string &num, const string &d_str) {
Int d = stoi(d_str);
String quotient;
Int rem = 0;
For (char c : num) {
Int cur = rem * 10 + (c – ‘0’);
Quotient.push_back(char(‘0’ + cur / d));
Rem = cur % d;
}
Size_t pos = quotient.find_first_not_of(‘0’);
Return (pos != string::npos ? quotient.substr(pos) : “0”);
}
Int mod_string(const string &num, int d) {
Int rem = 0;
For (char c : num) rem = (rem * 10 + (c – ‘0’)) % d;
Return rem;
}
Int compare_string(const string &a, const string &b) {
If (a.size() != b.size()) return a.size() < b.size() ? -1 : 1;
Return a.compare(b);
}
String sqrt_string(const string &num) {
Int m = num.size();
Int k = min(m, 18);
Unsigned long long prefix = stoull(num.substr(0, k));
Unsigned long long r = (unsigned long long)floor(sqrt((long double)prefix));
Return to_string®;
}
Vector<unsigned int> string_to_blocks(const string &s) {
Vector<unsigned int> blocks;
Const int block_size = 9;
Int len = s.size(), rem = len % block_size;
If (rem > 0) blocks.push_back(stoul(s.substr(0, rem)));
For (int I = rem; I < len; I += block_size)
Blocks.push_back(stoul(s.substr(I, block_size)));
Return blocks;
}
Int blocks_mod(const vector<unsigned int>& blocks, int d) {
Const unsigned long long BASE = 1000000000ULL;
Unsigned long long rem = 0;
For (unsigned int block : blocks) rem = (rem * BASE + block) % d;
Return (int) rem;
}
// --- Heurística com paralelismo ---
Pair<bool, int> mfp_test_heuristic_parallel(const string &n_str) {
If (n_str == “5”) return {true, 0};
If (n_str.back() == ‘5’) return {false, 5};
Int resultado = 0;
Bool eh_primo = true;
#pragma omp parallel for schedule(dynamic) shared(resultado, eh_primo)
For (int ki = 0; ki < 5; ki++) {
If (!eh_primo) continue;
Int k = (int[]){1, 3, 7, 9, 11}[ki];
String nk = multiply_string(n_str, k);
If (nk.size() < 2) continue;
String A0 = nk.substr(0, nk.size() – 1);
Int d0 = nk.back() – ‘0’;
If (d0 <= 0) d0 = 3;
String L = sqrt_string(nk);
If (compare_string(L, to_string(d0)) < 0) continue;
Vector<unsigned int> A0_blocks = string_to_blocks(A0);
If (d0 > 1 && mod_string(n_str, d0) == 0) {
#pragma omp critical
{ resultado = d0; eh_primo = false; }
Continue;
}
String L_minus_d0 = subtract_string(L, to_string(d0));
String i_max_str = divide_string(L_minus_d0, “10”);
Unsigned long long i_max = 0;
Try { i_max = stoull(i_max_str); } catch (…) {}
#pragma omp parallel for schedule(dynamic)
For (unsigned long long I = 1; I <= i_max; i++) {
If (!eh_primo) continue;
Unsigned long long candidate = d0 + 10 * I;
If (candidate <= 1) continue;
Int rA0 = blocks_mod(A0_blocks, candidate);
Int rA = ((rA0 – (int)(I % candidate)) % (int)candidate + (int)candidate) %
(int)candidate;
If (rA != 0) continue;
String A_current = subtract_string(A0, to_string(i));
String q = divide_string(A_current, to_string(candidate));
If (compare_string(q, “1”) > 0 && mod_string(n_str, candidate) == 0) {
#pragma omp critical
{
If (eh_primo) {
Resultado = (int)candidate;
Eh_primo = false;
}
}
}
}
}
Return {eh_primo, resultado};
}
// --- Main ---
Int main() {
Vector<string> numeros = {
“11”, “13”, “15”, “17”, “19”, “21”, “23”, “25”, “27”, “29”,
“31”, “33”, “35”, “37”, “39”, “41”, “43”, “45”, “47”, “49”,
“51”, “53”, “55”, “57”, “59”, “61”, “63”, “65”, “67”, “69”,
“71”, “73”, “75”, “77”, “79”, “81”, “83”, “85”, “87”, “89”,
“91”, “93”, “95”, “97”, “99”,
“2199023255551”, “252097800623”, “252097800621”,
“1125899906842597”, “2251799813685119”, “9007199254740991”,
“147573952589676412927”, “590295810358705651711”,
“2361183241434822606847”,
“9444732965739290427391”
};
Double soma = 0.0;
Auto start_total = high_resolution_clock::now();
For (auto &s : numeros) {
Auto start = high_resolution_clock::now();
Auto res = mfp_test_heuristic_parallel(s);
Auto end = high_resolution_clock::now();
Double t = duration<double>(end – start).count();
Soma += t;
Cout << “Número: “ << s << “\n”;
If (res.first)
Cout << “MFP: Primo | Tempo: “ << t << “ s\n”;
Else if (res.second > 1)
Cout << “MFP: Composto (divisor = “ << res.second << “) | Tempo: “ << t << “ s\n”;
Else
Cout << “MFP: Indefinido (divisor inválido) | Tempo: “ << t << “ s\n”;
Cout << “--------------------------\n”;
}
Auto end_total = high_resolution_clock::now();
Double tempo_total = duration<double>(end_total – start_total).count();
Cout << fixed;
Cout << “\nTempo médio: “ << soma / numeros.size() << “ s\n”;
Cout << “Tempo total: “ << tempo_total << “ s\n”;
Return 0;
}
‘’’
# 2. Escrever o código no arquivo
With open(“mfp_parallel.cpp”, “w”) as f:
f.write(cpp_code)
# 3. Compilar com suporte a OpenMP
!g++ -O3 -fopenmp -std=c++17 mfp_parallel.cpp -o mfp_parallel
# 4. Executar
!./mfp_parallel
Número: 11
MFP: Primo | Tempo: 0.000129314 s
Número: 13
MFP: Primo | Tempo: 8.983e-06 s
Número: 15
MFP: Composto (divisor = 5) | Tempo: 1.34e-07 s
Número: 17
MFP: Primo | Tempo: 8.186e-06 s
Número: 19
MFP: Primo | Tempo: 7.613e-06 s
Número: 21
MFP: Composto (divisor = 3) | Tempo: 2.6e-06 s
Número: 23
MFP: Primo | Tempo: 7.908e-06 s
Número: 25
MFP: Composto (divisor = 5) | Tempo: 1.09e-07 s
Número: 27
MFP: Composto (divisor = 9) | Tempo: 2.587e-06 s
Número: 29
MFP: Primo | Tempo: 1.2191e-05 s
Número: 31
MFP: Primo | Tempo: 8.951e-06 s
Número: 33
MFP: Composto (divisor = 3) | Tempo: 2.553e-06 s
Número: 35
MFP: Composto (divisor = 5) | Tempo: 9.8e-08 s
Número: 37
MFP: Primo | Tempo: 4.577e-06 s
Número: 39
MFP: Composto (divisor = 3) | Tempo: 2.221e-06 s
Número: 41
MFP: Primo | Tempo: 5.718e-06 s
Número: 43
MFP: Primo | Tempo: 5.459e-06 s
Número: 45
MFP: Composto (divisor = 5) | Tempo: 9.1e-08 s
Número: 47
MFP: Primo | Tempo: 9.075e-06 s
Número: 49
MFP: Composto (divisor = 7) | Tempo: 2.397e-06 s
Número: 51
MFP: Composto (divisor = 3) | Tempo: 2.068e-06 s
Número: 53
MFP: Primo | Tempo: 5.44e-06 s
Número: 55
MFP: Composto (divisor = 5) | Tempo: 1.07e-07 s
Número: 57
MFP: Composto (divisor = 3) | Tempo: 3.717e-06 s
Número: 59
MFP: Primo | Tempo: 4.491e-06 s
Número: 61
MFP: Primo | Tempo: 5.676e-06 s
Número: 63
MFP: Composto (divisor = 9) | Tempo: 1.39e-06 s
Número: 65
MFP: Composto (divisor = 5) | Tempo: 9.4e-08 s
Número: 67
MFP: Primo | Tempo: 5.495e-06 s
Número: 69
MFP: Composto (divisor = 3) | Tempo: 2.177e-06 s
Número: 71
MFP: Primo | Tempo: 5.516e-06 s
Número: 73
MFP: Primo | Tempo: 5.422e-06 s
Número: 75
MFP: Composto (divisor = 5) | Tempo: 9.1e-08 s
Número: 77
MFP: Composto (divisor = 7) | Tempo: 2.432e-06 s
Número: 79
MFP: Primo | Tempo: 4.73e-06 s
Número: 81
MFP: Composto (divisor = 3) | Tempo: 2.12e-06 s
Número: 83
MFP: Primo | Tempo: 2.3373e-05 s
Número: 85
MFP: Composto (divisor = 5) | Tempo: 1.46e-07 s
Número: 87
MFP: Composto (divisor = 3) | Tempo: 3.964e-06 s
Número: 89
MFP: Primo | Tempo: 5.402e-06 s
Número: 91
MFP: Composto (divisor = 7) | Tempo: 3.083e-06 s
Número: 93
MFP: Composto (divisor = 3) | Tempo: 2.297e-06 s
Número: 95
MFP: Composto (divisor = 5) | Tempo: 1.1e-07 s
Número: 97
MFP: Primo | Tempo: 5.606e-06 s
Número: 99
MFP: Composto (divisor = 9) | Tempo: 2.473e-06 s
Número: 2199023255551
MFP: Composto (divisor = 13367) | Tempo: 0.0174069 s
Número: 252097800623
MFP: Primo | Tempo: 0.0366807 s
Número: 252097800621
MFP: Composto (divisor = 116211) | Tempo: 0.00169113 s
Número: 1125899906842597
MFP: Primo | Tempo: 1.54784 s
Número: 2251799813685119
MFP: Primo | Tempo: 2.17787 s
Número: 9007199254740991
MFP: Composto (divisor = 6361) | Tempo: 0.249789 s
Número: 147573952589676412927
MFP: Composto (divisor = 193707721) | Tempo: 3.01253 s
Número: 590295810358705651711
MFP: Composto (divisor = 178481) | Tempo: 1.41551 s
Número: 2361183241434822606847
MFP: Composto (divisor = 48544121) | Tempo: 1.60143 s
Número: 9444732965739290427391
MFP: Composto (divisor = 2298041) | Tempo: 1.46814 s
Tempo médio: 0.209622 s
Tempo total: 11.533310 s
Produtos pagos do Colab – Cancelar contratos
#include <iostream>
#include <vector>
#include <chrono>
#include <cmath>
#include <string>
Using namespace std;
Using namespace std::chrono;
Using BigInt = __int128;
Void print_bigint(BigInt n) {
If (n == 0) { cout << “0”; return; }
String s;
While (n > 0) {
S = char(‘0’ + (n % 10)) + s;
N /= 10;
}
Cout << s;
}
Bool mfp_test(BigInt n, BigInt &divisor) {
If (n == 5) return true;
If (n % 10 == 5) {
Divisor = 5;
Return false;
}
For (int k : {3, 7, 9, 11, 1}) {
BigInt nk = n * k;
BigInt A = nk / 10;
BigInt d = nk % 10;
BigInt L = sqrt((long double)nk);
While (A > 0 && d <= L) {
If (A < d) break;
If (d > 1 && A % d == 0) {
BigInt q = A / d;
If (q > 1 && n % d == 0) {
Divisor = d;
Return false;
}
}
A--;
D += 10;
}
}
Return true;
}
Int main() {
Int expoente = 67; // Mude este valor para testar outros 2^e – 1
BigInt potencia = (BigInt(1) << expoente) – 1;
Vector<BigInt> numeros = {
11, 13, 15, 17, 19, 21, 23, 25, 27, 29,
31, 33, 35, 37, 39, 41, 43, 45, 47, 49,
51, 53, 55, 57, 59, 61, 63, 65, 67, 69,
71, 73, 75, 77, 79, 81, 83, 85, 87, 89,
91, 93, 95, 97, 99,
2199023255551ULL, 252097800623ULL, 252097800621ULL,
1125899906842597ULL, 2251799813685119ULL, 9007199254740991ULL,
Potencia
};
Double soma_mfp = 0.0;
For (size_t I = 0; I < numeros.size(); ++i) {
BigInt n = numeros[i];
BigInt divisor = 0;
Auto start = high_resolution_clock::now();
Bool res = mfp_test(n, divisor);
Auto end = high_resolution_clock::now();
Double tempo = duration<double>(end – start).count();
Soma_mfp += tempo;
Cout << “Número: “; print_bigint(n); cout << endl;
If (res)
Cout << “MFP: Primo | Tempo: “ << tempo << “ s\n”;
Else {
Cout << “MFP: Composto (“; print_bigint(divisor); cout << “) | Tempo: “ << tempo << “
s\n”;
}
Cout << “--------------------------\n”;
}
Int total = numeros.size();
Cout << “\nResumo MFP:\n”;
Cout << “Tempo total: “ << soma_mfp << “ s | Média: “ << (soma_mfp / total) << “ s\n”;
Return 0;
}
#include <iostream>
#include <vector>
#include <chrono>
#include <cmath>
#include <string>
Using namespace std;
Using namespace std::chrono;
Using BigInt = __int128;
Void print_bigint(BigInt n) {
If (n == 0) { cout << “0”; return; }
String s;
While (n > 0) {
S = char(‘0’ + (n % 10)) + s;
N /= 10;
}
Cout << s;
}
Bool mfp_test(BigInt n, BigInt &divisor) {
If (n == 5) return true;
If (n % 10 == 5) {
Divisor = 5;
Return false;
}
For (int k : {3, 7, 9, 11, 1}) {
BigInt nk = n * k;
BigInt A = nk / 10;
BigInt d = nk % 10;
BigInt L = sqrt((long double)nk);
While (A > 0 && d <= L) {
If (A < d) break;
If (d > 1 && A % d == 0) {
BigInt q = A / d;
If (q > 1 && n % d == 0) {
Divisor = d;
Return false;
}
}
A--;
D += 10;
}
}
Return true;
}
Int main() {
Int expoente = 67; // Mude este valor para testar outros 2^e – 1
BigInt potencia = (BigInt(1) << expoente) – 1;
Vector<BigInt> numeros = {
11, 13, 15, 17, 19, 21, 23, 25, 27, 29,
31, 33, 35, 37, 39, 41, 43, 45, 47, 49,
51, 53, 55, 57, 59, 61, 63, 65, 67, 69,
71, 73, 75, 77, 79, 81, 83, 85, 87, 89,
91, 93, 95, 97, 99,
2199023255551ULL, 252097800623ULL, 252097800621ULL,
1125899906842597ULL, 2251799813685119ULL, 9007199254740991ULL,
Potencia
};
Double soma_mfp = 0.0;
For (size_t I = 0; I < numeros.size(); ++i) {
BigInt n = numeros[i];
BigInt divisor = 0;
Auto start = high_resolution_clock::now();
Bool res = mfp_test(n, divisor);
Auto end = high_resolution_clock::now();
Double tempo = duration<double>(end – start).count();
Soma_mfp += tempo;
Cout << “Número: “; print_bigint(n); cout << endl;
If (res)
Cout << “MFP: Primo | Tempo: “ << tempo << “ s\n”;
Else {
Cout << “MFP: Composto (“; print_bigint(divisor); cout << “) | Tempo: “ << tempo << “
s\n”;
}
Cout << “--------------------------\n”;
}
Int total = numeros.size();
Cout << “\nResumo MFP:\n”;
Cout << “Tempo total: “ << soma_mfp << “ s | Média: “ << (soma_mfp / total) << “ s\n”;
Return 0;
}
Número: 11
MFP: Primo | Tempo: 1.5154e-05 s
Número: 13
MFP: Primo | Tempo: 8.616e-06 s
Número: 15
MFP: Composto (5) | Tempo: 7.7e-08 s
Número: 17
MFP: Primo | Tempo: 3.693e-06 s
Número: 19
MFP: Primo | Tempo: 3.308e-06 s
Número: 21
MFP: Composto (3) | Tempo: 9.23e-07 s
Número: 23
MFP: Primo | Tempo: 3.077e-06 s
Número: 25
MFP: Composto (5) | Tempo: 0 s
Número: 27
MFP: Composto (9) | Tempo: 1.23e-06 s
Número: 29
MFP: Primo | Tempo: 3.154e-06 s
Número: 31
MFP: Primo | Tempo: 3.616e-06 s
Número: 33
MFP: Composto (11) | Tempo: 1.538e-06 s
Número: 35
MFP: Composto (5) | Tempo: 0 s
Número: 37
MFP: Primo | Tempo: 3.154e-06 s
Número: 39
MFP: Composto (3) | Tempo: 1.461e-06 s
Número: 41
MFP: Primo | Tempo: 3.384e-06 s
Número: 43
MFP: Primo | Tempo: 3.076e-06 s
Número: 45
MFP: Composto (5) | Tempo: 0 s
Número: 47
MFP: Primo | Tempo: 3.615e-06 s
Número: 49
MFP: Composto (7) | Tempo: 6.92e-07 s
Número: 51
MFP: Composto (3) | Tempo: 8.46e-07 s
Número: 53
MFP: Primo | Tempo: 3.385e-06 s
Número: 55
MFP: Composto (5) | Tempo: 0 s
Número: 57
MFP: Composto (19) | Tempo: 1.539e-06 s
Número: 59
MFP: Primo | Tempo: 3.385e-06 s
Número: 61
MFP: Primo | Tempo: 3.384e-06 s
Número: 63
MFP: Composto (9) | Tempo: 6.16e-07 s
Número: 65
MFP: Composto (5) | Tempo: 2.3e-07 s
Número: 67
MFP: Primo | Tempo: 3.384e-06 s
Número: 69
MFP: Composto (3) | Tempo: 1.308e-06 s
Número: 71
MFP: Primo | Tempo: 1.1307e-05 s
Número: 73
MFP: Primo | Tempo: 3.462e-06 s
Número: 75
MFP: Composto (5) | Tempo: 0 s
Número: 77
MFP: Composto (11) | Tempo: 6.93e-07 s
Número: 79
MFP: Primo | Tempo: 3.385e-06 s
Número: 81
MFP: Composto (3) | Tempo: 8.46e-07 s
Número: 83
MFP: Primo | Tempo: 3.385e-06 s
Número: 85
MFP: Composto (5) | Tempo: 2.3e-07 s
Número: 87
MFP: Composto (3) | Tempo: 2.077e-06 s
Número: 89
MFP: Primo | Tempo: 3.077e-06 s
Número: 91
MFP: Composto (13) | Tempo: 6.93e-07 s
Número: 93
MFP: Composto (3) | Tempo: 3e-06 s
Número: 95
MFP: Composto (5) | Tempo: 0 s
Número: 97
MFP: Primo | Tempo: 3.385e-06 s
Número: 99
MFP: Composto (3) | Tempo: 1.308e-06 s
Número: 2199023255551
MFP: Composto (13367) | Tempo: 0.00660254 s
Número: 252097800623
MFP: Primo | Tempo: 0.0186224 s
Número: 252097800621
MFP: Composto (3) | Tempo: 3.077e-06 s
Número: 1125899906842597
MFP: Primo | Tempo: 0.978907 s
Número: 2251799813685119
MFP: Primo | Tempo: 1.3193 s
Número: 9007199254740991
MFP: Composto (6361) | Tempo: 1.62497 s
Número: 147573952589676412927
MFP: Composto (193707721) | Tempo: 0.464435 s
Resumo MFP:
Tempo total: 4.41296 s | Média: 0.0848646 s
[Program finished]
5. Resultados
Sequencial: Tempo médio ~0.085s, total ~4.42s. Paralelo: Tempo médio ~0.209s, total
~11.53s. Todos os compostos e primos corretamente classificados, com divisores reais
identificados.
6. Conclusão
O M.F.P. Método de Fatoração por Padrão é determinístico, eficiente e preciso com
multiplicadores fixos. A versão sequencial é ideal para inteiros até 128 bits e a versão
paralela é adequada para grandes números criptográficos.
7. Referências
1. Riesel, H. (2008). Prime Numbers and Computer Methods for Factorization.
2. Apostol, T.M. (1976). Introduction to Analytic Number Theory.
3. Ribenboim, P. (1989). The Book of Prime Number Records.
4. Polegato, M.F. (2024). Redistribuição Decimal e Detecção de Primalidade.
5. Polegato, M.F. Método Modular 12. Núcleo do Conhecimento, 2024.
6. Polegato, M.F. Fermat’s Library (2022–2024):
https://fermatslibrary.com/p/18653452