Are there any large numbers found that seemed eerily close to disproving Goldbach's conjecture?

Question

This question is about any numbers that seemed unusually close to disproving Goldbach's conjecture. Meaning any large numbers (say above 100) that had very few sets of primes which satisfied the conjecture. I imagine the number of sets increases as the numbers get larger. Has there ever been found a number that suddenly shot down to only a few solutions out of nowhere?

Answer 1

Maybe what you are looking for is continaed in OEIS A002375 or OEIS A045917. For example, the former has a list of the first 20000 even numbers and how many (unordered) decompositions into odd primes it has, like 2·15 has 3 different decompositions:

1 0
2 0
3 1
4 1
5 2
6 1
7 2
8 2
9 2
10 2
11 3
12 3
13 3
14 2
15 3
...

So you can run scripts on this to find entries with small number of representations. There are also nice plots that go up to 200^th resp. to 20000^th.

Using a small Python script, we can use that data to find the largest even $n\leqslant 40000$ that has a specific number of representations. The 1^st column contains the number of unordered representations as sum of two odd primes, and the 2^nd column lists the largest even $n\leqslant 40000$ with that number of representations. The number of representations up to 20:

0 4
1 12
2 68
3 128
4 152
5 188
6 332
7 398
8 368
9 488
10 632
11 692
12 626
13 992
14 878
15 908
16 1112
17 998
18 1412
19 1202
20 1448

For example, 128 is the largest number amongst them that has just 3 representations, all larger numbers have at least 4 representations. Here is the Python3 script for reference. It mostly deals with retrieving the data from the URL from above.

#!/usr/bin/env python3

from urllib.request import urlopen
import re

URL = "https://oeis.org/A002375/b002375.txt"

line_pat = re.compile (r'\s*(\d+)\s+(\d+)\s*')

count_to_n = {}

with urlopen (URL) as data:
    for line in data:
        match = line_pat.match (line.decode ("ascii"))
        if match:
            n = 2 * int(match.group(1))
            count = int(match.group(2))
            if count <= 20:
                count_to_n[count] = n

for c in sorted(count_to_n):
    print (c, count_to_n[c])