The Morita p-Adic Gamma Function: Computation, Adelic Structure, and the Factoring Question

In the paper's words

<p>The Morita p-adic Gamma function Γ_p(n) = (-1)^n ∏_k=1, p nmid k^n-1 k is a p-adic analytic object that interpolates factorials while explicitly skipping multiples of p. This document provides a self-contained exposition: the definition and functional equation, a computational implementation with benchmarks, the Freund-Witten adelic Beta identity and its regularization, the relationship to the completed Riemann zeta function, and a rigorous analysis of whether the adelic st

The abstract, verbatim, and its opening sentence is the claim. Every line below is quoted from the text.

Numbers it reports

1. The value $\Gamma_2(1000)$ is the product of all odd integers from $1$ to $999$, with sign $(-1)^{1000} = +1$: $$\Gamma_2(1000) = \prod_{k=1}^{500} (2k-1) = 999!!.$$ [CODE-EXECUTED] The computation yields a 1,284-digit positive integer: First 40 digits: 1007483297637508540040389173923035382503 Last 40 digits: 9697420848324327380396425724029541015625 Digits: 1284 Compute time: <1 ms The result was verified by independently computing the double factorial $999!!$ and confirming equality.

   from 2.2 Gamma_2(1000) — The First Computation

2. [CODE-EXECUTED] The following table reports digit counts and computation times for $\Gamma_2(n)$ at increasing $n$ (Python 3.12, standard big-integer arithmetic): $n$ Digits of $|\Gamma_2(n)|$ Time (ms) 10 3 $\lt 0.001$ 50 32 $\lt 0.001$ 100 79 $\lt 0.001$ 200 187 $\lt 0.001$ 500 567 $\lt 0.001$ 1000 1,284 $\lt 0.001$ 2000 2,867 1.01 5000 8,162 1.51 The time grows roughly as $O(n^2 \log n)$, consistent with the cost of multiplying integers of $O(n \log n)$ bits.

   from 2.3 Benchmark: Scaling with $n$

3. [CODE-EXECUTED] Equation (3) is verified for $p = 2,3,5,7$ and all $n \leq 10$: For every case where $p \mid n$, the ratio $|\Gamma_p(n+1)/\Gamma_p(n)| = 1$.

   from 2.6 Divisibility Encoding Verified

4. [CODE-EXECUTED] The following table computes $\prod_{p \leq 29} |\Gamma_p(x)|$ (the naive product, without the regularization factors $p^{\{x\}_p}$) and compares with the classical Gamma function $\Gamma(x)$: $x$ $\prod_{p \leq 29} |\Gamma_p(x)|$ $\Gamma(x)$ Ratio 1 $1.00 \times 10^{0}$ 1 $1.00 \times 10^{0}$ 2 $1.00 \times 10^{0}$ 1 $1.00 \times 10^{0}$ 3 $5.12 \times 10^{2}$ 2 $2.56 \times 10^{2}$ 4 $1.01 \times 10^{7}$ 6 $1.68 \times 10^{6}$ 5 $2.64 \times 10^{12}$ 24 $1.10 \times 10^{11}$ 6 $5.16 \times 10^{18}$ 120 $4.30 \times 10^{16}$ The ratio grows without bound as more primes are included.

   from 3.4 The Regularized Product Divergence — Numerical Evidence

How it is done

1. The core finding: $\Gamma_p$ encodes p-divisibility directly (the ratio $|\Gamma_p(n+1)/\Gamma_p(n)|$ equals $1$ exactly when $p \mid n$), but this observation does not yield a factoring algorithm—the index circularity, computational cost, and the regularization dependence of the adelic product provide fundamental obstructions.

   from Computation, Adelic Structure, and the Factoring Question

2. For a prime $p$, set $n=p$ in definition (1): $$\Gamma_p(p) = (-1)^p \prod_{\substack{1 \leq k \lt p \\ p \nmid k}} k = (-1)^p \cdot (p-1)!.$$ Wilson's theorem states $(p-1)! \equiv -1 \pmod{p}$.

   from 1.4 Connection to Wilson's Theorem

3. The algorithm performs approximately $n(1 - 1/p)$ multiplications, each on integers of growing bit-length.

   from 2.1 Core Algorithm

4. [CODE-EXECUTED] The following table reports digit counts and computation times for $\Gamma_2(n)$ at increasing $n$ (Python 3.12, standard big-integer arithmetic): $n$ Digits of $|\Gamma_2(n)|$ Time (ms) 10 3 $\lt 0.001$ 50 32 $\lt 0.001$ 100 79 $\lt 0.001$ 200 187 $\lt 0.001$ 500 567 $\lt 0.001$ 1000 1,284 $\lt 0.001$ 2000 2,867 1.01 5000 8,162 1.51 The time grows roughly as $O(n^2 \log n)$, consistent with the cost of multiplying integers of $O(n \log n)$ bits.

   from 2.3 Benchmark: Scaling with $n$

What would falsify it

The paper's text states no explicit falsification criterion; the limits below are what it says about where the claim stops.

Where the claim stops

1. The core finding: $\Gamma_p$ encodes p-divisibility directly (the ratio $|\Gamma_p(n+1)/\Gamma_p(n)|$ equals $1$ exactly when $p \mid n$), but this observation does not yield a factoring algorithm—the index circularity, computational cost, and the regularization dependence of the adelic product provide fundamental obstructions.

   from Computation, Adelic Structure, and the Factoring Question

2. The algorithm performs approximately $n(1 - 1/p)$ multiplications, each on integers of growing bit-length.

   from 2.1 Core Algorithm

3. The digit count of $\Gamma_p(n)$ scales as $\sim n \log_{10} n$ (since the product approximates a factorial with $1/p$ of terms removed).

   from 2.1 Core Algorithm

Where to read

1. Computation, Adelic Structure, and the Factoring Question161 words · 1 min
2. 1. Definition and First Properties415 words · 2 min
3. 2. Computational Implementation503 words · 2 min
4. 3. The Adelic Beta Function Identity449 words · 2 min
5. 4. Relationship to the Riemann Zeta Function356 words · 2 min
6. 5. The Factoring Question470 words · 2 min
7. 6. Genuine Mathematical Significance264 words · 1 min
8. 7. Open Questions and Future Directions170 words · 1 min
9. Appendix: Python Implementation80 words · 1 min