Восстановите число из нескольких его остатков (китайская теорема об остатках) - PullRequest
Новая
       76

Восстановите число из нескольких его остатков (китайская теорема об остатках)

5 голосов
/ 13 марта 2011

У меня длинное целое число, но оно хранится не в десятичной форме, а как набор остатков.

Итак, у меня есть не число N, а набор таких остатков: 

r_1 = N % 2147483743
r_2 = N % 2147483713
r_3 = N % 2147483693
r_4 = N % 2147483659
r_5 = N % 2147483647
r_6 = N % 2147483629

Я знаю, что N меньше, чем умножение этих простых чисел, поэтому китайская теорема об остатках делаетработать здесь (http://en.wikipedia.org/wiki/Chinese_remainder_theorem).

Как я могу восстановить N в десятичном формате, если у меня есть эти 6 остатков? Замечательно будет любая программа, чтобы сделать это (C / C + GMP / C ++ / perl / java / bc).

Например, какое минимальное N может иметь этот набор остатков: 

r_1 = 1246736738 (% 2147483743)
r_2 = 748761 (% 2147483713)
r_3 = 1829651881 (% 2147483693)
r_4 = 2008266397 (% 2147483659)
r_5 = 748030137 (% 2147483647)
r_6 = 1460049539 (% 2147483629)

Ответы [ 3 ]

6 голосов
/ 13 марта 2011

Ссылочная статья уже предоставляет конструктивный алгоритм для поиска решения .

По сути, для каждого i вы решаете целочисленное уравнение ri*ni + si*(N/ni) = 1, где N = n1*n2*n3*....ri и si здесь неизвестны.Это можно решить с помощью расширенного евклидова алгоритма .Он очень популярен, и у вас не будет проблем с поиском примеров реализации на любом языке.

Тогда, предполагая ei = si*(N/ni), ответ будет sum(ei*ai) для каждого i.
Все это описано в этой статье, с доказательством и примером.

2 голосов
/ 13 марта 2011

Вот код (C + GMP), основанный на этом коде LGPL Бена Линна blynn @ github;Стэнфорд алгоритма Гарнера (найден с помощью RIP Google Code Search по запросу garner mpz_t): https://github.com/blynn/pbc/blob/master/guru/indexcalculus.c (часть его библиотеки The PBC (Pairing-Crypto))

Компиляция с gcc -std=c99 -lgmp.Также измените размер для вашего случая. 

#include <gmp.h>
#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>

// Garner's Algorithm.
// See Algorithm 14.71, Handbook of Cryptography.

//    x - result    v residuals    m - primes   t-size of vectors
static void CRT(mpz_t x, mpz_ptr *v, mpz_ptr *m, int t) {
  mpz_t u;
  mpz_t C[t];
  int i, j;

  mpz_init(u);
  for (i=1; i<t; i++) {
    mpz_init(C[i]);
    mpz_set_ui(C[i], 1);
    for (j=0; j<i; j++) {
      mpz_invert(u, m[j], m[i]);
      mpz_mul(C[i], C[i], u);
      mpz_mod(C[i], C[i], m[i]);
    }
  }
  mpz_set(u, v[0]);
  mpz_set(x, u);
  for (i=1; i<t; i++) {
    mpz_sub(u, v[i], x);
    mpz_mul(u, u, C[i]);
    mpz_mod(u, u, m[i]);
    for (j=0; j<i; j++) {
      mpz_mul(u, u, m[j]);
    }
    mpz_add(x, x, u);
  }

  for (i=1; i<t; i++) mpz_clear(C[i]);
  mpz_clear(u);
}

const int size=6; // Change this please

int main()
{
    mpz_t res;
    mpz_ptr t[size], p[size];
    for(int i=0;i<size;i++) { 
        t[i]=(mpz_ptr)malloc(sizeof(mpz_t));
        p[i]=(mpz_ptr)malloc(sizeof(mpz_t));
        mpz_init(p[i]);
        mpz_init(t[i]);
    }
    mpz_init(res);

    for(int i=0;i<size;i++){
        unsigned long rr,pp;
        scanf("%*c%*c%*c = %lu (%% %lu)\n",&rr,&pp);
        printf("Got %lu res on mod %% %lu \n",rr,pp);
        mpz_set_ui(p[i],pp);
        mpz_set_ui(t[i],rr);
    }

    CRT(res,t,p,size);

    gmp_printf("N = %Zd\n", res);
}

Пример решен: 

$ ./a.out
r_1 = 1246736738 (% 2147483743)
r_2 = 748761 (% 2147483713)
r_3 = 1829651881 (% 2147483693)
r_4 = 2008266397 (% 2147483659)
r_5 = 748030137 (% 2147483647)
r_6 = 1460049539 (% 2147483629)

Got 1246736738 res on mod % 2147483743 
Got 748761 res on mod % 2147483713 
Got 1829651881 res on mod % 2147483693 
Got 2008266397 res on mod % 2147483659 
Got 748030137 res on mod % 2147483647 
Got 1460049539 res on mod % 2147483629 
N = 703066055325632897509116263399480311

N равно 703066055325632897509116263399480311

1 голос
/ 21 апреля 2019

Вот реализация Python 3, основанная на задаче Rosetta Code: https://rosettacode.org/wiki/Chinese_remainder_theorem

from functools import reduce
from operator import mul    

def chinese_remainder(n, a):
    """
    Chinese Remainder Theorem.

    :param n: list of pairwise relatively prime integers
    :param a: remainders when x is divided by n
    """
    s = 0
    prod = reduce(mul, n)
    for n_i, a_i in zip(n, a):
        p = prod // n_i
        s += a_i * inverse(p, n_i) * p
    return s % prod    

def inverse(a, b):
    """
    Modular multiplicative inverse.
    """
    b0 = b
    x0, x1 = 0, 1
    if b == 1:
        return 1
    while a > 1:
        q = a // b
        a, b = b, a % b
        x0, x1 = x1 - q * x0, x0
    if x1 < 0:
        x1 += b0
    return x1    

n = [2147483743, 2147483713, 2147483693, 2147483659, 2147483647, 2147483629]
a = [1246736738, 748761, 1829651881, 2008266397, 748030137, 1460049539]

print(chinese_remainder(n, a))  # 703066055325632897509116263399480311

Приятной особенностью Python является то, что он поддерживает произвольно большие целые числа естественным образом.

...