Residue Number Systems Methods and Apparatuses

Abstract

A method for performing reconstruction using a residue number system includes selecting a set of moduli. A reconstruction coefficient is estimated based on the selected set of moduli. A reconstruction operation is performed using the reconstruction coefficient.

Description

FIELD OF THE INVENTION

The invention relates to performing residue number system calculations, and in particular, to reduced complexity algorithms and hardware designs for performing residue number system calculations. This invention is in the field of the Residue Number Systems (RNS) and their applications.

§1 BACKGROUND OF THE INVENTION

The RNS uses a set “” of pair-wise co-prime positive integers called as the “moduli” ={m₁, m₂, . . . , m_r, . . . , m_k} where m_r>1 ∀r ∈ [1, K] and gcd (m_i, m_j)=1 for i≠j (B-1)

Note that ||=the number of moduli=K (also referred to as the number of “channels” in the literature)

We use the term “component-modulus” to refer to any single individual modulus (ex: m_r) in the set .

For the sake of convenience, we also impose an additional ordering constraint: m_i<m_j if i<j

Total-modulus m₁×m₂× . . . ×m_K. Typically >>K (B-2)

Any integer Z ∈ [0,, can be uniquely represented by the ordered-touple (or vector) of residues:

∀ Z ∈ [0, −1]; Z≡=[z₁, z₂, . . . , z_K] where, z_r=(Z mod m_r), r=1, . . . , K (B-3)

Conversion from residues back to an integer is done using the “Chinese Remainder Theorem” as follows:

Z=(Z_T mod ) (B-4) where

$Z_T=\left(\sum _{r=1}^K{ℳ}_r·{\rho }_r\right)$

(B-5)

p_r=((z_r·w_r) mod m_r), r=1, . . . , K where (B-6)

outer-weights

${ℳ}_i=\frac{m_i}{};$

inner-weights

$w_i=\left(\frac{1}{{ℳ}_i}\mathrm{mod}m_{i}\right)$

are constants for a given (B-7)

The Residue Number Systems (abbreviated “RNS”) have been around for while [4]. The underlying Residue Domain representation (or simply Residue Representation, abbreviated “RR”) has some unique attributes (explained below) that make it attractive for signal processing. It is therefore not surprising that the early work in this area was contributed by the signal-processing community.

Thereafter, from the late 1970s through the mid 1980s, the field of cryptology was revolutionized by the invention of the 3 most fundamental and widely used cryptology algorithms, viz., Diffie-Hellman, RSA, and Elliptic-curves. In the beginning, the aforementioned cryptology algorithms were not easy to implement in hardware. However, as semiconductor device sizes kept on shrinking, the hardware that could be integrated on a single chip kept on becoming larger as well as faster. As a result, today (in 2011) it possible to easily realize the cryptographic (abbreviated “crypto”) algorithms in hardware. The word-lengths used in crypto methods are substantially larger as compared with wordlengths required by other applications; typical crypto word lengths today are at least 256 bits or higher. It turns out that the same attributes of the Residue Number Systems that are attractive for signal processing are also beneficial when implementing cryptographic algorithms at long word-lengths. Consequently the cryptology and computer-arithmetic communities also started researching RNS. This coincidental convergence of goals (to research and improve RNS, which is now shared by the signal processing, cryptology as well as computational/computer arithmetic communities) has in-turn led to a resurgence of interest as well as activity in the RNS [5].

§1.1 Advantages of the Residue Domain Representation

The main advantage of the Residue Number (RN) system is that in the Residue-Domain (RD), the operations {±, ×, } can be implemented on a per-component/channel basis, wherein the processing required in any single channel is completely independent of the processing required in any other channel. In other words, these operations can be implemented fully in parallel on a per-channel basis as follows:

Z = XY[z_r=(x_ry_r) mod m_r)], r=1, . . . , K where ∈ {±, ×, ?}  (1)

Note that equality of two numbers can be checked by comparing their residues which can be done in parallel in all channels. In other words, in the RD, the most fundamental operations viz., addition/subtraction, equality check AND Multiplication can all be performed in parallel in each channel independently of any other channel(s). This independence of channels implies that each of the above operations can be implemented with O(n) computing effort (operations/steps), where

┌lg┐=n   (2)

i.e., n is the number of bits required to represent the total-modulus or the overall range of the RNS.

In contrast, in the regular integer domain, a multiplication is a convolution of the digit-strings representing the two numbers being multiplied. A convolution is substantially more expensive than add/subtract operations (Addition/Subtraction fundamentally require O(n) operations and can be implemented in O(lg n) delay using the “carry-look-ahead” method and its variants. Naive paper-and-pencil multiplication, requires O(n²) operations. Asymptotically fastest multiply methods use transforms such as floating point FFT (Fast Fourier Transform) or number-theoretic transforms to convert the convolution in the original domain into a point-wise product in the transform domain, so that the number of operations required turns out to be ≈O(nlg n); for further details, please refer to [2]).

Thus, performing the multiplications in the RD is substantially faster as well as cheaper (in terms of interconnect length and therefore h/w area as well as power consumption). Consequently, wherever multiplication is heavily used, adopting the RR can lead to smaller and faster realizations that also consume less power. For example:

(i) Filtering is heavily used in signal processing. Most of the effort in filtering is in the repeated multiply and add operations. It is therefore not surprising that the first practical use of the RNS was in synthesizing fast filters for signal processing.

(2) Multiplication (note that squaring is a special case of multiplication) also gets used heavily in long-wordlength cryptology algorithms. Therefore RD implementations of cryptological algorithms are also smaller, faster and consume lower power.

§1.2 Disadvantages of the Residue Domain Representation

Together with the advantages, also come some of the disadvantages of the residue domain: when compared to the “easy operations” above, several fundamental operations are relatively a lot more difficult to realize in the RD [4, 6-8]:

• • 1. Reconstruction or conversion back to a weighted, non redundant positional representation (ex, binary or decimal or the “mixed-radix” representation [6])
  • 2. Base extension or change.
  • 3. Sign and overflow detection or equivalently, a magnitude-comparison.
  • 4. Scaling or division by a constant, wherein, the divisor is known ahead of time (such as the Modulus in the RSA or Diffie-Hellman algorithms)
  • 5. Division by an arbitrary divisor whose value is dynamic, i.e., available only at run-time.

Reconstruction in the regular format by directly using the CRT turns out to be a slow operation. Note that a straightforward/brute-force application of the CRT entails directly implementing Equation (B-4). Accordingly, Z_T is fully evaluated first, and then a division by the modulus M is carried out to retrieve the remainder (Z). For long word-lengths (ex, in cryptography applications) the final division by M is unacceptably slow and inefficient.

Re-construction by evaluating the mixed-radix representation takes advantage of the “mixed-radix” representation associated with every residue-domain-representation [6], wherein a number is represented by an ordered set of digits. The value of the number is a weighted sum where the weights are positional (just like the weights of a normal single radix decimal or binary representation). As a result, a digit-by-digit comparison starting with the most-significant-digit is feasible. However, to the best of our knowledge it takes O(K²) sequential operations (albeit on small sized operands of about the same size as the component-moduli m_i) in the residue-domain. The inherently sequential nature of this method makes it slow.

Moreover, at a first glance, it appears that for magnitude-comparison and division, the operands need to be fully reconstructed in the form of a unique digit string representing an integer either in the regular or the mixed-radix-format.

§1.3 Related Prior Art

§1.3.1 Base-Extension or Change

In a sign-magnitude representation or a radix-complement (such as the two's complement) representation, a 32 bit integer can be easily extended into a 64 bit value. The corresponding operation in the RNS is considerably more involved. Related Prior work in this area falls under two categories, each is briefly explained next.

§1.3.1.A Deploying a Redundant Modulus

Shenoy and Kumarersan [9] start by re-expressing the CRT in a slightly different form:

Z=Z _T−α· where 0 αK−1

In the above equation α=_C is the only unknown. It is clear that knowledge of (Z mod m_e), i.e., the residue/remainder of Z, w.r.t. one extra/redundant modulus m_e is sufficient to determine the value of _C. They assume the availability of such an extra residue, which lets them evaluate α=_C.

This base extension method has been widely adopted in the literature. For example, Algorithms for modular multiplication developed by Bajard et. al. [10, 11] perform their computations in two independent RNS systems and change base from one to the other using the shenoy-kumaresan method. This is done so as to avoid a full reconstruction at intermediate steps. As a result, they end up requiring a base-conversion in each step and consequently, their algorithm requires O(K) units of delay when O(K) dedicated processing elements are available (where K=the total number of moduli or channels in the RNS system).

§1.3.1.B Iterative Determination of _C

Another base-extension algorithm related to our work is described in [12-15]. They show a method to evaluate an approximate estimate in a recursive, bit-by-bit (i.e., one bit-at-a-time) manner and then derive conditions under which the approximation is error-free. This method is at the heart of their base-extension algorithm.

The recursive structure of this method makes it relatively slower and cumbersome.

The idea of using the “fractional-representation” of CRT has been around for a while. For instance, Vu [16, 17] proposed using a Fractional interpretation of the CRT in the mid 1980s. However, he ends up using a very high (actually the FULL) precision: [lg (K·)] bits (see equations (13) and (14) in reference [17]).

§1.3.2 Sign Detection and Magnitude Comparison

In the RNS, the total range is divided into positive and negative intervals of the same length (to the extent possible). For example, if the set of RNS moduli is ={2, 3, 5, 7} then =210 and the overall range of the RNS is [−105,+104], where,

the numbers 1 through 104 represent +ve numbers, and

the numbers 105 thru 209 represent −ve numbers from −105 to −1, respectively.

In general, all negative values in the range [−(−1), −1] satisfy the relation

(−α) mod ≡−α  (3)

Sign detection in the RNS is not straightforward, rather, it has been known to be relatively difficult to realize in the Residue Domain.

Likewise, comparison of magnitudes of two numbers represented as residue touples is also not straightforward (independent of whether or not negative numbers are included in the representation). For instance, with the same simple moduli set ={2,3,5,7} above, note that 18≡(1, 1, 4, 5) and 99≡(1,0,4,1) while 79≡(1, 1, 4, 1) and the negative number −101≡(1,1,4,4).

In other words, the touples of remainders corresponding to +ve and −ve numbers cannot be easily distinguished.

Prior Work on Sign Detection and Magnitude Comparison

Sign detection operation has been known to be relatively difficult to realize in the RNS for a while (early works date back to 1960's, for example [4,18]). Recent works related to Sign detection in RNS have tended to focus on using moduli having special forms [19, 20], which limits their applicability. The idea of “core-functions” was introduced in [21] in the context of coding-theory. RNS sign-detection algorithms based on idea of using “core-functions” have been published [22-24]. However, these methods are unnecessarily complicated and appear to be useful only with moduli with special properties [24], limiting their applicability.

Lu and Chiang [25, 26] introduced a method to use the least significant bit (lsb) to keep track of the sign. However, tracking the lsb of arbitrary (potentially all possible) numbers is not an easy task. In their quest to keep track of the lsb, Lu and Chiang first proposed an exhaustive method in their first publication [25]; which turns out to be infeasible for all but small toy examples because the size of their look-up table was the same as the total range M. In the follow up publication, they abandoned the exhaustive look-up approach [26] and ended up unnecessarily using the full precision, just as Vu does in his work [17].

§1.3.3 Scaling or Division by a Constant

In general, “scaling” includes both multiplication as well as division by a fixed constant, (viz., the scaling factor S_f). Early versions of signal processors often deployed a fixed-point format which necessitated scaling to cover a wider dynamic range of input values. Consequently, scaling has been heavily used in signal processing. It is therefore not surprising that the early work in realizing the scaling operation in the residue-domain comes from the signal-processing community [27, 28].

Shenoy and Kumaresan [29, 30] introduced a scaling method that works only if the constant divisor has the special form

D=m _{d 1} ·m _{d 2} . . . m _{d s} wherein s<K and

{m_d1, m_ds . . . m_ds}⊂{m₁, m₂, . . . , m_k}==the set of RNS moduli   (4)

i.e., the divisor is a factor of the overall modulus M. This restriction renders their method inapplicable in most cryptographic algorithms; because the modulus (aka, the constant divisor) N is either a large prime number (as in elliptic curve methods) or a product of two large primes numbers (as in RSA). In either case, it does not share a factor with the total modulus .

All methods and apparata for scaling in the RNS that have been published thus far [23, 31-33]; including more recent ones [33-35] are either limited to special moduli or are more involved than necessary because they all attempt to estimate the remainder first, subtract it off and then arrive at the quotient, which is the quantity of interest in scaling. Consequently, none of the methods or apparata are even remotely similar to the new algorithm that I have invented for RNS division by a constant.

§2 SUMMARY OF THE INVENTION

The following presents a simplified summary in order to provide a basic understanding of some aspects of the claimed subject matter. This summary is not an extensive overview, and is not intended to identify key or critical elements, or to delineate any scope of the disclosure or claimed subject matter. The sole purpose of the subject summary is to present some concepts in a simplified form as a prelude to the more detailed description that is presented later. In one exemplary aspect, a method for performing reconstruction using a residue number system is disclosed. A set of moduli is selected. A reconstruction coefficient is estimated based on the selected set of moduli. A reconstruction operation is performed using the reconstruction coefficient. In another exemplary aspect, an apparatus for performing reconstruction using a residue number system includes means for selecting a set of moduli, means for estimating a reconstruction coefficient based on the selected set of moduli and means for performing a reconstruction operation using the reconstruction coefficient. In yet another exemplary aspect, a computer program product comprising a non-volatile, computer-readable medium, storing computer-executable instructions for performing reconstruction using a residue number system, the instructions comprising code for selecting a set of moduli, estimating a reconstruction coefficient based on the selected set of moduli and performing a reconstruction operation using the reconstruction coefficient is disclosed. In yet another exemplary aspect, a method for performing division using a residue number system comprises selecting a set of moduli, determining a reconstruction coefficient and determining a quotient using an exhaustive pre-computation and a look-up strategy that covers all possible inputs. In yet another exemplary aspect, a method of computing a modular exponentiation in a residue number system includes iterating, without converting to a regular integer representation, by performing modular multiplications and modular squaring and computing the modular exponentiation as a result of the iterations.

§3 BRIEF DESCRIPTION OF DRAWINGS

FIG. 1: shows summation of fraction estimates (obtained via look-up-tables) to estimate the Reconstruction Coefficient.

FIG. 2: is a flow chart for the Reduced Precision Partial Reconstruction (“RPPR”) algorithm.

FIG. 3: is a schematic block diagram of a generic architecture to implement the RPPR algorithm.

FIG. 4: illustrates conventional method of incorporating negative integers in the RNS.

FIG. 5: illustrates sign and Overflow Detection by Interval Separation (SODIS).

FIG. 6: Flow chart for the Quotient First Scaling (QFS) algorithm.

FIG. 7: is a schematic timing diagram for the QFS algorithm.

FIG. 8: is a flow chart for the modular exponentiation algorithm

FIG. 9: is a flow chart representation of a process of performing reconstruction using a residue number system.

FIG. 10: is a block diagram representation of a portion of an apparatus for performing reconstruction using a residue number system.

FIG. 11: is a flow chart representation of a process of performing division using a residue number system.

FIG. 12: is a block diagram representation of a portion of an apparatus for performing division using a residue number system.

FIG. 13: is a flow chart representation of a process of computing a modular exponentiation using a residue number system.

FIG. 14: is a block diagram representation of a portion of an apparatus for computing a modular exponentiation using a residue number system.

§4 DETAILED DESCRIPTIONS

In this section, first, I explain my moduli-selection method. After that, each new algorithm illustrated in detail. Since the “RPPR” algorithm is used in all others, it has been explained in more detail than other algorithms.

Notations Used in this Document

Notations-1 Math Functions, Symbols

The symbol ≡ means “equivalent-to”; whereas the symbol means “is defined as”

LHSLeft Hand Side of a relation; RHSthe right-hand-side

a mod bthe remainder when integer a is divided by integer b.

ulp≡wight or value a unit or a “1” in the least-significant-place

gcdgreatest common divisor (also known as highest common factor or hcf)

lg≡log-to-base 2, ln≡log-to-base-c, log≡log-to-base-10

floor function: └x┘=the largest integer x≡Round to the nearest integer toward−∞

ceiling function: ┌x┐=the smallest integer x≡Round to the nearest integer toward+∞

truncation: trunc(x)=only the integer-part of x≡Round toward 0

O( )≡Order-of or the big-O function as defined in the algorithms literature (for example see [2]). |•|≡cardinality if argument is a set; ≡absolute value of integer argument.

“RR” is abbreviation for “Residue Representation”, “RD” is abbreviation for “Residue Domain”, “integer-domain” refers to the set of all integers .

denotes the “equality-check” operation.

Notations-2 Algorithm Pseudo-Code

The pseudo-code syntax closely resembles MAPLE [3] syntax.

Lines beginning with # as well as everything between /* and */ are comments.

All entities/variables with a bar on top are vectors/ordered-touples (ex, Z≡[z₁, . . . , z_K])

Operations that can be implemented in parallel in all channels are shown inside a square/rectangular box. for example Z= XY[z_r=(x_r ‡ y_r) mod)], r=1, . . . , K

Brief Introduction to RNS and Canonical Definitions

Definition 1: We define “Reconstruction-Remainders” to be the component-wise values p₁, p₂, . . . , p_K defined by relations (B-6) above.

Note that Equation (B-4) can be re-written as Z_T=Z+Q·M (B-8.1) or equivalently as Z=Z_T−Q·M where, (B-8.2)

$Q=\lfloor \frac{Z_T}{}\rfloor =\mathrm{Quotient}$

when Z_T is divided by _C 0_C K−1 (B-9)

Definition 2: We define the coefficient of (which is denoted by the variable Q) in Equations (B-8*) to be the “Reconstruction-Coefficient” and henceforth denote it by the dedicated symbol “_C”

Definition 3: Full reconstruction of the integer corresponding to a residue-touple refers to the process of retrieving the entire unique digit-string representing that integer in a non-redundant, weighted-positional format (such as two's complement or decimal or the mixed-radix format).

D-4: Full-precision≡d_T base-b digits; where d_T=┌log_b(K)┐≈┌log_b┐n_b; since >>K (B-10)

If the base b=2 then n_b=n₂ is the bit-length required to represent the total modulus or the overall range of RNS; and is therefore also denoted simply by the variable n without any subscript.

Definition 5: Any method/algorithm that simply determines the value of _C without attempting to fully reconstruct Z is referred-to as a “Partial-Reconstruction” (PR).

Evaluating _C yields an exact equality (Eqn. (B-8.2)) for the target integer Z, without any “mod” i.e., remaindering operations in it (unlike the statement of CRT, Eqn. (B-4)). For most operations (especially division with a constant) such an exact equality for Z suffices, i.e., there is no need to fully reconstruct Z. This is why Partial-Reconstruction (i.e., evaluating _C) is an important enabling step underlying most other operations

§4.1 Moduli Selection

Note that a modulus of value m_r needs a table with (m_r−1) entries to cover all possible values of the reconstruction-remainder p_r w.r.t. m_r, (excluding the value 0). Therefore, the total number of memory locations required by all moduli is

$\begin{array}{cc}\#\mathrm{memory}\mathrm{locations}\mathrm{required}=\sum _{r=1}^K\left(m_r-1\right)\approx \sum _{r=1}^Km_r{}_{}& \left(5\right)\end{array}$

Thus, in order to minimize the memory needed, each component modulus should be as small as it can be.

Therefore, in order to cover a range [0, R] we select smallest consecutive K prime numbers starting with either 2 or 3, such that their product exceeds R: ={m1, m2, . . . , m_K}={2, 3, . . . , K-th prime number}, where

$\begin{array}{cc}\prod _{t=1}^Km_t=>R& \left(6\right)\end{array}$

This selection leads to the following two analytically tractable approximations:

The notation defines m_K to be the K-th prime number. In other words, K is the index of prime number whose value is m_K. Consequently, K and m_K can be related to each other via the well-known “prime-counting” function [36] defined as

$\begin{array}{cc}\pi \left(x\right)=\left(\mathrm{The}\mathrm{number}\mathrm{of}\mathrm{prime}\mathrm{numbers}x\right)\approx \frac{x}{\ln x}\mathrm{and}\mathrm{therefore}& \left(7\right)\\ K=\pi \left(m_k\right)\approx \left(\frac{m_k}{\ln m_k}\right)& \left(8\right)\end{array}$

2 The overall modulus becomes the well known “primorial” function [37] which for any positive integer N is denoted as “N#” and defined as

$\begin{array}{cc}\begin{array}{c}N\#=1\mathrm{if}N=1\\ =\left(\mathrm{product}\mathrm{of}\mathrm{all}\mathrm{prime}\mathrm{numbers}N\right),\mathrm{otherwise}\end{array}& \left(9\right)\end{array}$

(Note that a the definition as well as the notation for the primorial is analogous to the well known “factorial” function (N!)). The primorial function satisfies well-known identities [37, 38]

2^N<(N#)<4^N=2^2N and   (10)

(N#)≈O(e^N) for large N   (11)

As a result, to be able to represent n bit numbers (i.e. the range [0,2ⁿ−1]), in the residue domain using all available prime numbers (starting with 2), the total modulus satisfies

≈exp (m_K)>2ⁿ and therefore   (12)

m _K≈(ln)=ln(2ⁿ)=n·ln2   (13)

Substituting this value of m_K in Eqn. (8), K, the number of moduli required to cover all “n”-bit long numbers can be approximated as :

$\begin{array}{cc}K=\pi \left(m_k\right)\approx \left(\frac{m_k}{\ln m_k}\right)\approx \frac{n\ln 2}{\ln \left(n\ln 2\right)}\approx O\left(\frac{n}{\ln n}\right)\approx O\left(\frac{\lg }{\left(\ln \left[\lg ℳ\right]\right)}\right)& \left(14\right)\end{array}$

These analytic expressions are extremely important because they imply:

A.1 K<m_K<< (which follows from relations (13) and (14) above.) Moreover, both   (15)

A.2 maximum-modulus m_K as well as the number of moduli K grow logarithmically w.r.t.   (16)

i.e., linearly w.r.t. the wordlength n (since n=┌lg┐).

§4.1.1 moduli selection enables exhaustive look-up strategy that covers all possible inputs

The attributes A.1 and A.2 make it possible to exhaustively deploy pre-computation and lookup because they guarantee that the total amount of memory required grows as a low degree polynomial of the wordlength n.

In other words, the main novelty in my method of moduli selection and its real significance is the fact that I leverage the selection to enable an exhaustive pre-computation and look-up strategy that covers all possible input cases. This exhaustive pre-computation and look-up in turn makes my algorithms extremely simple, efficient and therefore ultrafast because I deploy the maximum amount of pre-computation possible, and perform as much of the task ahead of time as possible; so that there is not much left to be done dynamically at run-time (a perfect example of this is the new “Quotient First Scaling” algorithm for RNS division by a constant divisor that is explained in detail in Section §4.5 below).

In other words, the “minimization” of the total number of look-up table entries is the best possible scenario, but it is not necessary to obtain the major benefits that are illustrated for the first time in this invention. There is a lot more flexibility in selecting the moduli as long as they do not make it infeasible to deploy the exhaustive precomputation strategy.

Consider a concrete example: Suppose the claims section says “select moduli so as to minimize the total amount of look-up table memory required.”

If the desired range is all 32-bit numbers, then the set of moduli ={2,3,5,7, 11,13, 17,19, 23,29} minimizes the total number of look-up table entries required.

Now, one can replace any component modulus from the above set (for example, say the modulus 29) with another prime number (such as 31, 37 or even 101). The resulting moduli set does not minimize the total number of look-up table entries required, but it is sufficiently close and would not make much of a difference in the ability to deploy the exhaustive precomputation strategy. In the strict sense, however, the modified moduli set does not satisfy the “minimization” criteria and this fact might be used to wiggle around having to acknowledge the use of intellectual property claimed by this patent.

We would therefore like to clarify that the spirit of this part of the invention (i.e., the moduli selection method) can be better captured by the following description:

Select the set moduli so as to simultaneously bound both

(i) m_k=the maximum value in the set of moduli by a low degree polynomial in n, as well as

(ii) K=the total number of moduli in the set = (also known as the number of RNS channels) by another low degree polynomial in the wordlength n.

(both polynomials could be identical which is a special case). Following usual practices, we consider any polynomial of degree 16 to be a low-degree polynomial.

In closing we would like to point out some additional benefits of our moduli selection:

• • +1: This selection is general, in the sense that for any value of R multiple moduli sets always exist.
  • +2: The moduli are relatively easy to find, since prime numbers are sufficiently densely abundant irrespective of the value of R.
  • +3: It fully leverages the parallelism inherent in the RNS
  • +4: limiting m_K and K to small values makes it more likely that the entire RNS fits in a single h/w module.

§4.2 The Reduced Precision Partial Reconstruction (“RPPR”) Algorithm

This is a fundamental algorithm that underlies all other algorithms to follow. To speed-up the Partial-Reconstruction, we combine the information contained in both integer as well as fractional domains. We express the CRT in the form:

$\begin{array}{cc}\frac{Z_T}{}=R_C+\frac{Z}{ℳ}=\left(\sum _{r=1}^K\frac{{\rho }_r}{m_r}\right)\stackrel{\Delta }{=}S\mathrm{where},f_r=\frac{{\rho }_r}{m_r}\Rightarrow & \left(17\right)\\ C_{}=\lfloor S\rfloor =\mathrm{the}\mathrm{integer}\mathrm{part}\mathrm{of}\mathrm{the}\mathrm{sum}\mathrm{of}\mathrm{fractions},\mathrm{and}& \left(18\right)\\ \frac{Z}{ℳ}=\left(S-\lfloor S\rfloor \right)=\mathrm{the}\mathrm{fractional}\mathrm{part}\mathrm{of}\mathrm{the}\mathrm{sum}\mathrm{of}\mathrm{fractions}& \left(19\right)\end{array}$

Relation (18) states that _C can be approximately estimated as the integer part of a sum of at most K proper fractions f_r, r=1, . . . , K. (proper fractions because the numerator p_r is a remainder w.r.t. m_r; and therefore it is strictly less than m_r).

To speed up such an estimation of the _C, we leverage pre-computation and look-up: for each modulus m_r, we pre-calculate the value of each of the (m_r−1) fractions, i.e., all possible fractions that can occur, and store them in the look-up table (denoted by m_r)

$\begin{array}{cc}{}_{m_r}=\left[\frac{1}{m_r},\frac{2}{m_r},\dots ,\frac{{ℳ}_r-2}{m_r},\frac{m_r-1}{m_r}\right]\Rightarrow \mathrm{the}i\text{-}\mathrm{th}\mathrm{entry}\mathrm{in}\mathrm{the}\mathrm{table}={}_{m_r}\left[i\right]=f_{i,r}=\frac{i}{m_r}& \left(20\right)\end{array}$

(if p_r=0 then the table entry is 0 which need not be explicitly stored).

The important point is that The look-up table for each modulus m_r can be accessed independent of (and therefore in parallel with) the look-up table for any other modulus m_s where r≠s.

The fractional values (obtained from the tables) are then added up as illustrated in FIG. 1

§4.2.1 Derivation of the Algorithm and Novel Aspects Therein

{circle around (1)} First, note that we need to estimate the integer part of a sum of fractions, i.e., we need to be able to accurately evaluate the most-significant digits/portion of the sum as illustrated in FIG. 1. The important point is that whenever a computation needs to generate the “most-significant” bits/digits of the target, approximation methods can be used. For instance, in a division, “Quotient” is a lot easier to approximate than the “Remainder”.

In other words, using the rational-domain interpretation allows us to focus on values that represent the “most-significant” bits/digits of the target and therefore approximation methods can be invoked.

{circle around (2)} The implication is that the precision of the individual fractional values that get added need not be very high. All that is required is that the fractions

$f_{i,r}=\frac{i}{m_r}$

be calculated to enough precision so that when they are all added together, the error is small enough so as not to reach up-to and affect the least significant digit of the integer part (to the extent possible).

Let the radix/base of the number representation be b and let w_f be the number of fractional (radix-b) digits required. Then, for each fraction f_i we generate an upper and lower bound as follows:

$\begin{array}{cc}\mathrm{For}{\rho }_i\ne 0,\mathrm{let}\frac{{\rho }_i}{m_i}=f_i\mathrm{the}\mathrm{exact}\mathrm{value}\mathrm{of}\mathrm{the}\mathrm{reconstruction}\text{-}\mathrm{fraction}\mathrm{in}\mathrm{channel}i& \left(21\right)\end{array}$

f _i=0.d₁d₂ . . . d_wf|d_wf+1d_wf+2   (22)

Truncation of f_i to w_f digits yields an under-estimate: {circumflex over (f)}_i—low=0.d₁d₂ . . . d_wff_i   (23)

and 0(f_i−{circumflex over (f)}_i—low)=0.0 . . . 0d_wf+1d_wf+2 . . . <1/b^wf   (24)

However, a ceiling or rounding-toward-∞ to retain w_f fractional digits adds a ulp to the least significant digit (lsd), yielding an over-estimate: (25)

$\begin{array}{cc}\begin{array}{c}{\hat{f}}_{\mathrm{i\_high}}=0·d_1d_2\dots \left[\left(d_{w_f}\right)+1\right]\\ ={\hat{f}}_{\mathrm{i\_low}}+\mathrm{ulp}f_i\mathrm{where}\mathrm{ulp}=\frac{1}{b^{w_f}}\end{array}& \left(26\right)\\ \mathrm{and}0\left({\hat{f}}_{\mathrm{i\_high}}-f_i\right)<1/b^{w_f}& \left(27\right)\\ \mathrm{combining}\left(23\right)\mathrm{and}\left(26\right)\mathrm{we}\mathrm{get}{\hat{f}}_{\mathrm{i\_low}}f_i{\hat{f}}_{\mathrm{i\_high}}=\left({\hat{f}}_{\mathrm{i\_low}}+\mathrm{ulp}\right)& \left(28\right)\\ \left({\hat{f}}_{\mathrm{l\_low}}+\dots +{\hat{f}}_{\mathrm{K\_low}}\right)\left(f_1+\dots +f_K\right)=C_{}+\frac{Z}{}\left({\hat{f}}_{\mathrm{l\_low}}+\dots +{\hat{f}}_{\mathrm{K\_low}}\right)+n_z·\mathrm{ulp}& \left(29\right)\\ \mathrm{where},n_z=\mathrm{number\_of}\mathrm{\_nonzero}\mathrm{\_residues}\mathrm{\_in}\mathrm{\_the}\mathrm{\_touple}& \left(30\right)\end{array}$

The understand the upper limit in relation (29) above, note that each non-zero p_i makes the corresponding over-estimate higher than the under-estimate by a ulp, as per Eqns (21), (23) and (26).

Let {circumflex over (S)}_low({circumflex over (f)}_l—low+ . . . +{circumflex over (f)}_K—low) and {circumflex over (I)}_low└{circumflex over (S)}_low┘=integer part of {circumflex over (S)}_low   (31)

{circumflex over (S)}_high{circumflex over (S)}_low+n_z·ulp and {circumflex over (I)}_high└{circumflex over (S)}_high┘=integer part of {circumflex over (S)}_high   (32)

Taking the “floor” of each expression in the inequalities in relations (29) above; substituting the floors from Eqns (31) and (32); and using the identity

$\begin{array}{cc}\lfloor C_{}+\frac{Z}{}\rfloor ={}_C\mathrm{we}\mathrm{obtain}& \left(33\right)\\ {\hat{I}}_{\mathrm{low}}{}_C{\hat{I}}_{\mathrm{high}}\mathrm{so}\mathrm{that}& \left(34\right)\\ \mathrm{if}{\hat{I}}_{\mathrm{low}}={\hat{I}}_{\mathrm{high}}\mathrm{then}\mathrm{the}\mathrm{estimate}{}_C=I_{\mathrm{high}}=I_{\mathrm{low}}\mathrm{must}\mathrm{be}\mathrm{exact}& \left(35\right)\end{array}$

since both upper and lower bounds converge to the same value. In practice (numerical simulations), this case is encountered in an overwhelmingly large fraction of numerical examples. Moreover,

$\begin{array}{cc}\mathrm{Since}n_zK\Rightarrow n_z·\mathrm{ulp}K·\mathrm{ulp}& \left(36\right)\\ \mathrm{by}\mathrm{selecting}w_f\mathrm{so}\mathrm{as}\mathrm{to}\mathrm{ensure}K·\mathrm{ulp}=K/b^{w_f}<1\mathrm{from}\left(29\right)\mathrm{we}\mathrm{get}& \left(37\right)\\ {\hat{S}}_{\mathrm{low}}C_{}+\frac{Z}{M}{\hat{S}}_{\mathrm{low}}+1\mathrm{taking}\mathrm{the}\mathrm{floor}\mathrm{of}\mathrm{each}\mathrm{expression}\mathrm{in}\mathrm{the}\mathrm{relation}\mathrm{above}\mathrm{yields}& \left(38\right)\\ {\hat{I}}_{\mathrm{low}}{}_C{\hat{I}}_{\mathrm{low}}+1& \left(39\right)\end{array}$

In other words, even in the uncommon/worst cases, wherein, Î_low≠Î_high, relation (39) demonstrates that the estimate of _C can be quickly narrowed down to a pair of consecutive integers.

{circle around (3)} It is intuitively clear that further “disambiguation” between these choices needs at least one bit of extra information. This information is obtained from the value (Z mod m_e) where m_e is the extra modulus. For efficiency, m_e should be as small as possible. Accordingly, our method leads to only two scenarios:

[a] if is odd then m_e=2 is sufficient for disambiguation

[b] otherwise if 2 is included in the set of moduli , then m_e=4 is sufficient for disambiguation

m_e ∈ {2,4} (this is analytically proved in [39])   (40)

Note that when includes “2” as a modulus, it already contains the value (z₁=Z mod 2), i.e., the least significant bit of the binary representation of Z. The value (Z mod 4) therefore conveys only one extra bit of information beyond what the residue touple conveys.

{circle around (4)} It is reasonable to assume that for primary/external inputs the extra-info is available. The exhaustive pre-computations can also assume that the extra-info is available. Starting with these, we generate the extra-bit of information (either explicitly or implicitly) for every intermediate value we calculate/encounter. This is done in a separate dedicated channel. Let

W=*(X) where * is a unary operation. Then,   (41)

W mod m_e=[*(X mod m_e)] mod m_e for * ∈ {left-shift, power}  (42)

If the operation is a right shift, then finding the remainder of the shifted value w.r.t. m_e, is slightly more involved but it can be evaluated using a method identical to “Quotient_First_Scaling”, i.e., “Divide_by_Constant', which explained in detail in Section §4.5 below.

Likewise, let

Z=X Y where is a binary operation. Then,   (43)

Z mod m_e=[(X mod m_e)(Y mod m_e)] mod m_e for ∈ {±, ×}  (44)

Finally, since division is fundamentally a sequence of shift and add/subtract operations, as long as we keep track of the remainder of every intermediate value w.r.t. m_e, we can also derive the values of (Quotient mod m_e) and (Remainder mod m_e). Thus all the basic arithmetic operations are covered.

§4.2.2 Analytical Results

Result 1 Pre-conditions: Let the radix of the original (non-redundant, weighted and positional, i.e., usual) number representation be denoted by the symbol “b” (note that b=10 yields the decimal representation, b=2 gives the binary representation). Suppose integer Z=[z₁, z₂, . . . , z_K] is being partially re-constructed and the extra-bit-of-information, i.e., the value of (Z mod m_e) is also available. Let

$\begin{array}{cc}\frac{Z_T}{}\approx \hat{S}=\hat{I}+\hat{F}=\sum _{r=1}^K{\hat{f}}_r\mathrm{where},& \left(45\right)\\ \hat{I}=\lfloor \hat{S}\rfloor =\mathrm{the}\mathrm{integer}\mathrm{part}\mathrm{of}\mathrm{the}\mathrm{approximate}\mathrm{sum}\hat{S},\mathrm{and}& \left(46\right)\\ \hat{F}=\hat{S}-\hat{I}=\mathrm{the}\mathrm{fractional}\mathrm{part}\mathrm{of}\mathrm{the}\mathrm{sum},\mathrm{and}& \left(47\right)\\ \begin{array}{c}{\hat{f}}_i={\hat{f}}_{\mathrm{i\_low}}\\ =\mathrm{Trunc}\left[w_F\right]\left(f_i\right)\\ =\mathrm{truncation}\mathrm{of}f_i\mathrm{to}w_F\mathrm{digits}\mathrm{where}\end{array}& \left(48\right)\\ f_i=\frac{{\rho }_i}{m_i}\Rightarrow 0f_i<1& \left(49\right)\end{array}$

and p_i values are the reconstruction-remainders defined in Equation (B-6)

$\begin{array}{cc}\mathrm{Let}\delta =\left(\frac{Z_T}{}-\hat{S}\right)\mathrm{be}\mathrm{the}\mathrm{total}\mathrm{error}\mathrm{in}\mathrm{the}\mathrm{approximate}\mathrm{estimate}\hat{S}& \left(50\right)\\ \mathrm{and}\mathrm{let}\mathrm{the}\mathrm{Reconstruction}\text{-}\mathrm{Coefficient}{}_C\mathrm{be}\mathrm{estimated}\mathrm{as}C_{}\approx \hat{I}\mathrm{then},& \left(51\right)\end{array}$

Result 1: In order to narrow the estimate of the Reconstruction Coefficient _C down to two successive integers, viz., Î or (Î+1), it is sufficient to carry out the summation of the fractions (whose values can obtained from the look-up-tables) in a fixed-point format with no more than a total of w_T radix-b digits, wherein

w _T =w _I =w _F where   (52)

w_I=Number of digits allocated to the Integer part, and   (53)

w_F=Number of digits allocated to hold the fractional part   (54)

where the precisions (i.e., the digit lengths) of the integer and fractional parts satisfy the conditions:

R1.1 w_I=┌log_b K┐  (55)

R1.2 w_F=┌log_b (K·Δ_uuzf)┐ where, K=number of moduli=, and   (56)

Δ_uuzf≡“Unicity Uncertainty Zone Factor”, that satisfies Δ_uuzf2   (57)

R1.3 The Rounding mode adopted in the look-up-tables (when limiting the pre-computed values of the fractions to the target-precision) as well as during the summation of fractions as per equation (51) must be TRUNCATION, i.e., discard excess bits.

For the proof of the above result as well as all other analytical results stated below, please refer to [39].

Result 2: In order to disambiguate between the two possible values of the Reconstruction Coefficient i.e., select the correct value (Î) or (Î+1), a small amount of extra information is sufficient.

R2.1 In particular, (prior) knowledge of the remainder of Z (the integer being partially reconstructed), w.r.t. one extra component modulus m_e that satisfies

gcd(, m_e)<m_e is sufficient for the disambiguation.   (58)

R2.2 For computational efficiency, the minimum value of m_e that satisfies (58) should be selected.

Such a selection gives rise to the following two canonical cases:

• • {circle around (1)} is odd: In this case, m_e=2 is sufficient for disambiguation.
  • {circle around (2)} contains the factor 2: then, m_e=4 is sufficient for disambiguation.

§4.2.3 RPPR Algorithm: Illustrative Examples

The pre-computations and Look-up-tables needed for the partial reconstruction are illustrated next.

§4.2.3.A First an Example with Small Values, to Bootstrap the Concepts

Let the set of moduli be ={3,5,7,11}, so that, K=4, =1155, and let m_e=2

TABLE 1
Look-up table for the RPPR algorithm for the RNS-ARDSP system with
= {3, 5, 7, 11}. This table uses the value of ρr as the address to look-up
the fraction $\left(\frac{\mathrm{\rho r}}{m_r}\right)$  explicit value of ρr is needed. In this case
K = 4 and Δuuzf = 2 and therefore wI = ┌log10(4 − 1)┐ = 1 integer
decimal-digit and wF = ┌log10(4 × 2)┐ = 1 fractional decimal-digit.
Accordingly, all the entries in the table have a single fractional digit.
In this toy example we have deliberately left the table entries in the
fixed-point fractional form for the sake of clarity (rather than
scaling them by the factor 101 and listing them as integers).
modulus	$\mathrm{table}\mathrm{entries}\mathrm{for}\mathrm{row}m_r:\mathrm{column}i\leftarrow \frac{i}{m_r}$
↓ mr	1	2	3	4	5	6	7	8	9	10
3 →	0.3	0.6
5 →	0.2	0.4	0.6	0.8
7 →	0.1	0.2	0.4	0.5	0.7	0.8
11 →	0.0	0.1	0.2	0.3	0.4	0.5	0.6	0.7	0.8	0.9

Then, the look-up table for the RPPR algorithm is shown in Table 1.

The table consists of 4 subtables (one per-channel/modulus) that are independently accessible in parallel.

For each value of m_r, the table consists of a row that simply stores the approximate pre-computed values of the fractions

$\frac{1}{m_r},\frac{2}{m_r},\dots ,\frac{m_r-1}{m_r}.$

§4.2.3.B Further Optimization: Skip the Computation of p_r Values

Note that instead of explicitly calculating p_r and then using it as an index into a table, the residue z_r could be directly used as an index into a table that stores the appropriate values of the precomputed fractions.

$\begin{array}{cc}\frac{{\rho }_r}{m_r}=\left(\frac{\left(\left(w_i\times z_r\right)\mathrm{mod}m_r\right)}{m_r}\right)& \left(59\right)\end{array}$

The resulting table is illustrated in Table 2.

In this toy example the number fractional digits required for intermediate computations is 1 which is not a sizable reduction from the full precision which is 3 digits.

The the following non-trivial long-wordlength example demonstrates the truly drastic reduction in precision that is afforded by our novel algorithm.

TABLE 2
Residue Addressed Look-up Table (RAT) for the RPPR algorithm for the
RNS-ARDSP system with  = {3, 5, 7, 11}. This table is a further optimized
version of Table 1 above: here, the residue value zr is directly used as
the address of a location that stores the corresponding value of
$\left(\frac{\left(\left(w_i\times z_r\right)\mathrm{mod}m_r\right)}{m_r}\right)$ in the rth row (i.e., sub-table) for component-
modulus mr. Calculation of ρr is not required when this table is used.
modulus	$\mathrm{table}\mathrm{entries}\mathrm{for}\mathrm{row}m_r:\mathrm{column}i\leftarrow \frac{(\left(i\times w_i\right)\mathrm{mod}m_r}{m_r}$
↓ mr	1	2	3	4	5	6	7	8	9	10
3 →	0.3	0.6
5 →	0.2	0.4	0.6	0.8
7 →	0.2	0.5	0.8	0.1	0.4	0.7
11 →	0.1	0.3	0.5	0.7	0.9	0.0	0.2	0.4	0.6	0.8

Note that the only difference between this table and Table 1 is a permutation of the entries in sub-tables for those moduli m_i for which the “inner-weights” are larger than unity (in this case w_i>1 for the last two rows corresponding to moduli 7 and 11).

§4.2.3.C A Nontrivial Long Word-Length Example

Now consider the partial reconstruction of numbers with a word-length=256 bits. Here the range is R=2²⁵⁶.

In this case, first 44 prime-numbers are required to cover the entire range. Therefore K=44 and ={2, 3, 5, 7, 11, . . . , 181, 191, 193}, m_e=4, and the product of all the component-moduli is =198962376391690981640415251545285153602734402721821058212203976095413910572270 and the ratio

$\left(\frac{ℳ}{2^{256}}\right)\approx 1.718$

m_k=m₄₄=44 th prime number=193

The word-length required to represent is

n=┌log ₁₀ ()┐=┌77.298┐=78 decimal digits and the word length required for Z_T is   (60)

d _T=┌log₁₀(×44)┐)=┌78.9┐=79 digits   (61)

Hence, any conventional full re-construction method to evaluate _C requires at least a few operations on 79 digit-long integers.

In contrast, our new partial-reconstruction method requires a drastically smaller precision as well as a drastically small number of simple operations (only additions) to accurately evaluate the reconstruction coefficient _C. As per Result R1.2 above, the number of fractional digits required in the look-up-tables as well as in intermediate computations is only

w _F=┌log₁₀(44×2)┐=2 decimal fractional digits.   (62)

When addition of such fractions is considered, the integer part that can accrue requires no more than 2 additional digits (since we are adding at most K=44 values, and each is a proper fraction their sum must be less than 44 and therefore requires no more than 2 decimal digits to store the integer-part).

Therefore, the total number of digits required in all intermediate calculations is as small as 4, which is a drastic reduction from 79. (In general the reduction in precision is from O(lg) required by conventional methods versus the much smaller amount O(lglg) required by our method).

Another extremely important point: by appropriate scaling, all the fixed point fractional values in the table can be converted into integers. Correspondingly, all the fixed-point computations (additions and subtractions of these fractions) are also scaled and can therefore be realized as integer-only operations.

The obvious scaling factor is 10^wF. The resulting look-up-table that contains the scaled integers as its entries is illustrated in Table 3.

TABLE 3
The Redsidue Addressed Table RAT for the RPPR algorithm
for the RNS-ARDSP system with first 44 prime numbers
as moduli, i.e.,  = {2, 3, 5, 7, 11, . . . , 191, 193}. The fixed point
truncated values of the fractions are scaled by a factor of Cs = 102.
component modulus	$\mathrm{Table}\mathrm{entries}\mathrm{for}\mathrm{row}m_r:\mathrm{column}i\leftarrow \lfloor \frac{\left[\left(\left(i\times w_r\right)\mathrm{mod}m_r\right)\times C_s\right]}{m_r}\rfloor$
↓ mr	1	2		. . .			189	190	191	192
2 →	50
3 →	66	33
			. . .
.				.
.				.
.				.
					. . .
191 →	71	42		. . .			57	28
193 →	77	55				. . .			44	22

Note that un-scaling requires a division. But since the scaling factor is a power of the radix of the underlying number representation, un-scaling can be achieved simply by left-shift and truncation of integers. Thus, with the scaling, floating point computations are entirely avoided.

Next we formally specify the algorithm and simultaneously illustrate it for two examples:

1. Example 1: find _C for value X=641 in the small wordlength case. inputs: X=[3, 4, 1, 2] (note that the fully reconstructed value for this touple viz., “641” is not known to the algorithm. It is only given the touple) and the extra-info value (X mod m_e=1));

2. Example 2: find _C for the value “X=1” in the long=wordlength case. (inputs: X=[1, 1, . . . , 1, 1] and (X mod m_e=1));

Right below every step of the algorithm, the computations actually performed for each of the two examples are also illustrated inside “comment-blocks”

§4.2.4 Specification of the Algorithm via Maple-Style Pseudo-Code

Algorithm Reduced_Precision_Partial_Reconstruction( Z, ze)
# Inputs: residue-touple Z = [z1, z2, . . . , zj], extra-info ze = (Z mod me), me ε {2, 4}
# Output: Exact value of the Reconstruction Coefficient  c
# Pre-computation : moduli, , me, all constants (ex,  j,wj = ((1/ j) mod mj) mod mj, . . . ))
# create (Reconstruction_Table(s) ) ;
# Step 1: using zr as the indexes, look up ultra low precision estimates {circumflex over (f)}r, r = 1 . . . K
#   Note that this can be done in parallel in all channels
nz := 0;
for i from 1 to K do  # for each channel i
if zr = 0 then
{circumflex over (f)}r := 0;
nzr := 1;
else
{circumflex over (f)} r := zrth element in the look-up-table for mr;
nzr := 0;
f i;    # same as “end if”
od;   # same as “end for”
# Example 1: K = 4 values read from Table 1 above (and scaled by the factor Cs = 10) = [5, 1, 2, 6]
# Example 2: K = 44 pre-scaled values read from Table 2 above = [50, 61, . . . , 71, 77]
# Step 2: Sum all the {circumflex over (f)}r values with a total of only wT digits of precision to obtain the bounds
${\hat{S}}_{\mathrm{low}}:=\sum _{r=1}^K{\hat{f}}_r;$	$n_z:=\sum _{r=1}^Kn_{z_r};\mathrm{and}$	Ŝhigh := Ŝlow + nz;
# Example 1: Ŝlow = 5 + 1 + 2 + 6 = 14 and Ŝhigh = 14 + 4 = 18
# Example 2: Ŝlow = (50 + 61 + . . . + 71 + 77) = 2581 and Ŝhigh = 2581 + 44 = 2625
# Step 3: unscale and take the floor of the bounds to obtain integer bounds on  C
# note that these can be realized as a right-shift followed by truncation
${\hat{I}}_{\mathrm{low}}:=\lfloor \frac{{\hat{S}}_{\mathrm{low}}}{C_s}\rfloor \mathrm{and}$	${\hat{I}}_{\mathrm{high}}:=\lfloor \frac{{\hat{S}}_{\mathrm{high}}}{C_s}\rfloor$
$\#\mathrm{Example}1\text{:}{\hat{I}}_{\mathrm{low}}=\lfloor \frac{14}{10}\rfloor =1\mathrm{and}$	${\hat{I}}_{\mathrm{high}}=\lfloor \frac{18}{10}\rfloor =1$
$\#\mathrm{Example}2\text{:}{\hat{I}}_{\mathrm{low}}=\lfloor \frac{2589}{100}\rfloor =25\mathrm{and}$	${\hat{I}}_{\mathrm{high}}=\lfloor \frac{2625}{100}\rfloor =26$
# Step 4: check if upper & lower integer bounds have same value. if yes, return it as the correct answer
if (Îlow == Îhigh) then
Return (Îlow);
fi;
# Example 1: both upper and lower bounds converge to the same value 1  correct value of  C = 1, and is returned
# Example 2: Bounds do not converge to the same value    need to disambiguate between {25, 26} using extra info
# Step 5: disambiguate using extra-info
if (ZT mod me = {(Îlow · ) mod me + Z mod me} mod me) then
Ans := Îlow;
else
Ans := Îhigh;
end if ;
# Example 2: it can be verified that: (ZT mod 4) = 1 ≠ ((25 × 2) + 1) mod 4 = 3 mod 4 but
# (ZT mod 4)   ((26 × 2) + 1) mod 4 = 1 mod 4
Return (Ans) ;   # Output = correct value of  C
End_Algorithm

The correctness of the algorithm can be proved by invoking Results 1, 2 and other equations and identities presented in this document. In addition, the algorithm has been implemented in Maple (software) and exhaustively verified for small wordlengths (upto 16 bits). A large number of random cases (>10⁵) for long wordlengths (up to 2²⁰≈million-bits) were also run and verified to yield the correct result.

§4.2.5 RPPR Architecture

FIG. 3 illustrates the block diagram of an architecture to implement the RPPR algorithm. The main goal of the architecture is to fully leverage the parallelism inherent in the RNS. There are K channels, each capable of performing all basic arithmetic operations, viz., {±, ×, division, shifts, powers, equality-check, comparison, . . . } modulo m_r which is the component-modulus value for that particular channel.

In addition, each channel is also capable of accessing it's own look-up-table(s) (independent of other channels). Finally there is a dedicated channel corresponding to the extra modulus m_e=2 or m_e=4 that evaluates Z mod m_e for every non-primary integer Z (non-primary refers to a value that is not an external input or is not one of the precomputed values).

We would like to emphasize that the schematic diagram is independent of whether the actual blocks in it are realized is in hardware or software. The parallelism inherent in the RNS is independent of whether it is realized in h/w or s/w. This should be contrasted with some other speed-up techniques (such as rendering additions/subtractions constant-time by deploying redundant representations) that are applicable only in hardware [40].

§4.2.6 Delay Models and Assumptions

In order to arrive at concrete estimates of delay, we assume a fully dedicated h/w implementation. Each channel has its own integer ALU that can perform all operations modulo any specified modulus. Among all the channels, the K-th one that performs all operations modulo-m_K requires the maximum wordlength since m_K is the largest component-modulus.

The maximum channel wordlength is: n_K=lg m_K≈O(lg n)≈lgln≈lglg  (63)

Note that this is drastically smaller than the wordlength n_c required for conventional binary representation, which is roughly O(n), the number of bits required to represent .

In accordance with the literature, we make the following assumptions about delays of hardware modules

<A-1> A carry-look-ahead adder can add/subtract two operands within a delay that is logarithmic w.r.t. the wordlength(s) of the operands.

<A-2> Likewise, a fast hardware multiplier (which is essentially a fast multi-operand accumulation tree followed by a fast carry-lookahead-adder and therefore) also requires a delay that is logarithmic w.r.t. the wordlength of the operands.

More generally, a fast-multi-operand addition of K numbers each of which is n-bits long requires a delay of

O(lgK)+O(lg(n+lgK)) which becomes ≈O(lgn) in our case.   (64)

<A-3> Assuming that the address-decoder is implemented in the form of a “tree-decoder”, a look-up table with entries requires ≈O(lg) delay to access any of it's entries.

<A-4> We assume that dedicated shifter(s) is(are) available. A multi-stage-shifter (also known as a “bar-rel” shifter [1, 6[) implements shift(s) of arbitrary (i.e., variable) number of bit/digit positions, where the delay is ≈O(lg(maximum_shift_distance_in_digits)) units.

§4.2.7 Estimation of the Total Delay

The preceding assumptions, together with Equation (63) imply that the delay Δ_CH all operations within individual channels can be approximated to be

Δ_CH=lg m_K≈O(lglgn)≈lglglg  (65)

which very small.

The delay estimation is summarized in Table 4.

TABLE 4
ESTIMATION OF THE DELAY REQUIRED BY THE RPPR ALGORITHM
Algorithm Step no:	can individual	Approximate Delay
and operation(s)	channels work	as a function of
performed	in parallel?	wordlength n	Justification
1:	Compute or look-up ρr values	yes	O(lg lg n)	Equation (65)
2:	Using ρr as the index	yes	O(lg lg n)	Equation (65)
	look up estimates {circumflex over (f)}r
3:	Add all the estimates	No	O(lg K) ≈	Assumption <A-2>
			O(lg n)	and Equation (64)
4:	Un-scale the sum back	No	O(lg lg n)	realized via a shift and
	and truncate			truncation
5:	Check if upper and lower bounds	No	O(1)	obvious, equality check
	converge to the same value			on small values
6:	Disambiguation	No	O(lg lg n)	me ε {2,4}
				tiny operands
Overall delay ≡ Latency		O(lg n)	dominant “functional”
			component

As seen in the table, the dominant delay is in Step 3, the accumulation of values read from the per-channel look-up tables.

Therefore, the overall delay is ≈O(lgn) ≈O(lglg)

§4.2.8 Memory Required by the PR Algorithm

The r-th channel associated with modulus m_r has its own Look-up table with (m_r−1) entries (since the case where the remainder is “0” need not be stored). Hence, the number of storage locations needed is

$\begin{array}{cc}\sum _{r=1}^K\left(m_r-1\right)<K·m_K\approx O\left(K^2\right)\approx O\left(n^2\right)& \left(66\right)\end{array}$

Each location stores a fractional value that is no longer than w_F digits ≈O(lgn) bits. Therefore, total storage (in bits)=O(n²) (locations)×O(lgn) (bits per locations) ≈O(n²lgn) bits (67)

There are several important points to note:

1 Although the above estimate makes it look as-though it is a single chunk of memory, in reality it is not. Realize that each channel has its own memory that is independently accessible. The implications are:

2 The address-selector (aka the decoder) circuitry is substantially smaller and therefore faster (than if the memory were to be one single block).

3 It is a READ-ONLY memory, the precomputed values are to be loaded only once, they never need to be written again. In a dedicated VLSI implementation, it would therefore be possible to utilize highly optimized, smaller and faster cells.

§4.3 Base Change/Extension

Those familiar with the art will realize that once the “RPPR” algorithm yields an exact equality for the operand (being partially re-constructed), a base-extension or change is straightforward.

Without loss of generality, the algorithm is illustrated via an example which extends a randomly generated 32-bit long unsigned integer to a 64-bit integer (without changing the value), which requires an extension of the residue touple as shown below.

In order to cover the (single-precision) range ┌0, 2³²┐, the moduli set required is =₃₂={2,3,5,7,11,13,17,19,23,29} so that K=||=10, and total product =6469693230, the reconstruction weights are

${ℳ}_i=\frac{m_i}{},$

i=1, . . . , 10 =[3234846615, 2156564410, 1293938646, 924241890, 588153930, 497668710, 380570190, 340510170, 281291010, 223092870] and the inner weights are

$w_i=\left(\frac{1}{i_{}}\right)\mathrm{mod}m_i,$

i =1, . . . , 10 =[1,1,1,3,1,11,4,9,11,12]

In order to cover the double-precision range [0, 2⁶⁴], the extended moduli set required is _ext=₆₄={2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53} so that K_ext=_ext|=16, and total product _ext=32589158477190044730

Let the single precision operand be Z=1355576195≡ Z=[1,2,0,1,6,12,3,10,10,21] and z_e=Z mod 4=3. The CRT expresses the value Z in the form

Z=(3234846615×p₁+2156564410×p₂+ . . . +223092870×p₁₀)−6469693230 _Cz   (68)

where, p_i=(z_i×w_i) mod m_i is the reconstruction remainder for channel i, for i=1, . . . , 10 and _Cz=the reconstruction coefficient for Z

The only unknown in Eqn (68) is _Cz which can be determined using the “RPPR” algorithm yielding an exact integer equality, enabling a straightforward evaluation of the extra-residues needed to extend the residue touple. For example the first extra-modulus in the example at hand is m₁₁=31. Accordingly, Z_ext[11]=z₁₁=(Z mod 31)

Note that (3234846615 mod 31), . . . , (6469693230 mod 31) are all constants for a given RNS and can be pre-calculated and stored. In general we always assume that whichever values can be pre-computed are actually pre-computed. Thus

θ_{(i,j )}=_i mod m_ej for i=1, . . . , K and j=K+1, . . . , K_ext   (69)

are all pre-computed and stored, so that the operation of evaluating the remainder w.r.t. an extra modulus m_er in the extended RNS system (such as the modulus 31 in the running example at hand) simplifies to

Z mod m_er=(θ_(1,er)p₁+ƒ_(2,er)p₂+ . . . +θ_(K,er)p_K−Δ_erCz)mod m_er   (70)

where, Δ_er= mod m_er

Next, we specify the algorithm exactly in Maple-style pseudo-code.

§4.3.1 Specification of the Algorithm via Maple-Style Pseudo-Code

Algorithm Base_extension_using_RPPR_method( Z,ze)
/*  Inputs : residue-touple Z = [z1,z2,...,zK], extra-info ze =
(Z mod me), me = 4
corresponding to a 32 bit unsigned integer Z  */
# Output:  residue touple for the 64-bit extension of Z
/*  Pre-computation : original moduli-set 32 = {2,3,...,29},
|32| = K32 = 10
extended moduli-set  64 = {2,3,...,53}, |64| = K64 = 16
all constants (ex,  j,wj = ( (1/j) mod mj,...))
Reconstruction_Table(s) for both 32 and 64, etc.  */
# Step 1:  evaluate  Cz using the “RPPR” algorithm
C                              z                = Reduced_Precision_Partial_Reconstruction( Z,ze) ;
# Step 2:  evaluate the extra residues as per Eqns (68) and (70)
# This can be executed in parallel in all channels corresponding to the
extension moduli
for i from 1 to Ke do  # in each extension channel i
sum := 0;
for j from 1 to Ke do
sum := sum + ρj × θi,j ;
od;
zi := (sum − Δi Cz ) mod mi ;
Z:= concat( Z, zi) ;    # append the new residue to the
residue touple
od ;
Return ( Z)   □
End_Algorithm

§4.4 Sign and Overflow Detection by Interval Separation (SODIS)

The next canonical operation I have sped-up is sign-detection. The new algorithms for sign-detection in the RNS are illustrated in this section.

As illustrated in FIG. 4, fundamentally, the RNS representation does allow a separation of positive and negative integers into distinct non-overlapping regions (what is meant here is that the RNS mapping is not so strange as to “mix” positive and negative numbers throughout the entire range. It takes an “interval” (namely the interval including all negative integers) and faithfully (i.e., without changing the length of the interval) simply translates (or displaces) it into another another “interval” which is not surprising since the “mapping” corresponding to the translation is the simple first degree equation describing the “modulo” operation, i.e., Eqn. (3))

Q: Where then is the problem in sign detection?

A: (i) Note that a “re-construction” of the overall magnitude is necessary

• • (ii) For the efficiency of representation (i.e., in order not to waste capacity) the following additional constraint is also imposed in most RNS implementations.

F _max ⁻ =F _max ⁺+1   (71)

In other words, ALL the unsigned integers in the range [0,−1] are utilized, not a single digit value is wasted.

An unfortunate by-product of this quest for representational efficiency is that consecutive integers F_max⁺ and F_max⁻ end up having opposite signs. Consequently, re-construction must be able to distinguish between consecutive integers, i.e., the resolution of the re-construction must be full, i.e., in fractional computations

$\begin{array}{cc}\mathrm{ulp}<\frac{1}{}& \left(72\right)\end{array}$

This, in-turn requires that all fractional computations must be carried out to the full precision, thereby rendering them slow.

The main question therefore is whether it is possible to make do with the drastically reduced precision we wish to deploy? and if so, then how?

The answer is to insert a sufficiently large “separation-zone” between the positive and negative regions, as illustrated in FIG. 5.

In FIG. 5, note that

both “0” as well as _e correspond to the actual magnitude 0   (73)

unsigned integers {1, . . . , F_max⁺} represent +ve values and   (74)

unsigned integers {F_max⁻, . . . , (_e−1)} represent −ve values {−(_e−F_max⁻), . . . , −1}, repsectively, wherein   (75)

Unsigned Integer F_max⁺ represents the maximum positive magnitude allowed, and   (76)

Unsigned Integer F_max⁻ represents the max. −ve magnitude allowed=(_e−F_max⁻)   (77)

The interval between F_max⁺ and F_max⁻ is the separation zone   (78)

Most practical/useful number representations try to equalize the number of +ve values and the number of −ve values included in order to attain maximal amount of symmetry. This yields the constraint

F _max ⁻≈_e−F_max⁺  (79)

Intuitively, it is clear that equal lengths should be allocated to

(1) the +ve interval

(2) the −ve interval and

(3) the separation-zone between the opposite polarity intervals.

For this to be possible, the extended modulus _e must satisfy _e>3·F_max⁺  (80)

Finally, the attainment of maximal possible symmetry dictates that to the extent possible, the separation-zone must be symmetrically split across the mid-point of the range [0, (_e−1)]. Note that FIG. 5 incorporates all these symmetries.

With the separation interval in place, note that all +ve numbers Z⁺ within the range [1,F_max⁺] when represented as fractions of the total magnitude _e now satisfy

$\begin{array}{cc}0<\frac{Z+}{e_{}}<\frac{1}{3}& \left(81\right)\end{array}$

Likewise, all −ve numbers Z⁻ when represented as fractions of the total magnitude M_e satisfy

$\begin{array}{cc}\frac{2}{3}<\frac{Z^{-}}{e_{}}<1& \left(82\right)\end{array}$

But Eqn (19) (repeated here for the sake of convenience) states that

$\begin{array}{cc}\frac{Z}{}=\left(S-\lfloor S\rfloor \right)=\mathrm{the}\mathrm{fractional}\mathrm{part}\mathrm{of}\mathrm{the}\mathrm{sum}\mathrm{of}\mathrm{fractions}\approx \sum _{r=1}^K\widehat{f_r}& \left(83\right)\end{array}$

In other words, the separation interval enables the evaluation of the sign of the operand under consideration by examining one (or at most two) most significant digits of the accumulated sum of fractions.

Recall that in the partial reconstruction, the integer part of the sum-of-fractions was of crucial importance.

It is quite striking that when the interval separation is properly leveraged as illustrated herein, the most significant digit(s) of the fractional part also convey equally valuable information, viz., the sign of the operand.

As per Equations (81) and (82) the natural choice of the detection boundaries T⁺ and T⁻ is specified by the relations

$\begin{array}{cc}\frac{T^{+}}{e_{}}=\frac{1}{3}=0.333\dots \mathrm{and}& \left(84\right)\\ \frac{T^{-}}{e_{}}=\frac{2}{3}=0.666\dots & \left(85\right)\end{array}$

However, note that even if the “detection boundaries” T⁺(for +ve numbers) and T⁻(for −ve numbers) are moved slightly into the “separation zone”, as illustrated in FIG. 5, the sign-detection outcome does not change.

For the ease of computation, we therefore set

$\begin{array}{cc}\frac{T^{+}}{e_{}}=\frac{4}{10}=0.4\mathrm{and}& \left(86\right)\\ \frac{T^{-}}{e_{}}=\frac{6}{10}=0.6& \left(87\right)\end{array}$

§4.4.1 Specification of Sign-Detection Algorithm via Maple-Style Pseudo-Code

Algorithm Eval_Sign ( Z, ze)
# Input(s): Given an integer Z represented by the residue touple/vector Z := [z1, . . . , zK]
# and one extra value, viz., ze = (Z mod me) where me = 4
/* Output(s): the Sign of Z, defined as
Sign                                                                                      (                              Z                              )                                                                                =                                                      {                                                                                                                            0                                                                                                                                                                            if                                                                                                                                                                                                                                      Z                                                                        =                                    0                                                                                                                                                                                                                                    +                                    1                                                                                                                                                                                                              if                                                                                                                                                                                                                                      Z                                                                        >                                    0                                                                                                                                                                                                                                    -                                    1                                                                                                                                    otherwise                                                                                                                                                                                                                                          (                          88                          )
The algorithm also returns two more values in addition to the sign
(i) the value of the reconstruction coefficient C for the input and
(ii) Approx_overflow_estimate which is a flag defined as follows:
Approx_overflow                                                        _estimate                                                    =                                                      {                                                                                                                            1                                                                                                                                      if                                                                                                                                                                                                                          overflow                                                                                                                                                                                                                          is                                                                                                                                                                                                                          detected                                                                                                                                                                                                                          for                                                                                                                                                                                                                          sure                                                                                                                                                                                                0                                                                                                  otherwise                                                                                                                                                                                                                                          (                          89                          )
further computation is needed to determine whether there is an overflow in the 2nd case above
Pre-computation: Everything needed for the “RPPR” algorithm, and in addition
Fmax+, Fmax−, decision boundaries T+ and T−, etc. */
# Step 1: Look up pre-stored estimates fr, r = 1 . . . K
for i from 1 to K do # for each channel i
if zr = 0 then
{circumflex over (f)}r := 0;
nzr := 1;
else
{circumflex over (f )}r := zr-th element in the look-up-table for mr;
nzr := 0;
end if
od;
# Step 2: Sum all the fr values with only wT total digits
S                          ^                                                low                                            :=                                                                        ∑                                                      r                            =                            1                                                    K                                                                                                                                                                                                                                f                            ^                                                    r                                                                                      ; n                        z                                            :=                                                                        ∑                                                      r                            =                            1                                                    K                                                                                                                                                                                                    n                                                      z                            r                                                                                                                ;                                                                  and                                                                                                                                                                                                        S                            ^                                                    high                                                                    :=                                                                                                    S                            ^                                                    low                                                +                                                  n                          z                                                                                      ;
if (nz == K)   then # all components = 0   Z = 0
Return(0, 0, 0);
fi;
# Step 3: unscale and separate integer and fractional parts
I                          ^                                                low                                            :=                                              ⌊                                                                                                            S                              ^                                                        low                                                                                C                            s                                                                          ⌋                                                              ;                                                                                            F                          ^                                                low                                            :=                                              (                                                                                                            S                              ^                                                        low                                                    -                                                                                    I                              ^                                                        low                                                                          )                                                              ;                    and I                          ^                                                high                                            :=                                              ⌊                                                                                                            S                              ^                                                        high                                                                                C                            s                                                                          ⌋                                                              ;                                                                                            F                          ^                                                high                                            :=                                              (                                                                                                            S                              ^                                                        high                                                    -                                                                                    I                              ^                                                        high                                                                          )                                                              ;
# important substitutions
{circumflex over (F)} = {circumflex over (F)}low; and Î = Îlow;
# Step 4: determine the temporary sign
Approx_overflow_estimate := 0;
if ({circumflex over (F)} < T+) then
Temp_Sign := +1;
else if ({circumflex over (F)} > T−) then
Temp_Sign := −1;
else
Approx_overflow_estimate := 1;
if ({circumflex over (F)} < 1/2) then
Temp_Sign := +1;
else
Temp_Sign := −1;
end if;
end if;
# Step 5: determine C
if (Îhigh = Îlow) then
C := Î
else
if (ZT mod 4 = {(Î ·  ) mod 4 + Z mod 4} mod 4) then
C := Î;
else
C := Î + 1;
fi;
fi;
if (C , = Î) then
Sign := Temp_Sign;
else
Sign := (−1) × Temp_Sign;
fi;
Return(Sign, C, Approx_overflow_estimate)
End_Algorithm

§ 4.4.2 Overflow Detection

Since we are dealing with sign-detection of integers, an underflow of “magnitude” simply results in the value “0”; no other action needs to be taken in case of magnitude underflow.

However, a magnitude overflow, must be detected and flagged. let A and B be the operands and let denote some operation, then “overflow of magnitude” includes both cases

case 1: (AB)>Posedge=F_max⁺ and   (90)

case 2: (AB)<Negedge=−(−F_max⁻) or dividing both sides by   (91)

$\begin{array}{cc}\frac{\left(A\otimes B\right)}{}>\frac{F_{\mathrm{ma}x}^{+}}{}\mathrm{and}& \left(92\right)\\ \frac{\left(A\otimes B\right)}{}<\frac{F_{\mathrm{ma}x}^{-}}{}& \left(93\right)\end{array}$

However, recall that the decision boundaries T⁺ and T⁻ are shifted by a small amount into the “separation region”. As a result, whenever input values in the range [F_max⁺,T⁺] or in the range [T, F_max] are encountered, they will be wrongly classified as being within the correct range even though they are actually outside the designated range. The only solution to this problem is to separately evaluate the sign of either (Z−F_max⁺) or (Z−F_max⁻) to explicitly check for overflow.

§4.4.2.A Specification of Overflow Detection Algorithm via Maple-Style Pseudo-Code

Algorithm Eval_overflow( Z, ze, Sign, approx_overflow)
# Note that every invocation of this algorithm must be immediately preceded by
# an invocation of the Eval_sign algorithm
/* Precomputations: same as those for algorithm Eval_sign
Inputs: Z, ze, Sign of Z, approx_overflow for Z
The last two values are obtained as a result of the execution of the
Eval_sign algorithm immediately preceding the invocation of this algorithm.
Output(s): overflow flag defined as
overflow                          =                                                      {                                                                                                                            1                                                                                                                                      if                                                                                                                                                                                                                          overflow                                                                                                                                                                                                                          is                                                                                                                                                                                                                          detected                                                                                                                                                                                                                          for                                                                                                                                                                                                                          sure                                                                                                                                                                                                0                                                                                                                                      no                                                                                                                                                                                                                          overflow                                                                                                                                                                                                                                                                            (                          94                          )
*/
# Step 1: handle the trivial cases first
if (Sign == 0) then
Return(0);
fi;
if (approx_overflow == 1) then
Return(1);
fi;
# Step 2: Determine the argument “TZ” for auxiliary sign-detection.
#  note that the residue touple TZ corresponding to the integer TZ is directly determined
#  via component-wise subtractions in the Residue Domain
if (Sign == +1) then
TZ := Z ⊖ Fmax+;   # ⊖ denotes component-wise subtraction in the residue domain
tze := (ze − (Fmax+mod 4)) mod 4;    # disambiguation-bootstrapping
else if (Sign == −1) then
TZ := Z ⊖ Fmax−;
tze := (ze − (Fmax+mod 4)) mod 4;  # keep track of all values modulo 4
end if ;
# Step 3: determine the sign of TZ, (which is denoted by the variable Stz herein
Stz, tmp_rc, approx_overflow_tz := Eval_sign( TZ, tze);
if (Sign == +1) then
if (Stz == +1) then
overflow := 1;
else
Overflow := 0;
end if;
else if (Sign == −1) then
if (Stz == −1) then
Overflow := 1;
else
Overflow := 0;
end if;
end if;
Return (overflow);
End_Algorithm

Once these building blocks are specified, the overall SODIS algorithm is specified next.

§4.4.2.B Specification of Sign and Overflow Detection Algorithm via Maple-Style Pseudo-Code

Algorithm  Sign_and_Overflow_Detection_by_Interval_Sepation( Z,
ze)
# this algorithm is abbreviated as “SODIS”
# Inputs:  Z, ze
# Outputs: Sign (Z), overflow,  Cz
Sign,   RCz , approx_overflow := Eval_sign ( Z, ze) ;
overflow := Eval_overflow( Z, ze, Sign, approx_overflow) ;
Return(Sign, overflow,  Cz ) ;   □
End_Algorithm

Those familiar with the art shall realize that using the algorithms presented in this section, a comparison of of two numbers say A and B can be realized extremely fast, without ever leaving the residue domain in a straightforward manner by detecting the sign of (A-B).

§4.5 The Quotient First Scaling (QFS) Algorithm for Dividing by a Constant

Assume that a double-length (i.e., 2n-bit) dividend X is to be divided by an n-bit divisor D, which is a constant, i.e., it is known ahead of time. The double length value X is variable/dynamic. It is either an external input or more typically it the result of a squaring or a multiplication of two n-bit integers. It is assumed that the extra-bit of information, i.e., the value of (X mod m_e) is available. Given positive integers X and D, a division entails computing the quotient Q and a remainder R such that

$\begin{array}{cc}X=Q\times D+R\mathrm{where}0R<D\mathrm{so}\mathrm{that}Q=\lfloor \frac{X}{D}\rfloor & \left(95\right)\end{array}$

To derive the Division algorithm, start with the alternative form of the Chinese Remainder Theorem (CRT) which expresses the target integer via an exact integer equality of the form illustrated in Equations (B-8.*). Express the double-length Dividend X as

$\begin{array}{cc}X=X_T-·{C_x}_{}=\left(\sum _{r=1}^K{ℳ}_r·{\rho }_r\right)-·{C_x}_{}& \left(96\right)\end{array}$

where the exact value of Reconstruction Coefficient _Cx is determined using the “RPPR” algorithm explained in Section 4.2 above. In other words, there is no unknown in the above exact integer equality expressing the value of the dividend X.

To implement Division, evaluate the quotient Q as follows:

$\begin{array}{cc}\begin{array}{c}Q=\lfloor \frac{X}{D}\rfloor \\ =\lfloor \sum _{r=1}^K\frac{{ℳ}_{r}·{\rho }_r}{D}-\frac{{C_x}_{}·}{D}\rfloor \\ =\lfloor \left\{\sum _{r=1}^K\left(Q_r+\frac{R_r}{D}\right)\right\}-\left(Q_{\mathrm{RC}}+\frac{R_{\mathrm{RC}}}{D}\right)\rfloor \end{array}& \left(97\right)\\ =\lfloor \left\{\sum _{r=1}^K\left(Q_r+f_r\right)\right\}-\left(Q_{\mathrm{RC}}+f_{\mathrm{RC}}\right)\rfloor \mathrm{where}& \left(98\right)\\ Q_r,Q_{\mathrm{RC}}=\lfloor \frac{{ℳ}_r·{\rho }_r}{D}\rfloor ,\lfloor \frac{{C_x}_{}·}{D}\rfloor =\mathrm{precomputed}\mathrm{quotient}\mathrm{values},\mathrm{and}& \left(99\right)\\ R_r,R_{\mathrm{RC}}=\left({ℳ}_r·{\rho }_r-Q_r·D\right),\left({C_x}_{}·-Q_{\mathrm{RC}}·D\right)=\mathrm{precomputed}\mathrm{remainders},\mathrm{and}& \left(100\right)\\ f_r,f_{\mathrm{RC}}=\frac{R_r}{D},\frac{R_{\mathrm{RC}}}{D}=\mathrm{remainders}\mathrm{expressed}\mathrm{as}\mathrm{fractions}\mathrm{of}\mathrm{the}\mathrm{divisor}D& \left(101\right)\end{array}$

The exact integer-quotient can be written as

$\begin{array}{cc}Q=\left(\sum _{r=1}^KQ_r\right)-Q_{\mathrm{RC}}+\lfloor \left(\sum _{r=1}^Kf_r\right)-f_{\mathrm{RC}}\rfloor =Q_I+Q_f\mathrm{where}& \left(102\right)\\ Q_I=\left(\sum _{r=1}^KQ_r\right)-Q_{\mathrm{RC}}=\mathrm{the}\mathrm{contribution}\mathrm{of}\mathrm{Integer}\text{-}\mathrm{part},\left(\mathrm{hence}\mathrm{the}\mathrm{subscript}I\right),\mathrm{and}& \left(103\right)\\ Q_f=\lfloor \left(\sum _{r=1}^Kf_r\right)-f_{\mathrm{RC}}\rfloor =\mathrm{the}\mathrm{contribution}\mathrm{of}\mathrm{fractional}\text{-}\mathrm{part}\left(\mathrm{hence}\mathrm{the}\mathrm{subscript}f\right)& \left(104\right)\end{array}$

Since exact values of Q_r and Q_RC are pre-computed and looked-up, the value of Q_I in Eqn (103) above is exact. However, since we use approximate precomputed values of the fractions truncated to drastically small precision, the value of Q_f calculated via Eqn (104) above is approximate. As a result, the value of Q that is calculated is also approximate. We indicate approximate estimates by a hat on top, which yields the relations:

$\begin{array}{cc}\hat{Q}=Q_I+\widehat{Q_f}\mathrm{where}& \left(105\right)\\ \widehat{Q_f}=\lfloor \left(\sum _{r=1}^K\widehat{f_r}\right)-\widehat{f_{\mathrm{RC}}}\rfloor & \left(106\right)\end{array}$

Our selection of moduli (explained in detail in Section 4.1 above) leads to the fact that the number of of memory-locations required for an exhaustive look-up turns out to be a small degree (quadratic) polynomial of n=lg. This amount of memory can be easily integrated in h/w modules in today's technology for word-lengths up to about 2¹⁷≈0.1-Million bits (which should cover all word-lengths of interest today as well as in the foreseeable future).

Note that the Reconstruction Coefficient _Cx can also assume only a small number of values (no more than (K-1) where K is the number of moduli as per Eqns (B-4, B-5) and (B-9) Hence, quotient values Q_RC and the fractions

$f_{\mathrm{RC}}=\left(\frac{R_{\mathrm{RC}}}{D}\right)$

can also be pre-computed and stored for all possible values the Reconstruction Coefficient _Cx can assume.

§4.5.1 Further Novel Optimizations

{circle around (1)} Store the pre-computed Quotient values directly as residue touples

Note that the quotient values themselves could be very large (about the same word-length as the divisor D). However, we need not store these long-strings of quotient values, since in many applications (such as modular exponentiation) the quotient is only an intermediate variable required to calculate the remainder. Obviously the extra bit of information conveyed by (Q_rs mod m_e) is also pre-computed and stored together with the touple representing the exact integer quotient

$\begin{array}{cc}{Q}_{\mathrm{ir}}=\lfloor \frac{r·{ℳ}_i}{D}\rfloor \mathrm{for}i=1,\dots ,K\mathrm{and}r=1,\dots ,\left(m_r-1\right)& \left(107\right)\end{array}$

The total memory required to store either the full-length long-integer value or storing the residues w.r.t. the component moduli as a touple is about the same. By opting to store only the residue-touples, we eliminate the delay required to convert integer quotient values into residues, without impacting the memory requirements significantly.

• • {circle around (2)} Only fractional remainders truncated to drastically reduced precision O(lgK)≈O(lglg) need to be pre-computed and stored (exactly similar to the “RPPR” algorithm).
  • {circle around (3)} simple scaling converts all fractional storage/computations into integer values.

Thus, the QFS algorithm needs 2 distinct Quotient_Tables.

§4.5.2 Quotient-Tables Explained via a Small Numerical Example

I believe that the tables can be best illustrated by a concrete-small example. Assume that the divisor D=209=11×19 (i.e. D is representable as an 8-bit number). The dividends of interest are therefore up-to 16-bit long numbers. In this case the moduli turn out to be [2, 3, 5, 7, 11, 13, 17]. Even if the first two moduli (viz., 2 and 3) are dropped, the product still exceeds the desired range [0, 2¹⁶]. Therefore we select

={5,7,11,13,17}K=5, =85085 and the extra-modulus m_e=2   (108)

To realize division by this divisor D=209, the first table required is shown in Table 5.

This table is referred to as “Quotient_Table_—1” (or also as the “Quotient_Touples_Table”). It stores all possible values of Quotients required to evaluate the first term (the sum) in Eqn (103). The entries (rows) corresponding to each component-modulus m_r constitute a sub-table of all possible values p_r can assume for that value of m_r. For the sake of clarity, we have used a “double-line” to separate one sub-table from the next.

To illustrate the pre-computations, we explain the last sub-table, in Quotient_Table_—1 corresponding to the component-modulus “m₅=17”, wherein,

${ℳ}_{17}=\frac{17}{}=5005.$

This sub-table has 16 rows. The first row corresponds to p₅=1 the second row corresponds to p₅=2 and so on. Now, we explain each entry in the penultimate row in Table 1 above (this row corresponds to p₅=15).

The value in the 3rd column titled “Quotient . . . ” lists the quotient, i.e.

$\lfloor \frac{{ℳ}_{17}\times 15}{D}=\frac{5005·15}{209}\rfloor =359.$

The next entry (within the angled-brackets ) simply lists the value of (Q_5—15 mod m_e)=(359 mod 2)=1. The 4th column stores the residue-touple [4,2,7,8,2] representing the quotient 359.

The last column in Table 1 stores the fixed point fractional remainder values scaled by the multiplying factor b^wf=10² to convert them into integers. For instance, in the penultimate row: the actual remainder is (5005×15−359×209)=44, corresponding fractional remainder is

$\frac{44}{209}\approx 0.21052\dots$

which when truncated to two decimal places yields 0.21

Accordingly,

$\mathrm{trunc}\left(\frac{44}{209}\times {10}^2\right)=21$

and this is the value stored in the last column.

TABLE 5
Quotient_Table_1 for RNS-ARDSP with moduli    = [5, 7, 11, 13, 17] and divisor D = 209. In
this case, two digits suffice to store the scaled fractional-remainders in the last column.
modulus mr ↓	ρr = [1, 2, . . . mr − 1] ↓	Quotient $Q_r=\lfloor \frac{M_r·{\rho }_r}{D}\rfloor$ and Qr mod 2	moduli mj, j = 1 . . . K [5, 7, 11, 13, 17] Qr mod mj, j = 1 . . . K	Remainder Rr = Mr · ρr − Qr · D Scaled Fractional Rem = $\mathrm{trunc}\left(\frac{R_r}{D}\times {10}^{w_f}\right)\downarrow$
5	1	81  1	[1, 4, 4, 3, 13]	42
	2	162  0	[2, 1, 8, 6, 9]	84
	3	244  0	[4, 6, 2, 10, 6]	26
	4	325  1	[0, 3, 6, 0, 2]	68
.
.
.
			. . .
				.
				.
				.
17	1	23  1	[3, 2, 1, 10, 6]	94
	2	47  1	[2, 5, 3, 8, 13]	89
	.
	.
	.
	15	359  1	[4, 2, 7, 8, 2]	21
	16	383  1	[3, 5, 9, 6, 9]	15

We would like to point out that the actual full-wordlength-long integer values of quotients Q_r (that are listed in column 3 in the table) need not be (and hence are not) stored in a real (h/w or s/w) implementation of the algorithm (the full decimal Q_r values were included in column 3 in Table 1 above, merely for the sake of illustration). In an actual implementation, only the extra-information, i.e., Q_r mod 2 values (shown inside the angled-braces in column3) and the residue-domain touples representing Q_r (as shown in column 4 in the table) are stored. For example, in the penultimate row, actual quotient value “359” need not be stored, only 359 mod 2=1 would be stored, together with the touple of residues of 359 w.r.t. the component moduli=[359 mod 5, . . . , 359 mod 17]=[4, 2, 7, 8, 2] as shown in column 4 therein.

Next we explain Table 6, which shows Quotient_Table_—2 (also referred to as the “Quotient_Rc_Table”)

TABLE 6
Quotient_Table_2 for RNS-ARDSP with moduli [5,7,11, 13, 17] and divisor D = 209.
C = [1, 2, . . . K] ↓	Quotient $Q_c=\lfloor \frac{M·R_C}{D}\rfloor$ Qc mod 2	moduli mj, j = 1 . . . K [5, 7, 11, 13, 17] Qc mod mj, j = 1 . . . K	Remainder Rc =   · C − Qc · D Scaled Fractional Remainder $\mathrm{Scaled}\mathrm{Fractional}\mathrm{Rem}=\mathrm{ceil}\left(\frac{R_c}{D}\times {10}^{w_f}\right)\downarrow$
1	407  1	[2, 1, 0, 4, 16]	11
2	814  0	[4, 2, 0, 8, 15]	22
3	1221  1	[1, 3, 0, 12, 14]	32
4	1628  0	[3, 4, 0, 3, 13]	43
5	2035  1	[0, 5, 0, 7, 12]	53

This table covers all possible values of the Reconstruction Coefficient _Cx in Eqns (96)-(98). Like Table 5, the values in column 2 (i.e., the full-wordlength-long integer values of quotient Q_c) are not stored in actual implementation, (they are included in the table only for the sake of illustration). In actual implementations, only the residues of Q_c with respect to (w.r.t.) 2 (shown inside angled braces in column 2) and the touple of residues of Q_c w.r.t. the component-moduli are stored as illustrated in the third column of the Table. The last column stores the fixed point fractional remainder values scaled by the factor 10^wf to convert them into integers.

Another nontrivial distinction of Quotient_Table_—2 from all previous tables is the fact that the fractional values in the last column are always rounded-up (the mathematical expression uses the “ceiling” function). Note that the last term in Equations (96) and (98), has a negative sign. As a result, when rounding the fractional remainders, we must “over-estimate” them, so that when this value is subtracted to obtain the final quotient estimate, we never over-estimate. In other words, the use of “ceiling” function is necessary to ensure that we are always “under-estimating” the total quotient.

§4.5.3 Specification (Pseudo-Code) of the QFS Algorithm

Like the RPPR-algorithm, we illustrate the division algorithm with 2 examples:

(i) first with small sized operands (dividend X=3249, divisor D=209) so that the reader can replicate the calculations by hand/calculator if needed.

(ii) The 2nd numerical example is a realistic long-wordlength case.

Instead of separating the pseudo-code and numerical illustration, we have waved in the numerical illustration of each step of the algorithm for the running (small) example at hand by including the numerical calculations into the pseudo code as comment blocks.

Algorithm Quotient_First_Scaling_Estimate ( X, X mod me) )
# Inputs: Dividend X as a residue-touple ( X = [x1, . . . , xK] and X mod me ), where me ε {2, 4}
# Pre-computations: Moduli, extra_modulus me, all constants ,Mr, wr, r = 1, 2, . . . , K etc.
create (Reconstruction_Tables); create (Quotient_Tables);
# Step 1: use the RPPR-algorithm to find the Reconstruction-(Remainders & Coefficient) for X
(1.1)	[ρ1, . . . ,ρK],  Cx := RPPR ( X, me, X mod me
(1.2)	nonzero_rrems := 0;
(1.3)	for i from 1 to Nmoduli do
if ρi ≠ 0 then nonzero_rrems := nonzero_rrems + 1; fi;
	od;
(1.4)	if (Cx ≠ 0) then   nonzero_rcx := 1;
	else
	nonzero_rcx := 0;
	fi;
# In the numerical example: ρ := [10, 2, 2, 5, 2]; Cx := 2; nonzero_rrems := 5; nonzero_rcx := 1;
# Step 2: Using the ρi and the the Cx values as “indexes”, look-up in parallel the touples Ti[ρi],
# scaled remainders Rri, QRcx, RRcx, and the corresponding extra_info values (all added in | |)
(2.1)  Ti := Quo_Tab_1 (i, ρi, 3]; Rri := Quo_Tab_1[i, ρi, 4]; i = 1, . . . , K
(2.2 )  QRcx := Quo_Tab_2[Cx, 3]; RRcx := Quo_Tab_2[rcx, 4];
(2.3)  extra_info_Ti := Quo_Tab_1[i, ρi, 2]; extra_info_QRcx := Quo_Tab_2[Cx, 2];
/* In the example: T1 := [4, 1, 8, 5, 1], T2 := [2, 6, 7, 10, 11], T3:= [4, 4, 8, 9, 6], T4 := [0, 3, 4, 4, 1],
T 5 := [2, 1, 8, 6, 9] and QRcx = [4, 2, 0, 8, 15]. (Rr1, Rr2, Rr3, Rr4, Rr5, Rrcx) := (47 63, 1, 78, 84, 22)
Note that there is no “extra-information” associated with the fractional-remainder values  */
# Step 3: Execute accumulations in parallel in all the RNS and extra channel(s)
$\begin{array}{c}\left(3.1\right){\stackrel{\_}{Q}}_I:=\left(\begin{array}{c}K\\ +\\ i=1\end{array}{\stackrel{\_}{T}}_i\right)-\stackrel{\_}{\mathrm{QRcx}};\\ \left(3.2\right){\hat{Q}}_f=\left(\sum _{j=1}^K{\mathrm{Rr}}_j\right)-\mathrm{RRcx};\hspace{1em}\end{array}$ $\text{/}*\pm \mathrm{denotes}a\mathrm{component}\text{-}\mathrm{wise}\mathrm{addition}\text{/}\mathrm{subtraction}\mathrm{of}\mathrm{touples}\mathrm{in}\mathrm{parallel}\mathrm{in}\mathrm{all}\mathrm{the}\mathrm{RNS}\mathrm{channels}.$
“Σ” denotes addition of scalars in the extra channel(s) In the example:
${\stackrel{\_}{Q}}_I=\left[4,1,8,5,1\right]+\left[2,6,7,10,11\right]+\left[4,4,8,9,6\right]+\left[0,3,4,4,1\right]+\left[2,1,8,6,9\right]-\left[4,5,0,8,15\right]=\left[\left(8\mathrm{mod}d\right),\dots ,\left(13\mathrm{mod}17\right)\right]=\left[3,6,2,0,13\right]\mathrm{and}{\hat{Q}}_f=\left(47+63+1+78+84\right)-22=251*\text{/}$
# Step 4: Set {circumflex over (Q)}f_unscaled := Unscaled {circumflex over (Q)}f. Also evaluate bounds on {circumflex over (Q)}f, and check if {circumflex over (Q)}f is exact.
$\begin{array}{c}\left(4.1\right)\hat{Q}\mathrm{f\_unscaled}:=\lfloor \frac{\left({\hat{Q}}_f\right)}{b^w}\rfloor ;\\ \left(4.2\right){\hat{Q}}_{f\_\mathrm{high}}:=\lfloor \frac{\left({\hat{Q}}_f+\mathrm{nonzero\_rrems}+\mathrm{nonzero\_rcx}\right)}{b^w}\rfloor ;\end{array}\hspace{1em}$
# here, b is the base and w is the precision   only left-shift followed by truncation suffices
(4.3) {circumflex over (Q)}f_ low := {circumflex over (Q)}f_unscaled
(4.4)       fi;	if ({circumflex over (Q)}f_low = {circumflex over (Q)}f_high) then     Q_is_exact := 1;   else   Q_is_exact := 0;	$\hspace{1em}\begin{array}{c}\pounds \mathrm{In}\mathrm{the}\mathrm{example}\text{:}\hspace{1em}\\ \pounds {\hat{Q}}_{f\_\mathrm{lo}w}:=\lfloor \frac{251}{{10}^2}\rfloor =2;\mathrm{and}\\ \pounds {\hat{Q}}_{f\_\mathrm{hig}h}:=\lfloor \frac{251+5+1}{{10}^2}\rfloor :=2;\Rightarrow \\ \pounds \mathrm{in}\mathrm{the}\mathrm{example},\mathrm{Q\_is}\mathrm{\_exact}:=1;\end{array}$
$\#\mathrm{Step}5\text{:}\mathrm{evaluate}\stackrel{\_}{Q}\text{:}\mathrm{convert}\hat{Q}\mathrm{f\_unscaled}\mathrm{into}a\mathrm{residue}\text{-}\mathrm{touple}\mathrm{and}\mathrm{add}\mathrm{it}\mathrm{to}\stackrel{\_}{Q_I}\left(5.1\right){\stackrel{\_}{Q}}_{\mathrm{f\_touple}}:=\mathrm{vector}\left(K,i\to \left(\hat{Q}\mathrm{f\_unscaled}\mathrm{mod}m_i\right)\right);$ $\left(5.2\right)\stackrel{\_}{Q}:=\stackrel{\_}{Q_I}+{\stackrel{\_}{Q}}_{\mathrm{f\_}\mathrm{toupl}e}\#\mathrm{In}\mathrm{the}\mathrm{example}\text{:}\stackrel{\_}{Q}:=\left[3,6,2,0,13\right]+\left[2,2,2,2,2\right]=\left[0,1,4,2,15\right]\hspace{1em}$
# Step 6: Also generate {circumflex over (Q)} mod me; the “disambiguation-bootstrapping” step
$\left(6.1\right)\mathrm{extra\_info}\_\hat{Q}:=\left[\left(\sum _{i=1}^K\mathrm{extra\_info}{\mathrm{\_T}}_i\right)-\mathrm{extra\_info}\mathrm{\_QRcx}\right]\mathrm{mod}m_e;$
(6.2) extra_info_{circumflex over (Q)} := (extra_info_{circumflex over (Q)} + {circumflex over (Q)}f_unscaled) mod me
# in the example: extra_info_{circumflex over (Q)} := ((1 + 0 + 0 + 0 + 0 − 0) mod 2 + 2) mod 2 = 1
(7) Output: Return ( {circumflex over ( Q)} , ({circumflex over (Q)} mod me), Q_is_exact);
End_Algorithm

/* In the example: Using the CRT, it can be verified that {circumflex over (Q)}=[0, 1,4, 2,15]≡15 and ({circumflex over (Q)} mod m_e)1.

It is also easy to independently check that

$\lfloor \frac{3249}{209}\rfloor =15,$

verifying the returned value of flag Q_is_exact */ We would like to clarify some important issues regarding the QFS algorithm.

• • {circle around (1)} From the residue touple {circumflex over (Q)}, returned by the algorithm, the remainder can be directly estimated as a residue-touple; and the extra info value ({circumflex over (R)} mod m_e) can also be evaluated using the fundamental division relation (Eqn (95) above):

{circumflex over (R)}:= X( {circumflex over (Q)}D)   (109 )

{circumflex over (R)} mod m_e:=[(X mod m_e)−({circumflex over (Q)} mod m_e)×(D mod m_e)]mod m_e   (110)

• • {circle around (2)} Note that the input X is made available to the algorithm only as a residue touple, not as a fully reconstructed decimal or binary integer. In addition, one extra bit_— conveyed by (X mod m_e) is also required by the algorithm. Given these inputs, the algorithm generates {circumflex over (Q)} as well as ({circumflex over (Q)} mod m_e) (and therefore {circumflex over (R)} and ({circumflex over (R)} mod m_e) as per Eqns (109) and (110)), thereby demonstrating that the outputs are delivered consistently in the same format as the inputs.
  • {circle around (3)} The integer estimate {circumflex over (Q)} corresponding to the residue-touple {circumflex over (Q)} can take only one of the two values

If the variable/flag “Q_is_exact” is set to the value “1”, then {circumflex over (Q)}=Q, i.e., the estimate equals the exact integer quotient. In practice (numerical experiments) this happens in an overwhelmingly large number of cases.

otherwise, the flag Q_is_exact=0, indicating that the algorithm could not determine whether or not {circumflex over (Q)} is exact. (because of the drastically reduced precision used to store the pre-computed fractions) In this case {circumflex over (Q)} could be exact, i.e., {circumflex over (Q)}=Q

or {circumflex over (Q)}=(Q−1), i.e., Q can under-estimate Q by a ulp.

Further disambiguation between these two values is possible by calculating the estimated-remainder {circumflex over (R)} and checking whether ({circumflex over (R)}−D) is +ve or −ve

Let the exact integer remainder be denoted by R. It is clear that the estimated integer-remainder {circumflex over (R)} can have only two possible values:

if {circumflex over (Q)} is exact, then {circumflex over (R)}=R, i.e., {circumflex over (R)} is also exact; or   (111)

{circumflex over (Q)}=(Q−1){circumflex over (R)}=X31 (Q−1)D=(X−Q·D)+D=R+D   (112)

In other words, in the relatively infrequent case , performing a sign-detection on ({circumflex over (R)}−D) is guaranteed to identify the correct Q and R in all cases. (if ({circumflex over (R)}−D) is +ve, then it is clear that {circumflex over (Q)} underestimated Q by a ulp; otherwise {circumflex over (Q)}=Q)

§4.5.4 Estimation of the Delay of and the Memory Required for the QFS Algorithm

§4.5.4.A Delay Model and Latency Estimation

We assume dedicated h/w implementation of all channels (including the extra channels). Within each channel the look-up tables are also implemented in h/w (note that the tables need not be “writable”). All tables are independently readable in parallel with a latency of O(lgn). Likewise, since each component modulus is small as well as the number of channels (K) is also small, we assume that a dedicated adder-tree is available in each channel for the accumulations modulo the component-modulus for that channel. The latency of the accumulations can be also shown to be logarithmic in the word-length, i.e., O(lgn). Likewise, we assume that a fast, multistage or barrel shifter is available per channel so that delay of “variable: shifts is also O(lgn).

FIG. 7 illustrates a timing diagram showing the sequence of successive time-blocks in which the various steps of the QFS algorithm get executed. At the top of each block, we have also shown its latency as a function of (the overall RNS word-length) n, under the assumptions stated above.

Since the maximum latency of any of the blocks is O(lgn), the overall/total latency of the h/w implementation is estimated to be O(lgn).

§4.5.4.B Memory Requirements

In addition to the reconstruction table, we also need the Quotient Tables. The total number of number of entries in both parts of the Quotient table is O(K²/2)+O(K−1)=O(K²). In this case, each table entry has K+1 components, wherein, each component is no bigger than O(lglgK) bits. Consequently the total storage (in bits) that is required is ≈O(K³lglgK) bits ≈O(n³lglgn) bits.

§4.6 Modular Exponentiation Entirely within the Residue Domain

Modular exponentiation refers to evaluating (X^Y mod D). In many instances, in addition to D, the exponent Y is also known ahead of time (ex: in the RSA method, Y is the public or private-key). Our method does not need Y to be a constant, but we assume that it is a primary/external input to the algorithm and hence available in any desired format (in particular, we require the exponent Y as a binary integer, i.e., a string of w-bits).

$\begin{array}{cc}\begin{array}{c}\mathrm{Let}Y=y_{w-1}2^{w-1}+y_{w-2}2^{w-2}+\dots +y_22^2+y_12^1+y_0\\ =(\dots \left(\left(y_{w-1}*2+y_{w-2}\right)*2+y_{w-3}\right)*2+\dots +y_0)\left(114\right)\end{array}& \left(113\right)\end{array}$

To the best of our knowledge, one of the fastest methods to perform modular exponentiation expresses the exponent Y as polynomial of radix 2, parenthesized as shown Eqn (114) above (known as the “Horner's method” of evaluating a polynomial). Since the coefficient of the leading-term in (113) must be non-zero, (i.e. y_w−1=1), the modular exponentiation starts with the initial value Ans:=X² mod D. If y_w−2≠0 then the result is multiplied (modulo-D) by X and is then squared. This operation is repeatedly performed in a loop as shown below:

# Initialization:	Ans = X2 mod D;	mod_red_1
# Loop:	for i from w − 2 by −1 to 1 do
	curbit := Y[i];
	if curbit = 1 then
	Ans := (Ans × X) mod D ;	mod_red_2
	fi;
	Ans := (Ans)2 mod D;	mod_red_3
	od;
	if (y0 = 1) then  Ans = (Ans × X) mod	mod_red_4
	D; fi;

The obvious speedup mechanism is to deploy the QFS algorithm to realize each modular-reduction, aka, remaindering operation. (the remaindering operations needed in modular-exponentiation are tagged with the label “mod_red_n” inside a box at the end of the corresponding line in the maple-style pseudo-code above).

§4.6.1 Further Optimization: Avoiding Sign-Detection at the End of QFS

Result 3: Directly using the estimate {circumflex over ({circumflex over (Q)})} to evaluate {circumflex over (R)} as a residue-touple (as per Eqn (109) above), corresponds to an estimated integer-remainder {circumflex over (R)} that is in the same residue class (w.r.t. the Divisor D) as the correct remainder R

Proof: Immediately follows from the definition of the residue class:

Definition 1: Integers p and q are in the same residue class w.r.t. D if (p mod D=q mod D)

Eqns (111) and (112) show that {circumflex over (R)} ∈ {R, R+D} it is in the same residue-class as the exact integer remainder R.

Next, we show that as long as the range of the RNS system is sufficiently large, it is possible to use incorrect values for the remainder at intermediate steps of modular exponentiation, (as long as they are in the proper residue class); and still generate the correct final result.

Result 4: If the inputs X₁ and X₂ to the QFS algorithm are in the same residue class w.r.t. the (constant/known) divisor D then the remainder estimates {circumflex over (R)}₁ and {circumflex over (R)}₂ evaluated using the quotient estimates {circumflex over (Q)}₁ and {circumflex over (Q)}₂ returned by the QFS algorithm both satisfy the constraints

{circumflex over (R)} ₁ can assume only one of the two values: {circumflex over (R)}₁=R or {circumflex over (R)}₁=R+D   (115)

{circumflex over (R)} ₂ can assume only one of the two values: {circumflex over (R)}₂=R or {circumflex over (R)}₂=R+D   (116)

where R is the correct/exact integer remainder. (this holds even if the “Q_is_exact” flag is set to 0, indicating that the algorithm could not determine whether or not the quotient estimate equals the exact quotient).

Result 5: If the range of the RNS is sufficiently large, then there is no need for a sign-detection at the end of the QFS algorithm in order to identify the correct remainder in intermediate steps during the modular-exponentiation operation.

Proof: Assume that at the end of some intermediate step i, {circumflex over (Q)}=(Q−1) thereby causing

Ans _i :={circumflex over (R)} _i =R _i +D instead of the correct value Ans_i:={circumflex over (R)}_i=R_i;   (117)

Then, as seen in the pseudo-code for modular exponentiation (which is illustrated in Section §4.6.2) above, the next operation is either a modular-square or a modular-multiplication:

Ans _(i+1):=(Ans_i)² mod D or Ans_(i+1):=(Ans_i×X) mod D  (118)

Ans _(i+1):=(R_i+D)² mod D or Ans_(i+1):=(R_i+D)×X mod D   (119)

instead of the correct values

Ans _(i+1) :=R _i ² mod D or Ans_(i+1):=(R_i×X) mod D

However, note that

R_j² is in the same residue class w.r.t. D as (R_i+D)² and   (120)

[(R_i+D)×X] is in the same residue class w.r.t. D as (R_i×X)   (121)

Therefore from claim 2 above, it follows that in either paths (modular-square or modular-product-by-X) the answers obtained at the end of the next step satisfy the exact same constraints, specified by Equations (115) and (116), independent of whether the answers (remainders) at the end of the previous step were exact or had an extra D in them; which shows that performing a sign-detection on the {circumflex over (Q)} returned by the QFS algorithm is not necessary.

Result 6: A single precision RNS range 3D, and correspondingly a double-precision range 9D² is sufficient to obviate the need for a sign-detection

Proof: Since the correct remainder satisfies the constraints 0R<D, it is clear that the erroneous remainder value (R+D) satisfies

0<D(R+D)<2D   (122)

As a result, the estimated remainder could be as high as about/almost 2D. We therefore set the single-precision range-limit to be 3D so that the full double length values could be as large as (3D)²=9D². Accordingly, we select K-smallest-consecutive prime numbers such that their product exceeds 9D². With this big a range, either modular-square or modular-multiplication using an inexact remainder does not cause overflow, as per constraint (122) above

§4.6.2 The ME-FWRD Algorithm: Maple-Style Pseudo-Code

# First we specify a procedure (“proc” in maple) which is a small wrapper around the QFS algorithm
QFS _rem_estimate := proc( X,(X mod me))
{circumflex over (Q)}, {circumflex over (Q)}_mod_me, Q_is_exact := Quotient_First_Scaling_Estimate( X,  X mod me  )
R_is_exact := Q_is_exact;  # if {circumflex over (Q)} is exact then so is {circumflex over (R)}
{circumflex over (R)}_mod_me := [X mod me − {circumflex over (Q)}_mod_me ×(D mod me)] mod me;  # bootstrapping...
{circumflex over (R)} = X    ( {circumflex over (Q)}     D);
Return( {circumflex over (R)}, {circumflex over (R)}_mod_me, R_is_exact);
end proc ;
Algorithm ModExp_Fully_Within_Residue_Domain ( X,(X mod me), Y)
# Inputs: X as a residue-touple, the extra-info, and Y as a w-bit binary-number
# We assume that the constraint X < M has been enforced before converting the primary input X into
# a residue-touple
# Pre-computations: moduli where     9D2, D_mod_me, D≡ residue-touple for D,...
# and everything required by the QFS algorithm
# Initializations
Ans, Ans_mod_me, Ans_is_exact := qfs_rem_estimate( X,  X mod me ) ;
Ans:= Ans     Ans;
Ans_mod_me := (Ans_mod_me)2 mod me   #bootstrapping...
Ans, Ans_mod_me, Ans_is_exact := qfs_rem_estimate( Ans, Ans_mod_me) ;
for i from w − 2 by −1 to 1 do   #Loop
curbit := Y[i];
if curbit = 1 then
Ans:= Ans      X;  Ans_mod_me := (Ans_mod_me × X_mod_me) mod me;
Ans, Ans_mod_me, Ans_is_exact := qfs_rem_estimate( Ans, Ans_mod_me) ;
fi;
Ans:= Ans      Ans;   Ans_mod_me := (Ans_mod_me)2 mod me ;
Ans, Ans_mod_me, Ans_is_exact := qfs_rem_estimate( Ans, Ans_mod_me) ;
od;
if (y0 = 1) then    # Ans = (Ans × X) mod D
Ans:= Ans     X;  Ans_mod_me := (Ans_mod_me × X_mod_me) mod me ;
Ans, Ans_mod_me, Ans_is_exact := qfs_rem_estimate( Ans, Ans_mod_me) ;
fi;
# Outputs: remainder-touple, extra-info, exactness-flag
Return( Ans, Ans_mod_me, Ans_is_exact); □
End_Algorithm

Correctness of the algorithm follows from the analytical results presented so far. Moreover the algorithm was implemented in Maple and extensively tested on a large number of cases.

§4.6.3 Delay Estimation of the Proposed Modular-Exponentiation Algorithm

Pre-computation costs are not considered (they represent one-time fixed costs).

(i) The main/dominant delay is determined by the delay of the loop.

Assuming that the exponent Y is about as big as D, the number of times the exponentiation loop is executed=lgY≈O(n) times.

(ii) Determination of the Quotient estimate is the most time-consuming operation in each iteration of the loop and it requires O(lgn) delay (as explained in Section §4.5.4-A).

As a result, each iteration of the loop requires (O(lgn) delay.

(iii) Therefore, the total delay is O(nlgn).

The memory requirements are exactly the same as those of the QFS algorithm: ≈O(n³lglgn) bits as shown above (in Section §4.5.4-B).

§4.6.4 Some Remarks about the ME-FWRD Algorithm

{circle around (1)} In a remaindering operation, it is possible to under-estimate the quotient, but it is not acceptable to over-estimate the quotient even by a ulp for the following reason:

if {circumflex over (Q)} is an over-estimate, then {circumflex over (R)}=X−{circumflex over (Q)}×D0 and therefore gets evaluated as   (123)

{circumflex over (R)}≡ −|{circumflex over (R)}| which is not in the same residue class w.r.t. D as the correct remainder R   (124)

{circle around (2)} The algorithm always works in full (double) precision mode. In the RNS, increased word length simply requires some more channels. In a dedicated h/w implementation, all the channels can execute concurrently, fully leveraging the parallelism inherent in the system. Hence, the incremental delay (as a result of doubling the word-length) is minimal: Since doubling the word-length adds one-level to each adder/accumulation-tree (within each RNS-channel),

the incremental delay is ≈O(1).

§4.7 Convergence Division via Reciprocation to Handle Arbitrary, Dynamic Divisors

let X be a 2n bit dividend

X=X _i·2ⁿ+X_l   (125)

where X_u is the upper-half (more-significant n bits) and X_l is the lower-half. Let D be an n bit-long divisor. Then, the quotient Q is

$\begin{array}{cc}\begin{array}{c}Q=\lfloor \frac{X}{D}\rfloor \\ =\lfloor \frac{X_u·2^n+X_l}{D}\rfloor \\ =\lfloor \frac{X_u·2^n}{D}\rfloor +\lfloor \frac{X_l}{D}\rfloor +\delta \end{array}\mathrm{wherein}\delta =\left\{0,1\right\}& \left(126\right)\end{array}$

Since X_l and D are both n bit long numbers X_l<2D   (127)

$\begin{array}{cc}\lfloor \frac{X_l}{D}\rfloor =\{\begin{array}{cc}0& \mathrm{if}X_l<D\\ 1& \mathrm{otherwise}\end{array}& \left(128\right)\end{array}$

The remaining term is

$\begin{array}{cc}\lfloor \frac{X_u·2^n}{D}\rfloor \mathrm{wherein}\frac{X_u·2^n}{D}=\frac{X_u}{D_f}\mathrm{where}D_f=\frac{D}{2^n}\Rightarrow \frac{1}{2}D_f<1& \left(129\right)\end{array}$

In the inequality above, the lower bound ½ follows from the fact that the leading bit of an n-bit long number D is 1 (if not, the word-length of D would be smaller than n). Also note that the maximum value of the n-bit integer D can be (2ⁿ−1), which yields the upper bound 1 on D_f.

$\begin{array}{cc}\mathrm{Let}D_{\mathrm{f\_inv}}=\frac{1}{D_f}\Rightarrow 1<D_{\mathrm{f\_inv}}2\mathrm{and}\mathrm{let}D_{\mathrm{f\_inv}}=1+F\mathrm{where}0<F1& \left(130\right)\\ \mathrm{Then},\frac{X_u}{D_f}=x_u\times D_{\mathrm{f\_inv}}=X_u\left(1+F\right)=X_u+X_uF\Rightarrow \lfloor \frac{X_u}{D_f}\rfloor =X_u+\lfloor X_uF\rfloor & \left(131\right)\end{array}$

From the last equality it is clear that in order to correctly evaluate └X_uD_f—inv┘, the value of F (which is the fractional part of D_f—inv) must be evaluated upto at least n bits of precision.

To evaluate D_f—inv, let

$\begin{array}{cc}Y=\left(1-D_f\right)\Rightarrow 0<Y\frac{1}{2}& \left(132\right)\end{array}$

Note that the integer Y_int=(2ⁿY)=(2ⁿ−D)   (133)

(134)

Substituting D_f in terms of Y, yields

$\begin{array}{cc}\begin{array}{c}{D}_{\mathrm{f\_inv}}=\frac{1}{D_f}\\ =\frac{1}{\left(1-Y\right)}\\ =\frac{\left(1+Y\right)}{\left(1-Y^2\right)}\\ =\frac{\left(1+Y\right)\left(1+Y^2\right)}{\left(1-Y^4\right)}\\ =\dots \\ =\frac{\left(1+Y\right)\left(1+Y^2\right)\dots \left(1+Y^{\left(2^t\right)}\right)}{\left(1-Y^{\left(2^{2t}\right)}\right)}\end{array}& \left(135\right)\end{array}$

In the last set of equalities, since the numerator and the denominator of each successive expression are both multiplied by the same

factor of the form (1+Y⁽²ⁱ⁾) at step i, i=0, 1,   (136)

the original value of the reciprocal does not change. Also note that each successive multiplication by a factor of the above form doubles the number of leading ones in the denominator. As a result the denominator in the successive expressions in Eqn (135) approaches the value 1 from below (it becomes 0.11111 . . . ).

It is well known [6] that

when the number of leading-ones in the denominator exceeds the word-length (i.e., n bits),

the error ε in the numerator also satisfies the bound ″ε|<2⁻ⁿ

and the iterations can be stopped. In other words, when t leads to the satisfaction of the constraint

$\begin{array}{cc}\left(1-Y^{\left(2^{2t}\right)}\right)\left(1-2^{\left(n\right)}\right)\Rightarrow \left(\mathrm{lgY}\right)2^{\left(2t\right)}n\Rightarrow t\frac{1}{2}\left(\mathrm{lgn}-\mathrm{lglgY}\right)& \left(137\right)\end{array}$

the iterations can be stopped and the approximation

$\begin{array}{cc}\begin{array}{c}{D}_{\mathrm{f\_inv}}=\frac{\left(1+Y\right)\left(1+Y^2\right)\dots \left(1+Y^{\left(2^t\right)}\right)}{\left(1-Y^{\left(2^{2t}\right)}\right)}\\ \approx \frac{\left(1+Y\right)\left(1+Y^2\right)\dots \left(1+Y^{\left(2^t\right)}\right)}{1}\end{array}& \left(138\right)\end{array}$

can be used. Thus, number of iterations in a convergence division is O(lg).

In contrast any digit-serial division fundamentally requires O(n) steps.

It turns out that the above convergence method is equivalent to newton-style convergence iterations (for details, please see any textbook on Computer Arithmetic [6,7]). Newton's method is quadratic which means that the error

ε_n+1 after the (n+1)th iteration ≈O((ε_n)²)   (139)

which in-turn implies that the number of accurate bits doubles after each iteration (which is why convergence-division is the method of choice in high speed implementations).

From (138) it is clear that

D _{f — inv}≈(1+Y)(1+Y²) . . . . (1+Y^(2t))

Accordingly the products need to be accumulated, so as to yield a precision of 2ⁿ-bits at the end. Since a product of two n bit numbers (which includes a square) can be upto 2n bits long, the lower half of the double length product must be discarded retaining only the n most significant bits at every step. Each such retention of n most significant bits is tantamount to division by a constant, viz., 2ⁿ. Thus the QFS algorithm needs to be invoked at every step in the convergence division method. In general the SODIS algorithm is also needed at each step. Those familiar with the art will appreciate that using all the preceding algorithms unveiled herein, an ultrafast convergence division via reciprocation can be realized without ever having to leave the residue domain at any intermediate step.

§5 Application Scenarios

The difficulty of implementing some basic canonical operations such as base-extension, sign-detection, scaling, and division has prevented the widespread adoption of the RNS. The algorithms and apparata unveiled herein streamline and expedite all these fundamental operations, thereby removing all roadblocks and unleashing the full potential of the RNS. Since a number representation is a fundamental attribute that underlies all computing systems, expediting all arithmetic operations using the RNS can potentially affect all scenarios that include computing systems. The scenarios that are most directly impacted are listed below.

• • {circle around (1)} At long wordlengths the proposed system yields substantially faster implementations. Therefore, cryptographic processors are likely to adopt the RNS together with the algorithms unveiled in this document. All other long wordlength applications (such as running Sieves for factoring large numbers or listing the prime numbers within a given interval, etc) will substantially benefit from hardware as well as software implementations of the proposed number system and the accompanying algorithms
  • {circle around (2)} Digital Signal Processing is dominated by multiply and add operations. The proposed representation is therefore likely to be adopted in DSP processors.
    • Scaling is particularly easy if the scaling factor is divisible by one or more of the component moduli.
    • My method of selecting moduli uses all prime numbers up to a certain threshold value. So there is ample scope to select a scale factor that is divisible by one or more of the moduli. This is an added advantage of the method of moduli selection that I have adopted.
  • {circle around (3)} Ultra-fast counters, constant-time or wordlength-independent up/down counters are significantly faster as well as simpler to realize when the RNS system is used.
    • Consequently, the theory as well as designs of such counters should switch over to using the RNS and the accompanying algorithms
  • {circle around (4)} Memory and cache organization/access is another potentially significant application area. Conceptually, memory needs be abstracted as though it were a “linear” storage because the indexing calculations in conventional (binary/decimal) number representations are easier when the memory is logically organized linearly. Adopting the RNS allows a different conceptual organization of storage resources (ex: under RNS, storage can be conceptualized as a collection of buckets)
  • {circle around (5)} Realization of hash functions is faster and easier when there is native/hardware support for modulo operations that are required in the RNS. That in turn opens up other possibilities to further streamline and expedite other algorithms and/or apparata (such as Bloom filters, for instance).
  • {circle around (6)} Coding Theory and practice have pretty much revolved around conventional number representations. RN systems offer a rich mix of choices to further improve coding theory and practice.
  • {circle around (7)} Hardware implementations based on the RNS are inherently more parallel, since all channels can do their processing independently, thereby increasing the “locality” of processing and drastically reducing long interconnects. This in turn makes the circuits more compact and faster while simultaneously requiring substantially lower amount of power (than equivalent circuits based on conventional number representations). Moreover, the independence of channels makes the hardware lot easier to test (VLSI testing is a critically important issue). Finally, hardware realizations based on the RNS are more reliable.
  • {circle around (8)} Even when the RNS is implemented in software, it can still improve the utilization of the multi-core processors today. Channel(s) in the RNS could be dynamically mapped onto threads which could in turn be dynamically allocated and executed on any of the multiple cores.
  • {circle around (9)} Random number generation based on RNS system is another area that appears to have a great potential.
  • {circle around (10)} Theoretical Issues: for instance the Remainder Theorem constitutes an “orthogonal” decomposition (in a sense analogous to the Discrete Fourier Transform, i.e., the DFT). This is why multiplication (which is a convolution) becomes so simple, all the cross-terms go away . . . .
    • What kind of redundancy is there in RNS representation?
    • The novelty of the methods unveiled herein lies in their use of both the integer as well as fractional parts rather than sticking to only one. Can such methods be further extended and applied to other well know hard problems ? are these methods related to “Interior Point Methods”?

5.1 Distinctions and Novel Aspects of this Invention

• • {circle around (1)} All of the algorithms make maximal use of those intermediate variables whose values can be expressed as the most significant digits of a computation (the reader can verify that this is the case in the “RPPR”, SODIS, as well as the QFS algorithm)
    • This enables the use of approximation methods.
  • {circle around (2)} Accuracy of approximation is in turn related to the precision required. The algorithms therefore use the minimal amount of precision necessary for the computation.
    • I leverage the rational domain interpretation (i.e., joint integer as well as fractional domain interpretations) of the Chinese Remainder Theorem in order to drastically reduce the precision of the fractional values that need to be pre-computed and stored in look-up tables. It turns out that a drastic reduction of precision from n-bits to ┌lgn┐ bits still allows a highly accurate estimation of some canonical intermediate variables, wherein the estimate can be off only by a ulp. In other words, the exact value of the computation can be narrowed down to a pair of successive integers. This strategy is adopted in all the methods (viz, RPPR, SODIS, as well as the QFS algorithms)
    • The novel “disambiguation” step then selects the right answer(by disambiguating between the two choices) in all cases.
    • In other words, in a fundamental sense, I have identified the optimal mix of which and how much information from the fractional domain needs be combined with which specific portion of the information available from the integer-domain interpretation of the CRT in order to achieve ultrafast execution; and developed new methods that fully exploit that optimal mix.
  • {circle around (3)} My Moduli selection method simultaneously achieves three optimizations:
    • O1: It maximizes the amount of pre-computation to the fullest extent; making it possible to deploy exhaustive look-up tables that cover all possible input cases.
    • O2: Simultaneously, it also minimizes the amount of memory required (otherwise an exhaustive look-up would not be feasible at long bit-lengths).
    • O3: It minimizes the size that each individual component-modulus nt_i can assume. The net effect is that the RNS is realized via a moderately large number of channels, each of which has a very small modulus.
    • In other words, the moduli-selection brings out the parallelism inherent in the RNS to the fullest extent.
  • {circle around (4)} The said moduli selection therefore leads to two critical benefits
    • B+1: Exhaustive pre-computation implies that there is very little left to be done at run-time, which leads to ultrafast execution (a good example is the Quotient First Scaling (QFS) algorithm).
    • B+2: Exploiting the parallelism to the fullest extent while also using the smallest amount of memory further speeds up execution and cuts down on area and power consumption of hardware realizations.
  • {circle around (5)} All of the prior works published hitherto had a narrower focus. For example, [9], [12] (and their derivatives that have appeared since) are mainly concerned with “base-extension”. On the other hand, Vi's first paper [16] was aimed at “fault detection in flight control systems”; while the follow-on journal paper [17] was focused on “sign-detection”. Likewise, Lu's work [25,26] was mainly focused on a more efficient sign-detection and its application to division in the RNS.
    • In contrast, we have developed a unified framework that expedites all the difficult RNS operations simultaneously.
  • {circle around (6)} The algorithms can be implemented in software (wherein the computation within each channel is done within a separate thread and the multiple threads get dynamically mapped onto different cores in a multi-core processor) or in hardware. In either case they offer a wide spectrum of choices that trade-off polynomially increasing amounts of pre-computations and look-up-table memory to achieve higher speed. In other words the algorithms are flexible and allow the designer a wide array of choices for deployment.

FIG. 9 is a flow chart representation of a process 900 of performing reconstruction using a residue number system. At box 902, a set of moduli is selected. At box 904, a reconstruction coefficient is estimated based on the selected set of moduli. At box 906, a reconstruction operation using the reconstruction coefficient is performed. As previously discussed, in some designs, additional operations may also be performed using the reconstruction operation.

In some designs, the operation of selecting the set of moduli is done so as to enable an exhaustive pre-computation and look-up strategy that covers all possible inputs. In some designs, the determination of reconstruction coefficient may be performed in hardware such that the determination is upper limited by delay of O(log n) where n is an integer number representing wordlength.

FIG. 10 is a block diagram representation of a portion of an apparatus 1000 for performing reconstruction using a residue number system. The module 1002 is provided for selecting a set of moduli. The module 1004 is provided for estimating a reconstruction coefficient based on the selected set of moduli. The module 1004 is provided for performing a reconstruction operation using the reconstruction coefficient.

FIG. 11 is a flow chart representation of a process 1100 of performing division using a residue number system. At box 1102, a set of moduli is selected. At box 1104, a reconstruction coefficient is determined. At box 1106, a quotient is determined using an exhaustive pre-computation and a look-up strategy that covers all possible inputs.

FIG. 12 is a block diagram representation of a portion of an apparatus 1200 for performing division using a residue number system. The module 1202 is provide for selecting a set of moduli. The module 1204 is provided for determining a reconstruction coefficient. The module 1206 is provided for determining a quotient using an exhaustive pre-computation and a look-up strategy that covers all possible inputs.

FIG. 13 is a flow chart representation of a process 1300 of computing a modular exponentiation using a residue number system. At box 1302, iterations are performed without converting to a regular integer representation, by performing modulator multiplications and modular squaring. At box 1304, the modular exponentiation is computed as a result of the iterations.

FIG. 14 is a block diagram representation of a portion of an apparatus 1400 for computing a modular exponentiation using a residue number system. The module 1402 is provided for iterating, without converting to a regular integer representation, by performing modular multiplications and modular squaring. The module 1404 is provided for computing the modular exponentiation as a result of the iterations.

It is noted that in one or more exemplary embodiments described herein, the functions and modules described may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media includes both computer storage media and communication media including any medium that facilitates transfer of a computer program from one place to another. A storage media may be any available media that can be accessed by a computer. By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer. Also, any connection is properly termed a computer-readable medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium. Disk and disc, as used herein, includes compact disc (CD), laser disc, optical disc, digital versatile disc (DVD), floppy disk and blue-ray disc where disks usually reproduce data magnetically, while discs reproduce data optically with lasers. Combinations of the above should also be included within the scope of computer-readable media.

As utilized in the subject disclosure, the terms {hacek over (r)}system,ś {hacek over (r)}module,ś {hacek over (r)}component,ś {hacek over (r)}interface,ś and the like are likewise intended to refer to a computer-related entity, either hardware, a combination of hardware and software, software, or software in execution. Components can include circuitry, e.g., processing unit(s) or processor(s), that enables at least part of the functionality of the components or other component(s) functionally connected (e.g., communicatively coupled) thereto. As an example, a component may be, but is not limited to being, a process running on a processor, a processor, a machine-readable storage medium, an object, an executable, a thread of execution, a program, and/or a computer. By way of illustration, both an application running on a computer and the computer can be a component. One or more components may reside within a process and/or thread of execution and a component may be localized on one computer and/or distributed between two or more computers.

The aforementioned systems have been described with respect to interaction between several components and modules. It can be appreciated that such systems, modules and components can include those components or specified sub-components, some of the specified components or sub-components, and/or additional components, and according to various permutations and combinations of the foregoing. Sub-components also can be implemented as components communicatively coupled to other components rather than included within parent component(s). Additionally, it should be noted that one or more components may be combined into a single component providing aggregate functionality or divided into several separate sub-components and may be provided to communicatively couple to such sub-components in order to provide integrated functionality. Any components described herein may also interact with one or more other components not specifically described herein but generally known by those of skill in the art.

Moreover, aspects of the claimed subject matter may be implemented as a method, apparatus, or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof to control a computer or computing components to implement various aspects of the claimed subject matter. The term “article of manufacture” as used herein is intended to encompass a computer program accessible from any computer-readable device, carrier, or media. For example, computer readable media can include but are not limited to magnetic storage devices (e.g., hard disk, floppy disk, magnetic strips, optical disks (e.g., compact disk (CD), digital versatile disk (DVD), smart cards, and flash memory devices (e.g., card, stick, key drive. Additionally it should be appreciated that a carrier wave can be employed to carry computer-readable electronic data such as those used in transmitting and receiving voice mail or in accessing a network such as a cellular network. Of course, those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope or spirit of what is described herein.

What has been described above includes examples of one or more embodiments. It is, of course, not possible to describe every conceivable combination of components or methodologies for purposes of describing the aforementioned embodiments, but one of ordinary skill in the art may recognize that many further combinations and permutations of various embodiments are possible. Accordingly, the described embodiments are intended to embrace all such alterations, modifications and variations that fall within the spirit and scope of the appended claims. Furthermore, to the extent that the term {hacek over (r)}includesś is used in either the detailed description or the claims, such term is intended to be inclusive in a manner similar to the term {hacek over (r)}comprisingś as {hacek over (r)}comprisingś is interpreted when employed as a transitional word in a claim.

Claims

1. A method of performing reconstruction using a residue number system, comprising; selecting a set of moduli;estimating a reconstruction coefficient based on the selected set of moduli; andperforming a reconstruction operation using the reconstruction coefficient.

2. The method of claim 1, wherein the selecting the set of moduli is done so as to enable an exhaustive pre-computation and look-up strategy that covers all possible inputs.

3. The method of claim 1, wherein the reconstruction coefficient is determined in a delay limit of O(log n).

4. The method of claim 1 wherein the estimating comprises: computing a plurality of reconstruction reminders; andquantizing the plurality of reconstruction reminders.

5. The method of claim 4 wherein the quantization comprises: expressing the reconstruction remainders as proper fractions;pre-computing the proper fractions in a pre-determined radix b;truncating the proper fractions to a precision of no more than (┌logb logb┐) radix-b fractional digits;scaling the truncated proper fractions by a scale factor so that multiplication by the scale factor simply amounts to a left-shifting of base-b digits and yields an integer value; andstoring the resulting integer values in look-up tables, wherein each RNS channel 1, with component-modulus mi requires one look-up table with (mi−1) entries.

6. The method of claim 5, wherein, channel look-up tables are read-only and are accessed completely independently of one another

7. The method of claim 1 wherein all the operands are integers and all the arithmetic operations are carried out with an ultra-low precision of no more than (┌logb K┐+┌logb logbM┐) radix-b digits.

8. The method of claim 1 wherein the estimate consists of a pair of consecutive integers, one of which is the correct value of the reconstruction coefficient.

9. The method of claim 8, wherein, a disambiguation step is required to select the correct answer from among the two choices, by using an independent extra bit of information which is maintained in the form of one extra residue, i.e., remainder, with respect to an extra “disambiguator-modulus” me that satisfies the condition: gcd(, me)<me

10. The method of claim 9, wherein, a systematic “disambiguation-bootstrapping” process is required (and is therefore adopted) to ensure that this extra remainder is always available for any value that the method encounters.

11. A method of performing division using a residue number system, comprising: selecting a set of moduli;determining a reconstruction coefficient; anddetermining a quotient using an exhaustive pre-computation and a look-up strategy that covers all possible inputs.

12. The method of claim 11, wherein, the disambiguation bootstrapping information regarding the determined quotient Q is also computed.

13. A method of computing a modular exponentiation in a residue number system, comprising: iterating, without converting to a regular integer representation, by performing modular multiplications and modular squaring;computing the modular exponentiation as a result of the iterations.

14. The method of claim 13, wherein there is no conversion between distinct moduli sets within a residue domain at any intermediate step throughout the computing process.

15. An apparatus for performing reconstruction using a residue number system, comprising: means for selecting a set of moduli;means for estimating a reconstruction coefficient based on the selected set of moduli;andmeans for performing a reconstruction operation using the reconstruction coefficient.

16. A computer program product comprising a non-volatile, computer-readable medium, storing computer-executable instructions for performing reconstruction using a residue number system, the instructions comprising code for: selecting a set of moduli;estimating a reconstruction coefficient based on the selected set of moduli; andperforming a reconstruction operation using the reconstruction coefficient.