|
![]()
|
|
Conjetura de Goldbach
Sistema de Descomposición de un Entero Par Dos Sumandos Primos José Enrique González Cornejo v.1.0/diciembre 2020 13 |
| Número Par a Descomponer: | |
|
|
|
|
|
|
|
|
|
| Nº Ingresado | |
| Sumandos Primos | |
| Verificación Suma de Primos |
| Nº | NºIngresado | Sumandos Primos |
|---|---|---|
|
|
Propuesta 3
(Simulador incorporado, abril 2026) |
| \(\require{cancel}\cancel{0}\) | \(\require{cancel}\cancel{1}\) | 2 | 3 | \(\require{cancel}\cancel{4}\) | 5 | \(\require{cancel}\cancel{6}\) | 7 | \(\require{cancel}\cancel{8}\) | \(\require{cancel}\cancel{9}\) | \(\require{cancel}\cancel{10}\) | 11 | \(\require{cancel}\cancel{12}\) | 13 | \(\require{cancel}\cancel{14}\) | \(\require{cancel}\cancel{15}\) | \(\require{cancel}\cancel{16}\) |
| false | false | true | true | false | true | false | true | false | false | false | true | false | true | false | false | false |
Desde ahí, se aplica la función goldbach(n), la cual obtiene la combinaciones de los dos primos cuya suma es \(n=16\)
| q=n-i | i | q | primes[i] | primes[q] | Resultado |
|---|---|---|---|---|---|
| 16-2=14 | 2 | 14 | true | false | (2,14) |
| 16-3=13 | 3 | 13 | true | true | (3,13) |
| 16-4=12 | 4 | 12 | false | false | (4,12) |
| 16-5=11 | 5 | 11 | true | true | (5,11) |
| 16-6=10 | 6 | 10 | false | false | (6,10) |
| 16-7=9 | 7 | 9 | true | false | (7,9) |
| 16-8=8 | 8 | 8 | false | false | (8,8) |
| 16-9=7 | 9 | 7 | false | true | (9,7) |
| 16-10=6 | 10 | 6 | false | false | (10,6) |
| 16-11=5 | 11 | 5 | true | true | (11,5) |
| 16-12=4 | 12 | 4 | false | false | (12,4) |
| 16-13=3 | 13 | 3 | true | true | (13,3) |
| 16-14=2 | 14 | 2 | false | true | (14,2) |
Breve Introducción
| Todo número par mayor que 2 puede escribirse como suma de dos números primos. |
| Christian Goldbach (1742) Carta dirigida a Leonard Euler |
La presentación del simulador y breve explicación de nuestro simple algoritmo computacional didáctico y conceptual9 acerca de la Conjetura de Goldbach, son un anexo que deriva desde un segmento del documento central realizado durante el año 2020: "Conceptos Matemáticos Básicos de Computación Cuántica".
Hasta hoy esta proposición de Goldbach sigue siendo una conjetura a demostrar. Según el matemático británico Godfrey Harold Hardy en 1921 dijo que "probablemente es una de conjeturas no resueltas más difíciles de la Teoría de Números".
Así mismo, oficial y públicamente durante los tres últimos siglos nadie ha sido capaz de demostrar la conjetura de Goldbach, que aparenta ser sencilla y que muchos audaces matemáticos se han aventurado a lograrlo. Existe una variante de la conjetura llamada débil que fue demostrada, pero no es la misma que se trata en este artículo1.
Igual se debe declarar que existen muchísimas demostraciones que están publicadas y múltiples de ellas disponibles en Internet2. No obstante, según mi entender son demostraciones de caracter heurístico. Porque formalmente en matemática, para que la conjetura se transforme en un teorema, se debe englobar el conjunto infinito de todos los números pares mayores que dos en forma genérica (i.e. demostrar que $\forall n\in \mathbb{N}|n>2 \land n \text{ es par}$, de modo que existen números primos $p$ y $q$ tales que su suma es $n$.
Quizás estamos con un problema a demostrar tan difícil como el Teorema de Fermat, pero en la Conjetura de Goldbach existen algunas pistas seductoras (que las voy a nombrar más adelante) que invitan a pensar erróneamente que su demostración no sería tan difícil. Hasta el momento, los resultados conocidos que se aproximan muy cerca de Goldbach son de los grandes matemáticos Ivan Vinogradov11 y Chen Jingrun12.
Sin embargo, introducirse en el desafío de comenzar a probar la Conjetura de Goldbach, nos puede llevar por unos laberintos inesperados del universo actual y futuro de las matemáticas, y pasar lo mismo o peor de lo que le sucedió al gran matemático Andrew J. Wiles, quien estuvo varios años de su vida dedicado para lograr demostrar el último teorema de Fermat.
La recompensa de Andrew J. Wiles no sólo fue el Premio Abel (considerado como el "Premio Nobel de las Matemáticas"), sino superar un anhelo que se había propuesto desde niño, y alcanzar la proeza que no había logrado ningún gran matemático por más de 350 años de búsqueda.
Bueno, todos los amantes de las matemáticas esperamos que en algún momento aparezca un científico como Andrew J. Wiles, que demuestre que no existe un número par que no pueda descomponerse como la suma de dos números primos.
Volviendo a la Conjetura de Golbach, las pistas más relevantes, -según mi parecer-, son por ejemplo:
De mi parte, por el momento sólo ofrezco el siguiente algoritmo computacional- que obviamente no es una demostración formal matemática-, sino sólo un desarrollo computacional que confirma la conjetura3, para cada vez que el usuario ingresa un número entero par.
El algoritmo opera sus tiempos de respuesta según la capacidad del ordenador sea clásico o cuántico.
En el este caso, - el simulador publicado con el que se comienza el presente artículo-, se limitó la magnitud de la entrada a un número par de hasta 15 dígitos. (Digamos hasta $99999999999998 = 67 + 99999999999931$, lo que toma unos segundos de ejecución). Obviamente, existen algoritmos y desarrollos computacionales más óptimos (Ver Simulador Miller-Rabin) que prueban heurísticamente esta conjetura de Goldbach.4
En esta propuesta, el usuario ingresa un número par mayor que $2$ o selecciona un número aleatorio presionando el botón
y ejecuta. El sistema opera el conjunto $U_f$ de funciones, toma el parámetro y devuelve los dos sumandos que primero encuentre5 que configuran la suma del número dado. (Ver simulador al inicio)
Algoritmos Propuestos y Javascript
(Nótese que en abril 2206, se incorporó en este artículo una tercera propuesta de un simulador significativamente más potente, basado en un núcleo matemático creado por Miller–Rabin, que mejora la búsqueda de primos, i.e. Goldbach optimizado ~ (Ver Simulador)
Entonces, sea $x\in\unicode{123}x\in Z|\text{x es par } \land x>2\unicode{125}$ y sean $y_1,y_2$ dos enteros primos, que asumimos como los sumandos de $x$, i.e. $x\longrightarrow U_f \longrightarrow x=y_1 + y_2$.5

Luego, el algoritmo $U_f$ lo conformaremos por las siguientes funciones en javascript:
|
<script language='javascript'> /*Conjunto de funciones para describir un algoritmo para la Conjetura de Goldbach ~ JEGC DocIRS 2021*/ function isEntero(x) { if (x === parseInt(x, 10)) return true else return false } function isPrimo(x) { if(isNaN(x) || !isFinite(x) || x%1 || x<2) {return false;} if (x%2==0) return (x==2); var m=Math.sqrt(x); for (var i=3;i<=m;i+=2) { if (x%i==0) return false; } return true; } function isPar(x) { if (x%2 == 0) {return true;} else {return false;} } function Goldbach(x) { if(isEntero(x)==false) { alert("Ingrese Número Entero") return } if(isPar(x)==false) { alert("Ingrese Número Par") return } if(x<4) { alert("Ingrese Número Par Mayor que 2") return } var auxiliar1=parseInt(x/2); var auxiliar2=parseInt(x/2); var vBool=false; do { if(isPrimo(auxiliar1)==false || isPrimo(auxiliar2)==false) { auxiliar1=auxiliar1-1; auxiliar2=auxiliar2+1; } else { var y1= auxiliar1; var y2= auxiliar2, vBool=true; break; } } while (vBool=true); var sMsg="x = " + eval(y1+y2) + " , donde " + " y1=" + y1 + " , y2=" + y2; return(sMsg) } </script> |
|
<script language='javascript'> /*Conjunto de funciones para describir un algoritmo para la Conjetura de Goldbach ~ Propuesta 2 Actualizada*/ // Conjetura de Goldbach ~ (versión optimizada) /** * Verifica si un número es entero. * @param {number} x * @returns {boolean} */ function isEntero(x) { return Number.isInteger(x); } /** * Verifica si un número es primo. * @param {number} x * @returns {boolean} */ function isPrimo(x) { if (x < 2 || !Number.isFinite(x)) return false; if (x === 2) return true; if (x % 2 === 0) return false; const sqrt = Math.sqrt(x); for (let i = 3; i <= sqrt; i += 2) { if (x % i === 0) return false; } return true; } /** * Verifica si un número es par. * @param {number} x * @returns {boolean} */ function isPar(x) { return x % 2 === 0; } ;/** * Implementación de la Conjetura de Goldbach para números pares mayores que 2. * @param {number} x * @returns {string|null} */ function goldbach(x) { if (!isEntero(x)) { alert("Ingrese un número entero."); return null; } if (!isPar(x)) { alert("Ingrese un número par."); return null; } if (x < 4) { alert("Ingrese un número par mayor que 2."); return null; } for (let i = 2; i <= x / 2; i++) { const j = x - i; if (isPrimo(i) && isPrimo(j)) { return `x = ${x}, y1 = ${i}, y2 = ${j}`; } } return "No se encontró una descomposición en primos (inesperado)."; } </script> |
|
Videos DocIRS |
|
Notas Complementarias Adjuntas
|
| DocIRS © 1988-2026 |