AMM算法

打不过你菜菜

于 2024-03-21 08:58:28 发布

阅读量622

点赞数 10

文章标签：算法

本文链接：https://blog.csdn.net/qq_63016521/article/details/136713108

版权

文章介绍了AMM算法在有限域中的应用，包括AMM2用于开平方根，以及如何通过AMM得到的解获取其他解。讨论了在特定条件下如何扩展到n次方根，以及相关的代码实现和测试案例。

摘要由CSDN通过智能技术生成

在这篇paper中推导了AMM算法，给出了如何在有限域中开2次，甚至n次方根问题的算法。

本文先介绍AMM算法是如何在有限域中开2次方根的问题，然后在介绍在有限域中开n次方根。

本文所涉及的模数均为素数。

前置知识

二次剩余：

模数为素数的平方剩余与非平方剩余

AMM2

AMM2解决的问题是在有限域下开平方根，并得到一个根。

p是一个素数，那么可以将p-1写成：p-1=2^t*s。其中s是奇数。

现在考虑在模p下的一个二次剩余δ和非二次剩余ρ。

在paper中给出了通过AMM算法得到一个根的算法：

算法实现：

我们由前置知识可得，若方程有解，那么a就是模p下的二次剩余，在算法的输入中提到算法的输入需要一个二次剩余δ，其实就是指这里的a。

代码：

def AMM2(residue,p):
    # 计算t,s
    t = 0
    s = p - 1
    while s % 2 == 0:
        t += 1
        s = s // 2
    if t==1:
        return pow(residue,(s+1)//2,p)
    #生成非二次剩余
    noresidue=random.randint(1,p)
    while pow(noresidue,(p-1)//2,p)==1:
        noresidue = random.randint(1,p)
    h=1
    a=pow(noresidue,s,p)
    b=pow(residue,s,p)
    for i in range(1,t):
        zhishu=2**(t-1-i)
        d=pow(b,zhishu,p)
        if d==1:
            k=0
        else:
            k=1
        b=b * pow(a, 2*k, p)%p
        h=pow(a,k,p)*h%p
        a=pow(a,2,p)
    return h*pow(residue,(s+1)//2,p)%p

测试用例是：

AMM算法一次只能得到一个解。

开2次方应该会有2个解，下面介绍怎么通过AMM2得到的一个解去获得另外的一个解。

由AMM2得到的一个解求其他解

完整代码：

import random
def find(p):
    #找到所有满足
    root=[]
    while len(root)<2:
        a=random.randint(2,p-1)
        res=pow(a,(p-1)//2,p)
        if res not in root:
            root.append(res)
    return root

def AMM2(residue,p):
    # 计算t,s
    t = 0
    s = p - 1
    while s % 2 == 0:
        t += 1
        s = s // 2
    if t==1:
        return pow(residue,(s+1)//2,p)
    #生成非二次剩余
    noresidue=random.randint(1,p)
    while pow(noresidue,(p-1)//2,p)==1:
        noresidue = random.randint(1,p)
    h=1
    a=pow(noresidue,s,p)
    b=pow(residue,s,p)
    for i in range(1,t):
        zhishu=2**(t-1-i)
        d=pow(b,zhishu,p)
        if d==1:
            k=0
        else:
            k=1
        b=b * pow(a, 2*k, p)%p
        h=pow(a,k,p)*h%p
        a=pow(a,2,p)
    return h*pow(residue,(s+1)//2,p)%p

residue=8
p=17
m0=AMM2(residue,p)
print("AMM2得到的一个根:",m0)
root_list=find(p)
for i in range(len(root_list)):
    a=m0*root_list[i]%p
    print("第{}个根:{}".format(i+1,a))

output：

AMM开e次方根

这里可以分两组情况来考虑：

原文：

算法：

代码：

def AMM(residue,r,p):
    # 计算t,s
    t = 0
    s = p - 1
    while s % r == 0:
        t += 1
        s = s // r
    #计算alpha
    k=1
    while ( k * s + 1 ) % r != 0:
        k+=1
    alpha=(k*s+1)//r
    #当t=1时的情况
    if t==1:
        return pow(residue,alpha,p)
    #t>=2的情况
    #计算一个r次非剩余
    noresidue = random.randint(1, p)
    while pow(noresidue, (p - 1) // r, p) == 1:
        noresidue = random.randint(1, p)
    a=pow( noresidue , ( r ** ( t-1 )) * s, p )
    b=pow( residue , r * alpha - 1, p )
    c=pow( noresidue , s , p )
    h=1
    for i in range(1,t):
        d=pow( b , r ** ( t-1-i ) , p )
        if d==1:
            j=0
        else:
            j=-math.log(d,a)
        b=pow( pow ( c , r , p ) , j , p ) * b % p
        h=pow( c , j , p ) * h % p
        c=pow( c , r , p )
    return pow( residue , alpha , p ) * h % p

测试用例：

由AMM得到的一个解求其他解

AMM只能得到一个根。

对于：

当r能够整除q-1时，会有r个单位根，当r不能整除q-1时，只有一个单位根，即1本身。

从一个根得到其他根的思路为：首先找到r个不同的单位根，然后让(AMM得到的根)*单位根%q。

完整代码：

import random
import math

def find(e,p):
    root = []
    while len(root) < e:
        a = random.randint(2, p - 1)
        res = pow(a, (p - 1) // e, p)
        if res not in root:
            root.append(res)
    return root

def AMM(residue,r,p):
    # 计算t,s
    t = 0
    s = p - 1
    while s % r == 0:
        t += 1
        s = s // r
    #计算alpha
    k=1
    while ( k * s + 1 ) % r != 0:
        k+=1
    alpha=(k*s+1)//r
    #当t=1时的情况
    if t==1:
        return pow(residue,alpha,p)
    #t>=2的情况
    #计算一个r次非剩余
    noresidue = random.randint(1, p)
    while pow(noresidue, (p - 1) // r, p) == 1:
        noresidue = random.randint(1, p)
    a=pow( noresidue , ( r ** ( t-1 )) * s, p )
    b=pow( residue , r * alpha - 1, p )
    c=pow( noresidue , s , p )
    h=1
    for i in range(1,t):
        d=pow( b , r ** ( t-1-i ) , p )
        if d==1:
            j=0
        else:
            j=-math.log(d,a)
        b=pow( pow ( c , r , p ) , j , p ) * b % p
        h=pow( c , j , p ) * h % p
        c=pow( c , r , p )
    return pow( residue , alpha , p ) * h % p

residue=6
e=3
p=37
if (p-1)%e==0:
    mp = AMM(residue, e, p)
    print("AMM得到的一个根为:{}".format(mp))
    root_list = find(e, p)
    for i in range(len(root_list)):
        a = mp * root_list[i] % p
        print("第{}个根:{}".format(i + 1, a))
else:
    print("e不能整除(p-1),AMM不适用")

output：