Начну с цитаты

Но я сегодня 13-ки замучила :)
Там такие интересные горизонты открываются!
Целый день обдумываю и экспериментирую.

В названии темы термин КПППЧ присутствует, надеюсь, что читатели его не забыли :)
Это я использовала для сокращения - "симметричные кортежи из последовательных простых чисел".
Ну, и чтобы термин (как начало всего, что здесь делается) не забывали.

А ещё в названии темы присутствует термин "нулевой период".
Пожалуй, надо немного пояснить, что означает этот термин.

Пусть мы имеем симметричный кортеж из последовательных простых чисел
Х: 0, p1, p2, p3, ..., pn

Для конкретности рассмотрим формулу этого кортежа на заданном периоде 19#
Х = k*19# + A
или так
Х = k*9699690 + A

Число k в этой формуле будем называть номером периода, а число А - добавкой.

Приведу конкретный пример для симметричного кортежа длины 7 из последовательных простых чисел.
Семёрочки любезно предоставил gris, вот несколько самых первых

[1056281, 15730031, 30508411, 41724077, 45374591, 45940247, 59642081, 79328657, 89913091, 93921257, 96165197, 96544661, 103389037, 111156307, 126509777, 131652461, 139284407, 141559127, 146072321, 181140067, 183165481, 190783861, 202668077, 222271157, 247113631, 247844081, 264796247, 314348351, 330601861, 368783641, 371622071, 383651621, 392079901, 403681351, 428841521, 430756237, 449504317, 477647201, 490242287, 500780801, 576425461, 621555287, 628415237, 639276031, 653927311, 655395421, 658069897, 696764141, 747429181, 763179811, 814930111, 819605587, 829616497, 837269681, 894222941, 908375681, 909894611, 928269967, 928637747, 964567957]

(это начальные элементы кортежей)

Самая интересная семёрочка первая, вот она в развёрнутом виде

{1056281, 1056287, 1056311, 1056317, 1056323, 1056347, 1056353}

или в сокращённом виде

1056281: 0, 6, 30, 36, 42, 66, 72

Рассмотрим эту семёрку на периоде 19#.
Её формула на этом периоде будет такая
1056281 = 0*19# + 1056281
или так
1056281 = 0*9699690 + 1056281

То есть эта семёрка находится в нулевом периоде, а начальный элемент этого кортежа совпадает с добавкой А.
А следующие семёрки из приведённого списка в нулевом периоде не находятся (для периода 19#).

Такой вот интересный нулевой период.
Я столкнулась с нулевым периодом при работе с центральными 13-ми на периоде 47#.
Об этом и сказано в цитате.

Попробуйте искать центральные семёрки по паттерну на периоде 19#.
Вы всё очень хорошо поймёте.
Не забывайте, что при поиске по паттерну на заданном периоде мы задаём номера периодов.
Так вот, задайте номера периодов так:
начльный период - 0
конечный период - 0
То есть поиск будет выполнен только в нулевом периоде.
И будет найдена только одна семёрка, та самая

1056281: 0, 6, 30, 36, 42, 66, 72

Кажется, я очень подробно рассказала о нулевом периоде и о том, что в нём можно искать.

А теперь о центральных 13-х на периоде
47# = 614889782588491410.

Вот эти 27 центральных 13-к находятся в нулевом периоде (при периоде 47#)

{2479672831189511,14532269076393311,18243592974347137,19841272539468077,28522877055638377,30490730621120881,31253201754308491,38282996618836381,49709746203086381,80367014131763771,83438316647980691,85836761919895097,94424620755941587,112152555556206731,127300190958286457,141573325723293161,190482508374758557,209626115330591917,324871384687349611,359200217773681241,377360542797737911,471562489911768821,507060265610887231,508915645637755207,513703914377659417,565872074218044991,591077243357392357}

(это начальные элементы кортежей)

Работая с центральными 13-ми на периодде 47#, я с удивлением обнаружила, что для всех кортежей, приведённых в списке, формула имеет вид
X = 0*614889782588491410 + X

Очень удивилась, спросила у gris, он подтвердил этот факт.
Так я познакомилась с нулевым периодом.

Кстати, функция в PARI/GP для нахождения формулы по заданному первому элементу кортежа x на заданном периоде
x=2479672831189511; print(x\614889782588491410," ",x%614889782588491410);

Выполнив этот скрипт, вы получите
0 2479672831189511
Это и есть формула для кортежа с начальным элементом х на заданном периоде 47#: k = 0, A = 2479672831189511.

Скриптом поделился gris.

А дальше, понятное дело, реализация этого уникального алгоритма.
Ничего похожего у меня ещё не было.
Может, у кого-то и было, но на форуме dxdy.ru я не видела ничего подобного.
Реализация оказалась очень сложной.
Активно помогал gris, спасибо ему!

Сейчас у меня работают программы поиска в нулевом периоде для центральных 13-к (на периодах 53# и 59#) и для центральных 15-к (на периоде 53#).

Программы вечные :)
Ну, точно по-петуховски, он сейчас мигом посчитал бы время и выдал вердикт: тысяча лет.

А и отлично: ничего не надо перезапускать!
Вот прямо один раз запустила программу и - собирай результаты до конца жизни :)
А потом corporal может собирать :)

Кстати, приближения тоже выдаются, а как же без них :)

Распараллеливание этой программы возможно ли в принципе?
Как мне кажется, структура программы не очень удобная для распараллеливания.
Но я не специалист по распараллеливанию.

Искусственное распараллеливание, конечно, возможно.
Я уже распараллелила программу для центральных 13-к на два потока, на периоде 53#.
На периоде 59# пока работает один поток.
Не хватает ресурсов.
Надо какую-то из прежних программ остановить.

Интересный приём я использовала в этой программе, он у меня всплыл из подсознания, из прошлой (программистской) жизни (как давно всплыло понятие процедуры).
Приём заключается в периодическом сбрасывании результатов из программы в выходные файлы.
Всё отлично получилось!
Теперь только смотрю, как появятся новые выходные файлы, забираю из них результаты и проверяю их своей утилитой.
А в выходных файлах что?
А в выходных файлах добавки, являющиеся Norm-числами!

Так что, программа результатами не переполнится, они из неё периодически выводятся.
Ну, и пусть себе работает тысячу лет! :)
Как верно заметил г. Петухов, меня тысяча лет не пугает.
У меня впереди вечность!

Господа!

Если кто-то хорошо разбирается в распараллеливании, напишите мне, пожалуйста.
Можем попробовать.
Адрес не изменился
natalimak1@yandex.ru

А если кто-то имеет доступ к кластеру... ну, дальше понятно :)

Эх, где же мой ВЦ? :(

Покажу приближения, полученные от результатов недавно появившегося выходного файла для центральных 15-к

24039239169810208723: [0, 18, 54, 70, 78, 96, 108, 114, 130, 144, 150, 168, 184, 210, 228]
24039239169810208723: [0, 0, 24, 10, 0, 12, 0, 0, 10, 0, 0, 0, -14, 0, 0]
24039239169810208723: [1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1]
valids=10
code=4829

20612161725108858283: [0, 18, 40, 60, 70, 84, 96, 114, 120, 144, 166, 168, 178, 210, 228]
20612161725108858283: [0, 0, 10, 0, -8, 0, -12, 0, 0, 0, 16, 0, -20, 0, 0]
20612161725108858283: [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1]
valids=10
code=5493

12736452752468889823: [0, 36, 46, 60, 78, 84, 108, 114, 120, 144, 168, 196, 198, 214, 228]
12736452752468889823: [0, 18, 16, 0, 0, 0, 0, 0, 0, 0, 18, 28, 0, 4, 0]
12736452752468889823: [1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1]
valids=10
code=2034

11027760156286167673: [0, 18, 58, 60, 78, 84, 100, 108, 120, 130, 136, 168, 198, 210, 228]
11027760156286167673: [0, 0, 28, 0, 0, 0, -8, -6, 0, -14, -14, 0, 0, 0, 0]
11027760156286167673: [1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1]
valids=10
code=5927

При проверкой утилитой вывод делался при valids>9.

Скажу вам по секрету: все центральные 15-ки, которые сидят в нулевом периоде (для периода 53#), то есть все с начальными элементами до 32589158477190044730, найдутся этой программой, хоть за тысячу лет, но с гарантией :)

И точно так же для центральных 13-к для периода 53#.

А центральные 13-ки для периода 59# найдутся все в интервале (32589158477190044730, 1922760350154212639070 ).
Хоть за миллион лет, но с гарантией!

Тэк-с, пойду проведаю Ахиллеса-3, может, новые выходные файлы появились.

Да, появился один новый выходной файл, это параллельный поиск центральной 13-ки на периоде 53#.

Вот нашлось одно приближение при valids>9

25563993144943627771: [0, 12, 42, 48, 52, 90, 96, 102, 126, 132, 166, 180, 192]
25563993144943627771: [0, 0, 0, -12, -14, 0, 0, 0, 0, 0, 16, 0, 0]
25563993144943627771: [1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1]
valids=10
code=1661

Каждый выходной файл содержит ровно 10000 Norm-чисел.
Каждое Norm-число начинает приближение к центральной 13-ке.
То есть каждый выходной файл содержит 10000 приближений, но большинство из них с низкими valids, вот в примере только одно приближение с valids=10.

А это приближения к центральной 13-ке при поиске в нулевом периоде для периода #59 (c valids>9)

904284451142839040671: [0, 40, 42, 48, 66, 90, 96, 102, 108, 132, 150, 180, 192]
904284451142839040671: [0, 28, 0, -12, 0, 0, 0, 0, -18, 0, 0, 0, 0]
904284451142839040671: [1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1]
valids=10
code=759

440064532198206409891: [0, 12, 42, 48, 60, 90, 96, 102, 126, 132, 150, 166, 192]
440064532198206409891: [0, 0, 0, -12, -6, 0, 0, 0, 0, 0, 0, -14, 0]
440064532198206409891: [1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1]
valids=10
code=1662

Обратите внимание на начальные элементы приближений.

А знаете ли вы, сколько этих самых добавок А программа должна сгенерировать и проверить?

Вот это для периода 53# для центральных 13-к

0 from number
0 to   number
[0,12,42,60,66,90,96,102,126,132,150,180,192]
patterns length 13
32589158477190044730 period
search in 0 (0.E-19) - 32589158477190044730 (3.3 E19)
central 3: [90,96,102]
prove by 53#: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53]
145544026521600 formulae expected

Количество добавок А = количество формул = 145544026521600.

Впечатляет? :)
На тысячу лет хватит программе работы? :)
Ну, г. Петухов точно вычислит :)

И вот среди этих 145544026521600 добавок есть такие, которые
а) начинают приближения;
б) начинают точные центральные 13-ки;
в) ничего не начинают.

Следует отметить, что программа генерирует все добавки, но проверяет на Norm-числа не все, есть фильтр.

А ещё проблемка: добавки генерируются программой не по порядку, а вразнобой.
Это сильно усложнило реализацию алгоритма.
Решить эту проблемку нам с gris не удалось.
Может, кто-нибудь знает решение?

Думаю над реализацией алгоритма для ключевой 17-ки.

Придётся искать в нулевом периоде для периода
61# = 117288381359406970983270

Ну, программу-то написать несложно, только вот как она работать будет.
Надо попробовать.

Г. Петухов уверяет же, что для 17-к поиск идёт быстрее, чем для 13-к и 15-к :)
Авось и правда :)

Пойду подкреплюсь и буду писать программу.

Ещё один выходной файл появился. для центральных 13-к на периоде 53#.

Найдены приближения с valids>9

31784040868408963531: [0, 12, 28, 40, 66, 70, 96, 102, 126, 132, 150, 180, 192]
31784040868408963531: [0, 0, -14, -20, 0, -20, 0, 0, 0, 0, 0, 0, 0]
31784040868408963531: [1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1]
valids=10
code=1215

22743302799603490501: [0, 12, 40, 60, 66, 90, 96, 102, 126, 132, 138, 190, 192]
22743302799603490501: [0, 0, -2, 0, 0, 0, 0, 0, 0, 0, -12, 10, 0]
22743302799603490501: [1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1]
valids=10
code=1532

14531949778158717301: [0, 12, 42, 60, 70, 88, 90, 102, 126, 132, 150, 180, 192]
14531949778158717301: [0, 0, 0, 0, 4, -2, -6, 0, 0, 0, 0, 0, 0]
14531949778158717301: [1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1]
valids=10
code=1823

10821053637785655661: [0, 12, 42, 48, 66, 90, 96, 102, 112, 132, 166, 180, 192]
10821053637785655661: [0, 0, 0, -12, 0, 0, 0, 0, -14, 0, 16, 0, 0]
10821053637785655661: [1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1]
valids=10
code=1781

С утра уже появилось шесть выходных файлов, этот 60000 приближений к центральной 13-ке и к центральной 15-ке (вместе).
С высоким valids, увы, приближений мало.

Появился новый выходной файл для центральных 15-к.

Найдены следующие приближения с valids>9

14438080081341631093: [0, 18, 30, 64, 78, 84, 108, 114, 120, 144, 150, 178, 198, 220, 228]
14438080081341631093: [0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 10, 0, 10, 0]
14438080081341631093: [1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1]
valids=12
code=7162

27863735852928529933: [0, 30, 46, 64, 96, 100, 108, 114, 120, 144, 150, 168, 198, 210, 228]
27863735852928529933: [0, 12, 16, 4, 18, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0]
27863735852928529933: [1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
valids=10
code=255

23929863701054795863: [0, 18, 30, 36, 78, 84, 106, 114, 136, 144, 156, 168, 190, 210, 228]
23929863701054795863: [0, 0, 0, -24, 0, 0, -2, 0, 16, 0, 6, 0, -8, 0, 0]
23929863701054795863: [1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1]
valids=10
code=6997

29811301122207349123: [0, 18, 30, 70, 78, 84, 108, 114, 120, 144, 178, 190, 198, 208, 228]
29811301122207349123: [0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 28, 22, 0, -2, 0]
29811301122207349123: [1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1]
valids=11
code=7154

O!
Есть с valids=12 !

Это для центральных 13-ок на периоде 59#

650364020716863987931: [0, 12, 52, 60, 66, 90, 96, 102, 126, 132, 166, 178, 192]
650364020716863987931: [0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 16, -2, 0]
650364020716863987931: [1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1]
valids=10
code=1532

1573424863765654303801: [0, 12, 40, 60, 66, 90, 96, 102, 126, 132, 148, 180, 192]
1573424863765654303801: [0, 0, -2, 0, 0, 0, 0, 0, 0, 0, -2, 0, 0]
1573424863765654303801: [1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]
valids=11
code=1533

1202741380509091097071: [0, 36, 42, 60, 66, 88, 96, 102, 126, 132, 150, 190, 192]
1202741380509091097071: [0, 24, 0, 0, 0, -2, 0, 0, 0, 0, 0, 10, 0]
1202741380509091097071: [1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1]
valids=10
code=958

Приближение с valids=11 близко.
Кстати, приближение с таким кодом, кажется, уже было (в другом алгоритме найдено).
"Дырки" симметрично расположены, с центральной семёркой, я его запомнила.
Вот оно

2846936057467248137235241: [0, 12, 18, 60, 66, 90, 96, 102, 126, 132, 166, 180, 192]
2846936057467248137235241: [0, 0, -24, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0]
2846936057467248137235241: [1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1]
valids=11
code=1533

PS. Для приближения, найденного в нулевом периоде, центральная семёрочка в нём

1573424863765654303861: 0, 6, 30, 36, 42, 66, 72

Красавица!
И находится она тоже в нулевом периоде (для периода 59#).

А вот центральная семёрочка из второго приближения находится аж в 1480-м периоде (для периода 59#)

2846936057467248137235241 = 1480*1922760350154212639070 + 1250739239013431411641

Поиск ключевой 17-ки в нулевом периоде запустила.
Пришлось считать на периоде 67#.

0 from number
0 to В  number
[0,6,24,36,66,84,90,114,120,126,150,156,174,204,216,234,240]
patterns length 17
7858321551080267055879090 period
search in 0 (0.E-19) - 7858321551080267055879090 (7.9 E24)
central 3: [114,120,126]
prove by 67#: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]
1999660772229120000 formulae expected
4368136789615248685995787,
2252967627500859663884317,
3056437290290587589245687,
3846159705217848632113327,
6769506872014858975012837,
6127723955908805344624357,
5519348263346011085941777,
1550350765394064900466027,
5723776147291540020102247,
3722293250610825264604057,

Как я и предполагала, здесь Norm-числа находятся в час по чайной ложке.
Но всё-таки находятся!
Тем более что программа эта не требует абсолютно никакого участия.
Запустил и забыл, можно вспомнить через год или через три года.
10000 Norm-чисел наберётся очень не скоро, так что, и выходной файл долго-долго не появится.

Проверила найденные Norm-числа, вот самое лучшее приближение

5723776147291540020102247: [0, 6, 36, 64, 66, 70, 90, 100, 120, 126, 142, 156, 174, 190, 210, 234, 240]
5723776147291540020102247: [0, 0, 12, 28, 0, -14, 0, -14, 0, 0, -8, 0, 0, -14, -6, 0, 0]
5723776147291540020102247: [1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1]
valids=10
code=19161

Неплохо для заоблачных высот.

Жаль, что добавочки не в порядке возрастания генерируются.
Всё было бы гораздо проще!
А вот мне что-то кажется (перекрестилась, всё равно кажется :) ), что г. Петухов знает про сортировку добавочек.

А мне мысль пришла: запустить генерацию, набирать добавки в вектор; набранный вектор отсортировать и вывести в выходной файл.
Можно даже и отфильтровать добавки по фильтру.
И пусть себе генерируются добавки и выводятся в выходные файлы отсортированные и отфильтрованные.
Потом просто собирать добавки из этих файлов и проверять их.

Надо завтра попробовать реализовать эту идею для центральных 13-к.

PS. Идея плохая.
Осенила другая идея: к чёрту Norm-числа!
Надо проверять генерируемые добавки сразу на точный кортеж.
И никаких выходных файлов не надо будет.
Потому что точных кортежей о-ч-е-н-ь мало, и они все в один вектор уместятся.

По большому счёту приближения нам не нужны, просто - посмотреть, что вообще находится.
Ну, посмотрели, хватит.

Сейчас опробую идею на центральных семёрках.

За ночь Ахиллес-3 много насчитал.

Самое интересное приближение для центральной 13-ки с valids=12

18776772943182748891: [0, 12, 42, 60, 66, 90, 96, 102, 126, 132, 150, 166, 192]
18776772943182748891: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -14, 0]
18776772943182748891: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1]
valids=12
code=2046

Ну вот, совсем близко к точной центральной 13-ке.

Norm-числа для ключевой 17-ке находятся, хотя и медленно.

А это приближения к центральной 13-ке на периоде 59#

1125730137986033904721: [0, 12, 46, 60, 70, 90, 96, 102, 126, 132, 166, 180, 192]
1125730137986033904721: [0, 0, 4, 0, 4, 0, 0, 0, 0, 0, 16, 0, 0]
1125730137986033904721: [1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1]
valids=10
code=1405

1777111010462860677001: [0, 12, 48, 60, 66, 90, 96, 112, 126, 132, 150, 166, 192]
1777111010462860677001: [0, 0, 6, 0, 0, 0, 0, 10, 0, 0, 0, -14, 0]
1777111010462860677001: [1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1]
valids=10
code=1518

Обратите внимание на начальные элементы приближений.

А это приближения к центральной 15-ке с valids>9

20932093081614719383: [0, 18, 36, 60, 78, 96, 108, 114, 120, 156, 166, 168, 196, 210, 228]
20932093081614719383: [0, 0, 6, 0, 0, 12, 0, 0, 0, 12, 16, 0, -2, 0, 0]
20932093081614719383: [1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1]
valids=10
code=5861

22727717231260245583: [0, 18, 54, 60, 78, 106, 108, 114, 120, 144, 150, 168, 198, 208, 228]
22727717231260245583: [0, 0, 24, 0, 0, 22, 0, 0, 0, 0, 0, 0, 0, -2, 0]
22727717231260245583: [1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1]
valids=12
code=5886

13001938337108174833: [0, 18, 60, 64, 78, 84, 88, 114, 136, 144, 150, 168, 198, 210, 228]
13001938337108174833: [0, 0, 30, 4, 0, 0, -20, 0, 16, 0, 0, 0, 0, 0, 0]
13001938337108174833: [1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1]
valids=11
code=4959

12237924085885232113: [0, 10, 30, 58, 78, 100, 108, 114, 120, 144, 150, 178, 184, 210, 228]
12237924085885232113: [0, -8, 0, -2, 0, 16, 0, 0, 0, 0, 0, 10, -14, 0, 0]
12237924085885232113: [1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1]
valids=10
code=2809

11249948418831526783: [0, 18, 58, 60, 78, 84, 88, 108, 120, 144, 168, 184, 198, 210, 228]
11249948418831526783: [0, 0, 28, 0, 0, 0, -20, -6, 0, 0, 18, 16, 0, 0, 0]
11249948418831526783: [1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1]
valids=10
code=5939

Самое лучшее пока с valids=12.

Цитата

PS. Идея плохая.
Осенила другая идея: к чёрту Norm-числа!
Надо проверять генерируемые добавки сразу на точный кортеж.
И никаких выходных файлов не надо будет.
Потому что точных кортежей о-ч-е-н-ь мало, и они все в один вектор уместятся.

По большому счёту приближения нам не нужны, просто - посмотреть, что вообще находится.
Ну, посмотрели, хватит.

Сейчас опробую идею на центральных семёрках.

Да, на семёрках всё прекрасно получилось.
Сейчас откорректирую программу для центральных 13-к и запущу её.

Запустила новую версию программы для центральных 13-к на периоде 53#.

Тут плохо то, что программа молчит (ничего не выводит) и будет молчать, пока не найдётся центральная 13-ка.
А она точно найдётся и не одна!
Ну ладно, будем ждать.

Начала опять с самого начала, потому что неизвестно, сколько добавок было сгенерировано и проверено прежней программой.
Кстати, пока не остановила её, пусть покрутится, посмотрим ещё на приближения, как часто будут появляться приближения с valids=12.

Теперь откорректирую программу для центральных 13-к на периоде 59# и тоже запущу.

А вот теперь программа хороша для распараллеливания!
Я её сейчас опубликую.

Программа поиска центральных 13-к в нулевом периоде для периода 53#

\l 13porc_53_res.txt;
default(timer,1);

{
\\enter pattern
pt=[0, 12, 42, 60, 66, 90, 96, 102, 126, 132, 150, 180, 192];

w=53;

fs=10013230717641471277;
\\fe=32589158477190044730;

np1=0; print(np1," from number");
np2=0; print(np2," to   number");
central=3;
\\ end of data

pl=#pt; 
nw=primepi(w);
printf("%d \n",pt);
print("patterns length ",pl);
prs=primes(nw);
period=vecprod(prs);
print(period," period");
vp=vector(np2-np1+1, i, period*(np1-1+i)); lvp=#vp;
printf("search in %d (%.1E) - %d (%.1E)\n",
        vp[1],vp[1],vp[lvp]+period,vp[lvp]+period);
cp=vector(central,i,pt[pl\2-central\2+i]);
printf("central %d: %d\n", central,cp);
printf("prove by %d#: ",prs[nw]);print(prs); 

vmy=vector(40); pat1=vector(13);

lpr=1;
wd=vector(nw);

for( ip=1,nw, 
  rip=[];
  for( r=1,prs[ip]-1,  
    for( i=1,pl, if( (r+pt[i])%prs[ip]==0,  next(2))); 
  rip =concat(rip,r)  );
  lpr=lpr*#rip;
  wd[ip]=rip;
); \\for ip
print(lpr," formulae expected");

k=0;
forvec(v=vector(#wd,i,[1,#wd[i]]), k++; 
  form=lift(chinese(  vector( #wd,j,Mod( wd[j][v[j]], prs[j]) )  ));
  
  \\ начало проверки кортежа
  if (form<fs, next);
  foreach(vp,bpp, 
  bpt=form+bpp; 
  
if(ispseudoprime(bpt) && ispseudoprime(bpt+192),
l=0; 
forprime(p=bpt,bpt+192, l++; vmy[l]=p; );
if(l==13, 
for(m=2,13, pat1[m]=vmy[m]-vmy[1]; );
if(pat1==pt, print(vmy[1],": ",pat1);  print("number form =",k); print(); );
   ); \\ if l==13
     ); \\ if ispseudoprime

 );\\ foreach

   \\ конец проверки кортежа

);\\ forvec
}

По-моему, в этой программе ничто не мешает распараллеливанию.

Господа!
Ещё раз прошу помочь распараллелить программу, кто умеет.

Кстати, PARI/GP поддерживает многопоточность.
Помнится, в проекте г. Лецко была какая-то многопоточная программа, написанная г. Петуховым.
Я её пыталась покрутить, но ни черта в ней не поняла, слишком мудрёно.
Но есть же документация, можно почитать.
К сожалению, я не читаю по-английски.

Предложила gris попробовать, но он отправился путешествовать :)

У меня на Ахиллесе 8 потоков.
Очень хорошо для распараллеливания.
Остановила бы работающие там программы и запустила бы многопоточную программу.
Конечно, не кластер, но и не один поток.