# Discrete logarithm calculator

This web application computes discrete logarithms.

The discrete logarithm problem is to find the exponent in the expression `Base`^{Exponent} = `Power` (mod `Modulus`).

This applet works for both prime and composite moduli. The only restriction is that the base and the modulus, and the power and the modulus must be relatively prime.

In this version of the discrete logarithm calculator only the Pohlig-Hellman algorithm is implemented, so the execution time is proportional to the square root of the largest prime factor of the modulus minus 1.
The applet works in a reasonable amount of time if this factor is less than 10^{17}.

I will add the index-calculus algorithm soon. This algorithm has subexponential running time.

## Expressions

You can also enter expressions that use the following operators and parentheses:

**+**for addition**-**for subtraction*****for multiplication**/**for division**%**for remainder**^**or******for exponentiation-
**<**,**==**,**>**;**<=**,**>=**, != for comparisons. The operators return zero for false and -1 for true. -
**Ans**: retrieves the last answer. -
**AND**,**OR**,**XOR**,**NOT**for binary logic. The operations are done in binary (base 2). Positive (negative) numbers are prepended with an infinite number of bits set to zero (one). -
**SHL**or**<<**: When`b`≥ 0,`a`SHL`b`shifts`a`left the number of bits specified by`b`. This is equivalent to`a`× 2^{b}. Otherwise,`a`SHL`b`shifts`a`right the number of bits specified by −`b`. This is equivalent to floor(`a`/ 2^{−b}). Example: 5 SHL 3 = 40. -
**SHR**or**>>**: When`b`≥ 0,`a`SHR`b`shifts`a`right the number of bits specified by`b`. This is equivalent to floor(`a`/ 2^{b}). Otherwise,`a`SHR`b`shifts`a`left the number of bits specified by −`b`. This is equivalent to`a`× 2^{−b}. Example: -19 SHR 2 = -5. -
**n!**: factorial (`n`must be greater than or equal to zero). Example: 6! = 6 × 5 × 4 × 3 × 2 = 720. -
**n!! ... !**: multiple factorial (`n`must be greater than or equal to zero). It is the product of`n`times`n`−`k`times`n`−`2k`... (all numbers greater than zero) where`k`is the number of exclamation marks. Example: 7!! = 7 × 5 × 3 × 1 = 105. -
**p#**: primorial (product of all primes less or equal than`p`). Example: 12# = 11 × 7 × 5 × 3 × 2 = 2310. -
**B(n)**: Previous probable prime before*n*. Example: B(24) = 23. -
**F(n)**: Fibonacci number F_{n}from the sequence 0, 1, 1, 2, 3, 5, 8, 13, 21, etc. where each element equals the sum of the previous two members of the sequence. Example: F(7) = 13. -
**L(n)**: Lucas number L_{n}= F_{n-1}+ F_{n+1} -
**N(n)**: Next probable prime after*n*. Example: N(24) = 29. -
**P(n)**: Unrestricted Partition Number (number of decompositions of`n`into sums of integers without regard to order). Example: P(4) = 5 because the number 4 can be partitioned in 5 different ways: 4 = 3+1 = 2+2 = 2+1+1 = 1+1+1+1. -
**Gcd(m,n, ...)**: Greatest common divisor of these integers. Example: GCD(12, 16) = 4. -
**Lcm(m,n, ...)**: Least common multiple of these integers. Example: LCM(12, 16, 24) = 48. -
**Modinv(m,n)**: inverse of`m`modulo`n`, only valid when`m`and`n`are coprime, meaning that they do not have common factors. Example: Modinv(3,7) = 5 because 3 × 5 ≡ 1 (mod 7) -
**Modpow(m,n,r)**: finds`m`^{n}modulo`r`. Example: Modpow(3, 4, 7) = 4, because 3^{4}≡ 4 (mod 7). -
**Totient(n)**: finds the number of positive integers less than`n`which are relatively prime to`n`. Example: Totient(6) = 2 because 1 and 5 do not have common factors with 6. -
**Jacobi(m,n)**: obtains the Jacobi symbol of`m`and`n`. When the second argument is prime, the result is zero when`m`is multiple of`n`, it is one if there is a solution of`x`² ≡`m`(mod`n`) and it is equal to −1 when the mentioned congruence has no solution. -
**Random(m,n)**: integer random number between`m`and`n`. -
**Abs(n)**: absolute value of`n`. -
**IsPrime(n)**: returns zero if`n`is not probable prime, -1 if it is. Example: IsPrime(5) = -1. -
**Sqrt(n)**: Integer part of the square root of the argument. -
**Iroot(n, r)**: Integer r-root of the first argument. Example: Iroot(8, 3) = 2. -
**NumDigits(n,r)**: Number of digits of`n`in base`r`. Example: NumDigits(13, 2) = 4 because 13 in binary (base 2) is expressed as 1101. -
**SumDigits(n,r)**: Sum of digits of`n`in base`r`. Example: SumDigits(213, 10) = 6 because the sum of the digits expressed in decimal is 2+1+3 = 6. -
**RevDigits(n,r)**: finds the value obtained by writing backwards the digits of`n`in base`r`. Example: RevDigits(213, 10) = 312.

You can use the prefix *0x* for hexadecimal numbers, for example 0x38 is equal to 56.

The exponentiation symbol is not present in some mobile devices, so two asterisks ** can by typed as the exponentiation operator.

Example: Find the number `n` such that 7^{n} ≡ 23 (mod 43241).

Type 7 in the Base input box, 23 in the Power input box and 43241 in the Mod input box. Then press the button named "Discrete logarithm".

The result is 3360 + 3930 k. As a check you can compute 7^{3360} ≡ 23 (mod 43241) and 7^{3930} ≡ 1 (mod 43241).

## Source code

You can download the source of the current program and the old sum polynomial factorization applet from GitHub. Notice that the source code is in C language and you need the Emscripten environment in order to generate JavaScript.

Written by Dario Alpern. Last updated 11 March 2023.