😊出会いの泉😊

lb(3),lb(5),lb(7),lb(11),lb(13)を通常に連分数からの打ち切り分数で
分母が6桁であるものをとると
lb(3)=301994/190537
lb(5)=227268/97879　(6桁であるものは取れなかった。)
lb(7)=1273419/453601
lb(11)=1444074/417431
lb(13)=201130/54353
が見つかる。

kuiperbelt氏による構成では
lb(3)=172295/108706=1033770/652236
lb(5)=504815/217412=1514445/652236
lb(7)=915529/326118=1831058/652236
lb(11)=376061/108706=2256366/652236
lb(13)=201130/54353=2413560/652236

そこで初めの方の異なる分数を652236へと統一したとすればそれぞれの分子は
lb(3)-->round(652236/190537*301994)=1033770
lb(5)-->round(652236/97879*227268)=1514445
lb(7)-->round(652236/453601*1273419)=1831058
lb(11)-->round(652236/417431*1444074)=2256366
lb(13)-->round(652236/54353*201130)=2413560
と矛盾なくつながりました。

1.の「2以上」は不要だと思います。

1について、πは2以上の数ですが、連続する整数の和では書けませんが？
2について、「正の」と一見不必要な情報をあえて書き足し強調した意図はなんでしょう？
3について、例えば7であれば、7（1連続）と3+4（2連続）の少なくとも2つがありますので成り立ちません。
4について、突然「逆」とだけ言われても何の逆か全くわかりません。
5について、奇数なら3で示したように1連続と2連続は必ず存在しますので、素数に限らず3以上の奇数全部で成り立ちます。

ksさんの投稿は全部に言えることですが、記述不足で内容が意味不明だったり明らかに誤っている記述になっていたり、いつもそういう投稿ばかりです。
言語化していない前提を勝手において話をしても誰にも何も伝わりませんよ。

皆様、ご指摘ありがとうございます。
先ず、管理人様の質問に対するお答えです。
1＝０＋1
2＝－1＋０＋1＋2
４＝ー3＋（－2）＋（－1）＋０＋1＋2＋3＋4
悪しからず。
２については、２，４，８、16…などは、
自然数の連続した和では、表せない。
３については、素数は、２以外は、全て奇数なので、
P＝２N＋１＝N＋（N＋１）で明らかですが、
他に連続した複数の和として表すことはできません。
４については、３の逆は成立しない。一通り⇒素数は成立しない。
５については、９以上の素数でない奇数は複数の表現、
連続する自然数の和という意味でした。
尚、説明不足であれば、よろしくご容赦ください。

私の挙げた反例とかは全部無視ですか？
「自分が正しいと判断したことが正しい根拠だ」では会話になりませんよ。

例えば123-70√2が24に近いなら、
115-70√2は16に(42-15√3よりも)近くなると思いますが、
16のときに42-15√3としているのはなぜでしょうか。
また逆の見方で、もし「自然数に近づけていく」のが目的ならば
右辺の自然数を変更することで
16≒42-15√3
16≒115-70√2
16≒260-63√15
のように左辺の値を一定にしたり
1≒27-15√3
2≒101-70√2
3≒247-63√15
のように8の倍数以外にすることもできますが、
左辺の値が8の倍数のみとなっているのは
8の倍数から右辺を導出する決まった手法があるということでしょうか。

> 左辺の値が8の倍数のみとなっているのは
> 8の倍数から右辺を導出する決まった手法があるということでしょうか。


ある本を読んでいて
m:=1/2*(sqrt(n+1)+sqrt(n-1))･････････①
と置くとき
1/m=sqrt(n+1)-sqrt(n-1)･･････････････②
m^2=1/2*(n+sqrt(n^2-1))･･･････････････③
n-m^2=1/(4*m^2)･･････････････････････④
が成り立ち
これらの等式を組み合わせることで
1/(8*m^5*(m+sqrt(n))^2)=(m-sqrt(n))^2/(8*m^5*(m^2-n)^2)
=(m^2-2*m*sqrt(n)+n)/(m/2)
=2*(m-2*sqrt(n)+n/m)
=(2*n+1)*sqrt(n+1)-(2*n-1)*sqrt(n-1)-4*sqrt(n)･･････････････(*)
なる等式が成立することに成る。
左辺を見ることで右辺の値はO(1/(n^(5/2)*n)=O(1/n^(3+1/2)のオーダーでほゞ無視出来ることができる。

この巧みな式を見てn+1,n-1,nがそれぞれ平方根√が外れる各nに対応して
(2*n+1)*sqrt(n+1)≒(2*n-1)*sqrt(n-1)+4*sqrt(n)
(2*n-1)*sqrt(n-1)≒(2*n+1)*sqrt(n+1)-4*sqrt(n)
4*sqrt(n)≒(2*n+1)*sqrt(n+1)-(2*n-1)*sqrt(n-1)
という風に左辺の自然数を右辺の2つの無理数で構成出来るなと思って先程の等式もどきを作っていきました。

なおここで第３番目の等式を両辺平方して
16*n≒8*n^3+10*n-2*(4*n^2-1)*sqrt(n^2-1)
÷2から
8*n≒4*n^3+5*n-(4*n^2-1)*sqrt(n^2-1)･･⑤
なる式を利用すれば
8の倍数の自然数が右辺の一つの無理数で近似出来ることが可能となる。

この⑤から構成していきました。


らすかるさんの指摘の様に
gp > forprime(p=2,100,for(n=1,1000000,if(frac(n*sqrt(p)) < 0.000001,print(n";"p))))
978122;3
902702;7
283009;17
566018;17
345777;19
254813;29
509626;29
528641;41
424802;43
829254;47
528896;53
951113;61
977001;89
594030;97
や
gp > forprime(p=2,100,for(n=1,10000000,if(frac(n*sqrt(p)) > 0.9999999,print(n";"p))))
9369319;2
7865521;3
7465176;5
3096720;7
9504180;11
2298912;17
4508361;19
9016722;19
5412001;23
8193638;29
9600319;31
1311360;41
3697884;43
7395768;43
6191808;47
8142716;61
2874480;71
5748960;71
8623440;71
4684249;73
4121279;79
8242558;79
9005009;89
6377352;97
なる素数や整数を組み合わせれば(bとpを上の組み合わせに取っておく意味)
a+b*sqrt(p)
はaを調節することで一個の無理数でなんぼでも自然数すべてを好きな近似精度で作り出すことは可能となるんでした。

しかし(*)の等式を作り出せるセンスにほどほど感心しました。

なるほど、やはり8の倍数にだけ使える式があったのですね。よくわかりました。

GAI さんが何をしたいのか全くわからないんですが、
16=42-15*sqrt(3) が特別な近似式であるかのように扱われている理由はどこにあるんです？

> 16=42-15*sqrt(3) が特別な近似式であるかのように扱われている理由はどこにあるんです？

らすかるさんへの返事の中の
8*n≒4*n^3+5*n-(4*n^2-1)*sqrt(n^2-1)･･⑤
なる式から
n=2,7,26で生まれる式が以下の式となる意味であり
16=42-15*sqrt(3)
56=1407-780*sqrt(3)
208=70434-40545*sqrt(3)
その
16=42-15*sqrt(3) が特別な近似式というつもりはありません。

上の3つの式から
sqrt(3)=(42-16)/15=26/15
sqrt(3)=(1407-56)/780=1351/780
sqrt(3)=(70434-208)/40545=70226/40545
等が発生します。(前に掲示している中から選んでいるだけです。)

ここにsqrt(3)の連分数を途中で打ち切って分数としていく手順を自動でやらせていくと
gp > contfracpnqn(contfrac(sqrt(3)),20)
%208 =
[1 2 5 7 19 26 71 97 265 362 989 1351 3691 5042 13775 18817 51409 70226 191861 262087 716035]

[1 1 3 4 11 15 41 56 153 209 571 780 2131 2911 7953 10864 29681 40545 110771 151316 413403]

の様に右に行くにしたがってよりsqrt(3)へ近似していけます。
この流れの中に
26/15,1351/780,70226/40545もいますから16=42-15*sqrt(3)が特別の式との解釈は "はて？"
と思ってしまいます。

ああ、具体的な方がいいかと思って1つ抽出したら質問の意図が伝わりませんでした。
5番の式で「8n=」の形にした式だけ特別視しているのはなぜですか？

この式を作るときに、その前に記載された式を平方して整理して得られる
4*n^3-3*n-(4*n^2-1)*sqrt(n^2-1)≒0
の両辺に突然 8n を加えてできたのが 5 番ですよね。
ここで両辺に 7n を足せば 7 の倍数の式ができるでしょうし、9n を足せば 9 の倍数の式ができるんじゃないでしょうか？
8n を選択する必然性はなんでしょう？

> 5番の式で「8n=」の形にした式だけ特別視しているのはなぜですか？

この式を作るときに、その前に記載された式を平方して整理して得られる
4*n^3-3*n-(4*n^2-1)*sqrt(n^2-1)≒0
と記載されている部分は

8*n≒4*n^3+5*n-(4*n^2-1)*sqrt(n^2-1)
をなぜ
3*n≒4*n^3-(4*n^2-1)*sqrt(n^2-1)
としないのか？
と解釈していいですか？

理由はこうすることを気付かなかったです。
2で割れるからそれで終わりと思い込み。そのままで数値で確認に行っていました。

これからは
6≒32-15*sqrt(3)
9≒108-35*sqrt(8)=108-70*sqrt(2)
12≒256-63*sqrt(15)
････････････
で掲載していたことでしょう。

お粗末様でした。

> 3*n≒4*n^3-(4*n^2-1)*sqrt(n^2-1)

さらに言えば、3n と 4n^3 を左右に分ける意味もないと思います。
n は具体的な整数を代入することを想定しているんでしょうかた、整数の近似式に整数を足す項があっては意義が薄いです。

一方で、これを逆に平方根の有理近似式として
√(n^2-1) = (4n^3-3n)/(4n^2-1)
とした式は何かに使えそうですね。

DD++さんからのアドバイスを受けてsqrt(n^2-1)≒(4*n^3-3*n)/(4*n^2-1)
の活用を見てみました。
時間の関係でプログラムのままの姿で申し訳ありません。


gp > for(n=1,100,if(core(n^2-1)==3,\
print(n,";sqrt(3)=",(4*n^3-3*n)/(4*n^2-1)/sqrtint((n^2-1)/3))))
2;sqrt(3)=26/15
7;sqrt(3)=1351/780
26;sqrt(3)=70226/40545
97;sqrt(3)=3650401/2107560
これに対して連分数からの近似
gp > contfracpnqn(contfrac(sqrt(3)),24)
%227 =
[1 2 5 7 19 26 71 97 265 362 989 1351
3691 5042 13775 18817 51409 70226
191861 262087 716035 978122 2672279 3650401
9973081]

[1 1 3 4 11 15 41 56 153 209 571 780
2131 2911 7953 10864 29681 40545
110771 151316 413403 564719 1542841 2107560
5757961]

-----------------------------------------------------------

for(n=1,10000,if(core(n^2-1)==5,\
print(n,";sqrt(5)=",(4*n^3-3*n)/(4*n^2-1)/sqrtint((n^2-1)/5))))
9;sqrt(5)=2889/1292
161;sqrt(5)=16692641/7465176
2889;sqrt(5)=96450076809/43133785636
これに対して連分数からの近似
gp > contfracpnqn(contfrac(sqrt(5)),20)
%222 =
[2 9 38 161 682 2889 12238 51841 219602 930249 3940598 16692641
70711162 299537289 1268860318 5374978561 22768774562 96450076809
408569081798 1730726404001 7331474697802]

[1 4 17 72 305 1292 5473 23184 98209 416020 1762289 7465176
31622993 133957148 567451585 2403763488 10182505537 43133785636
182717648081 774004377960 3278735159921]

-------------------------------------------------------------

gp > for(n=1,10000,if(core(n^2-1)==6,\
print(n,";sqrt(6)=",(4*n^3-3*n)/(4*n^2-1)/sqrtint((n^2-1)/6))))
5;sqrt(6)=485/198
49;sqrt(6)=470449/192060
485;sqrt(6)=456335045/186298002
4801;sqrt(6)=442644523201/180708869880
これに対して連分数からの近似
gp > contfracpnqn(contfrac(sqrt(6)),24)
%226 =
[2 5 22 49 218 485 2158 4801 21362 47525 211462 470449
2093258 4656965 20721118 46099201 205117922 456335045
2030458102 4517251249 20099463098 44716177445 198964172878
442644523201 1969542265682]

[1 2 9 20 89 198 881 1960 8721 19402 86329 192060
854569 1901198 8459361 18819920 83739041 186298002
828931049 1844160100 8205571449 18255302998 81226783441
180708869880 804062262961]

-------------------------------------------------------------

gp > for(n=1,10000,if(core(n^2-1)==7,\
print(n,";sqrt(7)=",(4*n^3-3*n)/(4*n^2-1)/sqrtint((n^2-1)/7))))
8;sqrt(7)=2024/765
127;sqrt(7)=8193151/3096720
2024;sqrt(7)=33165873224/12535521795
これに対して連分数からの近似
gp > contfracpnqn(contfrac(sqrt(7)),36)
%233 =
[2 3 5 8 37 45 82 127 590 717 1307 2024
9403 11427 20830 32257 149858 182115 331973
514088 2388325 2902413 5290738 8193151
38063342 46256493 84319835 130576328 606625147 737201475
1343826622 2081028097 9667939010 11748967107 21416906117 33165873224
154080399013]

[1 1 2 3 14 17 31 48 223 271 494 765
3554 4319 7873 12192 56641 68833 125474
194307 902702 1097009 1999711 3096720
14386591 17483311 31869902 49353213 229282754 278635967
507918721 786554688 3654137473 4440692161 8094829634 12535521795
58236916814]

近似スピードが稼げます。

手元では同様ですね。
PARI は、ひとたび小数を扱うことになると２進数で内部表現するのかな？　と思いましたが、ざっとみ、それだけではうまく説明できないような？

? for(n=1,20,print(n";"floor(log(10^n)/log(10))))
1;1
2;2
3;2
4;4
5;5
6;5
7;7
8;8
9;9
10;10
11;10
12;11
13;12
14;14
15;14
16;16
17;16
18;18
19;19
20;20

JavaScript では以下の通りです。

for (let n = 1; n <= 20; n++) {
console.log(n + ";" + Math.floor(Math.log(Math.pow(10, n)) / Math.log(10)));
}

上を RUN すると
"1;1"
"2;2"
"3;2"
"4;4"
"5;5"
"6;5"
"7;7"
"8;8"
"9;8"
"10;10"
"11;11"
"12;11"
"13;12"
"14;14"
"15;14"
"16;16"
"17;17"
"18;17"
"19;19"
"20;20"

となります。
JavaScript ではたぶん小数点以下は、最寄りの２進数で捉えているので……

他の計算ソフトでも調査してみた。
＊sageMathのソフト
sage: for i in range(21) :print(i,floor(ln(10^i)/ln(10)));
(0, 0)
(1, 1)
(2, 2)
(3, 3)
(4, 4)
(5, 5)
(6, 6)
(7, 7)
(8, 8)
(9, 9)
(10, 10)
(11, 11)
(12, 12)
(13, 13)
(14, 14)
(15, 15)
(16, 16)
(17, 17)
(18, 18)
(19, 19)
(20, 20)
全部上手く走る


＊Rubyのソフト
irb(main):001:0> include Math
=> Object
irb(main):012:0> 0.upto(20){|i| print i,";",log(10**i)/log(10),"\n"}
0;0.0
1;1.0
2;2.0
3;2.9999999999999996
4;4.0
5;5.0
6;5.999999999999999
7;7.0
8;8.0
9;8.999999999999998
10;10.0
11;11.0
12;11.999999999999998
13;12.999999999999998
14;14.0
15;14.999999999999998
16;16.0
17;17.0
18;17.999999999999996
19;19.0
20;20.0
3,6,9,12,13,15,18で上手くいかなくなる。



＊Maximaのソフト
(%i13) for i :1 thru 20 do
print(float(log(10^i)/log(10)));

1.0" "
2.0" "
3.0" "
4.0" "
5.0" "
6.0" "
7.0" "
8.0" "
8.999999999999998" "
9.999999999999998" "
11.0" "
12.0" "
13.0" "
14.0" "
15.0" "
16.0" "
17.0" "
18.0" "
19.0" "
20.0" "
9,10で難点

PARI で、床関数を使う前に微量な下駄をはかせましたが 258,259で破綻。

for(n=257,260,print(n";"floor(10^(-36)+log(10^n)/log(10))))

257;257
258;257
259;258
260;260

PARI にて、
n = 308 までの範囲で微小量を足すテストをしました。
(javascriptだと10^308を超えると途中計算結果に無限大が現れる扱いになったので……PARIではどうなのかわからず、とりあえずです)

微小量としては、2 ^{-119}と2 ^{- 120} とのあいだに分水嶺があります。以下。

? i = -120; for(n = 1, 308, if(n == floor(2^i + log(10^n)/log(10)), next, print(n, ";", floor(2^i + log(10^n)/log(10))) ) ); print("END")
　
上を走らせると

258;257
259;258
265;264
266;265
271;270
272;271
277;276
278;277
283;282
284;283
290;289
291;290
296;295
297;296
302;301
303;302
308;307
END
　
となり

? i = -119; for(n = 1, 308, if(n == floor(2^i + log(10^n)/log(10)), next, print(n, ";", floor(2^i + log(10^n)/log(10))) ) ); print("END")

上を走らせると
　
END

となります。

近似分数に関しては以前少し研究したことがあります。
（分数の昇順で精度順に分数を列挙する方法を考えました(何十桁でもOK)。）
書かれている分数は、すべて連分数を打ち切って得られる分数ですね。
しかしそれは「3桁以下で最も良い」分数が得られるとは限りません。
例えばlog17は299/243より881/716の方が良い近似になります。
同様にlog29も525/359より914/625の方が少しだけ良い近似になります。
log23は3桁以下で連分数打ち切りで得られる分数では64/47が最大で
精度が出ないために分子4桁を許容したものと思いますが、
975/716でもそこそこの精度は出ます。
大半の値は、小数点以下の精度が(分母の桁数×2)桁程度になりますが、
たまたま連分数打ち切り直後の値が大きい場合は精度が良くなりますね。
log7は[0;1,5,2,5,6,1,4813,1,1,…]で4813の前で打ち切っているため
これだけ特別に精度が良くなっています。
円周率の355/113も同様ですね。

単に 1 つの対数値を機械計算を許して自由に有理数近似するだけでしたら、
数学感動秘話 > 累乗の上 4 桁
他、このサイトの何ヶ所かで同じ議論が繰り返し行われていますね。

29までの素数で、常用対数の連分数展開を求めてみましたが、log_{10}(7)のときの4813のような大きな数は現れませんでした。なお、log_{10}(5)=1-log_{10}(2)なので省略しています。

log_{10}(2)=[0;3,3,9,2,2,4,6,2,1,1,3,1,18,...]
[0;3,3,9,2,2,4,6,2,1,1,3,1]=97879/325147
=0.301029995663499893894146339963

log_{10}(3)=[0,2,10,2,2,1,13,1,7,18,...]
[0,2,10,2,2,1,13,1,7]=34367/33001
=0.477121254550546065527863343601

log_{10}(11)=[1;24,6,3,2,1,1,3,1,1,1,9,...]
[1;24,6,3,2,1,1,3,1,1,1]=22014/21139
=1.04139268507014938941244204721

log_{10}(13)=[1;1,8,1,3,2,7,1,6,16,...]
[1;1,8,1,3,2,7,1,6]=5113/4590
=1.11394335511982570806100217865

log_{10}(17)=[1,4,2,1,17,1,13,1,1,3,3,26,...]
[1;4,2,1,17,1,13,1,1,3,3]=99797/81106
=1.23045150790323773826843883313

log_{10}(19)=[1;3,1,1,2,2,1,3,2,2,1,4,1,1,1,6,1,3,1,3,1,47,...]
[1;3,1,1,2,2,1,3,2,2,1,4,1,1,1,6,1,3,1,3,1]=6497723/5081294
=1.27875360095282815755199364571

log_{10}(23)=[1;2,1,3,4,17,2,1,2,66,...]
[1;2,1,3,4,17,2,1,2]=9016/6621
=1.36172783567436943059960731007

log_{10}(29)=[[1;2,6,6,1,2,1,2,2,2,1,1,1,1,1,5,1,2,3,37,...]
[1;2,6,6,1,2,1,2,2,2,1,1,1,1,1,5,1,2,3]=5243915/3585833
=1.46239799789895402267757589380

log[10]7で連分数の8番目の値が4813ですが、
log[10]2は137番目が5393
log[10]3は562番目が2788
log[10]11は2179番目が3864
log[10]13は133番目が1378
log[10]17は710番目が3301
log[10]19は1341番目が2249
log[10]23は921番目が2695
log[10]29は352番目が1901
のようにずっと先まで見れば大きな数はいずれ出てきます。
log[10]7は奇跡的に前の方にあったということですね。

同じ問題についてなので、間借りします。

平面幾何的解法です。

この三角形の外心を O とすると、△OBC は OB = OC である直角二等辺三角形なので、
あとは OH を対角線とする長方形を書いてなんやかんやすれば
AH = 5 + √{ (5√2)^2 - 1 } = 12
と求まりますね。

とりあえず(1)だけ
> 分母 239 というのはどのくらいの優秀さなんでしょうか？

分母＜1000では(相対誤差の合計で)70番目に優秀でした。
239で相対誤差の合計は0.001457…です。
1位は568で、相対誤差の合計は0.0001758…です。
2位以下は897,960,807,794,…と続きますが、分母が大きければ相対誤差が小さいのは当然で、
そういう意味では69番目までに分母が239未満のものはありませんので、239は結構優秀と言えると思います。
分母の大きさも考慮して「相対誤差の合計×分母」でランキングを作ると、
1位の568、2位の897は変わりませんが、3位が329、そして4位が239となります。
相対誤差の合計×分母の具体値(5位まで)は
568 0.099882607730
897 0.222871229356
329 0.285662258393
239 0.348293385746
103 0.383956736568
のようになっていて、これを見ても568だけ突出している感じです。
ちなみに分母が568の場合の対数の近似値は
log2 ≒ 171/568 ≒ 0.30106
log3 ≒ 271/568 ≒ 0.47711
log5 ≒ 397/568 ≒ 0.69894
log7 ≒ 480/568 ≒ 0.84507
なのでかなり良い近似になっていますね。
分母が568になるような組合せを適当に探してみると、
(2400,2401),(4374,4375),(250000,250047)
から式を立てれば上記の値になるようです。
(検算していません。)

おおー、568 優秀ですね。
しかし 250047 は人力じゃ流石にちょっと出てこない……。

やっぱり桁数が多いと 2 数の差が少しあっても気にならなくなっていくので精度上がるっぽいですね。

(3)について
5log2 + log7 ≒ 2log3 + 2log5
5log2 + log3 + 2log5 ≒ 4log7
log2 + 7log3 ≒ 4log5 + log7
を
5log2 + log7 + a = 2log3 + 2log5
5log2 + log3 + 2log5 + b = 4log7
log2 + 7log3 + c = 4log5 + log7
（a,b,c＞0）
として計算すると
log2 = (72 - 27a - 5b - 7c) / 239
log3 = (114 + 17a + 12b - 31c) / 239
log5 = (167 + 27a + 5b + 7c) / 239
log7 = (202 - 16a + 59b - 13c) / 239
となります。この式から
log2 ＜ 72/239
log5 ＞ 167/239
はただちにわかりますが、log3 と 114/239 の大小関係は
17a + 12b - 31c の符号を調べないとわかりません。
しかし 17a + 12b - 31c の符号を調べるために計算すると
17a + 12b - 31c = 239log3 - 114log10
となって 3^239 と 10^114 の大小関係を調べることになり、本末転倒です。
よって同様の方法で不等式で上下からおさえるためには
近似式を多数用意してたまたま大小関係がわかることに期待するぐらいしか
思いつきませんが、追加の近似式を用意しようとすると桁数が増えて
手計算に不向きになってきますので、とりあえず
「この方法での不等号での評価は難しい」
と言ってよいかと思います。

> 17a + 12b - 31c の符号を調べないとわかりません。

なるほど、差分を定数化してしまえばよかったのですね。
連立方程式を解く手間はけっこう増えてしまいますけれども。
手でやるなら逆行列用意して解くのが一番早いかな？

{1/n - 1/(2*n^2)} log e < log{1+(1/n)} < {1/n} log e
を使えば、log e は括り出して放置でいいので、a, b, c の線型結合の正負評価はなんとかなるケースが多そうに思います。
(224, 225), (2400, 2401), (4374, 4375) のケースは実際それでなんとかなるみたいです。

長文です。
(2)について
素数2,3,5,7、10桁以下で(2400,2401)より誤差率が小さいものは
以下の6個しかありませんでした。左端は誤差率(大きい方の値÷小さい方の値－1)です。
0.000040616 78121827 78125000
0.000066758 645657712 645700815
0.000107377 3954653486 3955078125
0.000188000 250000 250047
0.000228624 4374 4375
0.000295397 184473632 184528125
0.000416667 2400 2401

78121827 = 3^13 * 7^2, 78125000 = 2^3 * 5^10, 差 = 3173 = 19 * 167
645657712 = 2^4 * 7^9, 645700815 = 3^17 * 5, 差 = 43103 (素数)
3954653486 = 2 * 7^11, 3955078125 = 3^4 * 5^11, 差 = 424639 (素数)
これを使って
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
4log2 + 9log7 = 17log3 + log5 (645657712, 645700815)
log2 + 11log7 = 4log3 + 11log5 (3954653486, 3955078125)
log2 + log5 = 1
を解くと一次従属で解けませんでした。
あらためて
78121827 = 3^13 * 7^2, 78125000 = 2^3 * 5^10, 差 = 3173 = 19 * 167
645657712 = 2^4 * 7^9, 645700815 = 3^17 * 5, 差 = 43103 (素数)
250000 = 2^4 * 5^6, 250047 = 3^6 * 7^3, 差 = 47 (素数)
これを使って
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
4log2 + 9log7 = 17log3 + log5 (645657712, 645700815)
4log2 + 6log5 = 6log3 + 3log7 (250000, 250047)
log2 + log5 = 1
を解くと
log2 = 171/568, log3 = 271/568, log5 = 397/568, log7 = 480/568
これは見覚えがありますね。
しかしこの値は(2400,2401),(4374,4375),(250000,250047)
からも得られるのではないかと思って上で「検算していません」と書いたのを
あらためて検算してみると、なんと
5log2 + log3 + 2log5 = 4log7 (2400, 2401)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
4log2 + 6log5 = 6log3 + 3log7 (250000, 250047)
log2 + log5 = 1
は一次従属で解けませんでした。結構解けない場合が出てくるのですね。
それではいろいろ組合せを変えて試すことにします。
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
log2 + 11log7 = 4log3 + 11log5 (3954653486, 3955078125)
4log2 + 6log5 = 6log3 + 3log7 (250000, 250047)
log2 + log5 = 1
→ log2 = 171/568, log3 = 271/568, log5 = 397/568, log7 = 480/568
4log2 + 9log7 = 17log3 + log5 (645657712, 645700815)
log2 + 11log7 = 4log3 + 11log5 (3954653486, 3955078125)
4log2 + 6log5 = 6log3 + 3log7 (250000, 250047)
log2 + log5 = 1
→ log2 = 171/568, log3 = 271/568, log5 = 397/568, log7 = 480/568
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
4log2 + 9log7 = 17log3 + log5 (645657712, 645700815)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
log2 + log5 = 1
→ log2 = 171/568, log3 = 271/568, log5 = 397/568, log7 = 480/568
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
log2 + 11log7 = 4log3 + 11log5 (3954653486, 3955078125)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
log2 + log5 = 1
→ log2 = 171/568, log3 = 271/568, log5 = 397/568, log7 = 480/568
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
4log2 + 6log5 = 6log3 + 3log7 (250000, 250047)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
log2 + log5 = 1
→ 一次従属
4log2 + 9log7 = 17log3 + log5 (645657712, 645700815)
4log2 + 6log5 = 6log3 + 3log7 (250000, 250047)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
log2 + log5 = 1
→ log2 = 171/568, log3 = 271/568, log5 = 397/568, log7 = 480/568
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
5log2 + log3 + 2log5 = 4log7 (2400, 2401)
log2 + log5 = 1
→ 一次従属
解が得られても同じものばかりでした。ちょっと精度が良いぐらいだと
あまり変わらないようです。

ではさらに精度が良いものを見つけて試します。
しかし「10桁以下」を11桁以下、12桁以下、・・・と増やしてもなかなか見つかりません。
「15桁以下」まで増やして、やっと
0.000026141 205885750000000 205891132094649
0.000033563 281474976710656 281484423828125
の二つが見つかりましたので、これと(78121827, 78125000)で試します。
205885750000000 = 2^7 * 5^9 * 7^7, 205891132094649 = 3^30,
差 = 5382094649 = 3673 * 1465313
281474976710656 = 2^48, 281484423828125 = 5^11 * 7^8,
差 = 9447117469 (素数)
7log2 + 9log5 + 7log7 = 30log3 (205885750000000, 205891132094649)
48log2 = 11log5 + 8log7 (281474976710656, 281484423828125)
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
log2 + log5 = 1
↓
log2 = 3125/10381 = 0.30103073 (真値 0.30103000)
log3 = 4953/10381 = 0.47712166 (真値 0.47712125)
log5 = 7256/10381 = 0.69896927 (真値 0.69897000)
log7 = 8773/10381 = 0.84510163 (真値 0.84509804)
ようやく少し精度が上がりました。

ちなみにもう一桁上の
0.000007053 2251783932057135 2251799813685248
2251783932057135 = 3^13 * 5 * 7^10, 2251799813685248 = 2^51,
差 = 15881628113 = 13 * 71 * 17206531
を使って
13log3 + log5 + 10log7 = 51log2 (2251783932057135, 2251799813685248)
7log2 + 9log5 + 7log7 = 30log3 (205885750000000, 205891132094649)
48log2 = 11log5 + 8log7 (281474976710656, 281484423828125)
log2 + log5 = 1
としても上と同じ分母10381の値になりました。
というわけで、
使う数字の桁数をかなり増やしても結果の精度もあまり上がらないらしい
ということがわかりました。

使う桁数が上がっても、2, 3, 5, 7 で作れる合成数の割合が減ることで打ち消されてしまい、誤差率がなかなか小さくならないんですね。
そうなると、11や13の使用を検討する方が精度上げには重要なのかな？

また長文です。これで当初の課題はとりあえず完結。
(4)

【11を追加した場合】

(1万まで)
0.000102041 9800 9801
0.000228624 4374 4375
0.000330688 3024 3025
0.000416667 2400 2401
0.001244444 5625 5632
9800 = 2^3 * 5^2 * 7^2, 9801 = 3^4 * 11^2
4374 = 2 * 3^7, 4375 = 5^4 * 7
3024 = 2^4 * 3^3 * 7, 3025 = 5^2 * 11^2
2400 = 2^5 * 3 * 5^2, 2401 = 7^4
3log2 + 2log5 + 2log7 = 4log3 + 2log11 (9800, 9801)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
4log2 + 3log3 + log7 = 2log5 + 2log11 (3024, 3025)
5log2 + log3 + 2log5 = 4log7 (2400, 2401)
log2 + log5 = 1
→ 一次従属
5625 = 3^2 * 5^4, 5632 = 2^9 * 11, 差 = 7
3log2 + 2log5 + 2log7 = 4log3 + 2log11 (9800, 9801)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
5log2 + log3 + 2log5 = 4log7 (2400, 2401)
2log3 + 4log5 = 9log2 + log11 (5625, 5632)
log2 + log5 = 1
↓
log2 = 270/897 = 0.301003 (真値 0.301030)
log3 = 428/897 = 0.477146 (真値 0.477121)
log5 = 627/897 = 0.698997 (真値 0.698970)
log7 = 758/897 = 0.845039 (真値 0.845098)
log11 = 934/897 = 1.041249 (真値 1.041393)
897は上の方で568に次いで精度の良い分母です。

(1億まで)
0.000016089 3294172 3294225
0.000022158 67108864 67110351
0.000040616 78121827 78125000
0.000050668 14348180 14348907
3294172 = 2^2 * 7^7, 3294225 = 3^2 * 5^2 * 11^4, 差 = 53 (素数)
67108864 = 2^26, 67110351 = 3 * 7^5 * 11^3, 差 = 1487 (素数)
78121827 = 3^13 * 7^2, 78125000 = 2^3 * 5^10, 差 = 3173 = 19 * 167
14348180 = 2^2 * 5 * 7^2 * 11^4, 14348907 = 3^15, 差 = 727 (素数)
2log2 + 7log7 = 2log3 + 2log5 + 4log11 (3294172, 3294225)
26log2 = log3 + 5log7 + 3log11 (67108864, 67110351)
13log3 + 2log7 = 3log2 + 10log5 (78121827, 78125000)
2log2 + log5 + 2log7 + 4log11 = 15log3 (14348180, 14348907)
log2 + log5 = 1
↓
log2 = 6421/21330 = 0.3010314 (真値 0.3010300)
log3 = 10177/21330 = 0.4771214 (真値 0.4771213)
log5 = 14909/21330 = 0.6989686 (真値 0.6989700)
log7 = 18026/21330 = 0.8451008 (真値 0.8450980)
log11 = 22213/21330 = 1,0413971 (真値 1.0413927)
結構精度が上がりました。

【13も追加した場合】

(1万まで)
0.000102041 9800 9801
0.000150263 6655 6656
0.000228624 4374 4375
0.000236742 4224 4225
0.000244200 4095 4096
0.000330688 3024 3025
0.000416667 2400 2401
9800 = 2^3 * 5^2 * 7^2, 9801 = 3^4 * 11^2
6655 = 5 * 11^3, 6656 = 2^9 * 13
4374 = 2 * 3^7, 4375 = 5^4 * 7
4224 = 2^7 * 3 * 11, 4225 = 5^2 * 13^2
4095 = 3^2 * 5 * 7 * 13, 4096 = 2^12
3024 = 2^4 * 3^3 * 7, 3025 = 5^2 * 11^2
2400 = 2^5 * 3 * 5^2, 2401 = 7^4
3log2 + 2log5 + 2log7 = 4log3 + 2log11 (9800, 9801)
log5 + 3log11 = 9log2 + log13 (6655, 6656)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
7log2 + log3 + log11 = 2log5 + 2log13 (4224, 4225)
2log3 + log5 + log7 + log13 = 12log2 (4095, 4096)
log2 + log5 = 1
→ 一次従属
3log2 + 2log5 + 2log7 = 4log3 + 2log11 (9800, 9801)
log5 + 3log11 = 9log2 + log13 (6655, 6656)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
7log2 + log3 + log11 = 2log5 + 2log13 (4224, 4225)
2log3 + log5 + log7 + log13 = 12log2 (4095, 4096)
4log2 + 3log3 + log7 = 2log5 + 2log11 (3024, 3025)
log2 + log5 = 1
→ 一次従属 (式が一つ多くてもなお一次従属なので他の式が必要)
3log2 + 2log5 + 2log7 = 4log3 + 2log11 (9800, 9801)
log5 + 3log11 = 9log2 + log13 (6655, 6656)
log2 + 7log3 = 4log5 + log7 (4374, 4375)
7log2 + log3 + log11 = 2log5 + 2log13 (4224, 4225)
5log2 + log3 + 2log5 = 4log7 (2400, 2401)
log2 + log5 = 1
↓
log2 = 270/897 = 0.301003 (真値 0.301030)
log3 = 428/897 = 0.477146 (真値 0.477121)
log5 = 627/897 = 0.698997 (真値 0.698970)
log7 = 758/897 = 0.845039 (真値 0.845098)
log11 = 934/897 = 1.041249 (真値 1.041393)
log13 = 999/897 = 1.113712 (真値 1.113943)
11だけ追加したときと同じ精度です。

(1億まで)
0.000007456 5767125 5767168
0.000008117 123200 123201
0.000013783 72772425 72773428
0.000015573 1990625 1990656
0.000016089 3294172 3294225
0.000018861 19140264 19140625
0.000022158 67108864 67110351
5767125 = 3 * 5^3 * 7 * 13^3, 5767168 = 2^19 * 11, 差 = 43 (素数)
123200 = 2^6 * 5^2 * 7 * 11, 123201 = 3^6 * 13^2
72772425 = 3^7 * 5^2 * 11^3, 72773428 = 2^2 * 7^2 * 13^5, 差 = 1003 = 17 * 59
1990625 = 5^5 * 7^2 * 13, 1990656 = 2^13 * 3^5, 差 = 31 (素数)
3294172 = 2^2 * 7^7, 3294225 = 3^2 * 5^2 * 11^4, 差 = 53 (素数)
19140264 = 2^3 * 3^2 * 11^2 * 13^3, 19140625 = 5^8 * 7^2, 差 = 361 = 19^2
67108864 = 2^26, 67110351 = 3 * 7^5 * 11^3, 差 = 1487 (素数)
log3 + 3log5 + log7 + 3log13 = 19log2 + log11 (5767125, 5767168)
6log2 + 2log5 + log7 + log11 = 6log3 + 2log13 (123200, 123201)
7log3 + 2log5 + 3log11 = 2log2 + 2log7 + 5log13 (72772425, 72773428)
5log5 + 2log7 + log13 = 13log2 + 5log3 (1990625, 1990656)
2log2 + 7log7 = 2log3 + 2log5 + 4log11 (3294172, 3294225)
log2 + log5 = 1
→ 一次従属
log3 + 3log5 + log7 + 3log13 = 19log2 + log11 (5767125, 5767168)
6log2 + 2log5 + log7 + log11 = 6log3 + 2log13 (123200, 123201)
7log3 + 2log5 + 3log11 = 2log2 + 2log7 + 5log13 (72772425, 72773428)
2log2 + 7log7 = 2log3 + 2log5 + 4log11 (3294172, 3294225)
3log2 + 2log3 + 2log11 + 3log13 = 8log5 + 2log7 (19140264, 19140625)
log2 + log5 = 1
↓
log2 = 6079/20194 = 0.3010300089 (真値 0.3010299957)
log3 = 9635/20194 = 0.4771219174 (真値 0.4771212547)
log5 = 14115/20194 = 0.6989699911 (真値 0.6989700043)
log7 = 17066/20194 = 0.8451025057 (真値 0.8450980400)
log11 = 21030/20194 = 1.0413984352 (真値 1.0413926852)
log13 = 22495/20194 = 1.1139447361 (真値 1.1139433523)
精度は11だけ追加のときと同程度です。
（log2とlog5は精度がいいですが、他はそこまで良くありません）

【29まで追加した場合（素数10個）】
(1億まで)
0.000000010 96059600 96059601
0.000000055 18085704 18085705
0.000000075 26578123 26578125
0.000000084 11859210 11859211
0.000000095 10556000 10556001
0.000000121 8268799 8268800
0.000000155 12901779 12901781
0.000000169 5909760 5909761
0.000000194 5142500 5142501
0.000000244 4096575 4096576
0.000000244 4090624 4090625
0.000000250 4004000 4004001
0.000000315 22194425 22194432
0.000000365 13697019 13697024
0.000000365 90312467 90312500
0.000000371 2697695 2697696
0.000000485 8254125 8254129
0.000000489 88012332 88012375
0.000000494 2023424 2023425
0.000000520 90312453 90312500
0.000000540 1852200 1852201
0.000000560 67874587 67874625
0.000000569 75557027 75557070
0.000000587 46000759 46000786
96059600 = 2^4 * 5^2 * 7^2 * 13^2 * 29, 96059601 = 3^8 * 11^4
18085704 = 2^3 * 3 * 7^3 * 13^3, 18085705 = 5 * 11 * 17 * 23 * 29^2
26578123 = 11 * 13^2 * 17 * 29^2, 26578125 = 3^5 * 5^6 * 7
11859210 = 2 * 3^4 * 5 * 11^4, 11859211 = 7 * 13 * 19^4
10556000 = 2^5 * 5^3 * 7 * 13 * 29, 10556001 = 3^4 * 19^4
8268799 = 7^2 * 11 * 23^2 * 29, 8268800 = 2^10 * 5^2 * 17 * 19
12901779 = 3^2 * 11 * 19^4, 12901781 = 23^2 * 29^3
5909760 = 2^8 * 3^5 * 5 * 19, 5909761 = 11^2 * 13^2 * 17^2
5142500 = 2^2 * 5^4 * 11^2 * 17, 5142501 = 3^3 * 7^2 * 13^2 * 23
4096575 = 3^4 * 5^2 * 7 * 17^2, 4096576 = 2^6 * 11^2 * 23^2
4090624 = 2^8 * 19 * 29^2, 4090625 = 5^5 * 7 * 11 * 17
4004000 = 2^5 * 5^3 * 7 * 11 * 13, 4004001 = 3^2 * 23^2 * 29^2
22194425 = 5^2 * 11^3 * 23 * 29, 22194432 = 2^8 * 3^3 * 13^2 * 19
13697019 = 3^4 * 7^3 * 17 * 29, 13697024 = 2^16 * 11 * 19
90312467 = 7 * 23^2 * 29^3, 90312500 = 2^2 * 5^7 * 17^2
2697695 = 5 * 7^3 * 11^2 * 13, 2697696 = 2^5 * 3^2 * 17 * 19 * 29
8254125 = 3^2 * 5^3 * 11 * 23 * 29, 8254129 = 13^4 * 17^2
88012332 = 2^2 * 3^4 * 17 * 19 * 29^2, 88012375 = 5^3 * 11^3 * 23^2
2023424 = 2^13 * 13 * 19, 2023425 = 3^2 * 5^2 * 17 * 23^2
90312453 = 3^2 * 7 * 11 * 19^4, 90312500 = 2^2 * 5^7 * 17^2
1852200 = 2^3 * 3^3 * 5^2 * 7^3, 1852201 = 13 * 17^3 * 29
67874587 = 11^2 * 23 * 29^3, 67874625 = 3^3 * 5^3 * 7 * 13^2 * 17
75557027 = 7 * 13^3 * 17^3, 75557070 = 2 * 3^3 * 5 * 23^4
46000759 = 7^6 * 17 * 23, 46000786 = 2 * 13^3 * 19^2 * 29
4log2 + 2log5 + 2log7 + 2log13 + log29 = 8log3 + 4log11 (96059600, 96059601)
3log2 + log3 + 3log7 + 3log13 = log5 + log11 + log17 + log23 + 2log29 (18085704, 18085705)
log11 + 2log13 + log17 + 2log29 = 5log3 + 6log5 + log7 (26578123, 26578125)
log2 + 4log3 + log5 + 4log11 = log7 + log13 + 4log19 (11859210, 11859211)
2log7 + log11 + 2log23 + log29 = 10log2 + 2log5 + log17 + log19 (8268799, 8268800)
2log3 + log11 + 4log19 = 2log23 + 3log29 (12901779, 12901781)
8log2 + 5log3 + log5 + log19 = 2log11 + 2log13 + 2log17 (5909760, 5909761)
4log3 + 2log5 + log7 + 2log17 = 6log2 + 2log11 + 2log23 (4096575, 4096576)
6log7 + log17 + log23 = log2 + 3log13 + 2log19 + log29 (46000759, 46000786)
log2 + log5 = 1
↓
log2 = 360565/1197771 = 0.3010299966 (真値 0.3010299957)
log3 = 571482/1197771 = 0.4771212527 (真値 0.4771212547)
log5 = 837206/1197771 = 0.6989700034 (真値 0.6989700043)
log7 = 1012234/1197771 = 0.8450981031 (真値 0.8450980400)
log11 = 1247350/1197771 = 1.0413927203 (真値 1.0413926852)
log13 = 1334249/1197771 = 1.1139433164 (真値 1.1139433523)
log17 = 1473796/1197771 = 1.2304488922 (真値 1.2304489214)
log19 = 1531654/1197771 = 1.2787536182 (真値 1.2787536010)
log23 = 1631038/1197771 = 1.3617277426 (真値 1.3617278360)
log29 = 1751618/1197771 = 1.4623980711 (真値 1.4623979979)
分母の1197771は10000000までで最も誤差が少なくなる値です。
# 誤差の少ない順に9個+(log2+log5=1)だと一次従属になります。
# そこから1個ずつ追加していってもしばらく一次従属のままで、
# 24個目の(46000759,46000786)の式を追加してようやく一次独立になります。
# そしてそこから逆順に消せる行を消していって10行に減らしたのが
# 上に書いた式です。
結論として、素数を2,3,5,7に限定してしまうと巨大な数にしても
あまり精度が向上しませんが、素数の個数を増やしていけば
現実的な値（といっても手計算は無理）で精度を上げられることが
わかりました。

非常に深く調査してくださり、ありがとうございました。
だんだんと方程式が一時従属になってしまう問題が強敵になっていくのは思いもよりませんでした。
手計算でやる大変さと得られるもののバランス的には、最初のやつが思った以上に優秀だったんですねえ……。

10人いたら簡単だとして、9人解ができそうでできない……
必要な最少人数って何人なんでしょうね？

DD++さんにとっては 10人は簡単……　うお。

9人解の探索をしようと思い、ファノ平面は使えないかと思いつきまして。

"000 000 000 ", 0,0,0,
"110 011 101 ", 6,3,5,
"111 110 001 ", 7,6,1,
"010 100 110 ", 2,4,6,
"011 001 010 ", 3,1,2,
"100 111 011 ", 4,7,3,
"001 101 100 ", 1,5,4,
"101 010 111 ", 5,2,7

これ、使えませんし、ここになにか1ビットを追加してもどうにもならないのでした。
たとえば
"010 100 110 ", 2,4,6,
"011 001 010 ", 3,1,2,
"001 101 100 ", 1,5,4,
の部分だけでも、1ビットを増やしたくらいでは、2人の嘘つきを確定できません。

はい、10人なら簡単です。
9人の場合も嘘つきが「確定2人」なら可能なんですけどねえ……

「確定２人」というお言葉に驚きました。
探したのですが、見つからず、です。

副産物として、以下の通りの変なものを見つけました。

3 ビットの 7 つの数を数珠つなぎにします。
" 100 111 010 110 001 011 101 "
数珠ですので、最後尾の 101 の次には 先頭の 100 につながることとします。

この数珠の、三連続する数の組みは　七通りあるわけですが、それぞれの組のなかの3つの数を XOR 演算すると、被らずに 001 から 111 までが漏れなく勢揃いします。(下記に一覧します)

onst codes = [
"100 111 010 ", // XOR結果 001
"111 010 110 ", // XOR結果 011
"010 110 001 ", // XOR結果 101
"110 001 011 ", // XOR結果 100
"001 011 101 ", // XOR結果 111
"011 101 100 ", // XOR結果 010
"101 100 111 ", // XOR結果 110
];

この結果は、よくわかりませんが、いわゆる魔円陣のバリエーションですね。

さて、上の一覧を、「放射能検査のために9人それぞれに割り当てる金貨の一覧(但し、0をガイガーカウンターではかる印とし、一覧にはないが全員がはかる金貨も１枚ある)」と見立てると……
ほんとに惜しいんです。
残りのひとりの10番目の技術者が検査すれば偽造金貨は見つかるのですけれど。

うーん残念。あとひとりをどうしても省力化したいのですが。

9人で嘘つきが確定2人の場合の手順は、以下です。

まず、
1人目と2人目：1,2,3,4
3人目と4人目：1,2,5,6
5人目と6人目：1,3,5,7
と測定します。

うち1回でも2人から不一致な報告された場合は、7人目と8人目にそれ（のうちの1つ）と同じ測定してもらいます。
不一致な報告が一度でもあったなら、2人が一致した報告は全て信頼できるので、これで
・上記3パターンの信頼できる結果が出揃っている
・上記3パターンのうち2パターンの信頼できる結果があり、9人目が正直者確定
のいずれかになっています。
前者はすでに偽物確定、後者は結果が得られていないものを9人目に頼めばいいです。

3組全てで一致する結果が報告された場合、例えば全て放射線検出されたと報告された場合は以下の4つの可能性があります。（他のパターンも番号が変わるだけで論理は同じ実質同じ）
・1が偽物で、残り3人に「確定で2人」嘘つきがいる
・2が偽物で、残り3人に嘘つきはいない
・3が偽物で、残り3人に嘘つきはいない
・5が偽物で、残り3人に嘘つきはいない
この場合、残り3人に、2と3と5をそれぞれ単体で調べてもらいます。
1人だけが放射線検出を報告した場合、その人の調べたコインが偽物です。（※）
2人が放射線検出を報告した場合、その2人が嘘つきで、1が偽物です。


嘘つきが「最大で2人」の場合、※のところで1が偽物で嘘つきが1人しかいなかった可能性が消し切れません。

DD++ さん、
すごいですね！！！

てっきりパリティビットが何らかの理由で不要になってしまった 9 ビットの符号なのかと予想しておりました。全符号の、符号全体のパリティが同一ならば、その 1 ビットは不要となりますので、それで稼いだのかと……

まさかの、頭の固い私には無理な発想です。
ご教示をありがとうございます。

数珠つなぎの件、中途半端な記述でしたので
精いっぱいきちんと投稿させていただきたく
文を練りました。以下です。

3 ビットのビット列が 7 つあり、それぞれを a, b, c, d, e, f, g と名付けます。この他に、3ビットのビット列が 1 つあり、これを z とします。
z = 000
とします。また、
a = 100
b = 111
c = 010
d = 110
e = 001
f = 011
g = 101
とします。

このとき以下の性質があります。(ここでは⊕を排他的論理和とします。)
e = a⊕b⊕c
f = b⊕c⊕d
g = c⊕d⊕e
a = d⊕e⊕f
b = e⊕f⊕g
c = f⊕g⊕a
d = g⊕a⊕b
《※サイクリックとなっています。》

3ビットのビット列 x のパリティをここでは p(x) と書くこととします。
ビット列の結合を∥で表します。たとえば
x = 011, y = 101 のとき
x∥y = 011101 となります。

e, f, g, a, b, c, d, z をエンコードして 10 ビットにしたものをそれぞれ、E, F, G, A, B, C, D, Z と名付けます。

さきほどのサイクリックな表をみながら、

E = a∥b∥c∥p(c)
F = b∥c∥d∥p(d)
G = c∥d∥e∥p(e)
A = d∥e∥f∥p(f)
B = e∥f∥g∥p(g)
C = f∥g∥a∥p(a)
D = g∥a∥b∥p(b)
Z = z∥z∥z∥p(z)
とします。

具体的には

E=100∥111∥010∥1 ←e=001
F=111∥010∥110∥0 ←f=011
G=010∥110∥001∥1 ←g=101
A=110∥001∥011∥0 ←a=100
B=001∥011∥101∥0 ←b=111
C=011∥101∥100∥1 ←c=010
D=101∥100∥111∥1 ←d=110
Z=000∥000∥000∥0 ←z=000
となります。

このようにサイクリックに作成した符号は、
最小ハミング距離が 5 となっています。

これで、不正確なガイガーカウンター報告の数が 0 から 2 までの間ならば、その誤りビットを訂正可能です。

他にも色々な作り方をしてはみたのですが、一番不思議な踊りを踊っているのが上記のものです。なぜうまくいくのかわからないので。タマタマなのかも？　しれません。

他の作り方のものも、近々、ご紹介させてください。

情報ビットが3ビットでコード長が10ビットのコードで、最小ハミング距離が5のコードであれば、2ビットまでの誤りを検出して訂正することができますが、そのようなコードとして、

0,0,0,0,0,0,0,0,0,0
1,0,0,1,1,0,0,1,1,1
0,1,0,1,0,1,0,1,1,0
1,1,0,0,1,1,0,0,0,1
0,0,1,1,0,0,1,1,0,1
1,0,1,0,1,0,1,0,1,0
0,1,1,0,0,1,1,0,1,1
1,1,1,1,1,1,1,1,0,0

というコードが考えられます。10人の技術者をA～Jとして、
技術者AとEは、1,3,5,7番の金貨を選択して測定、
技術者BとFは、2,3,6,7番の金貨を選択して測定、
技術者CとGは、4,5,6,7番の金貨を選択して測定、
技術者DとHは、1,2,4,7番の金貨を検出して測定、
技術者Iは1,2,5,6番の金貨を選択して測定、
技術者Jは1,3,4,6番の金貨を選択して測定することにして、
各技術者の陽性の報告を「1」、陰性の報告を「0」で表すと、
すべての報告が正しかったとすると、以下の8通りの組み合わせ
があって、それぞれが1～8番のいずれかが偽造品である場合
と対応します。

-|A,B,C,D,E,F,G,H,I,J
0|0,0,0,0,0,0,0,0,0,0 →8番が偽造品
1|1,0,0,1,1,0,0,1,1,1 →1番が偽造品
2|0,1,0,1,0,1,0,1,1,0 →2番が偽造品
3|1,1,0,0,1,1,0,0,0,1 →3番が偽造品
4|0,0,1,1,0,0,1,1,0,1 →4番が偽造品
5|1,0,1,0,1,0,1,0,1,0 →5番が偽造品
6|0,1,1,0,0,1,1,0,1,1 →6番が偽造品
7|1,1,1,1,1,1,1,1,0,0 →7番が偽造品

10人の技術者の報告のうち2人の報告が誤りである場合は、
10ビットのうち2ビットが誤りである場合に相当しますが、
上記の8状態は最小ハミング距離が5なのでいずれも5ビット
以上の差があり、2ビットの誤り、すなわち、2人の報告が
誤りである場合までは訂正することができます。

技術者が 10 → 21 人に増員されたときに、最大 5人 までの範囲で誤った報告をしてきても偽金貨を突き止めることができると判明しました。

"100 111 010 110 001 011 101",
"111 010 110 001 011 101 100",
"010 110 001 011 101 100 111",
"110 001 011 101 100 111 010",
"001 011 101 100 111 010 110",
"011 101 100 111 010 110 001",
"101 100 111 010 110 001 011",
"000 000 000 000 000 000 000",

Minimum Hamming Distance: 12

なお、上記では 21 中に、誤らない技術者が1人報告をロストしても大丈夫です。
1人ロストかつ２人誤り報告でも。
対称性が高いので。

別の言い方をすれば
技術者が 10 → 20 人に増員されたときに、最大 5人 までの範囲で誤った報告をしてきても偽金貨を突き止めることができます。
Minimum Hamming Distance: 11
となりますので。

元の問題からみると、
技術者が2倍に増えて
許容できる誤り報告数が2.5倍です。

こんなのをみるとやはり
9人の技術者(うち最大2名は嘘つき)
でもできるのでは？と変な予想をたててしまいたくなります。

情報ビットが3ビット、最小ハミング距離が7のコードで、最短なのはコード長が13ビットのコードで、以下のようなものでした。

A,B,C,D,E,F,G,H,I,J,K,L,M
-------------------------
0,0,0,0,0,0,0,0,0,0,0,0,0
1,0,0,1,1,0,1,0,0,1,1,0,1
0,1,0,1,0,1,0,1,0,1,0,1,1
1,1,0,0,1,1,1,1,0,0,1,1,0
0,0,1,0,1,1,0,0,1,0,1,1,1
1,0,1,1,0,1,1,0,1,1,0,1,0
0,1,1,1,1,0,0,1,1,1,1,0,0
1,1,1,0,0,0,1,1,1,0,0,0,1

13人の技術者をA～Mとして、
技術者AとGは、1,3,5,7番の金貨を選択して測定、
技術者BとHは、2,3,6,7番の金貨を選択して測定、
技術者CとIは、4,5,6,7番の金貨を選択して測定、
技術者DとJは、1,2,5,6番の金貨を選択して測定、
技術者EとKは、1,3,4,6番の金貨を選択して測定、
技術者FとLは、2,3,4,5番の金貨を選択して測定、
技術者Mは、1,2,4,7番の金貨を検出して測定することにすれば、
最大で3人までが誤りの報告をしても8枚の金貨から1枚の偽造品を特定できます。

また、情報ビットが3ビット、最小ハミング距離が9のコードで、最短なのはコード長が17ビットのコードで、以下のようなものでした。

A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q
---------------------------------
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1,0,0,1,0,0,1,0,0,1,1,1,0,1,1,1,0
0,1,0,0,1,0,0,1,0,1,1,0,1,1,1,0,1
1,1,0,1,1,0,1,1,0,0,0,1,1,0,0,1,1
0,0,1,0,0,1,0,0,1,1,0,1,1,1,0,1,1
1,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,1
0,1,1,0,1,1,0,1,1,0,1,1,0,0,1,1,0
1,1,1,1,1,1,1,1,1,1,0,0,0,1,0,0,0

17人の技術者をA～Qとして、
技術者AとDとGは、1,3,5,7番の金貨を選択して測定、
技術者BとEとHは、2,3,6,7番の金貨を選択して測定、
技術者CとFとIは、4,5,6,7番の金貨を選択して測定、
技術者JとNは、1,2,4,7番の金貨を検出して測定、
技術者KとOは、1,2,5,6番の金貨を選択して測定、
技術者LとPは、1,3,4,6番の金貨を選択して測定、
技術者MとQは、2,3,4,5番の金貨を選択して測定することにすれば、
最大で4人までが誤りの報告をしても8枚の金貨から1枚の偽造品を特定できます。

なお、情報ビットが3ビット、最小ハミング距離が3のコードで、最短なのはコード長が6ビットのコードで、以下のようなものでした。

A,B,C,D,E,F
-----------
0,0,0,0,0,0
1,0,0,1,1,0
0,1,0,1,0,1
1,1,0,0,1,1
0,0,1,0,1,1
1,0,1,1,0,1
0,1,1,1,1,0
1,1,1,0,0,0

6人の技術者をA～Fとして、
技術者Aは、1,3,5,7番の金貨を選択して測定、
技術者Bは、2,3,6,7番の金貨を選択して測定、
技術者Cは、4,5,6,7番の金貨を選択して測定、
技術者Dは、1,2,5,6番の金貨を選択して測定、
技術者Eは、1,3,4,6番の金貨を選択して測定、
技術者Fは、2,3,4,5番の金貨を選択して測定することにすれば、
1人までが誤りの報告をしても8枚の金貨から1枚の偽造品を特定できます。

DD++ さんがおっしゃっていた、
《10人ではなく9 人、うち2名は《必ず》嘘をつく》場合に解があることを私も確認しました。別解ですね。

9人の技術者を前半組6人、後半組3人にわけます。
前半では①と②と③とのどれかが発生します。どれが発生したかは我々にはわかります。
後半では、①②③ごとに、対処策があります。

・前半部
8枚の金貨を２枚づつペアにして計4ペアとします。(A,a), (B,b),(C ,c ),(D,d)と名付けます。あるいは(X,x)のようにまとめて書くこともあります。

６名の技術者に以下のように測定の指示を出します。1 のマークがついた金貨を測ります。

[
"0 0 0 0 0 0" ,//(A,a)
"0 0 1 1 1 1" ,//(B,b)
"1 1 0 0 1 1" ,//(C,c)
"1 1 1 1 0 0" ,//(D,d)
]

上はハミング距離が 4 なので
以下の3つのケースが結果として判明します。


①
陽性判定は偶数個である。
が、そのものズバリの判定結果が得られない。
すなわち、前半6人組に２人嘘つきがいる。
偽物の入った(X,x)はこの時点ではまったく不明。

②
陽性判定は偶数個である、かつ、
上の4ケースそれぞれのうちどれかひとつが
そのものズバリの結果となる。

このとき前半6人組に嘘つきがいない。
偽物の入った(X,x)が確定する。

③
陽性判定は奇数個である。
が、そのものズバリの判定結果が得られない。
すなわち、前半6人組に１人の嘘つきがいる。
この場合には嘘つきが特定できて、
偽物の入った(X,x)が確定する。

以上が前半部です。

次は後半部での対処。

①:
後半部3名の技術者が正直者なので、
８枚の金貨から１枚の偽金貨を見付けるには
二分木で捜索すればよい。
《目的終了》

②
偽物の入った(X,x)が確定している。
残りの３名の技術者のうち２名が嘘つきである。
３名にXが偽造か調べさせ、得られた結果を２対１で多数決をとり、その結果の判定を反転させたものが真の測定結果となる。
《目的終了》

③
偽物の入った(X,x)が確定している。
残りの３名の技術者のうち１名が嘘つきである。
３名にXが偽造か調べさせ、得られた結果を２対１で多数決をとり、その結果が真の測定結果となる。
《目的終了》

※以上が別解です.
後半部の多数決が効いてくるためにも、嘘つき２名は必ず嘘をつくことが必要となります。

=====

なお、揃って嘘をつくとは限らない場合に
9名で足りるかというお話しについては、
私は、かなり否定的に捉えるようになりました。
個人的には探索はおわります。

技術者を1人増やして11人にすると、偽造品1枚を含む16枚の金貨から、最大2人の誤りを含む報告を用いて特定することができます。

情報ビットが4ビット、最小ハミング距離が5のコードで、最短なのはコード長が11ビットの以下のコードで、これを用いると、

-|A,B,C,D,E,F,G,H,I,J,K
-----------------------
0|0,0,0,0,0,0,0,0,0,0,0→16番が偽造品
1|1,0,0,0,1,1,1,0,0,1,0→1番が偽造品
2|0,1,0,0,1,1,0,1,1,0,1→2番が偽造品
3|1,1,0,0,0,0,1,1,1,1,1→3番が偽造品
4|0,0,1,0,1,0,1,1,1,0,0→4番が偽造品
5|1,0,1,0,0,1,0,1,1,1,0→5番が偽造品
6|0,1,1,0,0,1,1,0,0,0,1→6番が偽造品
7|1,1,1,0,1,0,0,0,0,1,1→7番が偽造品
8|0,0,0,1,0,1,1,0,1,1,1→8番が偽造品
9|1,0,0,1,1,0,0,0,1,0,1→9番が偽造品
a|0,1,0,1,1,0,1,1,0,1,0→10番が偽造品
b|1,1,0,1,0,1,0,1,0,0,0→11番が偽造品
c|0,0,1,1,1,1,0,1,0,1,1→12番が偽造品
d|1,0,1,1,0,0,1,1,0,0,1→13番が偽造品
e|0,1,1,1,0,0,0,0,1,1,0→14番が偽造品
f|1,1,1,1,1,1,1,0,1,0,0→15番が偽造品

11人の技術者をA～Kとして、
技術者Aは、1,3,5,7,9,11,13,15番の金貨を選択して測定、
技術者Bは、2,3,6,7,10,11,14,15番の金貨を選択して測定、
技術者Cは、4,5,6,7,12,13,14,15番の金貨を選択して測定、
技術者Dは、8,9,10,11,12,13,14,15番の金貨を選択して測定、
技術者Eは、1,2,4,7,9,10,12,15番の金貨を検出して測定、
技術者Fは、1,2,5,6,8,11,12,15番の金貨を選択して測定、
技術者Gは、1,3,4,6,8,10,13,15番の金貨を選択して測定、
技術者Hは、2,3,4,5,10,11,12,13番の金貨を選択して測定、
技術者Iは、2,3,4,5,8,9,14,15番の金貨を選択して測定、
技術者Jは、1,3,5,7,8,10,12,14番の金貨を選択して測定、
技術者Kは、2,3,6,7,8,9,12,13番の金貨を検出して測定することにすれば、
最大で2人までが誤りの報告をしても16枚の金貨から1枚の偽造品を特定できます。

kuiperbeltさんによる[2151]のご投稿へのコメントです。
8 番から 15 番までは本物、という情報があらかじめ与えられていれば
技術者Dによる計測は不要となり、技術者の総人数は 10 人でよいこととなります。

すなわち
0番(=16番)から7番までの8枚の金貨から技術者10名で１枚の偽造金貨をみつける方法にもなっています。(最大2人まで嘘をつくこととして)

私の[2140]の投稿の続きです。
別解でして、恐ろしく形が憶えやすいものです。

情報ビットは 3 ビットとします。これを w と記します。
w について全てのビットを反転したものを W とします。
3 ビット分のデータのパリティ(1ビット)を求める関数を p(・)と書きます。
ビット列 x とビット列 y とを結合する記号を∥とします。

w をエンコードして 10 ビットのビット列を次のように作ります。

w∥w∥p(w)∥w ……ただしp(w)=0 のとき。
w∥w∥p(w)∥W ……ただしp(w)=1 のとき。

これが目的を果たします。
みつけたときには物凄くビックリしました。
なぜコレでうまくいくかというとゴニョゴニョです。

> なぜコレでうまくいくかというとゴニョゴニョです。

3ビットの w を１ビットづつに分解すると
w=w1∥w2∥w3
さきのエンコードは
w1∥w2∥w3∥w1∥w2∥w3∥w1+w2+w3∥w2+w3∥w1+w3∥w2+w3
トなっています。

※ただし加算記号は ビット毎の排他的論理和にて。。

このスレッドの趣旨からは脱線中です。

本日考えた[2154]への個人的な気づきです。

「コレ」でうまく行く？　という観察から実験数学的にあれこれやっておりました。

符号語の数が 16 で情報ビットが 4 、検査ビットが 3 、符号長が 7 、最小ハミング距離が 3 ゆえにビット反転誤りを 1 ビットまで訂正可能な、(7,4,3)ハミング符号は、よく知られていて世の中に実際に応用されている枯れた技術のようです。

これに対抗して！？

符号語の数が 16 で情報ビットが 4 、検査ビットが 10 、符号長が 14 、最小ハミング距離が 7 ゆえにビット反転誤りを 3 ビットまで訂正可能な、そのような符号をたった今みつけました。(車輪の再発明かも？)

情報ビットをそのままに、符号長が 7 から 14 と2倍になるのを生贄にして、
ビット反転誤りへの訂正能力を 1 ビットから 3 ビットへと、 3 倍にできるという。

通信路の状況が悪いときにはかなり有効なのでは？　と。

"0000 000000 0000",
"0001 001011 0111",
"0011 011110 1100",
"0010 010101 1011",
"0110 110011 0110",
"0111 111000 0001",
"0101 101101 1010",
"0100 100110 1101",
"1100 011110 0011",
"1101 010101 0100",
"1111 000000 1111",
"1110 001011 1000",
"1010 101101 0101",
"1011 100110 0010",
"1001 110011 1001",
"1000 111000 1110",

　16ビットめへの追加、末尾に全体へのパリティをつけるのも乙なものですが。

とにかく各ビットを怠けさせない、他のビットと相関させる、そんな作戦が良いのかもしれません。

DD++ さんが提起なさった
《技術者が 9 人でも大丈夫？》という問い
について何度も諦めようと努めたのですが
なかなか頭を離れず、もう思い切ってとことん考えてみようと試みました。

結果として、もしもひとつの【予想】が正しければ、 9 人の技術者(うち、嘘つきは 0 人から 2 人の可能性がある)でも、8枚中１枚の偽金貨を突き止められそうと考えつきました。

偽金貨をつきとめる段階として、第一段階と第二段階とに分けます。
第二段階では第一段階までの中間結果をみてから測定方法を都度考えることにします。
(なお二段階にわけずに一発でやろうとするならば技術者は10人必要だろうことはほぼ間違いないという感触を得ています。)

第一段階では、７人の技術者を使い
第二段階では、２人の技術者を使います。

第一段階終了時点で既に偽造金貨が確定済みならば第二段階は実行しません。この場合の発生条件は、７人中嘘つきが１人以下であることです。(必要十分条件)

第一段階終了時点で７名中嘘つきが２名いたと確定できれば、かつ、8枚中少なくとも4枚が本物であると確定できれば、残りの４枚について第二段階で正直者のみで構成された２名の技術者がうち１枚の偽金貨を確定できることでしょう。

第一段階のアルゴリズムになにが必要かをまとめなおします。
以下の３パターンのどれかが必ず発生するものとします。

①嘘つきがちょうど１人発生したことの検知確定と、同時に一枚の偽金貨の確定。
[第二段階不要]

②嘘つきがちょうど０人であることの検知確定と、同時に一枚の偽金貨の確定。
[第二段階不要]

③嘘つきがちょうど２人であることの検知確定と、同時に、本物の金貨(少なくとも)４枚の確定。偽金貨は残りもののなかにあると絞れる。
[第二段階では２人の正直者が残りものから偽金貨をつきとめることになりますがそれは十分に可能であることでしょう。]

上のようなアルゴリズムがみつかれば、10人ならず9人でも偽金貨を確定できることとなります。

①〜③までで、もっとも難解なのが③が発生するケースです。

私は次のようなものをとりあえず考えてみました。

(長くなったので次に投稿します。)

第一段階の設計について。

８枚の硬貨にたいして７名の技術者が以下のリストにあるように測定します。
(1 )はガイガーカウンターで測ります。

"0 0 0 0 0 0 0",
"0 0 1 0 1 1 1",
"1 0 0 1 0 1 1",
"1 1 0 0 1 0 1",
"1 1 1 0 0 1 0",
"0 1 1 1 0 0 1",
"1 0 1 1 1 0 0",
"0 1 0 1 1 1 0",

ケース①
７つの測定結果が得られた時
陽性(1)が、奇数個、得られたケースです。
このとき、７名中に嘘つきは必ず１名です。
上のテーブルでは最小ハミング距離が４なので嘘つきも確定し偽金貨も確定します。
第二段階は不要です。

ケース②
７つの測定結果が得られた時　
陽性(1)が、偶数個、得られ、かつ、
上のテーブルと一致したケースです。
このとき、７名中に嘘つきはいません。
偽金貨も確定します。
第二段階は不要です。

ケース③
７つの測定結果が得られた時　
陽性(1)が、偶数個、得られ、かつ、
上のテーブルと【一致しない】ケースです。
このとき、７名中の嘘つきは必ず２名です。

偽金貨は確定しません。
２名の正直者が待っている第二段階が必要です。

=====

ここで実験的にかなりやり込んでみたのですが (手動)
偽測定値を２個含む７個のデータを得られたときに、
偽金貨の候補は《いつも》３枚なのです。
ということは第二段階で偽金貨が確定できることとなります。

以下が私の【予想】です。

偽測定値を２個含む７個のデータを得られたときに、
偽金貨の候補は《いつも》３枚です。

============

上記の予想に反例があったり、証明があるようでしたならば、是非とも、ご教示をください。

気になって気になって仕方がありません。
ぽんつくな私のことですから
ボーンヘッドがあるかも(恥ずかしい)ですけれども。

皆様、何卒ご教示を賜りたく、宜しくお願い申し上げます。

※証明の見通しがよくなるかどうかわかりませんが上記のテーブルは巡回的に作ってあります。

なるほど、カークマンの組分け問題の解を利用すれば確かにいけますね。

証明は、陽性報告の人数ごとに場合分けをすれば容易かと思います。

いかがでしょう？

DD++ さん。
早速のコメントおよびヒントを有難うございます。

陽性報告の人数で場合分け……ですか……
やってみます。

ご指摘どおりカークマンでしたね……
自分としてはファノ平面を使ったつもりでした。(0のポジション)