|
|
本帖最后由 kgz4484 于 2024-12-5 17:19 编辑
import math
import copy
"""
python 小程序，重点求质质配对常数 k ，质质配对数量 Up = 质质配对常数 k * 数列长度 L ，即： Up = k*L , 并进行验证，
误差率很少超过 10% 。质质配对常数 k 不等于零，说明存在质质配对数量，即说明哥德巴赫猜想成立。
本程序有两个模式，选择 2 为长数列模式，质质配对数量包括偶数等于两个质数相加，也等于两个人质数相减，选择 1 为短数列模式，
质质配对数量包括偶数等于两个质数相加，不包括两个质数相减内容。
"""
"""
整数数列（集合）
n ∈ N+ n为正整数，包括 0
A（ 6n+1 a≡1（mod 6 ）） 1 7 13 19 25 31 37 43 49 55 61 67 73 79 85 91 97 …… A 类型奇数
B（ 6n-1 b≡5（mod 6 ）） 5 11 17 23 29 35 41 47 53 59 65 71 77 83 89 95 101 …… B 类型奇数
C（ 6n+2 c≡2（mod 6 ）） 2 8 14 20 26 32 38 44 50 56 62 68 74 80 86 92 98 …… C 类型偶数
D（ 6n-2 d≡4（mod 6 ）） 4 10 16 22 28 34 40 46 52 58 64 70 76 82 88 94 100…… D 类型偶数
E（ 6n+3 e≡3（mod 6 ）） 3 9 15 21 27 33 38 45 51 57 63 69 75 81 87 93 99 …… E 类型奇数
F（ 6n f≡0（mod 6 ）） 0 6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96 …… F 类型偶数
n ∈ N n为正负整数，包括 0
AB = A+B ： 6n+1 a≡1（mod 6 ） 6n-1 a≡5（mod 6 ） A、B 两个数列（集合）合并，且是无首项无限等差数列，步长：6 ，哥德巴赫猜想所说的质数只存在于AB数列中，与E类型奇数无关。
或者：AB: …… 103 97 91 85 79 73 67 61 55 49 43 37 31 25 19 13 7 1 -5 -11 -17 -23 -29 -35 -41 -47 -53 -59 -65 -71 -77 -83 -89 -95 -101 ……
或者：AB: …… -103 -97 -91 -85 -79 -73 -67 -61 -55 -49 -43 -37 -31 -25 -19 -13 -7 -1 5 11 17 23 29 35 41 47 53 59 65 71 77 83 89 95 101 ……
或者：AB: …… 107 101 95 89 83 77 71 65 59 53 47 41 35 29 23 17 11 5 -1 -7 -13 -19 -25 -31 -37 -43 -49 -55 -61 -67 -73 -79 -85 -91 -97 ……
或者：AB: …… -107 -101 -95 -89 -83 -77 -71 -65 -59 -53 -47 -41 -35 -29 -23 -17 -11 -5 1 7 13 19 25 31 37 43 49 55 61 67 73 79 85 91 97 ……
CD = C+D ： 6n+2 a≡2（mod 6 ） 6n-2 a≡4（mod 6 ） C、D 两个数列（集合）合并，且是无首项无限等差数列，步长：6
或者： CD: …… 104 98 92 86 80 74 68 62 56 50 44 38 32 26 20 14 8 2 -4 -10 -16 -22 -28 -34 -40 -46 -52 -58 -64 -70 -76 -82 -88 -94 -100 ……
或者： CD: …… -104 -98 -92 -86 -80 -74 -68 -62 -56 -50 -44 -38 -32 -26 -20 -14 -8 -2 4 10 16 22 28 34 40 46 52 58 64 70 76 82 88 94 100 ……
或者： CD: …… -106 -100 -94 -88 -82 -76 -70 -64 -58 -52 -46 -40 -34 -28 -22 -16 -10 -4 2 8 14 20 26 32 38 44 50 56 62 68 74 80 86 92 98 ……
或者： CD: …… 106 100 94 88 82 76 70 64 58 52 46 40 34 28 22 16 10 4 -2 -8 -14 -20 -26 -32 -38 -44 -50 -56 -62 -68 -74 -80 -86 -92 -98 ……
E： 6n+3 e≡3（mod 6 ） 3 9 15 21 27 33 38 45 51 57 63 69 75 81 87 93 99 ……
F： 6n f≡0（mod 6 ） 0 6 12 18 24 30 36 42 48 54 60 66 72 78 84 90 96 ……
名词解译
cdf数列：任意确定一个偶数 cdf ，在AB数列中，如果只考虑相加配对等于偶数，那么能够配对相加等于 cdf 的所有元素构成的集合是有限的，该集合实际是从无限的AB数列中截取一段
有限长度的AB数列。用L表示。如果增加一点难度（研究意向），既考虑配对相加，又考虑配对相减，则要在无限的AB数列中截取更长一段，可自行设置长度，这里设置的长度是相加配对
长度与相减配对长度相同。这样的数列就是“哥猜”具体到某个偶数的研究对象，称之为cdf数列。
最大数am最小数bn：确定了偶数cdf。又确定了研究意向，则确定了数列数列长度L，数列长度与最大数最小数密不可分，自然存在最大数最小数。
中心数z：偶数 cdf 除以 2 的结果就是中心数 z ，z+z=cdf ，以 z 为对称点，AB数列中对称的两个元素相加等于 cdf ，即：（z+6n）+（z-6n）= cdf
对称质数r：中心数质因数有个特性，它的倍数是互为对称配对相加等于偶数，即一定是合合配对相加等于偶数。这样的质因数称为对称质数。
截止质数 pm ：cdf数列中的合数一定能分解成若干个质因数相乘，在合数的全部质因数当中，如果最小的那个质因数的平方大于数列的最大数，则该合数不属于cdf数列，也就是说，该质数 p 与
大于等于 p 的质数相乘，这样的合数不存在于cdf数列之中，为防止出现这种情况，必须有截止质数，所以，截止质数是小于最大数的平方根的最大质数。
有合配对：在cdf数列中，以中心数为对称点，对称的两个数相加等于cdf偶数，两个加数称为配对。配对有三种情况：1，合数与合数相加配对，2，合数与质数相加配对，3，质数与质数相加配对，
前两种情况加数至少有一个是合数，称为有合配对，第三种情况两个加数都是质数，称为质质配对。
质质配对常数解译：
AB集合是一个无首项无限等差数列，集合中的元素相乘所得合数仍然属于集合，即集合中合数来源于集合中质数相乘，任何一个元素a与AB集中的每一个元素相乘生成该元素的倍数集合
f(n) = a*(6n+1) ，任意元素a在AB数列中的相对步长是 a ，那么 a 的倍数数量占AB集数量的 1/a ，与之配对的数量也是 1/a ，寻到有合配对占比就是 2/a 。利用这一原理可设计出
一种筛法，从质数5开始，分离出每一质数的有合配对占比和剩余配对占比，并进行累计，一直到截止质数结束，累计有合配对占比就是数列中全部有合配对占比，累计剩余占比则是纯粹的质质配对占比。
占比不再变化，即比占演化成常数，用有合配对常数乘以数列长度则是数列中有合配对数量，用质质配对常数乘以数列长度则是哥德巴赫猜想所说的质质配对数量，成功将有合配对与质质配对分离开来。
具体筛法如下所述，首先将AB等差数列分列成 5 个子等差数列，自然而然，5 的倍数集中在一列（倍数列），占比 1/5 ，当然，存在着与倍数列对称的那个数列（配偶列），占比也是 1/5 ，
即有合配对占比是 2/5 ，这样成功分离出 5 的合数及其配偶，剩余的占比当然是 3/5，这种筛法实质是一种分离比例，即有合配对数量 ： 剩余数量 = 2：3 。接下来对剩余的数列进行
配对组合，然后将每个组分列成 7 个子列，自然而然，7 的倍数集中在一列，当然，7倍数有合配对数量 ： 剩余数量 = 2：5 ， 7倍数有合配对占比为 2/7 ，剩余配对占比为 5/7 ，到此，
两次分列后被分离的有合配对占比是：2/5+(3/5)*(2/7)，剩余的占比则是(3/5)*(5/7) 。分离的两个部分（有合配对和剩余配对）相加一定等于 1 。(2/5+(3/5)*(2/7)+(3/5)*(5/7)) = 1
以此类推，下一质数是11，那么，质数11 的分离比例是，有合配对 ：剩余 = 2 ：9 ，有合配对占比是：(3/5)*(5/7)*(2/11) ，剩余占比是：(3/5)*(5/7)*(9/11) ，累计有
合配对占比是：2/5+(3/5)*(2/7)+(3/5)*(5/7)*(2/11) 。（print((3/5)*(5/7)*(9/11)+2/5+(3/5)*(2/7)+(3/5)*(5/7)*(2/11) ) 输出 1 ）。 继续分离，
13层次，分离比例是，有合配对 ：剩余 = 2 ：11 ，有合配对占比 2/13 ， 剩余占比 11/13 ， 累计有合配对占比：((2/5)+(3/5)*((2/7)+(5/7)*((2/11)+(9/11)*(2/13)))) 累计剩余占比：(3/5)*(5/7)*(9/11)*(11/13)
17层次，分离比例是，有合配对 ：剩余 = 2 ：15 ，有合配对占比 2/17 ， 剩余占比 15/17 ， 累计有合配对占比：((2/5)+(3/5)*((2/7)+(5/7)*((2/11)+(9/11)*((2/13)+(11/13)*(2/17)))) 累计剩余占比：(3/5)*(5/7)*(9/11)*(11/13)*(15/17)
19层次，分离比例是：有合配对 ：剩余 = 2 ：17 ，有合配对占比 2/19 ， 剩余占比 17/19 ， 累计有合配对占比：((2/5)+(3/5)*((2/7)+(5/7)*((2/11)+(9/11)*((2/13)+(11/13)*((2/17)+(15/17)*(2/19))))) 累计剩余占比：(3/5)*(5/7)*(9/11)*(11/13)*(15/17)*(17/19)
…… ，……
质数 p 的分离比例是，有合配对 ：剩余 = 2 ：(p-2) ，有合配对占比 2/p ， 剩余占比 (p-2)/p 。 有种特殊情况，如果遇到 p 是对称质数，则
有合配对 ：剩余 = 1 ：(p-1) ，有合配对占比 1/p ， 剩余占比 (p-1)/p 。原因是 p 的倍数互为对称配对，是合合配对，不与质数配对。
继续筛法分离，直至完成截止质数层次的分离后结束，至此，将全部的有合配对与质质配对分离开来，剩余的不再有合数及配偶，是纯粹的质质配对占比，最后的累计有合占比演化成有合配对常数，
剩余占比演化成质质配对常数。用有合配对常数乘以数列长度则是数列中有合配对数量，用质质配对常数乘以数列长度则是哥德巴赫猜想所说的质质配对数量。
想验证式子是否有误，可测试累计有合占比 + 累计剩余占比 = 1，如19层次，print(((2/5)+(3/5)*((2/7)+(5/7)*((2/11)+(9/11)*((2/13)+(11/13)*((2/17)+(15/17)*(2/19)))))+(3/5)*(5/7)*(9/11)*(11/13)*(15/17)*(17/19))) # 输出 1.0
观察质质配对常数公式 k = （3/5）*（5/7）*（9/11）*（11/13）*（15/17）*（……）*（（p-2）/ p） ，通用于所有偶数，随着偶数增大，截止质数越来越大，层次越来越多，公式越来越长，
k 值越来越小，越来越趋近于 0 ，但是，（（p-2）/ p） 不为零，因此，k 值永远不为零，因此任意偶数都有质质配对。这是不是“哥猜”成立的证据。
本文的重点是质质配对常数，即常数的原理，方法，计算，并进行验证，误差很少超过 10% ，对于超大偶数的误差是多少，由于电脑性能不足，无法计算，感兴趣的网友可自己验证。
"""
"""
判断是否为质数
"""
def is_prime(num):
if num < 1:
num = num * (-1) # 如果是负数就转换为正数
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True
"""
准备一个质数列表，质数大于等于5，小于等于1000000 ，不包括 1、2、3
"""
P= [] # 大写字母 P ，表示质数集合，小写字母 p 表示集合中的元素。
for i in range(1,166666+1):
x = 6*i-1
y = 6*i+1
if is_prime(x):
P.append(x)
if is_prime(y):
P.append(y)
P.sort()
# print(P)
"""
利用计算机能力暴力计算统计质质配对数量， 传递两个参数：cdf_1（数列），num（偶数）
"""
def p_num(cdf_0, num): # 利用计算机能力暴力计算统计质质配对数量， 传递两个参数：cdf（数列），num（偶数） i1 = lcdf[lcdf.index(i) + 1]
lcdf = copy.copy(cdf_0)
t1=0 # 共计质质配对数量
t2 = 0 # 相加质质配对数量
t3 = 0 # 相减质质配对数量
for i in range(0, len(lcdf), 2):
if is_prime(lcdf) and is_prime(lcdf[i+1]):
# print(i, lcdf, lcdf[i + 1])
t1=t1+2
if lcdf>0 and lcdf[i + 1]>0:
t2=t2+2
else:
t3=t3+2
return t1, t2, t3
"""
求截止质数，即对最大数开平方，求小于最大数算术平方根的最大质数，数列中不再有大于截止质数相乘的合数
"""
def p_max(x):
pr = math.sqrt(x)
for i in P:
if i*i > x:
return
i1 = P[P.index(i) + 1]
if i1 > pr >= i:
return i
"""
对中心数进行因数分解，找出它的质因数集合并返回。中心数的质因数的倍数必然是以中心数为对称点互为对称配对相加等于偶数，这样的质数称为对称质数。
"""
def x0x(z):
r = []
for i in P:
if z % i == 0 and z != i:
r.append(i)
return r
"""
求有合配对常数，质质配对常数，有合配对数量，质质配对数量。 有合配对常数 + 质质配对常数 = 1 。有合配对数量 + 质质配对数量 = L（数列长度）
"""
def ke(c, cdf, pm, p_p):
global abu, abp
u = 0 # 每层次淘汰常数累加
k = 1 # 质质配对常数初始值，从1开始逐层次减少趋近于0
L = len(cdf)
print("质质配对常数： k = ", end=" ")
for i in P:
if i > pm: # 大于截止质数就结束，截止质数的用途
break
if i in p_p: # 如果遇到对称质数就使用下面的算法
u = u + k * (1 / i) # i层次有合配对常数
k = k * ((i - 1) / i) # i层次剩余元素常数， 当完成截止质数层次后，剩余元素常数转弯为质质配对常数，因为此数列中再无合数。
if i == pm:
print(f"({i-1}/{i})")
else:
print(f"({i-1}/{i})", end="*") # 输出质质配对常数的内容
else: # 其它不遇到对称质数就使用下面的算法
u = u + k * (2 / i) # i层次有合配对常数
k = k * ((i - 2) / i) # i层次剩余元素数量
if i == pm:
print(f"({i-2}/{i})")
else:
print(f"({i-2}/{i})", end="*")
# 公式：有合配对常数 u + 质质配对常数 k = 1
Uu = L * u # 公式：有合配对数量Uu = 数列长度L * 有合配对常数u
Up = L * k # 公式：质质配对数量Up = 数列长度L * 质质配对常数k
# 公式：有合配对数量Uu + 质质配对数量Up = 数列长度L
print("有合配对常数：", u, "\t", "质质配对常数：", k, "\t", "淘汰有合配对：", Uu, "\t", "公式质质配对：", Up)
pp = p_num(cdf, c) # 调用验证函数。
pp1 = pp[0] # 验证的质质配对总数量。
pp2 = pp[1] # 质质配对数量中相加数量。
pp3 = pp[2] # 质质配对数量中相减数量。
print("公式质质配对：", Up, "\t", "验证质质配对：", pp1, "\t", "验证相加质质配对:", pp2, "\t", "验证相减质质配对:", pp3, "误差率%：",
(Up - pp1) / pp1 * 100)
return Up, pp1, pp2, pp3
"""
输出偶数的一些参数,包括偶数，中心数，数列，偶数配对数量，最大数最小数，对称质数，截止质数
"""
def print_cdf(n, L, z, r, pm, am, bn):
print("配对数量", n + 1, "\t", "数列长度：", L, "\t", "中心：", z, z % 6, "对称质数：", r, "截止质数", pm, "\t", "最大最小加数：", "\t",
am, abs(am) % 6, " ", bn, abs(bn) % 6) # %6 是绝对值求余，要么余1，a类型，要么余5，b类型。
"""
输出数列，两种排列方式数列
"""
def print_lcdf(lcdf):
print("对称配对数列：", lcdf) # 输出配对加数生成的数列
lcdf_1=copy.copy(lcdf)
lcdf_1.sort() # 从小到大排列，必然转换为等差数列
print("对称等差数列：", lcdf_1) # 输出等差数列
"""
公式计算结果与验证进行比较，算出误差率
"""
def print_f(f1, f2):
f1_0 = f1[0]
f1_1 = f1[1]
f1_2 = f1[2]
f1_3 = f1[3]
f2_0 = f2[0]
f2_1 = f2[1]
f2_2 = f2[2]
f2_3 = f2[3]
print("公式质质配对：", f1_0 + f2_0, end="\t")
print("验证质质配对：", f1_1 + f2_1, end="\t")
print("验证相加质质配对：", f1_2 + f2_2, end="\t")
print("验证相减质质配对：", f1_3 + f2_3, end="\t")
print("误差率", ( (f1_0 + f2_0)-(f1_1 + f2_1) ) / (f1_1 + f2_1) * 100)
"""
对偶数进行全面分析，分类处理。
"""
def cdf(cdf, s): # cdf三个字母是c、d、f 三个类型偶数的总称
if s == 2: # 长数列
n = cdf // 6 # 找出偶数的自变量 , 也是偶数的配对数量，即一个偶数有n对加数，加数是 6n+1 或 6n-1 类型奇数。
print("长数列", end=" ")
if s == 1: # 长数列
n = cdf // (6*2) # 找出偶数的自变量 , 也是偶数的配对数量，即一个偶数有n对加数，加数是 6n+1 或 6n-1 类型奇数。
print("短数列", end=" ")
z = cdf // 2 # 这个数列的中心数，对称点，与该对称点对称的两个元素相加等于偶数。当 z=1 或 z=4 时，cdf为c类型偶数
if cdf % 6 == 2:
print(cdf, "6n+2型偶数 c=a+a，c=a-b")
if cdf % 6 == 4:
print(cdf, "6n-2型偶数 d=b+b，d=b-a")
if cdf % 6 == 0:
print(cdf, "6n型偶数 f=a+b，f=a-a, f=b-b")
if z % 6 == 1: # c偶数（6n+2），中心数类型：a ，（6n+1），配对类型：c=a1+a2，c=a-b，使用下列规则
am = z + 6 * n # 数列中最大数
bn = z - 6 * n # 数列中最小数
r = x0x(z) # 对称质数，对中心数进行质因数分解，列出中心数的质因数。（质数 2、3 排除在外）
pm = p_max(am) # 截止质数
list_cdf = [] # 能够配对相加等于 cdf 偶数的所有元素生成一个数列，用一个列表存储
for i in range(0, n + 1): # 以对称配对的方式生成列表
list_cdf.append(z + 6 * i) # 确保数列中的元素为 a 类型和 b 类型
list_cdf.append(z - 6 * i) # (z + 6 * i) 对称 (z - 6 * i)，对称的两个数字相加等于偶数
L = len(list_cdf) # 数列长度
print_cdf(n, L, z, r, pm, am, bn) # 输出参数
print_lcdf(list_cdf) # 打印数列
ke(cdf, list_cdf, pm, r) # 求质质配对数量
if z % 6 == 4: # c偶数（6n+2），中心数类型：b ，（6n-1），配对类型：c=a1+a2，c=a-b，使用下列规则
am = z + 3 + 6 * n
bn = z - 3 - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf = []
for i in range(0, n + 1):
list_cdf.append(z + 3 + 6 * i)
list_cdf.append(z - 3 - 6 * i)
L = len(list_cdf)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf)
ke(cdf, list_cdf, pm, r)
if z % 6 == 2: # d偶数（6n-2），中心数类型：c ，（6n+2），配对类型：c=b1+b2，d=b-a，使用下列规则
if s==1:
n = n -1
am = z + 3 + 6 * n
bn = z - 3 - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf = []
for i in range(0, n + 1):
list_cdf.append(z + 3 + 6 * i)
list_cdf.append(z - 3 - 6 * i)
L = len(list_cdf)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf)
ke(cdf, list_cdf, pm, r)
if z % 6 == 5: # d偶数（6n-2），中心数类型：b ，（6n-1），配对类型：c=b1+b2，d=b-a，使用下列规则
am = z + 6 * n
bn = z - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf = []
for i in range(0, n + 1):
list_cdf.append(z + 6 * i)
list_cdf.append(z - 6 * i)
L = len(list_cdf)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf)
ke(cdf, list_cdf, pm, r)
if z % 6 == 3: # f偶数（6n），中心数类型：e ，（6n+3），配对类型：f=a+b，f=a1-a2，f=b1-b2，使用下列规则
am = z + 2 + 6 * n
bn = z - 2 - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf = [] # f 类型偶数有两个数列 第 1 个数列
for i in range(0, n + 1):
list_cdf.append(z + 2 + 6 * i)
list_cdf.append(z - 2 - 6 * i)
L = len(list_cdf)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf)
f1 = ke(cdf, list_cdf, pm, r)
print("_"*15, "有两个不相同的数列")
if s==1:
n = n -1
am = z + 4 + 6 * n
bn = z - 4 - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf_2 = [] # f 类型偶数有两个数列 第 2 个数列
for i in range(0, n + 1):
list_cdf_2.append(z + 4 + 6 * i)
list_cdf_2.append(z - 4 - 6 * i)
L = len(list_cdf_2)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf_2)
f2 = ke(cdf, list_cdf_2, pm, r)
print_f(f1, f2)
if z % 6 == 0: # f偶数（6n），中心数类型：f ，（6n），配对类型：f=a+b，f=a1-a2，f=b1-b2，使用下列规则
if s==1:
n = n -1
am = z + 1 + 6 * n
bn = z - 1 - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf = [] # 第 1 个数列
for i in range(0, n + 1):
list_cdf.append(z + 1 + 6 * i)
list_cdf.append(z - 1 - 6 * i)
L = len(list_cdf)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf)
f1 = ke(cdf, list_cdf, pm, r)
print("_"*15, "有两个不相同的数列")
am = z + 5 + 6 * n
bn = z - 5 - 6 * n
r = x0x(z)
pm = p_max(am)
list_cdf_2 = [] # 第 2 个数列
for i in range(0, n + 1):
list_cdf_2.append(z + 5 + 6 * i)
list_cdf_2.append(z - 5 - 6 * i)
L = len(list_cdf)
print_cdf(n, L, z, r, pm, am, bn)
print_lcdf(list_cdf_2)
f2 = ke(cdf, list_cdf_2, pm, r)
print_f(f1, f2)
# cdf(20000000,1) # 任意偶数，此程序计算的最大偶数
for x in range(30004, 30032 + 1, 2): # 批量生成一些偶数，用于研究偶数的质质配对问题，可随意选择需要研究的偶数。对于越大偶数是否适用，有待验证。
cdf(x, 2) # 参数 1 是短数列模式，质质配对只有两质数相加，不包括两质数相减
# print("+"*15)
# cdf(x, 1) # 参数 2 是长数列模式，质质配对包括两质数相加，两质数相加相减
print("-"*100)
|
|
IP卡
狗仔卡
发表于 2024-12-4 01:37
提升卡
置顶卡
沉默卡
喧嚣卡
变色卡
显身卡
楼主