ฟังก์ชันผกผันการคูณแบบโมดูลาร์ใน Python

โมดูล Python มาตรฐานบางตัวมีฟังก์ชันในการคำนวณค่าผกผันการคูณแบบโมดูลาร์หรือไม่y = invmod(x, p)เช่นจำนวนนั้นx*y == 1 (mod p)หรือไม่ Google ดูเหมือนจะไม่ได้ให้คำแนะนำที่ดีเกี่ยวกับเรื่องนี้

แน่นอนว่าเราสามารถสร้างอัลกอริธึมแบบยุคลิดแบบขยายที่ผลิตเองในบ้านได้ 10 สายแต่ทำไมต้องสร้างวงล้อขึ้นมาใหม่

ตัวอย่างเช่น Java BigIntegerมีmodInverseวิธีการ Python ไม่มีอะไรที่คล้ายกัน?

อาจมีคนพบว่าสิ่งนี้มีประโยชน์ (จากวิกิตำรา ):

def egcd(a, b):
    if a == 0:
        return (b, 0, 1)
    else:
        g, y, x = egcd(b % a, a)
        return (g, x - (b // a) * y, y)

def modinv(a, m):
    g, x, y = egcd(a, m)
    if g != 1:
        raise Exception('modular inverse does not exist')
    else:
        return x % m

หากโมดูลัสของคุณเป็นไพรม์ (คุณเรียกมันว่าp) คุณสามารถคำนวณได้ดังนี้

y = x**(p-2) mod p  # Pseudocode

หรือใน Python ที่เหมาะสม:

y = pow(x, p-2, p)

นี่คือคนที่ใช้ความสามารถด้านทฤษฎีจำนวนใน Python: http://www.math.umbc.edu/~campbell/Computers/Python/numbthy.html

นี่คือตัวอย่างที่ทำเมื่อพร้อมต์:

m = 1000000007
x = 1234567
y = pow(x,m-2,m)
y
989145189L
x*y
1221166008548163L
x*y % m
1L

คุณอาจต้องการดูโมดูลgmpy เป็นอินเทอร์เฟซระหว่าง Python และไลบรารีความแม่นยำหลาย GMP gmpy มีฟังก์ชัน invert ที่ตอบสนองสิ่งที่คุณต้องการ:

>>> import gmpy
>>> gmpy.invert(1234567, 1000000007)
mpz(989145189)

คำตอบที่อัปเดต

ตามที่ระบุไว้โดย @hyh gmpy.invert()ผลตอบแทนเป็น 0 หากไม่มีสิ่งผกผัน ที่ตรงกับพฤติกรรมของ GMP ของmpz_invert()ฟังก์ชั่น ให้แก้ปัญหาทั่วไปgmpy.divm(a, b, m)a=bx (mod m)

>>> gmpy.divm(1, 1234567, 1000000007)
mpz(989145189)
>>> gmpy.divm(1, 0, 5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: not invertible
>>> gmpy.divm(1, 4, 8)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: not invertible
>>> gmpy.divm(1, 4, 9)
mpz(7)

divm()จะคืนค่าโซลูชันเมื่อgcd(b,m) == 1และเกิดข้อยกเว้นเมื่อไม่มีผกผันการคูณ

คำเตือน: ฉันเป็นผู้ดูแลห้องสมุด gmpy ในปัจจุบัน

คำตอบที่อัปเดต 2

ตอนนี้ gmpy2 เพิ่มข้อยกเว้นอย่างถูกต้องเมื่อไม่มีสิ่งผกผัน:

>>> import gmpy2

>>> gmpy2.invert(0,5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: invert() no inverse exists

จาก 3.8 pythons pow () ฟังก์ชันสามารถรับโมดูลัสและจำนวนเต็มลบได้ ดูที่นี่ . กรณีของพวกเขาสำหรับวิธีการใช้งานคือ

>>> pow(38, -1, 97)
23
>>> 23 * 38 % 97 == 1
True

นี่คือหนึ่งซับสำหรับCodeFights ; เป็นหนึ่งในวิธีแก้ปัญหาที่สั้นที่สุด:

MMI = lambda A, n,s=1,t=0,N=0: (n < 2 and t%N or MMI(n, A%n, t, s-A//n*t, N or n),-1)[n<1]

มันจะกลับมา-1ถ้าไม่มีผกผันในAn

การใช้งาน:

MMI(23, 99) # returns 56
MMI(18, 24) # return -1

วิธีการแก้ปัญหาใช้ขยายยุคลิดอัลกอริทึม

Sympyโมดูล python สำหรับคณิตศาสตร์เชิงสัญลักษณ์มีฟังก์ชันผกผันแบบแยกส่วนในตัวหากคุณไม่ต้องการใช้งานของคุณเอง (หรือหากคุณใช้ Sympy อยู่แล้ว):

from sympy import mod_inverse

mod_inverse(11, 35) # returns 16
mod_inverse(15, 35) # raises ValueError: 'inverse of 15 (mod 35) does not exist'

ดูเหมือนจะไม่ได้รับการบันทึกไว้ในเว็บไซต์ Sympy แต่นี่คือ docstring: Sympy mod_inverse docstring บน Github

นี่คือรหัสของฉันมันอาจจะเลอะเทอะ แต่ดูเหมือนว่าจะใช้ได้กับฉันอยู่ดี

# a is the number you want the inverse for
# b is the modulus

def mod_inverse(a, b):
    r = -1
    B = b
    A = a
    eq_set = []
    full_set = []
    mod_set = []

    #euclid's algorithm
    while r!=1 and r!=0:
        r = b%a
        q = b//a
        eq_set = [r, b, a, q*-1]
        b = a
        a = r
        full_set.append(eq_set)

    for i in range(0, 4):
        mod_set.append(full_set[-1][i])

    mod_set.insert(2, 1)
    counter = 0

    #extended euclid's algorithm
    for i in range(1, len(full_set)):
        if counter%2 == 0:
            mod_set[2] = full_set[-1*(i+1)][3]*mod_set[4]+mod_set[2]
            mod_set[3] = full_set[-1*(i+1)][1]

        elif counter%2 != 0:
            mod_set[4] = full_set[-1*(i+1)][3]*mod_set[2]+mod_set[4]
            mod_set[1] = full_set[-1*(i+1)][1]

        counter += 1

    if mod_set[3] == B:
        return mod_set[2]%B
    return mod_set[4]%B

โค้ดด้านบนจะไม่ทำงานใน python3 และมีประสิทธิภาพน้อยกว่าเมื่อเทียบกับตัวแปร GCD อย่างไรก็ตามรหัสนี้มีความโปร่งใสมาก มันกระตุ้นให้ฉันสร้างเวอร์ชันที่กะทัดรัดขึ้น:

def imod(a, n):
 c = 1
 while (c % a > 0):
     c += n
 return c // a

นี่คือ 1 ซับสั้น ๆ ที่ทำได้โดยไม่ต้องใช้ไลบรารีภายนอกใด ๆ

# Given 0<a<b, returns the unique c such that 0<c<b and a*c == gcd(a,b) (mod b).
# In particular, if a,b are relatively prime, returns the inverse of a modulo b.
def invmod(a,b): return 0 if a==0 else 1 if b%a==0 else b - invmod(b%a,a)*b//a

โปรดทราบว่านี่เป็นเพียงแค่ egcd ซึ่งมีความคล่องตัวในการคืนค่าสัมประสิทธิ์ดอกเบี้ยเดียวเท่านั้น

ในการหาค่าผกผันการคูณแบบโมดูลาร์ฉันขอแนะนำให้ใช้อัลกอริทึมแบบยูคลิดแบบขยายดังนี้:

def multiplicative_inverse(a, b):
    origA = a
    X = 0
    prevX = 1
    Y = 1
    prevY = 0
    while b != 0:
        temp = b
        quotient = a/b
        b = a%b
        a = temp
        temp = X
        a = prevX - quotient * X
        prevX = temp
        temp = Y
        Y = prevY - quotient * Y
        prevY = temp

    return origA + prevY

ฉันลองวิธีแก้ปัญหาที่แตกต่างจากเธรดนี้และในที่สุดฉันก็ใช้อันนี้:

def egcd(a, b):
    lastremainder, remainder = abs(a), abs(b)
    x, lastx, y, lasty = 0, 1, 1, 0
    while remainder:
        lastremainder, (quotient, remainder) = remainder, divmod(lastremainder, remainder)
        x, lastx = lastx - quotient*x, x
        y, lasty = lasty - quotient*y, y
    return lastremainder, lastx * (-1 if a < 0 else 1), lasty * (-1 if b < 0 else 1)


def modinv(a, m):
    g, x, y = self.egcd(a, m)
    if g != 1:
        raise ValueError('modinv for {} does not exist'.format(a))
    return x % m

Modular_inverse ใน Python

ฉันไม่มีฟังก์ชันใน python แต่ฉันมีฟังก์ชันใน C ซึ่งคุณสามารถแปลงเป็น python ได้อย่างง่ายดายในฟังก์ชัน c ด้านล่างขยายอัลกอริธึมยูคลิดเดียนใช้ในการคำนวณม็อดผกผัน

int imod(int a,int n){
int c,i=1;
while(1){
    c = n * i + 1;
    if(c%a==0){
        c = c/a;
        break;
    }
    i++;
}
return c;}

ฟังก์ชัน Python

def imod(a,n):
  i=1
  while True:
    c = n * i + 1;
    if(c%a==0):
      c = c/a
      break;
    i = i+1

  return c

การอ้างอิงถึงฟังก์ชัน C ข้างต้นนำมาจากลิงค์ต่อไปนี้โปรแกรม C เพื่อค้นหา Modular Multiplicative Inverse ของเลขหลักสองตัว

จากซอร์สโค้ดการใช้งาน cpython :

def invmod(a, n):
    b, c = 1, 0
    while n:
        q, r = divmod(a, n)
        a, b, c, n = n, c, b - q*c, r
    # at this point a is the gcd of the original inputs
    if a == 1:
        return b
    raise ValueError("Not invertible")

ตามความคิดเห็นด้านบนรหัสนี้สามารถส่งคืนค่าลบเล็กน้อยดังนั้นคุณสามารถตรวจสอบได้ว่าเป็นลบหรือไม่และเพิ่ม n เมื่อเป็นค่าลบก่อนที่จะส่งคืน b

ลิงก์หลายรายการด้านบนเสียในวันที่ 23 มกราคม 2560 ฉันพบการใช้งานนี้: https://courses.csail.mit.edu/6.857/2016/files/ffield.py