Вчера и сегодня скопировала окончание файлов логов первых 15 потоков на Ахиллесе-3

a1.txt
2 2.3.11^2 53^2: 3096561 / 3365396 (823325.36s)

a2.txt
2.3.11^2 47^2: 1596315 / 1682698 (825150.06s)

a3.txt
2.3.11^2 53^2: 3868320 / 5048094 (823338.34s)

a4.txt
2.3.11^2 53^2: 6108326 / 6730792 (823349.19s)
 
a5.txt
2.3.11^2 53^2: 7873633 / 8413491 (823337.20s)
 
а6.txt
 2.3.11^2 53^2: 8790070 / 10096189 (820935.88s)

а7.txt
 2.3.11^2 47^2: 10672544 / 11778887 (819805.34s)

а8.txt
 2.3.11^2 47^2: 12645408 / 13461586 (819777.59s)

а9.txt
 2.3.11^2 47^2: 13677743 / 15144284 (819775.95s)

а10.txt
 2.3.11^2 47^2: 16260717 / 16826983 (819158.27s)
 
а11.txt
2.3.11^2 61^2: 22233132 / 50480949 (857560.05s)

а12.txt
2.3.11^2 61^2: 58766876 / 84134917 (857515.28s)

а13.txt
2.3.11^2 61^2: 108841301 / 117788883 (857507.86s)

а14.txt
2.3.11^2 61^2: 118464576 / 151442850 (857498.31s)

а15.txt
2.3.11^2 61^2: 159804807 / 168269833 (856866.03s)

Вроде всё работает стабильно.

Это диапазоны от (7е54, 1е55) до (3е56, 5е56) включительно.

О трёх потоках, которые продолжают работать в поиске D(48,22)

Поток (3е51, 5е51)

. . . . . . . . 
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.53^2 3.47^2 2^3.41^2 5.31^2 2.3^5 11.29^2 2^2.7 3.43^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 2105130 / 3130659 (1993867.97s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.53^2 3.31^2 2^3.47^2 5.43^2 2.3^5 11.29^2 2^2.7 3.41^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 2369213 / 3130659 (1994466.76s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.43^2 3.41^2 2^3.31^2 5.47^2 2.3^5 11.29^2 2^2.7 3.53^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 2924687 / 3130659 (1995065.39s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.43^2 3.47^2 2^3.31^2 5.53^2 2.3^5 11.29^2 2^2.7 3.41^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 2925542 / 3130659 (1995663.95s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.53^2 3.43^2 2^3.47^2 5.41^2 2.3^5 11.31^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 3121896 / 3130660 (1996262.47s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.41^2 3.53^2 2^3.47^2 5.43^2 2.3^5 11.31^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 2135655 / 3130659 (1996861.05s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.41^2 3.29^2 2^3.43^2 5.53^2 2.3^5 11.31^2 2^2.7 3.47^2 2.5^2 59^2 2^5.3 37^2 2.13^2 3^2.5.7 2^2.17 19.23^2 2.3.11^2: 1942960 / 3130659 (1997459.59s)

Показываю окончание файла логов на данный момент.

Поток (5е51, 7е51)

. . . . . . . . . . . 
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.41^2 3.23^2 2^3.37^2 5.47^2 2.3^5 11.29^2 2^2.7 3.43^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 3321401 / 4382923 (1988484.01s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.29^2 3.43^2 2^3.47^2 5.23^2 2.3^5 11.37^2 2^2.7 3.41^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 4050921 / 4382923 (1989082.67s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.43^2 3.23^2 2^3.47^2 5.41^2 2.3^5 11.37^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 3599506 / 4382923 (1989681.29s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.23^2 3.29^2 2^3.41^2 5.43^2 2.3^5 11.37^2 2^2.7 3.47^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 3210193 / 4382923 (1990279.76s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.23^2 3.43^2 2^3.41^2 5.47^2 2.3^5 11.37^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 3322681 / 4382923 (1990878.37s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.43^2 3.23^2 2^3.37^2 5.29^2 2.3^5 11.41^2 2^2.7 3.47^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 4353334 / 4382924 (1991476.82s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.47^2 3.43^2 2^3.23^2 5.37^2 2.3^5 11.41^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.53^2 2.3.11^2: 4374692 / 4382923 (1992075.20s)

Поток (7е51, 9е51)

. . . . . . . . . 
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.29^2 3.53^2 2^3.23^2 5.37^2 2.3^5 11.41^2 2^2.7 3.47^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 4565078 / 5635188 (1980037.49s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.47^2 3.29^2 2^3.23^2 5.53^2 2.3^5 11.41^2 2^2.7 3.37^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 4400110 / 5635188 (1980636.11s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.37^2 3.53^2 2^3.41^2 5.23^2 2.3^5 11.47^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 5126525 / 5635188 (1981234.62s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.29^2 3.23^2 2^3.41^2 5.37^2 2.3^5 11.47^2 2^2.7 3.53^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 5128437 / 5635188 (1981833.24s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.23^2 3.37^2 2^3.53^2 5.41^2 2.3^5 11.47^2 2^2.7 3.29^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 4752592 / 5635188 (1982431.72s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.41^2 3.29^2 2^3.47^2 5.23^2 2.3^5 11.53^2 2^2.7 3.37^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 4867771 / 5635187 (1983030.27s)
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.23^2 3.37^2 2^3.41^2 5.29^2 2.3^5 11.53^2 2^2.7 3.47^2 2.5^2 59^2 2^5.3 31^2 2.13^2 3^2.5.7 2^2.17 19.43^2 2.3.11^2: 4998174 / 5635188 (1983628.74s)

Все три потока были перезапущены после зависания Ахиллеса-3.
Вроде пока всё стабильно работает.

Напомню: у меня есть ещё 11 потоков, в которых можно продолжать поиск меньшей D(48,22).
Приглашаю желающих попробовать.
Перезапуск очень простой.
Правда, с Виндой 7 могут быть проблемы.
Файлы логов (для перезапуска) пришлю.

Не знаю, можно ли делать перезапуск программы, работающей в прежней версии, новой версией программы.
Я делаю перезапуск в прежней версии программы.

Ура!
Поняла-таки, как добывать цепочку по логам.

Помог этот пост г. Петухова
https://dxdy.ru/post1711735.html#p1711735
с готовой программой

{v=[63, 3610, 3179, 12, 17797, 3362, 75, 392, 841, 18, 2209, 20, 1587, 242, 6727, 96, 14045, 338, 243, 68, 35131];
print("v=",v);
print("m= ",m=lcm(v));
n0=lift(chinese([Mod(-j+1, v[j]) | j<-[1..#v]]));
for(d=0,5,
   n=n0+m*d; print1("d=",d,": ",y=[((n+j-1)/v[j])%6 | j<-[1..#v]]);
   if(#select(t->(t%2==0||t==3),y)==0, print(" OK, n0=",n) , print);
);}

А вот и поиск по пучку лучей; ну, лучей всего два

11
12824771244445693247089415897279258062116487995920337
11
12880669995791265521073444618019437945564317283920337
10
12912612139417306820492889601299540736105934019920337
11
13008438570295430718751224551139849107730784227920337
10
13088293929360533967299837009340106084084826067920337
10
13112250537080064941864420746800183176991038619920337
10
13703180194161828981124152937482084802010948235920337
12
13775050017320421904817904149862316080729585891920337
10
13838934304572504503656794116422521661812819363920337
11
13910804127731097427350545328802752940531457019920337
10
14142384669019896848141521457583498171958178355920337
10
14198283420365469122125550178323678055406007643920337

Это для D(48,22).
Первое число - valids, второе - начальное число цепочки.
Программа выводит цепочки с valids>9.
Я бегу здесь по лучам с большим шагом: 10000.

В отличие от кортежей, здесь я не уверена, что на лучах может найтись решение.
Надо иметь аналитическое доказательство этого.
Если это удастся доказать, будет очень здорово.

P. S. Теперь г. Петухов не скажет. что я намеренно ничего не читаю.
Я как раз намеренно читаю, но только там, где мне постоянно не выливают помои на голову.
И не только читаю, но и пытаюсь разобраться.
И иногда даже получается.

А это два луча

Х = 578590111530182255110317987659657368491920337 + k*798553590651032485486124582002569763540418400
X = 2175697292832247226082567151664796895572757137 + k*798553590651032485486124582002569763540418400

Известная 22-ка получается так (по первому лучу)
578590111530182255110317987659657368491920337+115160118*798553590651032485486124582002569763540418400

или так (по второму лучу)
2175697292832247226082567151664796895572757137+115160116*798553590651032485486124582002569763540418400

Вот получила первое приближение для D(48,23)

5
63469501535636383892601819359498403469061644600994225937

Первое число это количество элементов цепочки подряд, начиная с первого, с 48 делителями.

Цепочка такая

63469501535636383892601819359498403469061644600994225937: [48, 48, 48, 48, 48, 24, 48, 96, 24, 192, 48, 192, 24, 24, 48, 48, 24, 48,
192, 192, 24, 768, 24]
valids = 10

И ещё немножко, пока все с низким valids

72859176190968036603658690211795000410760578431024493137: [48, 48, 48, 48, 192, 96, 48, 192, 96, 56, 24, 96, 48, 96, 96, 384, 96, 192, 192, 48, 96, 96, 12]
valids = 7
76543734400375526532991088478138137402526610545360493137: [48, 48, 48, 48, 96, 24, 192, 96, 192, 24, 24, 192, 192, 12, 96, 96, 48, 96, 96, 48, 192, 48, 48]
valids = 8
82545998580216760127548705008793892824597082215488493137: [48, 48, 48, 48, 192, 48, 64, 192, 48, 192, 24, 192, 24, 96, 12, 192, 96, 24, 192, 96, 48, 48, 24]
valids = 8

Но всё-таки теперь я вижу "живые" цепочки!
К чему и стремилась.

А вот и немножко побольше valids

84150564252055505741935394576394936353269386523344493137: [48, 48, 48, 48, 12, 96, 24, 96, 48, 48, 192, 96, 48, 12, 24, 48, 6, 192, 48, 96, 48, 24, 48]
valids = 11
88459120222733618965751505452360701383963536979624493137: [48, 48, 48, 48, 192, 24, 96, 384, 96, 28, 24, 12, 48, 48, 6, 96, 48, 768,
24, 48, 48, 48, 24]
valids = 10
83615714970945078828790255041600394440169465355186225937: [48, 48, 48, 48, 48, 384, 48, 96, 24, 96, 24, 48, 12, 192, 96, 96, 24, 24, 192, 24, 48, 192, 48]
valids = 9

Ну, до ласточек и журавлей ещё очень далеко :)

Замечу: это поиск по двум лучам; паттерн везде один и тот же, начальный элемент n0 разный в лучах, шаг m одинаковый.

Первоначальные программы Лецко - это поиск по одному лучу: фиксированные паттерн, n0 и m.

Прогресс: valids = 12

107951627660499387313655046816882887958366080691002225937: [48, 48, 48, 48, 96, 48, 12, 48, 48, 48, 48, 24, 256, 96, 48, 384,
96, 96, 384, 48, 96, 384, 48]
valids = 12

Замечательно!

Программа работает быстро.
Можно, наверное, оптимизировать, это к Ядряре, он оптимизирует запросто, но не покажет :)

Можно до бесконечности варьировать диапазон поиска (как вниз, так и вверх), а также шаг движения по лучам.
Сейчас у меня этот шаг равен 10000.

Таким образом, у этой программы неограниченные возможности.
И никакой мороки с паттернами!

Только вот доказать, что решение найдётся именно на этих двух лучах, пока никто не пытался.
Приглашаю!!

И ещё одно приближение с valids = 12

124026998557994968376306881188589638865990462738226225937: [48, 48, 48, 48, 48, 192, 96, 48, 24, 768, 24, 48, 48, 96, 24, 48, 48, 96,
384, 48, 48, 384, 12]
valids = 12

А вот и ещё прогресс

139389223214059729763136429875845675608858529269720493137: [48, 48, 48, 48, 48, 48, 96, 96, 48, 48, 192, 48, 384, 48, 6, 192, 12, 48,
1536, 48, 96, 48, 24]
valids = 13

У меня остались кое-какие вопросы по программке г. Петухова, которая находит m и n0 по заданному паттерну.
Но отвечать на них г. Петухов вряд ли будет.
Поэтому пока останусь с вопросами и буду искать приближения по двум лучам.

Сейчас программа работает на черепашке.
Если будут хорошие приближения, перенесу программу на Ахиллес.

Показываю окончание файла логов последнего потока на Ахиллесе

. . . . . . . . . . . 
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.59^2 3.23^2 2^3.47^2 5.29^2 2.3^5 11.61^2 2^2.7 3.41^2 2.5^2 43^2 2^5.3 53^2 2.13^2 3^2.5.7 2^2.17 19.37^2 2.3.11^2 31^2: 6122259 / 8413491 (836239.99s) [13897118951 1120916909 88006148 6697132 498353 41405 4796 809 153 28 4 3 0 0 0 0 0 0 0 0 0 0 0]
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.41^2 3.47^2 2^3.59^2 5.29^2 2.3^5 11.61^2 2^2.7 3.23^2 2.5^2 43^2 2^5.3 53^2 2.13^2 3^2.5.7 2^2.17 19.37^2 2.3.11^2 31^2: 7610389 / 8413491 (836804.35s) [13906436932 1121669666 88065396 6701625 498690 41424 4799 809 153 28 4 3 0 0 0 0 0 0 0 0 0 0 0]
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.47^2 3.23^2 2^3.59^2 5.41^2 2.3^5 11.61^2 2^2.7 3.29^2 2.5^2 43^2 2^5.3 53^2 2.13^2 3^2.5.7 2^2.17 19.37^2 2.3.11^2 31^2: 5646019 / 8413491 (837369.14s) [13915735652 1122420323 88124162 6706084 499068 41460 4802 810 153 28 4 3 0 0 0 0 0 0 0 0 0 0 0]
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.47^2 3.29^2 2^3.23^2 5.41^2 2.3^5 11.61^2 2^2.7 3.59^2 2.5^2 43^2 2^5.3 53^2 2.13^2 3^2.5.7 2^2.17 19.37^2 2.3.11^2 31^2: 6960228 / 8413491 (837933.80s) [13925011293 1123169610 88183331 6710505 499417 41487 4803 812 154 28 4 3 0 0 0 0 0 0 0 0 0 0 0]
305 b0: 3^2 2.19^2 17^2 2^2.3.5 7^2.13 2.23^2 3.59^2 2^3.29^2 5.41^2 2.3^5 11.61^2 2^2.7 3.47^2 2.5^2 43^2 2^5.3 53^2 2.13^2 3^2.5.7 2^2.17 19.37^2 2.3.11^2 31^2: 8329854 / 8413490 (838497.17s) [13934302970 1123918731 88242025 6714974 499736 41511 4808 812 154 28 4 3 0 0 0 0 0 0 0 0 0 0 0]

Как мне кажется, числа в наборах суммируются, то есть с каждым выводимым паттерном числа прибавляются к предыдущему итогу.

Это последний набор чисел

[13934302970 1123918731 88242025 6714974 499736 41511 4808 812 154 28 4 3 0 0 0 0 0 0 0 0 0 0 0]

Ну, и какие тут приближения?
Неудобоваримый вывод!

Читаю ответы Hugo на вопросы Евгения и понимаю только то, что я ничего не понимаю.

Цитата

If the last text in the log file does not end in a newline character (ASCII 0x0a), I assume this is a partial line written before a crash, and remove it.

Только от одного этого можно сойти с ума!
Я чудом осталась в своём уме!
П-о-м-у-ч-и-л-а-с-ь!
То программа не понимает первую строку файла журнала, когда она заканчивается символом начала новой строки!.
То она не понимает эту строку, когда она не заканчивается этим символом!!
То она просто удаляет эту строку и начинает считать чёрт знает что, вообще не соответствующее заданному в строке паттерну.
То она вообще отказывается считать, сообщая, что не могла распознать введённую строку.
Это было очень увлекательное шоу!
При этом на разных компьютерах по-разному.

О других деталях вообще молчу.
Всё настолько усложнено и запутано, что понять всё это я просто не в состоянии.

Я делала запуск трёх разных программ: для 19-ки, для 22-ки и для 23-ки.
Это стоило очень больших усилий, чтобы всё наконец запустилось и стало считаться, как положено.
При этом всё сначала тестировала на черепашке, а потом уже переносила на Ахиллесы.
Но!
То, что уже работало на черепашке, на Ахиллесах работать отказывалось!!!
И надо было начинать всё сначала.

Вообще говоря, программа считает неплохо.
Вот 22-ку довольно быстро нашла.
Однако запуск программы ну очень капризный.
То строка в файле журнала не такая, то ключ -х не такой, то ещё что-нибудь не такое.

Паттерн Лецо, получен факторизацией его журавля

13*61^2,2*17^2,3*37^2,2^2*7,5*47^2,2*3^2,31^2,2^3*11*59^2,3*53^2,2*5^2,7*43^2,2^2*3,29^2,2*13^2,3^2*5,2^5,19^2,2*3*7^2,11^2*17,2^2*5,3*67^2,2*41^2,23^2

Интересно, что для этого паттерна программа г. Петухова выдаёт только один луч

v=[48373, 578, 4107, 28, 11045, 18, 961, 306328, 8427, 50, 12943, 12, 841, 338,
45, 32, 361, 294, 2057, 20, 13467, 3362, 529]
m= 494025740801380594168851129558373415652261593824800
d=0: [1, 1, 5, 1, 1, 3, 1, 5, 1, 5, 5, 5, 1, 1, 5, 2, 5, 5, 5, 1, 5, 5, 5]
d=1: [1, 1, 5, 1, 1, 1, 1, 5, 1, 5, 5, 5, 1, 1, 3, 5, 5, 5, 5, 1, 5, 5, 5]
d=2: [1, 1, 5, 1, 1, 5, 1, 5, 1, 5, 5, 5, 1, 1, 1, 2, 5, 5, 5, 1, 5, 5, 5]
d=3: [1, 1, 5, 1, 1, 3, 1, 5, 1, 5, 5, 5, 1, 1, 5, 5, 5, 5, 5, 1, 5, 5, 5]
d=4: [1, 1, 5, 1, 1, 1, 1, 5, 1, 5, 5, 5, 1, 1, 3, 2, 5, 5, 5, 1, 5, 5, 5]
d=5: [1, 1, 5, 1, 1, 5, 1, 5, 1, 5, 5, 5, 1, 1, 1, 5, 5, 5, 5, 1, 5, 5, 5] OK, 
n0=2785729930871412767319403991459609692773556601469841

А для моего паттерна получилось два луча.

Итого у меня теперь три луча.
Интересненько!

Вот первый проход программы - по трём лучам сразу идёт проверка

15760230758531706844376995032385338075337309353237290641: [48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 24, 48, 48, 48, 48, 48, 48]
valids = 22
15914366789661737589757676584807550581020814970510628241: [48, 48, 48, 48, 96, 384, 48, 192, 96, 32, 48, 48, 24, 48, 48, 48, 12, 192, 48, 384, 96, 48, 48]
valids = 13
97067412484514977708132120051543304789560874140582737: [48, 48, 48, 48, 24, 96, 96, 384, 192, 48, 48, 48, 288, 16, 48, 96, 48, 16, 24, 48, 384, 48, 48]
valids = 12
122883091293653907148486858872502316228644170115865937: [48, 48, 48, 48, 48, 24, 24, 48, 64, 96, 192, 96, 48, 48, 48, 48, 24, 384, 48, 48, 80, 96, 12]
valids = 12
135897901743012621576290007587488558183430638390697937: [48, 48, 48, 48, 192, 24, 48, 192, 48, 48, 48, 12, 48, 48, 24, 384, 24, 48, 384, 192, 24, 96, 128]
valids = 11
22977946831639877325183910035233173678016851239017618641: [48, 48, 48, 48, 96, 48, 48, 384, 24, 24, 48, 24, 48, 24, 192, 48, 48, 48, 96, 384, 192, 24, 12]
valids = 11
24006508423988351722243458086973707129404859877360852241: [48, 48, 48, 48, 24, 48, 48, 768, 12, 32, 192, 48, 24, 96, 96, 192, 24, 48, 48, 48, 48, 96, 24]
valids = 11
24163608609563190751189152746173269875582279064197138641: [48, 48, 48, 48, 24, 48, 48, 192, 24, 48, 48, 96, 48, 96, 48, 96, 48, 384, 48, 12, 24, 48, 6]
valids = 13
time = 1h, 3min, 15,597 ms.

Начинается вывод как раз с того самого журавля, по которому получен паттерн Лецко.

Программа выводит приближения с valids>10.
Цепочки с меньшими начальными числами - это по моим лучам, а цепочки с бОльшими начальными числами - это по лучу Лецко.

Ещё результаты тестирования поиска по трём лучам

25116090237828252536746697723961813820959839417091353041: [48, 48, 48, 48, 768, 96, 48, 96, 48, 48, 96, 96, 12, 48, 80, 96, 12, 96, 48, 48, 48, 384, 48]
valids = 12
151182875476232079799262472653673313575079403871459537: [48, 48, 48, 48, 192, 1152, 12, 48, 24, 384, 48, 24, 96, 12, 48, 96, 48, 48, 48, 48, 48, 96, 12]
valids = 12
28785713440500907590232923914321411552424838536021967441: [48, 48, 48, 48, 48, 48, 48, 768, 48, 48, 96, 24, 48, 24, 64, 48, 24, 192, 128, 96, 24, 24, 24]
valids = 11
178876490405004504106825337042639472255127322666307537: [48, 48, 48, 48, 48, 48, 24, 96, 24, 3584, 48, 192, 48, 48, 48, 96, 6, 96, 96, 24, 48, 96, 48]
valids = 12
31634265861961668096210519527354992667075778886015764241: [48, 48, 48, 48, 24, 24, 12, 384, 12, 32, 48, 96, 48, 48, 384, 48, 48, 192, 48, 48, 12, 24, 24]
valids = 11
32594651902079551971274766123216470587103775424411175441: [48, 48, 48, 48, 48, 48, 48, 192, 12, 96, 384, 48, 12, 48, 384, 96, 24, 192, 192, 48, 24, 48, 6]
valids = 11
32825855948774598089345788451849789345629033850321181841: [48, 48, 48, 48, 24, 24, 48, 768, 48, 12, 96, 48, 12, 48, 160, 384, 48, 48, 48, 96, 48, 48, 24]
valids = 13
225438609067436251842824273198766050207525486562795537: [48, 48, 48, 48, 24, 24, 192, 96, 48, 384, 48, 48, 24, 48, 48, 768, 24, 48, 192, 24, 192, 48, 16]
valids = 11
237710565039091843301003954521344401639778480621027537: [48, 48, 48, 48, 24, 24, 192, 48, 48, 56, 32, 24, 48, 12, 6, 48, 48, 48, 768, 48, 96, 96, 96]
valids = 11

Вопросы, вопросы, вопросы...

Беру паттерн Лецко из его давнишней программы поиска D(48,21), которую он выкладывал на форуме

M =  [3698, 3971, 12, 49, 50, 5043, 362024, 529, 18, 4805, 28, 4107, 242, 841, 480, 289, 4418, 63, 4, 845, 320226]

и скармливаю его программе г. Петухова.
Получаю следующее:

? \r petuhov.txt
v=[3698, 3971, 12, 49, 50, 5043, 362024, 529, 18, 4805, 28, 4107, 242, 841, 480, 289, 4418, 63, 4, 845, 320226]
m= 29576058913001203166152762296391472723719200
d=0: [5, 1, 1, 1, 1, 5, 5, 5, 3, 5, 5, 1, 5, 5, 2, 1, 1, 1, 1, 1, 5]
d=1: [5, 1, 1, 1, 1, 5, 5, 5, 1, 5, 5, 1, 5, 5, 5, 1, 1, 3, 1, 1, 5]
d=2: [5, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 1, 5, 5, 2, 1, 1, 5, 1, 1, 5]
d=3: [5, 1, 1, 1, 1, 5, 5, 5, 3, 5, 5, 1, 5, 5, 5, 1, 1, 1, 1, 1, 5]
d=4: [5, 1, 1, 1, 1, 5, 5, 5, 1, 5, 5, 1, 5, 5, 2, 1, 1, 3, 1, 1, 5]
d=5: [5, 1, 1, 1, 1, 5, 5, 5, 5, 5, 5, 1, 5, 5, 5, 1, 1, 5, 1, 1, 5] OK, 
n0=176489786412268292104919362270458494891360146

Ни m, ни n0 не совпадают с теми значениями, что я вижу в программе Лецко

m =  554159729309947409007752567806326895200
p1 = 30475766721704852566432501877740394775491

p1 это по идее n0.

И как это понимать???

В программе г. Петухова написано

print("m= ",m=lcm(v));

Но у Лецко m имеет совсем другое значение.
Почему?

Нашла ещё два луча программой г. Петухова

v=[9, 722, 289, 60, 637, 5618, 5043, 27848, 4205, 486, 10571, 28, 4107, 50, 1849
, 96, 2209, 338, 315, 68, 10051, 726, 4489]
m= 3584707068432484827347213248609535668532938197600
d=0: [5, 5, 5, 5, 1, 1, 5, 5, 1, 5, 5, 5, 1, 5, 5, 1, 1, 1, 5, 5, 5, 5, 1] OK, 
n0=1346939943949170952784716363243992278697637342737
d=1: [5, 5, 5, 5, 1, 1, 5, 5, 1, 3, 5, 5, 1, 5, 5, 4, 1, 1, 5, 5, 5, 5, 1]
d=2: [5, 5, 5, 5, 1, 1, 5, 5, 1, 1, 5, 5, 1, 5, 5, 1, 1, 1, 5, 5, 5, 5, 1] OK, 
n0=8516354080814140607479142860463063615763513737937
d=3: [5, 5, 5, 5, 1, 1, 5, 5, 1, 5, 5, 5, 1, 5, 5, 4, 1, 1, 5, 5, 5, 5, 1]
d=4: [5, 5, 5, 5, 1, 1, 5, 5, 1, 3, 5, 5, 1, 5, 5, 1, 1, 1, 5, 5, 5, 5, 1]
d=5: [5, 5, 5, 5, 1, 1, 5, 5, 1, 1, 5, 5, 1, 5, 5, 4, 1, 1, 5, 5, 5, 5, 1]

Теперь к меня уже пучочек лучей - 5 штук.
Запустила сейчас поиск по 5 лучам, черепашка прилежно тестирует.

Шаг движения по лучам у меня сейчас равен 6.
Проверяю небольшие интервальчики.

Удалось gris чуть-чуть заинтересовать поиском по лучам.
Тем более что ему Ядряра приписал этот алгоритм :)
Немножко тестирует, пока по трём лучам.
Статистику собирает, он любит собирать статистику.
Я этим сильно не увлекаюсь.
Меня интересуют приближения.
Я сразу вижу их в логах, с valids>10.
Пока есть только приближения с valids=13 максимум.

Вспомнила опять давнишнюю программу Лецко, с которой я начинала.
У него шаг движения по лучу равен 1.
Но!
Там фильтр, и, похоже, не один.
В самом начале фильтр по переменной цикла.
Потом, кажется, ещё какой-то.
Послала программу gris и сказала: "Расколите фильтры!"
Если расколет, это позволит ускорить мою программу поиска по пучку лучей.

По-хорошему, ничего не надо раскалывать, а просто задать вопрос на форуме и получить подробный ответ.
Ну, это для нормального сообщества.
На форуме dxdy.ru оно явно ненормальное.

gris уже боится на форум вылезать с вопросами.
Помните, какой был допрос с пристрастием от Ядряры, когда gris задал вопрос по оптимизации моей программы?

Вот найдено приближение только на одном луче

249612255424273224900144365720136978108491857406144618641: [48, 48, 48, 48, 32, 12, 96, 192, 384, 768, 96, 48, 48, 48, 16, 48, 12, 768, 48, 48, 48, 48, 12]
valids = 12
time = 20min, 21,754 ms.

Выполняется быстро, потому что интервал маленький.

Это на луче Лецко найдено приближение.
Он всего один.
Остальные 4 луча мои.

Задала Алисе задачку:

имеем уравнения двух параллельных прямых

y = 798553590651032485486124582002569763540418400*x + 578590111530182255110317987659657368491920337
y = 798553590651032485486124582002569763540418400*x + 2175697292832247226082567151664796895572757137

Требуется найти значения х1 и х2, при которых на обеих прямых

y=91961526307286709380597649336434597932204049205291537

С первого раза она нашла х1 и х2 неправильно, у неё получились дробные значения.
Я сказала ей, что значения эти точные и показала их.
Тогда она провела вычисления правильно и результаты получила.
Графически это изобразить она так и не смогла, сколько я ни билась.

Написала ей, что её разработчики ни черта не работают!

Нашла два замечательных луча для D(48,22).
Это конкретный известный паттерн.
Найденная 22-ка лежит на обоих этих лучах.

А что, есть для этих цепочек гипотеза, аналогичная гипотезе Диксона для кортежей из последовательных простых чисел?
Если на этих двух лучах найдено решение, то оно, наверное, не единственное???

Можно поискать по этим двум лучам ниже найденной 22-ки.
Кстати, ниже искать удобнее, потому что для меньших чисел программа работает быстрее.

P. S. Показываю значения Х, при которых на лучах находится известная 22-ка

х1=115160118
х2=115160116

Теперь надо поискать для малюсеньких чисел, например, 50-значных или 49-значных.
Напомню: я начинала поиск 22-ки с диапазона (1е50, 1е51).

А у gris прогресс в поиске по лучу, полученному из паттерна Лецко для D(48,23)

13381990842313860664048145694691328452387322040564703441: [48, 96, 48, 48, 192, 20, 24, 48, 48, 48, 48, 48, 48, 192, 48, 48, 96, 48, 48, 48, 192, 48, 12]
valids = 15

Меня немного удивляет элемент с 20 делителями.
Может быть, я неправильно паттерн составила по журавлю Лецко?
Или луч неправильно найден по паттерну (программой г. Петухова).
Может быть, для паттернов Лецко программа г. Петухова не работает?

Вопросов много, ответов нет :(

Вот ещё приближение из результатов gris - тоже по паттерну Лецко

16688505125497500980820266304825521723347908888034089841 
[48,48,192,48,96,16,48,48,48,48,128,48,48,256,48,32,48,48,48,12,24,48,12] 
valids=14

Здесь ещё большее разнообразие количества делителей.

Может, они (количества делителей) вовсе и не должны быть кратными 12 (или 6)???

А черепашка старательно ползёт по двум лучам для D(48,22).

Пока идём чуть вниз по лучам от известной 22-ки.
Выполняется тестирование.

И вот это приближение вывелось два раза подряд

91960555266120477725095298208942882807371584056517137: [48, 48, 48, 48, 48, 24, 192, 96, 48, 48, 48, 48, 48, 96, 24, 192, 96, 48, 96, 24, 96, 768]
valids = 11

Видимо, оно есть на обоих лучах.
Интересно!

К тому же, здесь количества делителей все кратны 12.

Мне кажется, это хорошие лучи и на них можно что-нибудь найти.
Но доказательства не имею.
Пока всё на интуиции построено.
Или "бабка надвое сказала" :)
Нужны практические эксперименты, а также теоретические исследования.

Вот ещё вывелось приближение, тоже два раза подряд

91958738556701746626190817275518826961159529604657137: [48, 48, 48, 48, 24, 384, 48, 48, 384, 224, 48, 48, 48, 48, 12, 416, 48, 48, 384, 24, 48, 48]
valids = 14

Тут уже есть количества делителей не кратные 12 (224, 416).
Может, это совсем и не обязательно - кратность количества делителей 12 ???

Появление приближений сразу на обоих лучах мне определённо нравится.
Известная 22-ка ведь тоже находится на обоих лучах, причём при очень близких значениях шага k движения по лучам.

Завтра буду тестировать в диапазоне 50-значых чисел.

Алиса рекомендует

Итоговый алгоритм (упрощённый)
Для x от 125225 до 1252264:

Вычислите N(x)=Ax+B.
Проверьте делимость на 4, 9, 25, 49, 121, 169 (квадраты малых простых). Запишите, на что делится.
Вычислите N(x)modm для m=4,8,9,12,16. Сверьтесь с таблицей допустимых остатков для d(N)=48. Если не подходит — отбрасываем.
Проверьте, делится ли N(x) на более чем 5 различных простых ≤100. Если да — отбрасываем.
Запустите тест Миллера‑Рабина. Если N(x) «скорее простое» — отбрасываем.
Попробуйте поделить N(x) на все простые до 10^6.
Если не делится ни на одно — вероятно, имеет большие простые множители (мало шансов на d(N)=48).

Не вникала, но, наверное, здесь есть что-то полезное для предпроверки получаемых значений функции, прежде чем проверять их на количество делителей.

Итак, диапазон для Х: (125225, 1252264).
В этом диапазоне получаем 51-значные числа на обоих лучах.

Сейчас запущу эту проверку.

Ой, я же собиралась проверять 50-значные числа, 51- значные числа проверялись в программе pcoul.
Сейчас пересчитаю диапазон для Х.

Ну вот, проверка 50-значных чисел поехала

? \r luch22.txt
   logfile = "luch22_res.txt"
11478189348538820096147178935110594868734925583537: [48, 48, 48, 48, 24, 96, 96, 48, 24, 96, 96, 192, 48, 48, 96, 224, 48, 48, 48, 96, 48, 48]
valids = 12
11678626299792229250004196205193239879383570601937: [48, 48, 48, 48, 12, 48, 24, 48, 192, 48, 48, 96, 96, 48, 48, 48, 24, 48, 192, 24, 24, 192]
valids = 12
time = 6min, 20,424 ms.

Тут небольшой интервальчик проверен.
Приближения имеются, хотя и с низким valids.

Сейчас я перенесу проверку на Ахиллес.
Уповаем только на Удачу!
К сожалению, пока есть только один свободный поток.

Напомню: проверка по лучу, на котором находится известная 22-ка.
Движемся по лучу вниз.
Вот сначала проверю 50-значные числа.
Потом можно 49-значные проверить.

Ой, что-то Ахиллес быстро управился с проверкой 50-значных чисел

   [logfile is "luch22_res.txt"] 
17143927074207895580671232844418827341054194131537: [48, 48, 48, 48, 48, 24, 48, 192, 48, 192, 24, 12, 96, 48, 48, 384, 6, 96, 48, 48, 64, 48]
valids = 12
20924279772349883366962546615618992601654534837137: [48, 48, 48, 48, 48, 48, 48, 48, 12, 48, 48, 96, 48, 24, 12, 192, 12, 24, 192, 24, 48, 24]
valids = 12
32431437013631261482817601842276022894271963981137: [48, 48, 48, 48, 48, 24, 192, 48, 48, 56, 12, 192, 48, 192, 48, 96, 48, 48, 96, 384, 192, 48]
valids = 12
76858167475910802780352656837406989119079601246737: [48, 48, 48, 48, 48, 48, 192, 48, 24, 48, 96, 24, 48, 64, 24, 192, 48, 24, 96, 48, 48, 192]
valids = 12
time = 4h, 14min, 54,260 ms.

Проверка выполнялась по одному лучу, потому что уравнения лучей очень похожи (каждое приближение выводилось при тестировании два раза).

Сейчас запущу проверку 49-значных чисел.

Примечание: несколько 50-значных приближений с valids = 12 было найдено на черепашке при тестировании программы.