再回到黎曼泽塔函数，

考虑，

已知，

导出，

所以 的实际数值，就是周期的三次方根的倒数。

现在，以1/2为对称轴，

的对称形式为 ,

其中第一个 是对称轴，第二个 是 ，第三个 是 。可见收敛的时候，用的是 ，不收敛的时候用的是-1，所以就是，

那么让我们看看，

同样找它的对称形式，

可见它关于 的对称形式就是，

而这里的，

注意，此处已经假定，

这是通过类比，

而得到的，其中 无论如何都要出现，后面两项才是比值对应的数值。而，

只有两项，那么算上 之后，它实际上只能是，

也就是 对应于1。继续，

也就是说，经过超越运算，可以得出，

这就不需要欧拉常数，

这个数值了， 根据对称性获得了精确解，也就是圆周率倒数的相反数，可以反过来计算欧拉常数的符号形式，

其实如果再把，

代回去，

也就是说，自然数倒数的全加和就等于1，但这个1，不是单位1，而是周期-1的平方。

现在，再把，

代入，

可见 就是这个模式之下的，

继续往回代入，认为左右两端的1相等，

这个1是周期平方，它的倒数为单位1，或者周期1，

因为质数本来就是负的或者说倒着数的，所以 就是把质数全部取反并平移单位1或者周期1，而它们的全乘积就是下一个层面的单位1。可见平移的距离的是周期1（周期-1的平方），也就是说，所有质数都是相对于当前层面的周期1（也就是下一个层面的单位1）而计算的负数，它们的乘积就是下一个层面的单位1。具体来说，下一个层面的单位1如果相对于当前层面的数值是11，那么，

这就是质数。 从数值上看，左边的1是11，右边的1是 ，可见这个过程是一种模运算前提下的放大过程。根据实验，右侧的1对应的可能是1或者质数，或者2的幂次（包括1），或者特定合数，而特定合数分解为两个或者多个质数之后，可以继续上述操作。对于合数的情况，分解为质数的乘积，再把构成乘积的质数因子用上述方法分解，这就使得合数可以找到其质数根基。最后，所有的质数都可以用这种方法找到其2的幂次的根基。比如质数89，用上述算法得到余数为33，33可以分解为3和11，3和11用上述方法都得到余数1，于是89的根基为3和11，以及最终的1。

先前我们只知道一个巨大的合数是如何由质数乘积得到的，现在通过这种运算，我们可以知道一个巨大的质数是如何从更小的质数得到的，而一旦遇到2的幂次，我们就可以把这个过程立即归结到1。

所以这个方程，

的实际意思是，

这就可以由已知质数构建质数的族谱。

验证程序如下，

    public static bool IsPrime(long n)
    {
        switch (n)
        {
            case < 2:
                return false;
            case 2:
                return true;
            default:
                if ((n & 1) == 0)
                    return false;
                else
                {
                    var boundary = Math.Sqrt(n);
                    for (var i = 3L; i <= boundary; i += 2)
                        if (n % i == 0) return false;
                    return true;
                }
        }
    }

    private static readonly List<long> primes = [];
    public static int GetPowerOfTwoExponent(BigInteger n)
    {
        var exponent = 0;
        while (n > 1)
        {
            n >>= 1;  // 右移一位相当于除以 2
            exponent++;
        }
        return exponent;
    }
    public static Dictionary<long, int> Decompose(long n)
    {
        if (n <= 1) return new() { [n] = 1 };

        var factors = new Dictionary<long, int>();
        var reminder = n;

        // 试除 2 到 sqrt(n) 的因子
        for (var i = 2L; i * i <= reminder; i++)
        {
            while (reminder % i == 0)
            {
                if (factors.TryGetValue(i, out int value))
                    factors[i] = ++value;
                else
                    factors[i] = 1;

                reminder /= i;
            }
        }

        // 如果剩余部分大于1，则为最后一个质因子
        if (reminder > 1L)
        {
            if (factors.TryGetValue(reminder, out var value))
                factors[reminder] = ++value;
            else
                factors[reminder] = 1;
        }
        return factors;
    }
    public static void Main(string[] args)
    {
        HashSet<BigInteger> powers = [];
        for (var i = 0L; i <= 400000; i++)
        {
            if (IsPrime(i))
            {
                var product = BigInteger.One;
                for (var j = 0; j < primes.Count; j++)
                    product *= (i - primes[j]);
                var result = product % i;
                if (BigInteger.IsPow2(result += (result < 0 ? i : 0)))
                {
                    var p = GetPowerOfTwoExponent(result);
                    powers.Add(p);
                    Console.WriteLine($"i = {i}, r = {result} = 2^{p}");
                }
                else
                {
                    var factors = Decompose((long)result);
                    var sorteds = new SortedDictionary<long, int>(factors);
                    var decomposed = sorteds.Select(p => (p.Key, p.Value)).ToArray();

                    Console.WriteLine(
                        $"i = {i}, r = {result} = {string.Join(" * ",
                            decomposed.Select(v =>
                                v.Value > 1 ? $"{v.Key}^{v.Value}" : $"{v.Key}"))}");
                    
                    if (factors.TryGetValue(2L, out var c))
                        powers.Add(c);
                }

                primes.Add(i);
            }
        }

        foreach (var p in powers.Order())
        {
            Console.WriteLine($"P={p}");
        }
    }