For each integer \(n\in\{0,1,\dots,50\}\), the problem defines an exceptional continued-fraction constant \(K_n\) coming from a dyadic truncation built out of powers of two. The final target is not one particular \(K_n\), but the geometric mean of all fifty-one constants.
The solution files make an important distinction between validation and production. The continued fraction is used only to confirm the limiting behavior numerically. The actual answer is obtained from explicit formulas for \(\log K_n\), followed by
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right).$$
So the computational problem is reduced to evaluating a short logarithmic sum accurately.
Two concrete mathematical objects appear in the implementations. The first is a finite truncation whose continued fraction gives an empirical approximation to the exceptional constant. The second is a closed form for the limiting value, and that closed form is organized by where \(n\) sits relative to neighboring powers of two.
For a truncation depth \(m\), set \(M=2^m\) and define
$$S_m=\sum_{i=0}^{m}2^{M-2^i}.$$
For a fixed \(n\), the validation experiment then forms
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}.$$
The ratio actually fed into the continued-fraction expansion is
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L],$$
and the empirical logarithmic mean of its partial quotients is
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j.$$
This \(E_{n,m}\) is not the final quantity requested by the problem. Instead, it is a finite-size observable used to check that the limiting value really is \(\log K_n\). The C++ implementation evaluates this model only for selected sample values of \(n\), precisely as a consistency check.
The production path starts from the Mersenne-type number
$$b=2^n-1.$$
From there, the formula for \(\log K_n\) depends on which dyadic region contains \(n\).
For the base case \(n=0\), the implementations use
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
so \(K_0=192^{1/4}\).
If \(n=2^t-1\) for some \(t\ge 1\), then
$$\log K_n=\frac{\log 2+2\log b}{5},$$
equivalently \(K_n=(2b^2)^{1/5}\).
If \(n=2^t\), then
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
equivalently \(K_n=b^{1/2}(b^2-1)^{1/12}\).
For the interior of a dyadic interval, let
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1.$$
Then the remaining branch is
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12},$$
or \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\).
This shows the real structure of the problem: outside the base case, the exceptional constant is determined by one Mersenne-type factor attached to \(n\) itself and, in the general dyadic interval, a second Mersenne-type factor attached to the distance from \(n\) to the next power of two.
The general interior formula contains the factors \(\log(c-1)\) and \(\log(c+1)\). If \(n=q-1=2^t-1\), then \(e=1\) and \(c=1\), so \(c-1=0\) and the term \(\log(c-1)\) breaks down. That is exactly why the “one less than a power of two” case is separated in the code.
The exact power-of-two case is cleaner. When \(n=2^t\), the dyadic interval begins at \(p=n\), hence \(q=2n\), \(e=n\), and therefore
$$c=2^e-1=2^n-1=b.$$
Substituting \(c=b\) into the general expression gives
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
which is exactly the power-of-two branch. So one boundary creates a genuine singularity, while the other collapses to a simpler identity. The branch structure is therefore a direct reflection of the dyadic geometry encoded by the formulas.
Take \(n=20\). It lies in the dyadic interval from \(16\) to \(32\), so
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
Therefore
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}.$$
Now move to \(n=31=2^5-1\). Here the distance to the next power of two is only \(1\), so the interior formula would produce \(c=1\) and \(\log(c-1)=\log 0\). The separate boundary formula avoids that problem and gives
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}.$$
At the next point, \(n=32=2^5\), the exact-power formula applies instead:
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
The same logic also explains the small checkpoint used by the validation code: for \(n=2\), the exact-power branch gives \(\exp(\log K_2)\approx 2.059767\).
The C++, Python, and Java implementations all use the same production algorithm. They iterate over \(n=0,1,\dots,50\), determine whether \(n\) is \(0\), a power of two, one less than a power of two, or an interior point of a dyadic interval, and then evaluate the corresponding closed formula for \(\log K_n\).
Those logarithms are accumulated in floating-point arithmetic, divided by \(51\), and converted back with one final exponential. This is both mathematically natural and numerically stable, because the requested result is a geometric mean. For the actual range \(0\le n\le 50\), every integer appearing in the closed formulas fits comfortably in ordinary 64-bit arithmetic.
The C++ implementation adds an explicit validation layer. It constructs the finite truncation for \(m=16\) using arbitrary-precision integers, reduces \(S_m\) modulo \(Q_{n,m}\), applies the Euclidean algorithm to extract the partial quotients of \(Q_{n,m}/R_{n,m}\), and averages their logarithms.
That empirical mean is compared against the closed formula for the sample values \(n\in\{0,1,2,5,20,31,32,50\}\), using small relative tolerances. The Python and Java implementations omit this verification path and keep only the closed-form computation needed for the final answer.
The production computation takes \(O(51)\) time and \(O(1)\) memory, because each of the fifty-one values of \(n\) is processed in constant time. If the same method were extended to \(0\le n\le N\), the cost would be \(O(N)\).
The validation layer in the C++ implementation uses arbitrary-precision arithmetic and a continued-fraction expansion, but it still contributes only fixed overhead here: the truncation depth is fixed at \(m=16\), and only eight sample values are checked.
Für jedes \(n\in\{0,1,\dots,50\}\) definiert das Problem eine Ausnahme-Konstante \(K_n\), die aus einer dyadischen Trunkierung auf Basis von Zweierpotenzen über Kettenbrüche entsteht. Gesucht ist nicht ein einzelnes \(K_n\), sondern das geometrische Mittel aller einundfünfzig Konstanten.
Die Lösungsdateien trennen dabei klar zwischen Verifikation und eigentlicher Berechnung. Der Kettenbruch dient nur zur numerischen Kontrolle des Grenzwerts. Die finale Antwort entsteht aus geschlossenen Formeln für \(\log K_n\) und anschließend
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right).$$
Damit reduziert sich das gesamte Problem auf eine kurze, aber sorgfältig strukturierte Summe von Logarithmen.
In den Implementierungen treten zwei konkrete mathematische Objekte auf. Erstens gibt es ein endliches Trunkierungsmodell, dessen Kettenbruch eine numerische Näherung für die Ausnahme-Konstante liefert. Zweitens gibt es eine geschlossene Formel für den Grenzwert, und diese Formel wird danach unterschieden, an welcher dyadischen Stelle sich \(n\) befindet.
Für eine Trunkierungstiefe \(m\) setze man \(M=2^m\) und definiere
$$S_m=\sum_{i=0}^{m}2^{M-2^i}.$$
Zu einem festen \(n\) werden dann
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}$$
gebildet. In den Kettenbruch geht das Verhältnis
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L]$$
ein, und aus seinen Teilquotienten wird das empirische logarithmische Mittel
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j$$
berechnet. Dieses \(E_{n,m}\) ist noch nicht die gesuchte Zielgröße. Es ist vielmehr eine endliche Beobachtungsgröße, mit der geprüft wird, ob der richtige Grenzwert tatsächlich \(\log K_n\) ist. Die C++-Implementierung verwendet dieses Modell nur für ausgewählte Testwerte von \(n\).
Der Produktionspfad beginnt mit der Mersenne-artigen Zahl
$$b=2^n-1.$$
Danach hängt die Formel für \(\log K_n\) davon ab, in welchem dyadischen Bereich \(n\) liegt.
Für den Basisfall \(n=0\) gilt
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
also \(K_0=192^{1/4}\).
Falls \(n=2^t-1\) mit \(t\ge 1\), verwenden die Implementierungen
$$\log K_n=\frac{\log 2+2\log b}{5},$$
äquivalent \(K_n=(2b^2)^{1/5}\).
Falls \(n=2^t\), gilt
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
also \(K_n=b^{1/2}(b^2-1)^{1/12}\).
Im Inneren eines dyadischen Intervalls setze man
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1.$$
Dann lautet der verbleibende Zweig
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12},$$
beziehungsweise \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\).
Daran sieht man die eigentliche Struktur des Problems: Außer im Basisfall wird die Ausnahme-Konstante durch eine Mersenne-artige Größe bestimmt, die direkt von \(n\) kommt, und im allgemeinen dyadischen Intervall zusätzlich durch eine zweite Größe, die den Abstand bis zur nächsten Zweierpotenz misst.
Im allgemeinen inneren Zweig treten die Terme \(\log(c-1)\) und \(\log(c+1)\) auf. Wenn aber \(n=q-1=2^t-1\) ist, dann gilt \(e=1\) und damit \(c=1\). Folglich wäre \(c-1=0\), also \(\log(c-1)=\log 0\), und genau deshalb wird der Fall „eins unter einer Zweierpotenz“ separat behandelt.
Der exakte Zweierpotenz-Fall verhält sich anders. Für \(n=2^t\) beginnt das dyadische Intervall bei \(p=n\), also \(q=2n\), \(e=n\), und damit
$$c=2^e-1=2^n-1=b.$$
Setzt man \(c=b\) in die allgemeine Formel ein, so erhält man
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
also genau den Zweig für Zweierpotenzen. Eine Randlage erzeugt also eine echte Singularität, die andere vereinfacht sich zu einer Identität. Die Fallunterscheidung ist damit keine Schablone, sondern direkt durch die dyadische Struktur der Formeln erzwungen.
Betrachte \(n=20\). Dieser Wert liegt im dyadischen Intervall von \(16\) bis \(32\), also
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
Daher ergibt sich
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}.$$
Geht man zu \(n=31=2^5-1\), dann ist der Abstand bis zur nächsten Zweierpotenz nur noch \(1\). Die innere Formel würde also \(c=1\) und damit \(\log(c-1)=\log 0\) liefern. Der separate Randzweig umgeht genau dieses Problem und liefert
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}.$$
Am nächsten Punkt \(n=32=2^5\) gilt stattdessen der exakte Zweierpotenz-Zweig:
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
Dieselbe Logik erklärt auch den kleinen Kontrollwert aus der Validierung: Für \(n=2\) liefert der Zweig für Zweierpotenzen \(\exp(\log K_2)\approx 2.059767\).
Die Implementierungen in C++, Python und Java verwenden im Kern denselben Produktionsalgorithmus. Sie laufen über \(n=0,1,\dots,50\), entscheiden, ob \(n\) gleich \(0\), eine Zweierpotenz, eins weniger als eine Zweierpotenz oder ein innerer Punkt eines dyadischen Intervalls ist, und werten dann die passende geschlossene Formel für \(\log K_n\) aus.
Diese Logarithmen werden in Gleitkommaarithmetik aufsummiert, durch \(51\) geteilt und erst ganz am Ende exponentiert. Das ist sowohl mathematisch natürlich als auch numerisch stabil, weil die Zielgröße ein geometrisches Mittel ist. Im tatsächlichen Bereich \(0\le n\le 50\) passen alle Ganzzahlen der Produktionsformeln problemlos in gewöhnliche 64-Bit-Arithmetik.
Die C++-Implementierung ergänzt einen expliziten Prüfschritt. Sie baut die endliche Trunkierung für \(m=16\) mit Ganzzahlen beliebiger Größe auf, reduziert \(S_m\) modulo \(Q_{n,m}\), extrahiert mit dem euklidischen Algorithmus die Teilquotienten des Kettenbruchs von \(Q_{n,m}/R_{n,m}\) und bildet daraus das empirische logarithmische Mittel.
Dieses empirische Mittel wird für die Stichprobe \(n\in\{0,1,2,5,20,31,32,50\}\) mit der geschlossenen Formel verglichen, und zwar mit kleinen relativen Fehlertoleranzen. Die Python- und Java-Versionen lassen diesen Verifikationspfad weg und behalten nur die geschlossene Rechnung für die finale Ausgabe.
Die eigentliche Berechnung benötigt \(O(51)\) Zeit und \(O(1)\) Speicher, denn jeder der einundfünfzig Werte von \(n\) wird in konstanter Zeit verarbeitet. Verallgemeinert auf \(0\le n\le N\), ergibt sich \(O(N)\).
Die Verifikationsschicht in C++ verwendet zwar beliebig große Ganzzahlen und eine Kettenbruch-Expansion, trägt hier aber nur festen Zusatzaufwand bei: Die Trunkierungstiefe ist auf \(m=16\) festgelegt, und es werden nur acht Stichprobenwerte geprüft.
Her \(n\in\{0,1,\dots,50\}\) için problem, ikinin kuvvetlerinden kurulan dyadik bir kesme üzerinden tanımlanan istisnai bir devamlı kesir sabiti \(K_n\) üretir. İstenen son nicelik tek bir \(K_n\) değil, bu elli bir sabitin geometrik ortalamasıdır.
Çözüm dosyaları doğrulama ile asıl hesaplamayı açık biçimde ayırır. Devamlı kesir sadece limit davranışını sayısal olarak sınamak için kullanılır. Nihai cevap ise \(\log K_n\) için açık formüller hesaplanıp ardından
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right)$$
ifadesinin değerlendirilmesiyle elde edilir. Böylece problem, dikkatli kurulmuş kısa bir logaritma toplamına dönüşür.
Uygulamalarda iki somut matematiksel nesne öne çıkar. Birincisi, istisnai sabitin sayısal izini veren sonlu bir kesme modelidir. İkincisi ise limit değeri doğrudan veren kapalı formdur; bu kapalı form da \(n\)'nin komşu iki kuvvet arasındaki dyadik konumuna göre dallanır.
Kesme derinliği \(m\) için \(M=2^m\) alalım ve
$$S_m=\sum_{i=0}^{m}2^{M-2^i}$$
toplamını tanımlayalım. Sabit bir \(n\) için doğrulama deneyi daha sonra
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}$$
büyüklüklerini kurar. Devamlı kesre giren oran
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L]$$
olur ve kısmi bölümlerin logaritmik ortalaması
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j$$
şeklinde tanımlanır. Bu \(E_{n,m}\) problemde istenen nihai değer değildir; seçilmiş \(n\) değerlerinde doğru limitin gerçekten \(\log K_n\) olduğunu sınamak için kullanılan sonlu boyutlu bir gözlemdir. C++ uygulaması bu modeli tam olarak böyle bir tutarlılık kontrolü olarak kullanır.
Asıl hesaplama şu Mersenne tipi sayıdan başlar:
$$b=2^n-1.$$
Bundan sonra \(\log K_n\) formülü, \(n\)'nin hangi dyadik bölgede olduğuna göre seçilir.
Temel durum \(n=0\) için
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
yani \(K_0=192^{1/4}\).
Eğer \(n=2^t-1\) ise
$$\log K_n=\frac{\log 2+2\log b}{5},$$
eşdeğer olarak \(K_n=(2b^2)^{1/5}\).
Eğer \(n=2^t\) ise
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
eşdeğer olarak \(K_n=b^{1/2}(b^2-1)^{1/12}\).
Dyadik aralığın iç noktalarında ise
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1$$
tanımlanır ve kalan dal
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12}$$
şeklindedir; yani \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\).
Burada problemin gerçek yapısı görünür: temel durum dışında istisnai sabit, bir yandan doğrudan \(n\)'den gelen bir Mersenne tipi çarpana, öte yandan genel dyadik aralıkta bir sonraki ikili sınıra olan uzaklıktan gelen ikinci bir Mersenne tipi çarpana bağlıdır.
Genel iç formülde \(\log(c-1)\) ve \(\log(c+1)\) terimleri vardır. Eğer \(n=q-1=2^t-1\) ise \(e=1\) ve dolayısıyla \(c=1\) olur. Bu durumda \(c-1=0\) olduğundan \(\log(c-1)=\log 0\) tanımsızdır. Kodda “bir kuvvetten bir eksik” durumunun ayrı tutulmasının tam nedeni budur.
Tam kuvvet durumu daha farklı davranır. \(n=2^t\) olduğunda dyadik aralık \(p=n\) noktasında başlar; dolayısıyla \(q=2n\), \(e=n\) ve
$$c=2^e-1=2^n-1=b$$
elde edilir. \(c=b\) genel ifadeye yerleştirilince
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12}$$
olur; yani tam olarak kuvvet dalına indirgenir. Bir sınır gerçek bir tekillik üretirken, öteki sınır doğal bir sadeleşme verir. Bu yüzden dallanma yapısı keyfi değil, doğrudan formüllerin dyadik geometrisinden gelir.
\(n=20\) değerini alalım. Bu sayı \(16\) ile \(32\) arasındaki dyadik aralıkta yer alır, dolayısıyla
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
Böylece
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}$$
elde edilir. Şimdi \(n=31=2^5-1\) değerine geçelim. Bir sonraki ikinin kuvvetine uzaklık yalnızca \(1\) olduğu için iç formül \(c=1\) ve dolayısıyla \(\log(c-1)=\log 0\) üretecektir. Ayrı sınır formülü bu sorunu aşar ve
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}$$
sonucunu verir. Bir sonraki noktada, \(n=32=2^5\) için ise tam kuvvet dalı kullanılır:
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
Aynı mantık, doğrulamada kullanılan küçük kontrol noktasını da açıklar: \(n=2\) için tam kuvvet dalı \(\exp(\log K_2)\approx 2.059767\) verir.
C++, Python ve Java uygulamaları aynı üretim algoritmasını kullanır. \(n=0,1,\dots,50\) üzerinde dolaşırlar, her değerin \(0\), bir kuvvet, bir kuvvetten bir eksik ya da dyadik aralığın iç noktası olup olmadığını belirlerler ve buna karşılık gelen \(\log K_n\) kapalı formülünü değerlendirirler.
Bu logaritmalar kayan noktalı aritmetikte toplanır, \(51\)'e bölünür ve en sonda tek bir üstel alınır. Bu yöntem hem matematiksel olarak doğrudur hem de sayısal olarak kararlıdır; çünkü hedef nicelik zaten geometrik ortalamadır. Gerçek aralık olan \(0\le n\le 50\) için kapalı formüllerde geçen tüm tamsayılar sıradan 64 bit aritmetiğe rahatça sığar.
C++ uygulaması buna ek olarak açık bir doğrulama katmanı içerir. \(m=16\) için sonlu kesmeyi keyfi hassasiyetli tamsayılarla kurar, \(S_m\)'yi \(Q_{n,m}\) modunda indirger, Öklid algoritmasıyla \(Q_{n,m}/R_{n,m}\) oranının devamlı kesir kısmi bölümlerini çıkarır ve bunların logaritmik ortalamasını alır.
Bu ampirik ortalama, \(n\in\{0,1,2,5,20,31,32,50\}\) örnekleri üzerinde kapalı formla küçük göreli hata eşikleri altında karşılaştırılır. Python ve Java uygulamaları bu doğrulama yolunu içermez; nihai cevap için gerekli olan kapalı form hesabını tutmaları yeterlidir.
Asıl hesaplama \(O(51)\) zaman ve \(O(1)\) bellek gerektirir; çünkü elli bir farklı \(n\) değerinin her biri sabit zamanda işlenir. Aynı yöntem \(0\le n\le N\) aralığına genellenirse maliyet \(O(N)\) olur.
C++ doğrulama katmanı keyfi hassasiyetli tamsayılar ve devamlı kesir açılımı kullansa da burada yalnızca sabit ek maliyet getirir: kesme derinliği \(m=16\) olarak sabittir ve sadece sekiz örnek değer sınanır.
Para cada \(n\in\{0,1,\dots,50\}\), el problema define una constante excepcional \(K_n\) a partir de una truncación diádica construida con potencias de dos y analizada mediante fracciones continuas. La cantidad pedida al final no es un único \(K_n\), sino la media geométrica de las cincuenta y una constantes.
Los archivos de solución separan con claridad la verificación del cálculo principal. La fracción continua solo se usa para comprobar numéricamente el comportamiento límite. La respuesta final sale de fórmulas cerradas para \(\log K_n\) y luego de
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right).$$
En otras palabras, el problema computacional real queda reducido a una suma corta de logaritmos.
En las implementaciones aparecen dos objetos matemáticos muy concretos. El primero es un modelo truncado cuyo desarrollo en fracción continua ofrece una aproximación empírica de la constante excepcional. El segundo es una fórmula cerrada para el valor límite, organizada según la posición de \(n\) con respecto a las potencias de dos vecinas.
Para una profundidad de truncación \(m\), se toma \(M=2^m\) y se define
$$S_m=\sum_{i=0}^{m}2^{M-2^i}.$$
Fijado \(n\), el experimento de validación construye
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}.$$
La razón que realmente se expande en fracción continua es
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L],$$
y el promedio logarítmico empírico de sus cocientes parciales es
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j.$$
Ese \(E_{n,m}\) no es todavía la magnitud final pedida por el problema. Es una observable de tamaño finito que sirve para comprobar que el valor límite correcto es \(\log K_n\). La implementación en C++ usa este modelo solo en algunos valores de muestra de \(n\), precisamente como control interno.
La ruta principal comienza con el número de tipo Mersenne
$$b=2^n-1.$$
A partir de ahí, la expresión de \(\log K_n\) depende de la región diádica a la que pertenece \(n\).
En el caso base \(n=0\), se usa
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
de modo que \(K_0=192^{1/4}\).
Si \(n=2^t-1\), entonces
$$\log K_n=\frac{\log 2+2\log b}{5},$$
equivalentemente \(K_n=(2b^2)^{1/5}\).
Si \(n=2^t\), entonces
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
equivalentemente \(K_n=b^{1/2}(b^2-1)^{1/12}\).
En el interior de un intervalo diádico, se define
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1.$$
Con esas cantidades, la rama restante es
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12},$$
o bien \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\).
Aquí se ve la estructura real del problema: salvo el caso base, la constante excepcional queda gobernada por un factor de tipo Mersenne asociado al propio \(n\) y, en el caso general, por un segundo factor de tipo Mersenne asociado a la distancia desde \(n\) hasta la siguiente potencia de dos.
La fórmula general del interior contiene los términos \(\log(c-1)\) y \(\log(c+1)\). Si \(n=q-1=2^t-1\), entonces \(e=1\) y por tanto \(c=1\). Eso hace que \(c-1=0\), así que \(\log(c-1)=\log 0\) deja de tener sentido. Esa es exactamente la razón por la que el caso “uno menos que una potencia de dos” aparece separado en el código.
La frontera de potencia exacta se comporta de otra manera. Cuando \(n=2^t\), el intervalo diádico empieza en \(p=n\), luego \(q=2n\), \(e=n\), y entonces
$$c=2^e-1=2^n-1=b.$$
Al sustituir \(c=b\) en la expresión general se obtiene
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
que coincide exactamente con la rama de potencia de dos. Una frontera produce una singularidad real y la otra se simplifica a una identidad más limpia. La partición en casos no es un molde genérico, sino una consecuencia directa de la geometría diádica que exhiben las fórmulas.
Tomemos \(n=20\). Ese valor cae en el intervalo diádico entre \(16\) y \(32\), de modo que
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
Por tanto,
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}.$$
Ahora pasemos a \(n=31=2^5-1\). La distancia hasta la siguiente potencia de dos es solo \(1\), así que la fórmula interior produciría \(c=1\) y, con ello, \(\log(c-1)=\log 0\). La rama especial evita exactamente ese problema y da
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}.$$
En el siguiente punto, \(n=32=2^5\), entra en juego la rama de potencia exacta:
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
La misma lógica explica también el pequeño punto de control usado en la validación: para \(n=2\), la rama de potencia exacta produce \(\exp(\log K_2)\approx 2.059767\).
Las implementaciones en C++, Python y Java usan el mismo algoritmo principal. Recorren \(n=0,1,\dots,50\), determinan si \(n\) es \(0\), una potencia de dos, uno menos que una potencia de dos o un punto interior de un intervalo diádico, y evalúan la fórmula cerrada correspondiente para \(\log K_n\).
Esos logaritmos se acumulan en coma flotante, se dividen por \(51\) y solo al final se aplica una exponencial. El procedimiento es natural desde el punto de vista matemático y además estable numéricamente, porque el objetivo pedido es una media geométrica. En el rango real \(0\le n\le 50\), todos los enteros que aparecen en las fórmulas de producción caben sin problemas en aritmética ordinaria de 64 bits.
La implementación en C++ añade una capa de verificación explícita. Construye la truncación finita con \(m=16\) usando enteros de precisión arbitraria, reduce \(S_m\) módulo \(Q_{n,m}\), aplica el algoritmo de Euclides para extraer los cocientes parciales de \(Q_{n,m}/R_{n,m}\) y promedia sus logaritmos.
Ese promedio empírico se compara con la fórmula cerrada en los valores de muestra \(n\in\{0,1,2,5,20,31,32,50\}\), con tolerancias relativas pequeñas. Las implementaciones en Python y Java omiten este camino de comprobación y conservan solo el cálculo cerrado necesario para la respuesta final.
El cálculo principal cuesta \(O(51)\) tiempo y \(O(1)\) memoria, porque cada uno de los cincuenta y un valores de \(n\) se procesa en tiempo constante. Si el mismo método se extendiera a \(0\le n\le N\), el coste sería \(O(N)\).
La capa de validación en C++ usa aritmética de precisión arbitraria y expansión en fracción continua, pero aquí sigue siendo un sobrecoste fijo: la profundidad de truncación está fijada en \(m=16\) y solo se revisan ocho valores de muestra.
对每个 \(n\in\{0,1,\dots,50\}\)，题目都会通过一个由二的幂构成的二进截断模型定义出例外常数 \(K_n\)，并把这个对象放到连分数框架里考察。最终要求的不是某一个 \(K_n\)，而是全部五十一个常数的几何平均。
解法文件把“验证”和“正式计算”分得很清楚。连分数只用来数值确认极限行为；真正输出答案时，程序直接计算每个 \(\log K_n\) 的闭式，然后利用
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right).$$
因此，最终的计算核心并不是展开巨大的连分数，而是把一个几何平均改写成一段很短的对数求和。
实现中真正出现了两个很具体的数学对象。第一个是有限截断模型，它给出连分数部分商的经验平均值，用来观察例外常数的极限。第二个是直接给出极限值的闭式，而这个闭式的分支方式完全由 \(n\) 相对于相邻二次幂的位置决定。
取截断深度 \(m\)，记 \(M=2^m\)，并定义
$$S_m=\sum_{i=0}^{m}2^{M-2^i}.$$
固定 \(n\) 之后，验证模型再构造
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}.$$
真正送入连分数展开的是比值
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L],$$
并且把部分商对数的平均定义为
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j.$$
这里的 \(E_{n,m}\) 不是题目最后要输出的量。它只是一个有限规模的观测值，用来检验真正的极限是否等于 \(\log K_n\)。C++ 实现只在少数几个代表性的 \(n\) 上计算这个模型，作用就是给闭式结果做数值交叉验证。
正式计算从一个 Mersenne 型整数开始：
$$b=2^n-1.$$
接下来 \(\log K_n\) 该取哪一个公式，只取决于 \(n\) 落在什么样的二进区域里。
当 \(n=0\) 时，基例为
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
因此 \(K_0=192^{1/4}\)。
如果 \(n=2^t-1\)，那么
$$\log K_n=\frac{\log 2+2\log b}{5},$$
等价地说 \(K_n=(2b^2)^{1/5}\)。
如果 \(n=2^t\)，那么
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
也就是 \(K_n=b^{1/2}(b^2-1)^{1/12}\)。
对于二进区间内部的点，定义
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1.$$
于是剩下的一般分支为
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12},$$
或者写成 \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\)。
这一点揭示了题目的真实结构：除了基例以外，例外常数总是由两个方向控制。一个方向来自 \(n\) 本身，对应 \(2^n-1\)；另一个方向来自 \(n\) 到下一个二次幂的距离，对应 \(2^{q-n}-1\)。
一般内部公式里含有 \(\log(c-1)\) 和 \(\log(c+1)\)。如果 \(n=q-1=2^t-1\)，那么 \(e=1\)，于是 \(c=1\)。这时 \(c-1=0\)，所以 \(\log(c-1)=\log 0\) 根本没有定义。这正是代码把“比二次幂小一”的情况单独分出来的原因。
而“恰好等于二次幂”的边界则表现得更整齐。当 \(n=2^t\) 时，二进区间从 \(p=n\) 开始，因此 \(q=2n\)、\(e=n\)，从而
$$c=2^e-1=2^n-1=b.$$
把 \(c=b\) 代入一般公式，就得到
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
这与二次幂分支完全一致。也就是说，一个边界会造成真正的奇异项，另一个边界则只是自然化简。整个分支结构直接反映了闭式内部的二进几何，而不是某种通用模板。
先看 \(n=20\)。它位于 \(16\) 到 \(32\) 之间的二进区间内部，因此
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
于是
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}.$$
再看 \(n=31=2^5-1\)。它离下一个二次幂只差 \(1\)，所以内部公式会给出 \(c=1\)，从而出现 \(\log(c-1)=\log 0\)。专门的边界公式就是为了解决这件事：
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}.$$
下一个点 \(n=32=2^5\) 则进入“恰好是二次幂”的分支：
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
同样的逻辑还解释了验证代码中的小型检查点：当 \(n=2\) 时，二次幂分支给出 \(\exp(\log K_2)\approx 2.059767\)。
C++、Python 和 Java 三个实现的正式计算路径完全一致。它们依次遍历 \(n=0,1,\dots,50\)，判断当前 \(n\) 属于 \(0\)、二次幂、二次幂减一，还是某个二进区间的内部点，然后计算对应的 \(\log K_n\) 闭式。
这些对数值在浮点数中累加，除以 \(51\) 之后，只在最后做一次指数运算。这样做既符合数学结构，也保证了数值稳定性，因为题目要求的本来就是几何平均。在实际范围 \(0\le n\le 50\) 内，闭式里出现的所有整数都能安全放进普通 64 位整数类型。
C++ 实现额外加入了显式验证层。它在 \(m=16\) 时用任意精度整数构造有限截断，把 \(S_m\) 对 \(Q_{n,m}\) 取模，再用欧几里得算法提取 \(Q_{n,m}/R_{n,m}\) 的连分数部分商，并对这些部分商的对数求平均。
然后把这个经验平均与闭式在样本集合 \(n\in\{0,1,2,5,20,31,32,50\}\) 上逐一比较，并要求相对误差足够小。Python 和 Java 版本不保留这条验证路径，只保留生成最终答案所需的闭式计算。
正式计算的时间复杂度是 \(O(51)\)，空间复杂度是 \(O(1)\)，因为五十一个 \(n\) 都是常数时间处理。如果把范围推广到 \(0\le n\le N\)，复杂度自然就是 \(O(N)\)。
C++ 的验证层虽然用到了任意精度整数和连分数展开，但在这里仍然只是常数级附加开销：截断深度固定为 \(m=16\)，而且只检查八个样本点。
Для каждого \(n\in\{0,1,\dots,50\}\) задача задает исключительную константу \(K_n\), возникающую из диадического усечения, построенного на степенях двойки и исследуемого через цепные дроби. В финале требуется не одно конкретное \(K_n\), а геометрическое среднее всех пятидесяти одной константы.
Файлы решений явно разделяют проверку и основное вычисление. Цепная дробь используется только для численного подтверждения предельного поведения. Сам ответ строится из явных формул для \(\log K_n\), а затем вычисляется
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right).$$
Тем самым вся вычислительная часть сводится к короткой сумме логарифмов.
В реализациях присутствуют два очень конкретных математических объекта. Первый - конечная модель усечения, чья цепная дробь дает эмпирическое приближение исключительной константы. Второй - закрытая формула для предельного значения, и она организована по тому, где именно число \(n\) находится относительно соседних степеней двойки.
Для глубины усечения \(m\) положим \(M=2^m\) и определим
$$S_m=\sum_{i=0}^{m}2^{M-2^i}.$$
После фиксации \(n\) в проверочной модели строятся величины
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}.$$
Именно отношение
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L]$$
разлагается в цепную дробь, а эмпирическое логарифмическое среднее ее неполных частных равно
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j.$$
Величина \(E_{n,m}\) не является окончательным ответом. Это лишь конечная наблюдаемая, с помощью которой проверяют, что правильный предел действительно равен \(\log K_n\). В реализации на C++ эта модель вычисляется только для нескольких характерных значений \(n\), именно как внутренняя проверка согласованности.
Основной путь начинается с числа мерсеннового типа
$$b=2^n-1.$$
Далее выбор формулы для \(\log K_n\) определяется тем, в какой диадической области лежит \(n\).
Для базового случая \(n=0\) используется
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
то есть \(K_0=192^{1/4}\).
Если \(n=2^t-1\), то
$$\log K_n=\frac{\log 2+2\log b}{5},$$
эквивалентно \(K_n=(2b^2)^{1/5}\).
Если \(n=2^t\), то
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
эквивалентно \(K_n=b^{1/2}(b^2-1)^{1/12}\).
Для внутренних точек диадического интервала вводятся
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1.$$
Тогда оставшаяся ветвь имеет вид
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12},$$
или \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\).
Здесь и проявляется настоящая структура задачи: вне базового случая исключительная константа определяется мерсенновым фактором, связанным с самим \(n\), а в общем случае еще и вторым мерсенновым фактором, который связан с расстоянием до следующей степени двойки.
Во внутренней общей формуле присутствуют слагаемые \(\log(c-1)\) и \(\log(c+1)\). Если \(n=q-1=2^t-1\), то \(e=1\), следовательно \(c=1\). Тогда \(c-1=0\), и выражение \(\log(c-1)=\log 0\) теряет смысл. Именно поэтому случай «на единицу меньше степени двойки» отделен в коде в самостоятельную ветвь.
Граница точной степени двойки устроена иначе. При \(n=2^t\) диадический интервал начинается в точке \(p=n\), значит \(q=2n\), \(e=n\), и потому
$$c=2^e-1=2^n-1=b.$$
Подстановка \(c=b\) в общую формулу дает
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
то есть точно ветвь для степени двойки. Одна граница создает настоящую особенность, а другая просто схлопывается в более короткое тождество. Поэтому разбиение на случаи продиктовано самой диадической геометрией формул, а не искусственным шаблоном.
Рассмотрим \(n=20\). Это значение лежит внутри диадического интервала от \(16\) до \(32\), поэтому
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
Следовательно,
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}.$$
Теперь перейдем к \(n=31=2^5-1\). Расстояние до следующей степени двойки здесь равно \(1\), так что внутренняя формула привела бы к \(c=1\) и, значит, к \(\log(c-1)=\log 0\). Специальная граничная ветвь как раз устраняет эту проблему и дает
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}.$$
В следующей точке, \(n=32=2^5\), начинает работать ветвь точной степени двойки:
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
Та же логика объясняет и небольшой контрольный пример из проверки: при \(n=2\) ветвь степени двойки дает \(\exp(\log K_2)\approx 2.059767\).
Реализации на C++, Python и Java используют один и тот же основной алгоритм. Они перебирают \(n=0,1,\dots,50\), определяют, является ли текущее \(n\) нулем, степенью двойки, числом на единицу меньше степени двойки или внутренней точкой диадического интервала, а затем вычисляют соответствующую закрытую формулу для \(\log K_n\).
Полученные логарифмы суммируются в вещественной арифметике, делятся на \(51\), и только после этого применяется одна экспонента. Такой порядок естественен математически и устойчив численно, поскольку искомая величина является геометрическим средним. Для реального диапазона \(0\le n\le 50\) все целые числа, возникающие в производственных формулах, свободно помещаются в обычные 64-битные типы.
Реализация на C++ добавляет явный слой проверки. Она строит конечное усечение при \(m=16\) с использованием целых произвольной точности, редуцирует \(S_m\) по модулю \(Q_{n,m}\), применяет алгоритм Евклида для извлечения неполных частных цепной дроби \(Q_{n,m}/R_{n,m}\) и усредняет их логарифмы.
Это эмпирическое среднее сравнивается с закрытой формулой на выборке \(n\in\{0,1,2,5,20,31,32,50\}\) при малых относительных допусках. Версии на Python и Java не включают этот проверочный путь и оставляют только закрытое вычисление, необходимое для финального ответа.
Основное вычисление требует \(O(51)\) времени и \(O(1)\) памяти, потому что каждое из пятидесяти одного значений \(n\) обрабатывается за константное время. При обобщении на диапазон \(0\le n\le N\) получаем \(O(N)\).
Проверочный слой в C++ использует целые произвольной точности и разложение в цепную дробь, но здесь дает лишь постоянный дополнительный расход: глубина усечения зафиксирована как \(m=16\), а проверяются только восемь значений.
لكل \(n\in\{0,1,\dots,50\}\) تعرّف المسألة ثابتًا استثنائيًا \(K_n\) ينشأ من قطع ثنائي مبني من قوى العدد \(2\) ويُفحَص عبر الكسور المستمرة. والكمية المطلوبة في النهاية ليست قيمة واحدة من هذه القيم، بل المتوسط الهندسي للثوابت الإحدى والخمسين كلها.
ملفات الحل تميّز بوضوح بين التحقق والحساب النهائي. فالكسر المستمر لا يُستعمل إلا لتأكيد السلوك الحدي عدديًا، أما الجواب الفعلي فيُستخرج من صيغ مغلقة لـ \(\log K_n\)، ثم من
$$G=\left(\prod_{n=0}^{50} K_n\right)^{1/51}=\exp\left(\frac{1}{51}\sum_{n=0}^{50}\log K_n\right).$$
وهكذا يتحول لب المسألة الحسابي إلى جمع قصير للوغاريتمات بدل التعامل مع كسور مستمرة هائلة.
يوجد في التنفيذات شيئان رياضيان محددان جدًا. الأول نموذج قطع منتهٍ تعطي كسوره المستمرة متوسطًا تجريبيًا يقارب الثابت الاستثنائي. والثاني صيغة مغلقة تعطي القيمة الحدية مباشرة، وهذه الصيغة تتفرع بحسب موضع \(n\) بالنسبة إلى قوى العدد \(2\) المجاورة.
عند عمق قطع \(m\)، نضع \(M=2^m\) ونعرّف
$$S_m=\sum_{i=0}^{m}2^{M-2^i}.$$
ثم بعد تثبيت \(n\) يبني نموذج التحقق الكميتين
$$Q_{n,m}=2^{M-n},\qquad R_{n,m}=S_m \bmod Q_{n,m}.$$
والنسبة التي تدخل فعلًا في التوسع إلى كسر مستمر هي
$$\frac{Q_{n,m}}{R_{n,m}}=[a_1;a_2,\dots,a_L],$$
ويكون المتوسط اللوغاريتمي التجريبي للحدود الجزئية
$$E_{n,m}=\frac{1}{L}\sum_{j=1}^{L}\log a_j.$$
هذه الكمية \(E_{n,m}\) ليست الجواب النهائي للمسألة، بل هي مشاهدة منتهية الحجم تُستعمل لاختبار أن الحد الصحيح هو فعلًا \(\log K_n\). لذلك لا تستعملها صيغة الإنتاج إلا بوصفها أداة تحقق، وتقوم نسخة C++ بحسابها فقط على مجموعة صغيرة من قيم \(n\) التمثيلية.
المسار الرئيسي يبدأ من العدد ذي الطابع المرسيـني
$$b=2^n-1.$$
وبعد ذلك تتحدد صيغة \(\log K_n\) حسب المنطقة الثنائية التي يقع فيها \(n\).
في الحالة الأساسية \(n=0\) تستعمل التنفيذات
$$\log K_0=\frac{\log 2+2\log 4+\log 6}{4},$$
ومن ثم \(K_0=192^{1/4}\).
إذا كان \(n=2^t-1\) فإن
$$\log K_n=\frac{\log 2+2\log b}{5},$$
وبصورة مكافئة \(K_n=(2b^2)^{1/5}\).
وإذا كان \(n=2^t\) فإن
$$\log K_n=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
أي \(K_n=b^{1/2}(b^2-1)^{1/12}\).
أما في النقاط الداخلية من مجال ثنائي فنعرّف
$$p=2^{\lfloor\log_2 n\rfloor},\qquad q=2p,\qquad e=q-n,\qquad c=2^e-1.$$
وعندئذ يصبح الفرع العام
$$\log K_n=\frac{\log b}{3}+\frac{\log c}{6}+\frac{\log(c-1)+\log(c+1)}{12},$$
أو بصورة مكافئة \(K_n=b^{1/3}c^{1/6}(c^2-1)^{1/12}\).
وهنا يظهر هيكل المسألة بوضوح: خارج الحالة الأساسية يتحكم في الثابت الاستثنائي عامل من نوع مرسين مرتبط مباشرة بـ \(n\)، وفي الحالة العامة يظهر عامل مرسيني ثانٍ مرتبط بالمسافة من \(n\) إلى القوة التالية للعدد \(2\).
الفرع الداخلي العام يحتوي على الحدين \(\log(c-1)\) و\(\log(c+1)\). فإذا كان \(n=q-1=2^t-1\)، فحينها \(e=1\) وبالتالي \(c=1\). وهذا يعني أن \(c-1=0\)، فتظهر العبارة \(\log(c-1)=\log 0\) غير المعرفة. ومن هنا جاء الفصل الصريح في الشيفرة لحالة "أقل بواحد من قوة للعدد \(2\)".
أما حالة القوة الدقيقة فتتصرف بصورة أنظف. عندما يكون \(n=2^t\)، يبدأ المجال الثنائي عند \(p=n\)، ومن ثم \(q=2n\) و\(e=n\)، ولذلك
$$c=2^e-1=2^n-1=b.$$
وبتعويض \(c=b\) في الصيغة العامة نحصل على
$$\frac{\log b}{3}+\frac{\log b}{6}+\frac{\log(b-1)+\log(b+1)}{12}=\frac{\log b}{2}+\frac{\log(b-1)+\log(b+1)}{12},$$
وهو بالضبط فرع قوة العدد \(2\). إذن أحد الحدين يولد تفردًا حقيقيًا، بينما الحد الآخر ينهار إلى تبسيط طبيعي. لذلك فالتقسيم إلى حالات ليس قالبًا عامًا، بل نتيجة مباشرة للهندسة الثنائية الظاهرة في الصيغ نفسها.
لنأخذ \(n=20\). هذه القيمة تقع داخل المجال الثنائي بين \(16\) و\(32\)، ولذلك
$$p=16,\qquad q=32,\qquad e=12,\qquad b=2^{20}-1=1048575,\qquad c=2^{12}-1=4095.$$
وعليه
$$\log K_{20}=\frac{\log 1048575}{3}+\frac{\log 4095}{6}+\frac{\log 4094+\log 4096}{12}.$$
والآن انتقل إلى \(n=31=2^5-1\). المسافة إلى القوة التالية للعدد \(2\) تساوي \(1\) فقط، ولذا ستعطي الصيغة الداخلية \(c=1\)، ومن ثم \(\log(c-1)=\log 0\). الفرع الخاص بالحافة يتجنب هذه المشكلة ويعطي
$$\log K_{31}=\frac{\log 2+2\log(2^{31}-1)}{5}.$$
أما عند النقطة التالية \(n=32=2^5\)، فيجري استعمال فرع القوة الدقيقة:
$$\log K_{32}=\frac{\log(2^{32}-1)}{2}+\frac{\log(2^{32}-2)+\log(2^{32})}{12}.$$
والمنطق نفسه يفسر أيضًا نقطة الفحص الصغيرة المستعملة في التحقق: عند \(n=2\) يعطي فرع القوة الدقيقة \(\exp(\log K_2)\approx 2.059767\).
تتبع تنفيذات C++ وPython وJava الخوارزمية الإنتاجية نفسها. فهي تمر على \(n=0,1,\dots,50\)، وتحدد هل القيمة الحالية هي \(0\)، أو قوة للعدد \(2\)، أو أقل بواحد من قوة للعدد \(2\)، أو نقطة داخلية في مجال ثنائي، ثم تحسب الصيغة المغلقة المناسبة لـ \(\log K_n\).
بعد ذلك تُجمع هذه اللوغاريتمات في الحساب العشري، وتُقسم على \(51\)، ولا تُطبق الدالة الأسية إلا في النهاية. هذا الترتيب طبيعي من الناحية الرياضية ومستقر عدديًا، لأن الكمية المطلوبة أصلًا متوسط هندسي. وفي المجال الفعلي \(0\le n\le 50\) تدخل جميع الأعداد الصحيحة المستخدمة في صيغ الإنتاج ضمن الحساب العادي ذي 64 بت.
تضيف نسخة C++ طبقة تحقق صريحة. فهي تبني القطع المنتهي عند \(m=16\) باستخدام أعداد صحيحة عالية الدقة، ثم تختزل \(S_m\) modulo \(Q_{n,m}\)، وتستعمل خوارزمية إقليدس لاستخراج الحدود الجزئية للكسر المستمر \(Q_{n,m}/R_{n,m}\)، ثم تحسب متوسط لوغاريتماتها.
ويُقارَن هذا المتوسط التجريبي مع الصيغة المغلقة على مجموعة العينات \(n\in\{0,1,2,5,20,31,32,50\}\) ضمن حدود صغيرة للخطأ النسبي. أما نسختا Python وJava فتستغنيان عن هذا المسار التحققي وتكتفيان بالحساب المغلق اللازم لإنتاج الجواب النهائي.
الحساب الرئيسي يكلف \(O(51)\) زمنًا و\(O(1)\) ذاكرة، لأن كل واحدة من القيم الإحدى والخمسين لـ \(n\) تُعالَج بزمن ثابت. وإذا عممنا الفكرة إلى المجال \(0\le n\le N\)، تصبح الكلفة \(O(N)\).
طبقة التحقق في C++ تستخدم أعدادًا صحيحة عالية الدقة وتوسعًا في كسور مستمرة، لكنها هنا لا تضيف إلا كلفة ثابتة: عمق القطع مثبت عند \(m=16\)، وعدد القيم المختبرة لا يتجاوز ثماني عينات.