The Goldbach Conjecture

It was 1742 when Christian Goldbach wrote to Leonard Euler about his conjecture:

Goldbach would have liked Euler to demonstrate it, but Euler only simplified the conjecture and gave it the form we know nowadays:

The Goldbach's Conjecture has been checked by vector computers for all the even integers up to very high values. It is still valid and is still (1998, May) not demonstrated by mathematical means.

If we forget the case 2 + 2 = 4 (which, I think, is a mere coincidence for GC), the Goldbach Conjecture can be expressed in this way:

GC
Every even natural n >= 6 can be written as the sum of 2 odd primes.

 

The eXtended Goldbach Conjecture

The charm of GC basically depends on three unique factors: the reference to prime numbers, its clear structure, and the well known objects. We can put GC in a way where all its objects are explicitly defined, including prime numbers.

GC (Verbose)
Every natural of the form 2 k >= 2 3 can be written as the sum of 2 numbers taken from the set obtained applying the Eratosthenes' sieve to the set of natural numbers of the form 1 + 2 k, with k ranging from 1 to infinity.

In this way, definition in spite of charm, the structure of GC is completely visible.
Besides, in this way a generalization is a quite natural thing.

XGC (Verbose)
Every natural of the form m k >= m (c + m) can be written as the sum of m numbers taken from the set obtained applying the extended Eratosthenes' sieve to the set of natural numbers of the form c + m k, with k ranging from 1 to infinity, and with c relatively prime to m and such that 0 < c < m.

 

Using Euclid(c, m), we can compress again the two conjectures:

GC (Euclidean form)
Every natural of the form 2 k >= 6 can be written as the sum of 2 numbers taken from the Euclid(1, 2) set.
XGC
Every natural of the form m k >= m (c + m) can be written as the sum of m numbers taken from the Euclid(c, m) set.

 

Sequence Algebra Formulation

To test XGC sistematically, we need a variation of a powerful Huen Yeong Kong's idea: the sequence algebra formulation of the Goldbach Conjecture. A symbolic computer system like Mathematica can do all the tedious stuff, and all in a clear, simple, elegant and fast way. (Thanks, Huen!)

  1. we represent the set of primes as a polynomial in z with prime exponents
  2. we square it to get a polynomial with all the combinations of the exponents
  3. we reset all the coefficients to 1
  4. we revert the polynomial to the set form

 

Here is the formulation of XGC as a Mathematica function:

XGC[ c, m, base ] 
pXGC[ c_Integer, m_Integer, base_List ] := PolyToSet[ Expand[ SetToPoly[ base ]^m ] ]

XGC[ c_Integer, m_Integer, base_List ] := 
  pXGC[ c, m, base ]  /; IsCoprime[ c, m ] && 0 < c < m && IsCongruent[ base, c, m ]

It gives the try of XGC(c, m) using the base set.

XGC[ c, m, t ] 
XGC[ c_Integer, m_Integer, t_Integer ] := pXGC[ c, m, Euclid[ c, m, t ] ]

It directly gives the try of XGC(c, m) using Euclid[ c, m, t ].

 

Properties

As you can see in the example above, there is a strong reason for the existence of the composite terms in a Euclid base for XGC(c, m). Here is a set of useful functions for studying the XGC(c, m) behaviour.

MissingTerms[ c, m, base, try ] 
pMissingTerms[ c_Integer, m_Integer, {}, {} ] := {}
pMissingTerms[ c_Integer, m_Integer, base_List, try_List ] :=
  Complement[
    Range[ m Min[ base ], m Max[ base ], m ], 
    try 
  ]

MissingTerms[ c_Integer, m_Integer, base_List, try_List ] :=
  pMissingTerms[ c, m, base, try ]  /; IsCoprime[ c, m ] && 0 < c < m && IsCongruent[ base, c, m ] && IsCongruent[ try, 0, m ]

It gives the subset of the missing numbers in the try of XGC(c, m) using the base set.

With this function we can reformulate the Goldbach Conjecture and the eXtended one in this way.

GC
{
  oddPrimes = Euclid[ 1, 2, infinity ],
  evenNaturals = XGC[ 1, 2, oddPrimes ]
}
==> MissingTerms[ 1, 2, oddPrimes, evenNaturals ] == {}
XGC
{
  euclid = Euclid[ c, m, infinity ],
  xgc = XGC[ c, m, euclid ]
}
==> MissingTerms[ c, m, euclid, xgc ] == {}

 

MissingTerms[ c, m, t ] 
MissingTerms[ c_Integer, m_Integer, t_Integer ] :=
  Module[ { base, try },
    base = Euclid[ c, m, t ];
    try = pXGC[ c, m, base ];
    pMissingTerms[c, m, base, try ]
  ]

It directly gives the subset of the missing numbers in the try of XGC(c, m) using Euclid[ c, m, t ].

 

MissingRatio[ base, missing ] 
MissingRatio[ base_List, missing_List ] := N[ 100 Length[ missing ] / (Max[ base ] - Min[ base ] + 1) ]

It gives the percentual of missing numbers in the try of XGC using the base set.

MissingRatio[ c, m, t ] 
MissingRatio[ c_Integer, m_Integer, t_Integer ] :=
  Module[ { base, try, missing },
    base = Euclid[ c, m, t ];
    try = pXGC[ c, m, base ];
    missing = pMissingTerms[c, m, base, try ];
    MissingRatio[ base, missing ]
  ]

It directly gives the percentual of missing numbers in the try of XGC(c, m) using Euclid[ c, m, t ].

 

PlotMissingRatio[ c, m, start, stop, step ] 
PlotMissingRatio[ c_Integer, m_Integer, start_Integer, stop_Integer, step_Integer ] :=
  ListPlot[ Table[ {k, MissingRatio[ c, m, k ]}, {k, start, stop, step} ],
    PlotJoined -> True,
    PlotRange -> All,
    Axes -> False,
    Frame -> True,
    FrameTicks -> {Automatic, Range[ 1, 100, 2]},
    GridLines -> {Range[ start, stop, step ], Range[ 1, 100, 1 ]}
  ]

It plots MissingRatio[ c, m, k ] with k ranging from start to stop, by step.