Add files using upload-large-folder tool

lib/python3.12/site-packages/sympy/crypto/__init__.py

@@ -0,0 +1,35 @@
+from sympy.crypto.crypto import (cycle_list,
+        encipher_shift, encipher_affine, encipher_substitution,
+        check_and_join, encipher_vigenere, decipher_vigenere, bifid5_square,
+        bifid6_square, encipher_hill, decipher_hill,
+        encipher_bifid5, encipher_bifid6, decipher_bifid5,
+        decipher_bifid6, encipher_kid_rsa, decipher_kid_rsa,
+        kid_rsa_private_key, kid_rsa_public_key, decipher_rsa, rsa_private_key,
+        rsa_public_key, encipher_rsa, lfsr_connection_polynomial,
+        lfsr_autocorrelation, lfsr_sequence, encode_morse, decode_morse,
+        elgamal_private_key, elgamal_public_key, decipher_elgamal,
+        encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key,
+        padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5,
+        bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key,
+        gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg,
+        encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash,
+        encipher_railfence, decipher_railfence)
+
+__all__ = [
+    'cycle_list', 'encipher_shift', 'encipher_affine',
+    'encipher_substitution', 'check_and_join', 'encipher_vigenere',
+    'decipher_vigenere', 'bifid5_square', 'bifid6_square', 'encipher_hill',
+    'decipher_hill', 'encipher_bifid5', 'encipher_bifid6', 'decipher_bifid5',
+    'decipher_bifid6', 'encipher_kid_rsa', 'decipher_kid_rsa',
+    'kid_rsa_private_key', 'kid_rsa_public_key', 'decipher_rsa',
+    'rsa_private_key', 'rsa_public_key', 'encipher_rsa',
+    'lfsr_connection_polynomial', 'lfsr_autocorrelation', 'lfsr_sequence',
+    'encode_morse', 'decode_morse', 'elgamal_private_key',
+    'elgamal_public_key', 'decipher_elgamal', 'encipher_elgamal',
+    'dh_private_key', 'dh_public_key', 'dh_shared_key', 'padded_key',
+    'encipher_bifid', 'decipher_bifid', 'bifid_square', 'bifid5', 'bifid6',
+    'bifid10', 'decipher_gm', 'encipher_gm', 'gm_public_key',
+    'gm_private_key', 'bg_private_key', 'bg_public_key', 'encipher_bg',
+    'decipher_bg', 'encipher_rot13', 'decipher_rot13', 'encipher_atbash',
+    'decipher_atbash', 'encipher_railfence', 'decipher_railfence',
+]

lib/python3.12/site-packages/sympy/crypto/crypto.py

@@ -0,0 +1,3367 @@
+"""
+This file contains some classical ciphers and routines
+implementing a linear-feedback shift register (LFSR)
+and the Diffie-Hellman key exchange.
+
+.. warning::
+
+   This module is intended for educational purposes only. Do not use the
+   functions in this module for real cryptographic applications. If you wish
+   to encrypt real data, we recommend using something like the `cryptography
+   <https://cryptography.io/en/latest/>`_ module.
+
+"""
+
+from string import whitespace, ascii_uppercase as uppercase, printable
+from functools import reduce
+import warnings
+
+from itertools import cycle
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.core import Symbol
+from sympy.core.numbers import Rational
+from sympy.core.random import _randrange, _randint
+from sympy.external.gmpy import gcd, invert
+from sympy.functions.combinatorial.numbers import (totient as _euler,
+                                                   reduced_totient as _carmichael)
+from sympy.matrices import Matrix
+from sympy.ntheory import isprime, primitive_root, factorint
+from sympy.ntheory.generate import nextprime
+from sympy.ntheory.modular import crt
+from sympy.polys.domains import FF
+from sympy.polys.polytools import Poly
+from sympy.utilities.misc import as_int, filldedent, translate
+from sympy.utilities.iterables import uniq, multiset
+from sympy.utilities.decorator import doctest_depends_on
+
+
+if GROUND_TYPES == 'flint':
+    __doctest_skip__ = ['lfsr_sequence']
+
+
+class NonInvertibleCipherWarning(RuntimeWarning):
+    """A warning raised if the cipher is not invertible."""
+    def __init__(self, msg):
+        self.fullMessage = msg
+
+    def __str__(self):
+        return '\n\t' + self.fullMessage
+
+    def warn(self, stacklevel=3):
+        warnings.warn(self, stacklevel=stacklevel)
+
+
+def AZ(s=None):
+    """Return the letters of ``s`` in uppercase. In case more than
+    one string is passed, each of them will be processed and a list
+    of upper case strings will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import AZ
+    >>> AZ('Hello, world!')
+    'HELLOWORLD'
+    >>> AZ('Hello, world!'.split())
+    ['HELLO', 'WORLD']
+
+    See Also
+    ========
+
+    check_and_join
+
+    """
+    if not s:
+        return uppercase
+    t = isinstance(s, str)
+    if t:
+        s = [s]
+    rv = [check_and_join(i.upper().split(), uppercase, filter=True)
+        for i in s]
+    if t:
+        return rv[0]
+    return rv
+
+bifid5 = AZ().replace('J', '')
+bifid6 = AZ() + '0123456789'
+bifid10 = printable
+
+
+def padded_key(key, symbols):
+    """Return a string of the distinct characters of ``symbols`` with
+    those of ``key`` appearing first. A ValueError is raised if
+    a) there are duplicate characters in ``symbols`` or
+    b) there are characters in ``key`` that are  not in ``symbols``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import padded_key
+    >>> padded_key('PUPPY', 'OPQRSTUVWXY')
+    'PUYOQRSTVWX'
+    >>> padded_key('RSA', 'ARTIST')
+    Traceback (most recent call last):
+    ...
+    ValueError: duplicate characters in symbols: T
+
+    """
+    syms = list(uniq(symbols))
+    if len(syms) != len(symbols):
+        extra = ''.join(sorted({
+            i for i in symbols if symbols.count(i) > 1}))
+        raise ValueError('duplicate characters in symbols: %s' % extra)
+    extra = set(key) - set(syms)
+    if extra:
+        raise ValueError(
+            'characters in key but not symbols: %s' % ''.join(
+            sorted(extra)))
+    key0 = ''.join(list(uniq(key)))
+    # remove from syms characters in key0
+    return key0 + translate(''.join(syms), None, key0)
+
+
+def check_and_join(phrase, symbols=None, filter=None):
+    """
+    Joins characters of ``phrase`` and if ``symbols`` is given, raises
+    an error if any character in ``phrase`` is not in ``symbols``.
+
+    Parameters
+    ==========
+
+    phrase
+        String or list of strings to be returned as a string.
+
+    symbols
+        Iterable of characters allowed in ``phrase``.
+
+        If ``symbols`` is ``None``, no checking is performed.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import check_and_join
+    >>> check_and_join('a phrase')
+    'a phrase'
+    >>> check_and_join('a phrase'.upper().split())
+    'APHRASE'
+    >>> check_and_join('a phrase!'.upper().split(), 'ARE', filter=True)
+    'ARAE'
+    >>> check_and_join('a phrase!'.upper().split(), 'ARE')
+    Traceback (most recent call last):
+    ...
+    ValueError: characters in phrase but not symbols: "!HPS"
+
+    """
+    rv = ''.join(''.join(phrase))
+    if symbols is not None:
+        symbols = check_and_join(symbols)
+        missing = ''.join(sorted(set(rv) - set(symbols)))
+        if missing:
+            if not filter:
+                raise ValueError(
+                    'characters in phrase but not symbols: "%s"' % missing)
+            rv = translate(rv, None, missing)
+    return rv
+
+
+def _prep(msg, key, alp, default=None):
+    if not alp:
+        if not default:
+            alp = AZ()
+            msg = AZ(msg)
+            key = AZ(key)
+        else:
+            alp = default
+    else:
+        alp = ''.join(alp)
+    key = check_and_join(key, alp, filter=True)
+    msg = check_and_join(msg, alp, filter=True)
+    return msg, key, alp
+
+
+def cycle_list(k, n):
+    """
+    Returns the elements of the list ``range(n)`` shifted to the
+    left by ``k`` (so the list starts with ``k`` (mod ``n``)).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import cycle_list
+    >>> cycle_list(3, 10)
+    [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]
+
+    """
+    k = k % n
+    return list(range(k, n)) + list(range(k))
+
+
+######## shift cipher examples ############
+
+
+def encipher_shift(msg, key, symbols=None):
+    """
+    Performs shift cipher encryption on plaintext msg, and returns the
+    ciphertext.
+
+    Parameters
+    ==========
+
+    key : int
+        The secret key.
+
+    msg : str
+        Plaintext of upper-case letters.
+
+    Returns
+    =======
+
+    str
+        Ciphertext of upper-case letters.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_shift, decipher_shift
+    >>> msg = "GONAVYBEATARMY"
+    >>> ct = encipher_shift(msg, 1); ct
+    'HPOBWZCFBUBSNZ'
+
+    To decipher the shifted text, change the sign of the key:
+
+    >>> encipher_shift(ct, -1)
+    'GONAVYBEATARMY'
+
+    There is also a convenience function that does this with the
+    original key:
+
+    >>> decipher_shift(ct, 1)
+    'GONAVYBEATARMY'
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L1`` of
+               corresponding integers.
+            2. Compute from the list ``L1`` a new list ``L2``, given by
+               adding ``(k mod 26)`` to each element in ``L1``.
+            3. Compute from the list ``L2`` a string ``ct`` of
+               corresponding letters.
+
+    The shift cipher is also called the Caesar cipher, after
+    Julius Caesar, who, according to Suetonius, used it with a
+    shift of three to protect messages of military significance.
+    Caesar's nephew Augustus reportedly used a similar cipher, but
+    with a right shift of 1.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Caesar_cipher
+    .. [2] https://mathworld.wolfram.com/CaesarsMethod.html
+
+    See Also
+    ========
+
+    decipher_shift
+
+    """
+    msg, _, A = _prep(msg, '', symbols)
+    shift = len(A) - key % len(A)
+    key = A[shift:] + A[:shift]
+    return translate(msg, key, A)
+
+
+def decipher_shift(msg, key, symbols=None):
+    """
+    Return the text by shifting the characters of ``msg`` to the
+    left by the amount given by ``key``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_shift, decipher_shift
+    >>> msg = "GONAVYBEATARMY"
+    >>> ct = encipher_shift(msg, 1); ct
+    'HPOBWZCFBUBSNZ'
+
+    To decipher the shifted text, change the sign of the key:
+
+    >>> encipher_shift(ct, -1)
+    'GONAVYBEATARMY'
+
+    Or use this function with the original key:
+
+    >>> decipher_shift(ct, 1)
+    'GONAVYBEATARMY'
+
+    """
+    return encipher_shift(msg, -key, symbols)
+
+def encipher_rot13(msg, symbols=None):
+    """
+    Performs the ROT13 encryption on a given plaintext ``msg``.
+
+    Explanation
+    ===========
+
+    ROT13 is a substitution cipher which substitutes each letter
+    in the plaintext message for the letter furthest away from it
+    in the English alphabet.
+
+    Equivalently, it is just a Caeser (shift) cipher with a shift
+    key of 13 (midway point of the alphabet).
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/ROT13
+
+    See Also
+    ========
+
+    decipher_rot13
+    encipher_shift
+
+    """
+    return encipher_shift(msg, 13, symbols)
+
+def decipher_rot13(msg, symbols=None):
+    """
+    Performs the ROT13 decryption on a given plaintext ``msg``.
+
+    Explanation
+    ============
+
+    ``decipher_rot13`` is equivalent to ``encipher_rot13`` as both
+    ``decipher_shift`` with a key of 13 and ``encipher_shift`` key with a
+    key of 13 will return the same results. Nonetheless,
+    ``decipher_rot13`` has nonetheless been explicitly defined here for
+    consistency.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13
+    >>> msg = 'GONAVYBEATARMY'
+    >>> ciphertext = encipher_rot13(msg);ciphertext
+    'TBANILORNGNEZL'
+    >>> decipher_rot13(ciphertext)
+    'GONAVYBEATARMY'
+    >>> encipher_rot13(msg) == decipher_rot13(msg)
+    True
+    >>> msg == decipher_rot13(ciphertext)
+    True
+
+    """
+    return decipher_shift(msg, 13, symbols)
+
+######## affine cipher examples ############
+
+
+def encipher_affine(msg, key, symbols=None, _inverse=False):
+    r"""
+    Performs the affine cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Explanation
+    ===========
+
+    Encryption is based on the map `x \rightarrow ax+b` (mod `N`)
+    where ``N`` is the number of characters in the alphabet.
+    Decryption is based on the map `x \rightarrow cx+d` (mod `N`),
+    where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`).
+    In particular, for the map to be invertible, we need
+    `\mathrm{gcd}(a, N) = 1` and an error will be raised if this is
+    not true.
+
+    Parameters
+    ==========
+
+    msg : str
+        Characters that appear in ``symbols``.
+
+    a, b : int, int
+        A pair integers, with ``gcd(a, N) = 1`` (the secret key).
+
+    symbols
+        String of characters (default = uppercase letters).
+
+        When no symbols are given, ``msg`` is converted to upper case
+        letters and all other characters are ignored.
+
+    Returns
+    =======
+
+    ct
+        String of characters (the ciphertext message)
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L1`` of
+               corresponding integers.
+            2. Compute from the list ``L1`` a new list ``L2``, given by
+               replacing ``x`` by ``a*x + b (mod N)``, for each element
+               ``x`` in ``L1``.
+            3. Compute from the list ``L2`` a string ``ct`` of
+               corresponding letters.
+
+    This is a straightforward generalization of the shift cipher with
+    the added complexity of requiring 2 characters to be deciphered in
+    order to recover the key.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Affine_cipher
+
+    See Also
+    ========
+
+    decipher_affine
+
+    """
+    msg, _, A = _prep(msg, '', symbols)
+    N = len(A)
+    a, b = key
+    assert gcd(a, N) == 1
+    if _inverse:
+        c = invert(a, N)
+        d = -b*c
+        a, b = c, d
+    B = ''.join([A[(a*i + b) % N] for i in range(N)])
+    return translate(msg, A, B)
+
+
+def decipher_affine(msg, key, symbols=None):
+    r"""
+    Return the deciphered text that was made from the mapping,
+    `x \rightarrow ax+b` (mod `N`), where ``N`` is the
+    number of characters in the alphabet. Deciphering is done by
+    reciphering with a new key: `x \rightarrow cx+d` (mod `N`),
+    where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_affine, decipher_affine
+    >>> msg = "GO NAVY BEAT ARMY"
+    >>> key = (3, 1)
+    >>> encipher_affine(msg, key)
+    'TROBMVENBGBALV'
+    >>> decipher_affine(_, key)
+    'GONAVYBEATARMY'
+
+    See Also
+    ========
+
+    encipher_affine
+
+    """
+    return encipher_affine(msg, key, symbols, _inverse=True)
+
+
+def encipher_atbash(msg, symbols=None):
+    r"""
+    Enciphers a given ``msg`` into its Atbash ciphertext and returns it.
+
+    Explanation
+    ===========
+
+    Atbash is a substitution cipher originally used to encrypt the Hebrew
+    alphabet. Atbash works on the principle of mapping each alphabet to its
+    reverse / counterpart (i.e. a would map to z, b to y etc.)
+
+    Atbash is functionally equivalent to the affine cipher with ``a = 25``
+    and ``b = 25``
+
+    See Also
+    ========
+
+    decipher_atbash
+
+    """
+    return encipher_affine(msg, (25, 25), symbols)
+
+
+def decipher_atbash(msg, symbols=None):
+    r"""
+    Deciphers a given ``msg`` using Atbash cipher and returns it.
+
+    Explanation
+    ===========
+
+    ``decipher_atbash`` is functionally equivalent to ``encipher_atbash``.
+    However, it has still been added as a separate function to maintain
+    consistency.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash
+    >>> msg = 'GONAVYBEATARMY'
+    >>> encipher_atbash(msg)
+    'TLMZEBYVZGZINB'
+    >>> decipher_atbash(msg)
+    'TLMZEBYVZGZINB'
+    >>> encipher_atbash(msg) == decipher_atbash(msg)
+    True
+    >>> msg == encipher_atbash(encipher_atbash(msg))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Atbash
+
+    See Also
+    ========
+
+    encipher_atbash
+
+    """
+    return decipher_affine(msg, (25, 25), symbols)
+
+#################### substitution cipher ###########################
+
+
+def encipher_substitution(msg, old, new=None):
+    r"""
+    Returns the ciphertext obtained by replacing each character that
+    appears in ``old`` with the corresponding character in ``new``.
+    If ``old`` is a mapping, then new is ignored and the replacements
+    defined by ``old`` are used.
+
+    Explanation
+    ===========
+
+    This is a more general than the affine cipher in that the key can
+    only be recovered by determining the mapping for each symbol.
+    Though in practice, once a few symbols are recognized the mappings
+    for other characters can be quickly guessed.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_substitution, AZ
+    >>> old = 'OEYAG'
+    >>> new = '034^6'
+    >>> msg = AZ("go navy! beat army!")
+    >>> ct = encipher_substitution(msg, old, new); ct
+    '60N^V4B3^T^RM4'
+
+    To decrypt a substitution, reverse the last two arguments:
+
+    >>> encipher_substitution(ct, new, old)
+    'GONAVYBEATARMY'
+
+    In the special case where ``old`` and ``new`` are a permutation of
+    order 2 (representing a transposition of characters) their order
+    is immaterial:
+
+    >>> old = 'NAVY'
+    >>> new = 'ANYV'
+    >>> encipher = lambda x: encipher_substitution(x, old, new)
+    >>> encipher('NAVY')
+    'ANYV'
+    >>> encipher(_)
+    'NAVY'
+
+    The substitution cipher, in general, is a method
+    whereby "units" (not necessarily single characters) of plaintext
+    are replaced with ciphertext according to a regular system.
+
+    >>> ords = dict(zip('abc', ['\\%i' % ord(i) for i in 'abc']))
+    >>> print(encipher_substitution('abc', ords))
+    \97\98\99
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Substitution_cipher
+
+    """
+    return translate(msg, old, new)
+
+
+######################################################################
+#################### Vigenere cipher examples ########################
+######################################################################
+
+def encipher_vigenere(msg, key, symbols=None):
+    """
+    Performs the Vigenere cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_vigenere, AZ
+    >>> key = "encrypt"
+    >>> msg = "meet me on monday"
+    >>> encipher_vigenere(msg, key)
+    'QRGKKTHRZQEBPR'
+
+    Section 1 of the Kryptos sculpture at the CIA headquarters
+    uses this cipher and also changes the order of the
+    alphabet [2]_. Here is the first line of that section of
+    the sculpture:
+
+    >>> from sympy.crypto.crypto import decipher_vigenere, padded_key
+    >>> alp = padded_key('KRYPTOS', AZ())
+    >>> key = 'PALIMPSEST'
+    >>> msg = 'EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJ'
+    >>> decipher_vigenere(msg, key, alp)
+    'BETWEENSUBTLESHADINGANDTHEABSENC'
+
+    Explanation
+    ===========
+
+    The Vigenere cipher is named after Blaise de Vigenere, a sixteenth
+    century diplomat and cryptographer, by a historical accident.
+    Vigenere actually invented a different and more complicated cipher.
+    The so-called *Vigenere cipher* was actually invented
+    by Giovan Batista Belaso in 1553.
+
+    This cipher was used in the 1800's, for example, during the American
+    Civil War. The Confederacy used a brass cipher disk to implement the
+    Vigenere cipher (now on display in the NSA Museum in Fort
+    Meade) [1]_.
+
+    The Vigenere cipher is a generalization of the shift cipher.
+    Whereas the shift cipher shifts each letter by the same amount
+    (that amount being the key of the shift cipher) the Vigenere
+    cipher shifts a letter by an amount determined by the key (which is
+    a word or phrase known only to the sender and receiver).
+
+    For example, if the key was a single letter, such as "C", then the
+    so-called Vigenere cipher is actually a shift cipher with a
+    shift of `2` (since "C" is the 2nd letter of the alphabet, if
+    you start counting at `0`). If the key was a word with two
+    letters, such as "CA", then the so-called Vigenere cipher will
+    shift letters in even positions by `2` and letters in odd positions
+    are left alone (shifted by `0`, since "A" is the 0th letter, if
+    you start counting at `0`).
+
+
+    ALGORITHM:
+
+        INPUT:
+
+            ``msg``: string of characters that appear in ``symbols``
+            (the plaintext)
+
+            ``key``: a string of characters that appear in ``symbols``
+            (the secret key)
+
+            ``symbols``: a string of letters defining the alphabet
+
+
+        OUTPUT:
+
+            ``ct``: string of characters (the ciphertext message)
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``key`` a list ``L1`` of
+               corresponding integers. Let ``n1 = len(L1)``.
+            2. Compute from the string ``msg`` a list ``L2`` of
+               corresponding integers. Let ``n2 = len(L2)``.
+            3. Break ``L2`` up sequentially into sublists of size
+               ``n1``; the last sublist may be smaller than ``n1``
+            4. For each of these sublists ``L`` of ``L2``, compute a
+               new list ``C`` given by ``C[i] = L[i] + L1[i] (mod N)``
+               to the ``i``-th element in the sublist, for each ``i``.
+            5. Assemble these lists ``C`` by concatenation into a new
+               list of length ``n2``.
+            6. Compute from the new list a string ``ct`` of
+               corresponding letters.
+
+    Once it is known that the key is, say, `n` characters long,
+    frequency analysis can be applied to every `n`-th letter of
+    the ciphertext to determine the plaintext. This method is
+    called *Kasiski examination* (although it was first discovered
+    by Babbage). If they key is as long as the message and is
+    comprised of randomly selected characters -- a one-time pad -- the
+    message is theoretically unbreakable.
+
+    The cipher Vigenere actually discovered is an "auto-key" cipher
+    described as follows.
+
+    ALGORITHM:
+
+        INPUT:
+
+          ``key``: a string of letters (the secret key)
+
+          ``msg``: string of letters (the plaintext message)
+
+        OUTPUT:
+
+          ``ct``: string of upper-case letters (the ciphertext message)
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L2`` of
+               corresponding integers. Let ``n2 = len(L2)``.
+            2. Let ``n1`` be the length of the key. Append to the
+               string ``key`` the first ``n2 - n1`` characters of
+               the plaintext message. Compute from this string (also of
+               length ``n2``) a list ``L1`` of integers corresponding
+               to the letter numbers in the first step.
+            3. Compute a new list ``C`` given by
+               ``C[i] = L1[i] + L2[i] (mod N)``.
+            4. Compute from the new list a string ``ct`` of letters
+               corresponding to the new integers.
+
+    To decipher the auto-key ciphertext, the key is used to decipher
+    the first ``n1`` characters and then those characters become the
+    key to  decipher the next ``n1`` characters, etc...:
+
+    >>> m = AZ('go navy, beat army! yes you can'); m
+    'GONAVYBEATARMYYESYOUCAN'
+    >>> key = AZ('gold bug'); n1 = len(key); n2 = len(m)
+    >>> auto_key = key + m[:n2 - n1]; auto_key
+    'GOLDBUGGONAVYBEATARMYYE'
+    >>> ct = encipher_vigenere(m, auto_key); ct
+    'MCYDWSHKOGAMKZCELYFGAYR'
+    >>> n1 = len(key)
+    >>> pt = []
+    >>> while ct:
+    ...     part, ct = ct[:n1], ct[n1:]
+    ...     pt.append(decipher_vigenere(part, key))
+    ...     key = pt[-1]
+    ...
+    >>> ''.join(pt) == m
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Vigenere_cipher
+    .. [2] https://web.archive.org/web/20071116100808/https://filebox.vt.edu/users/batman/kryptos.html
+       (short URL: https://goo.gl/ijr22d)
+
+    """
+    msg, key, A = _prep(msg, key, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    key = [map[c] for c in key]
+    N = len(map)
+    k = len(key)
+    rv = []
+    for i, m in enumerate(msg):
+        rv.append(A[(map[m] + key[i % k]) % N])
+    rv = ''.join(rv)
+    return rv
+
+
+def decipher_vigenere(msg, key, symbols=None):
+    """
+    Decode using the Vigenere cipher.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_vigenere
+    >>> key = "encrypt"
+    >>> ct = "QRGK kt HRZQE BPR"
+    >>> decipher_vigenere(ct, key)
+    'MEETMEONMONDAY'
+
+    """
+    msg, key, A = _prep(msg, key, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    N = len(A)   # normally, 26
+    K = [map[c] for c in key]
+    n = len(K)
+    C = [map[c] for c in msg]
+    rv = ''.join([A[(-K[i % n] + c) % N] for i, c in enumerate(C)])
+    return rv
+
+
+#################### Hill cipher  ########################
+
+
+def encipher_hill(msg, key, symbols=None, pad="Q"):
+    r"""
+    Return the Hill cipher encryption of ``msg``.
+
+    Explanation
+    ===========
+
+    The Hill cipher [1]_, invented by Lester S. Hill in the 1920's [2]_,
+    was the first polygraphic cipher in which it was practical
+    (though barely) to operate on more than three symbols at once.
+    The following discussion assumes an elementary knowledge of
+    matrices.
+
+    First, each letter is first encoded as a number starting with 0.
+    Suppose your message `msg` consists of `n` capital letters, with no
+    spaces. This may be regarded an `n`-tuple M of elements of
+    `Z_{26}` (if the letters are those of the English alphabet). A key
+    in the Hill cipher is a `k x k` matrix `K`, all of whose entries
+    are in `Z_{26}`, such that the matrix `K` is invertible (i.e., the
+    linear transformation `K: Z_{N}^k \rightarrow Z_{N}^k`
+    is one-to-one).
+
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext message of `n` upper-case letters.
+
+    key
+        A `k \times k` invertible matrix `K`, all of whose entries are
+        in `Z_{26}` (or whatever number of symbols are being used).
+
+    pad
+        Character (default "Q") to use to make length of text be a
+        multiple of ``k``.
+
+    Returns
+    =======
+
+    ct
+        Ciphertext of upper-case letters.
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L`` of
+               corresponding integers. Let ``n = len(L)``.
+            2. Break the list ``L`` up into ``t = ceiling(n/k)``
+               sublists ``L_1``, ..., ``L_t`` of size ``k`` (with
+               the last list "padded" to ensure its size is
+               ``k``).
+            3. Compute new list ``C_1``, ..., ``C_t`` given by
+               ``C[i] = K*L_i`` (arithmetic is done mod N), for each
+               ``i``.
+            4. Concatenate these into a list ``C = C_1 + ... + C_t``.
+            5. Compute from ``C`` a string ``ct`` of corresponding
+               letters. This has length ``k*t``.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hill_cipher
+    .. [2] Lester S. Hill, Cryptography in an Algebraic Alphabet,
+       The American Mathematical Monthly Vol.36, June-July 1929,
+       pp.306-312.
+
+    See Also
+    ========
+
+    decipher_hill
+
+    """
+    assert key.is_square
+    assert len(pad) == 1
+    msg, pad, A = _prep(msg, pad, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    P = [map[c] for c in msg]
+    N = len(A)
+    k = key.cols
+    n = len(P)
+    m, r = divmod(n, k)
+    if r:
+        P = P + [map[pad]]*(k - r)
+        m += 1
+    rv = ''.join([A[c % N] for j in range(m) for c in
+        list(key*Matrix(k, 1, [P[i]
+        for i in range(k*j, k*(j + 1))]))])
+    return rv
+
+
+def decipher_hill(msg, key, symbols=None):
+    """
+    Deciphering is the same as enciphering but using the inverse of the
+    key matrix.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_hill, decipher_hill
+    >>> from sympy import Matrix
+
+    >>> key = Matrix([[1, 2], [3, 5]])
+    >>> encipher_hill("meet me on monday", key)
+    'UEQDUEODOCTCWQ'
+    >>> decipher_hill(_, key)
+    'MEETMEONMONDAY'
+
+    When the length of the plaintext (stripped of invalid characters)
+    is not a multiple of the key dimension, extra characters will
+    appear at the end of the enciphered and deciphered text. In order to
+    decipher the text, those characters must be included in the text to
+    be deciphered. In the following, the key has a dimension of 4 but
+    the text is 2 short of being a multiple of 4 so two characters will
+    be added.
+
+    >>> key = Matrix([[1, 1, 1, 2], [0, 1, 1, 0],
+    ...               [2, 2, 3, 4], [1, 1, 0, 1]])
+    >>> msg = "ST"
+    >>> encipher_hill(msg, key)
+    'HJEB'
+    >>> decipher_hill(_, key)
+    'STQQ'
+    >>> encipher_hill(msg, key, pad="Z")
+    'ISPK'
+    >>> decipher_hill(_, key)
+    'STZZ'
+
+    If the last two characters of the ciphertext were ignored in
+    either case, the wrong plaintext would be recovered:
+
+    >>> decipher_hill("HD", key)
+    'ORMV'
+    >>> decipher_hill("IS", key)
+    'UIKY'
+
+    See Also
+    ========
+
+    encipher_hill
+
+    """
+    assert key.is_square
+    msg, _, A = _prep(msg, '', symbols)
+    map = {c: i for i, c in enumerate(A)}
+    C = [map[c] for c in msg]
+    N = len(A)
+    k = key.cols
+    n = len(C)
+    m, r = divmod(n, k)
+    if r:
+        C = C + [0]*(k - r)
+        m += 1
+    key_inv = key.inv_mod(N)
+    rv = ''.join([A[p % N] for j in range(m) for p in
+        list(key_inv*Matrix(
+        k, 1, [C[i] for i in range(k*j, k*(j + 1))]))])
+    return rv
+
+
+#################### Bifid cipher  ########################
+
+
+def encipher_bifid(msg, key, symbols=None):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    This is the version of the Bifid cipher that uses an `n \times n`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext string.
+
+    key
+        Short string for key.
+
+        Duplicate characters are ignored and then it is padded with the
+        characters in ``symbols`` that were not in the short key.
+
+    symbols
+        `n \times n` characters defining the alphabet.
+
+        (default is string.printable)
+
+    Returns
+    =======
+
+    ciphertext
+        Ciphertext using Bifid5 cipher without spaces.
+
+    See Also
+    ========
+
+    decipher_bifid, encipher_bifid5, encipher_bifid6
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bifid_cipher
+
+    """
+    msg, key, A = _prep(msg, key, symbols, bifid10)
+    long_key = ''.join(uniq(key)) or A
+
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    N = int(n)
+    if len(long_key) < N**2:
+      long_key = list(long_key) + [x for x in A if x not in long_key]
+
+    # the fractionalization
+    row_col = {ch: divmod(i, N) for i, ch in enumerate(long_key)}
+    r, c = zip(*[row_col[x] for x in msg])
+    rc = r + c
+    ch = {i: ch for ch, i in row_col.items()}
+    rv = ''.join(ch[i] for i in zip(rc[::2], rc[1::2]))
+    return rv
+
+
+def decipher_bifid(msg, key, symbols=None):
+    r"""
+    Performs the Bifid cipher decryption on ciphertext ``msg``, and
+    returns the plaintext.
+
+    This is the version of the Bifid cipher that uses the `n \times n`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string.
+
+    key
+        Short string for key.
+
+        Duplicate characters are ignored and then it is padded with the
+        characters in symbols that were not in the short key.
+
+    symbols
+        `n \times n` characters defining the alphabet.
+
+        (default=string.printable, a `10 \times 10` matrix)
+
+    Returns
+    =======
+
+    deciphered
+        Deciphered text.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_bifid, decipher_bifid, AZ)
+
+    Do an encryption using the bifid5 alphabet:
+
+    >>> alp = AZ().replace('J', '')
+    >>> ct = AZ("meet me on monday!")
+    >>> key = AZ("gold bug")
+    >>> encipher_bifid(ct, key, alp)
+    'IEILHHFSTSFQYE'
+
+    When entering the text or ciphertext, spaces are ignored so it
+    can be formatted as desired. Re-entering the ciphertext from the
+    preceding, putting 4 characters per line and padding with an extra
+    J, does not cause problems for the deciphering:
+
+    >>> decipher_bifid('''
+    ... IEILH
+    ... HFSTS
+    ... FQYEJ''', key, alp)
+    'MEETMEONMONDAY'
+
+    When no alphabet is given, all 100 printable characters will be
+    used:
+
+    >>> key = ''
+    >>> encipher_bifid('hello world!', key)
+    'bmtwmg-bIo*w'
+    >>> decipher_bifid(_, key)
+    'hello world!'
+
+    If the key is changed, a different encryption is obtained:
+
+    >>> key = 'gold bug'
+    >>> encipher_bifid('hello world!', 'gold_bug')
+    'hg2sfuei7t}w'
+
+    And if the key used to decrypt the message is not exact, the
+    original text will not be perfectly obtained:
+
+    >>> decipher_bifid(_, 'gold pug')
+    'heldo~wor6d!'
+
+    """
+    msg, _, A = _prep(msg, '', symbols, bifid10)
+    long_key = ''.join(uniq(key)) or A
+
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    N = int(n)
+    if len(long_key) < N**2:
+        long_key = list(long_key) + [x for x in A if x not in long_key]
+
+    # the reverse fractionalization
+    row_col = {
+        ch: divmod(i, N) for i, ch in enumerate(long_key)}
+    rc = [i for c in msg for i in row_col[c]]
+    n = len(msg)
+    rc = zip(*(rc[:n], rc[n:]))
+    ch = {i: ch for ch, i in row_col.items()}
+    rv = ''.join(ch[i] for i in rc)
+    return rv
+
+
+def bifid_square(key):
+    """Return characters of ``key`` arranged in a square.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...    bifid_square, AZ, padded_key, bifid5)
+    >>> bifid_square(AZ().replace('J', ''))
+    Matrix([
+    [A, B, C, D, E],
+    [F, G, H, I, K],
+    [L, M, N, O, P],
+    [Q, R, S, T, U],
+    [V, W, X, Y, Z]])
+
+    >>> bifid_square(padded_key(AZ('gold bug!'), bifid5))
+    Matrix([
+    [G, O, L, D, B],
+    [U, A, C, E, F],
+    [H, I, K, M, N],
+    [P, Q, R, S, T],
+    [V, W, X, Y, Z]])
+
+    See Also
+    ========
+
+    padded_key
+
+    """
+    A = ''.join(uniq(''.join(key)))
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    n = int(n)
+    f = lambda i, j: Symbol(A[n*i + j])
+    rv = Matrix(n, n, f)
+    return rv
+
+
+def encipher_bifid5(msg, key):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Explanation
+    ===========
+
+    This is the version of the Bifid cipher that uses the `5 \times 5`
+    Polybius square. The letter "J" is ignored so it must be replaced
+    with something else (traditionally an "I") before encryption.
+
+    ALGORITHM: (5x5 case)
+
+        STEPS:
+            0. Create the `5 \times 5` Polybius square ``S`` associated
+               to ``key`` as follows:
+
+                a) moving from left-to-right, top-to-bottom,
+                   place the letters of the key into a `5 \times 5`
+                   matrix,
+                b) if the key has less than 25 letters, add the
+                   letters of the alphabet not in the key until the
+                   `5 \times 5` square is filled.
+
+            1. Create a list ``P`` of pairs of numbers which are the
+               coordinates in the Polybius square of the letters in
+               ``msg``.
+            2. Let ``L1`` be the list of all first coordinates of ``P``
+               (length of ``L1 = n``), let ``L2`` be the list of all
+               second coordinates of ``P`` (so the length of ``L2``
+               is also ``n``).
+            3. Let ``L`` be the concatenation of ``L1`` and ``L2``
+               (length ``L = 2*n``), except that consecutive numbers
+               are paired ``(L[2*i], L[2*i + 1])``. You can regard
+               ``L`` as a list of pairs of length ``n``.
+            4. Let ``C`` be the list of all letters which are of the
+               form ``S[i, j]``, for all ``(i, j)`` in ``L``. As a
+               string, this is the ciphertext of ``msg``.
+
+    Parameters
+    ==========
+
+    msg : str
+        Plaintext string.
+
+        Converted to upper case and filtered of anything but all letters
+        except J.
+
+    key
+        Short string for key; non-alphabetic letters, J and duplicated
+        characters are ignored and then, if the length is less than 25
+        characters, it is padded with other letters of the alphabet
+        (in alphabetical order).
+
+    Returns
+    =======
+
+    ct
+        Ciphertext (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_bifid5, decipher_bifid5)
+
+    "J" will be omitted unless it is replaced with something else:
+
+    >>> round_trip = lambda m, k: \
+    ...     decipher_bifid5(encipher_bifid5(m, k), k)
+    >>> key = 'a'
+    >>> msg = "JOSIE"
+    >>> round_trip(msg, key)
+    'OSIE'
+    >>> round_trip(msg.replace("J", "I"), key)
+    'IOSIE'
+    >>> j = "QIQ"
+    >>> round_trip(msg.replace("J", j), key).replace(j, "J")
+    'JOSIE'
+
+
+    Notes
+    =====
+
+    The Bifid cipher was invented around 1901 by Felix Delastelle.
+    It is a *fractional substitution* cipher, where letters are
+    replaced by pairs of symbols from a smaller alphabet. The
+    cipher uses a `5 \times 5` square filled with some ordering of the
+    alphabet, except that "J" is replaced with "I" (this is a so-called
+    Polybius square; there is a `6 \times 6` analog if you add back in
+    "J" and also append onto the usual 26 letter alphabet, the digits
+    0, 1, ..., 9).
+    According to Helen Gaines' book *Cryptanalysis*, this type of cipher
+    was used in the field by the German Army during World War I.
+
+    See Also
+    ========
+
+    decipher_bifid5, encipher_bifid
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5)
+    key = padded_key(key, bifid5)
+    return encipher_bifid(msg, '', key)
+
+
+def decipher_bifid5(msg, key):
+    r"""
+    Return the Bifid cipher decryption of ``msg``.
+
+    Explanation
+    ===========
+
+    This is the version of the Bifid cipher that uses the `5 \times 5`
+    Polybius square; the letter "J" is ignored unless a ``key`` of
+    length 25 is used.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string.
+
+    key
+        Short string for key; duplicated characters are ignored and if
+        the length is less then 25 characters, it will be padded with
+        other letters from the alphabet omitting "J".
+        Non-alphabetic characters are ignored.
+
+    Returns
+    =======
+
+    plaintext
+        Plaintext from Bifid5 cipher (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_bifid5, decipher_bifid5
+    >>> key = "gold bug"
+    >>> encipher_bifid5('meet me on friday', key)
+    'IEILEHFSTSFXEE'
+    >>> encipher_bifid5('meet me on monday', key)
+    'IEILHHFSTSFQYE'
+    >>> decipher_bifid5(_, key)
+    'MEETMEONMONDAY'
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5)
+    key = padded_key(key, bifid5)
+    return decipher_bifid(msg, '', key)
+
+
+def bifid5_square(key=None):
+    r"""
+    5x5 Polybius square.
+
+    Produce the Polybius square for the `5 \times 5` Bifid cipher.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import bifid5_square
+    >>> bifid5_square("gold bug")
+    Matrix([
+    [G, O, L, D, B],
+    [U, A, C, E, F],
+    [H, I, K, M, N],
+    [P, Q, R, S, T],
+    [V, W, X, Y, Z]])
+
+    """
+    if not key:
+        key = bifid5
+    else:
+        _, key, _ = _prep('', key.upper(), None, bifid5)
+        key = padded_key(key, bifid5)
+    return bifid_square(key)
+
+
+def encipher_bifid6(msg, key):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    This is the version of the Bifid cipher that uses the `6 \times 6`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext string (digits okay).
+
+    key
+        Short string for key (digits okay).
+
+        If ``key`` is less than 36 characters long, the square will be
+        filled with letters A through Z and digits 0 through 9.
+
+    Returns
+    =======
+
+    ciphertext
+        Ciphertext from Bifid cipher (all caps, no spaces).
+
+    See Also
+    ========
+
+    decipher_bifid6, encipher_bifid
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6)
+    key = padded_key(key, bifid6)
+    return encipher_bifid(msg, '', key)
+
+
+def decipher_bifid6(msg, key):
+    r"""
+    Performs the Bifid cipher decryption on ciphertext ``msg``, and
+    returns the plaintext.
+
+    This is the version of the Bifid cipher that uses the `6 \times 6`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string (digits okay); converted to upper case
+
+    key
+        Short string for key (digits okay).
+
+        If ``key`` is less than 36 characters long, the square will be
+        filled with letters A through Z and digits 0 through 9.
+        All letters are converted to uppercase.
+
+    Returns
+    =======
+
+    plaintext
+        Plaintext from Bifid cipher (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_bifid6, decipher_bifid6
+    >>> key = "gold bug"
+    >>> encipher_bifid6('meet me on monday at 8am', key)
+    'KFKLJJHF5MMMKTFRGPL'
+    >>> decipher_bifid6(_, key)
+    'MEETMEONMONDAYAT8AM'
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6)
+    key = padded_key(key, bifid6)
+    return decipher_bifid(msg, '', key)
+
+
+def bifid6_square(key=None):
+    r"""
+    6x6 Polybius square.
+
+    Produces the Polybius square for the `6 \times 6` Bifid cipher.
+    Assumes alphabet of symbols is "A", ..., "Z", "0", ..., "9".
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import bifid6_square
+    >>> key = "gold bug"
+    >>> bifid6_square(key)
+    Matrix([
+    [G, O, L, D, B, U],
+    [A, C, E, F, H, I],
+    [J, K, M, N, P, Q],
+    [R, S, T, V, W, X],
+    [Y, Z, 0, 1, 2, 3],
+    [4, 5, 6, 7, 8, 9]])
+
+    """
+    if not key:
+        key = bifid6
+    else:
+        _, key, _ = _prep('', key.upper(), None, bifid6)
+        key = padded_key(key, bifid6)
+    return bifid_square(key)
+
+
+#################### RSA  #############################
+
+def _decipher_rsa_crt(i, d, factors):
+    """Decipher RSA using chinese remainder theorem from the information
+    of the relatively-prime factors of the modulus.
+
+    Parameters
+    ==========
+
+    i : integer
+        Ciphertext
+
+    d : integer
+        The exponent component.
+
+    factors : list of relatively-prime integers
+        The integers given must be coprime and the product must equal
+        the modulus component of the original RSA key.
+
+    Examples
+    ========
+
+    How to decrypt RSA with CRT:
+
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+    >>> primes = [61, 53]
+    >>> e = 17
+    >>> args = primes + [e]
+    >>> puk = rsa_public_key(*args)
+    >>> prk = rsa_private_key(*args)
+
+    >>> from sympy.crypto.crypto import encipher_rsa, _decipher_rsa_crt
+    >>> msg = 65
+    >>> crt_primes = primes
+    >>> encrypted = encipher_rsa(msg, puk)
+    >>> decrypted = _decipher_rsa_crt(encrypted, prk[1], primes)
+    >>> decrypted
+    65
+    """
+    moduluses = [pow(i, d, p) for p in factors]
+
+    result = crt(factors, moduluses)
+    if not result:
+        raise ValueError("CRT failed")
+    return result[0]
+
+
+def _rsa_key(*args, public=True, private=True, totient='Euler', index=None, multipower=None):
+    r"""A private subroutine to generate RSA key
+
+    Parameters
+    ==========
+
+    public, private : bool, optional
+        Flag to generate either a public key, a private key.
+
+    totient : 'Euler' or 'Carmichael'
+        Different notation used for totient.
+
+    multipower : bool, optional
+        Flag to bypass warning for multipower RSA.
+    """
+
+    if len(args) < 2:
+        return False
+
+    if totient not in ('Euler', 'Carmichael'):
+        raise ValueError(
+            "The argument totient={} should either be " \
+            "'Euler', 'Carmichalel'." \
+            .format(totient))
+
+    if totient == 'Euler':
+        _totient = _euler
+    else:
+        _totient = _carmichael
+
+    if index is not None:
+        index = as_int(index)
+        if totient != 'Carmichael':
+            raise ValueError(
+                "Setting the 'index' keyword argument requires totient"
+                "notation to be specified as 'Carmichael'.")
+
+    primes, e = args[:-1], args[-1]
+
+    if not all(isprime(p) for p in primes):
+        new_primes = []
+        for i in primes:
+            new_primes.extend(factorint(i, multiple=True))
+        primes = new_primes
+
+    n = reduce(lambda i, j: i*j, primes)
+
+    tally = multiset(primes)
+    if all(v == 1 for v in tally.values()):
+        phi = int(_totient(tally))
+
+    else:
+        if not multipower:
+            NonInvertibleCipherWarning(
+                'Non-distinctive primes found in the factors {}. '
+                'The cipher may not be decryptable for some numbers '
+                'in the complete residue system Z[{}], but the cipher '
+                'can still be valid if you restrict the domain to be '
+                'the reduced residue system Z*[{}]. You can pass '
+                'the flag multipower=True if you want to suppress this '
+                'warning.'
+                .format(primes, n, n)
+                # stacklevel=4 because most users will call a function that
+                # calls this function
+                ).warn(stacklevel=4)
+        phi = int(_totient(tally))
+
+    if gcd(e, phi) == 1:
+        if public and not private:
+            if isinstance(index, int):
+                e = e % phi
+                e += index * phi
+            return n, e
+
+        if private and not public:
+            d = invert(e, phi)
+            if isinstance(index, int):
+                d += index * phi
+            return n, d
+
+    return False
+
+
+def rsa_public_key(*args, **kwargs):
+    r"""Return the RSA *public key* pair, `(n, e)`
+
+    Parameters
+    ==========
+
+    args : naturals
+        If specified as `p, q, e` where `p` and `q` are distinct primes
+        and `e` is a desired public exponent of the RSA, `n = p q` and
+        `e` will be verified against the totient
+        `\phi(n)` (Euler totient) or `\lambda(n)` (Carmichael totient)
+        to be `\gcd(e, \phi(n)) = 1` or `\gcd(e, \lambda(n)) = 1`.
+
+        If specified as `p_1, p_2, \dots, p_n, e` where
+        `p_1, p_2, \dots, p_n` are specified as primes,
+        and `e` is specified as a desired public exponent of the RSA,
+        it will be able to form a multi-prime RSA, which is a more
+        generalized form of the popular 2-prime RSA.
+
+        It can also be possible to form a single-prime RSA by specifying
+        the argument as `p, e`, which can be considered a trivial case
+        of a multiprime RSA.
+
+        Furthermore, it can be possible to form a multi-power RSA by
+        specifying two or more pairs of the primes to be same.
+        However, unlike the two-distinct prime RSA or multi-prime
+        RSA, not every numbers in the complete residue system
+        (`\mathbb{Z}_n`) will be decryptable since the mapping
+        `\mathbb{Z}_{n} \rightarrow \mathbb{Z}_{n}`
+        will not be bijective.
+        (Only except for the trivial case when
+        `e = 1`
+        or more generally,
+
+        .. math::
+            e \in \left \{ 1 + k \lambda(n)
+            \mid k \in \mathbb{Z} \land k \geq 0 \right \}
+
+        when RSA reduces to the identity.)
+        However, the RSA can still be decryptable for the numbers in the
+        reduced residue system (`\mathbb{Z}_n^{\times}`), since the
+        mapping
+        `\mathbb{Z}_{n}^{\times} \rightarrow \mathbb{Z}_{n}^{\times}`
+        can still be bijective.
+
+        If you pass a non-prime integer to the arguments
+        `p_1, p_2, \dots, p_n`, the particular number will be
+        prime-factored and it will become either a multi-prime RSA or a
+        multi-power RSA in its canonical form, depending on whether the
+        product equals its radical or not.
+        `p_1 p_2 \dots p_n = \text{rad}(p_1 p_2 \dots p_n)`
+
+    totient : bool, optional
+        If ``'Euler'``, it uses Euler's totient `\phi(n)` which is
+        :meth:`sympy.functions.combinatorial.numbers.totient` in SymPy.
+
+        If ``'Carmichael'``, it uses Carmichael's totient `\lambda(n)`
+        which is :meth:`sympy.functions.combinatorial.numbers.reduced_totient` in SymPy.
+
+        Unlike private key generation, this is a trivial keyword for
+        public key generation because
+        `\gcd(e, \phi(n)) = 1 \iff \gcd(e, \lambda(n)) = 1`.
+
+    index : nonnegative integer, optional
+        Returns an arbitrary solution of a RSA public key at the index
+        specified at `0, 1, 2, \dots`. This parameter needs to be
+        specified along with ``totient='Carmichael'``.
+
+        Similarly to the non-uniquenss of a RSA private key as described
+        in the ``index`` parameter documentation in
+        :meth:`rsa_private_key`, RSA public key is also not unique and
+        there is an infinite number of RSA public exponents which
+        can behave in the same manner.
+
+        From any given RSA public exponent `e`, there are can be an
+        another RSA public exponent `e + k \lambda(n)` where `k` is an
+        integer, `\lambda` is a Carmichael's totient function.
+
+        However, considering only the positive cases, there can be
+        a principal solution of a RSA public exponent `e_0` in
+        `0 < e_0 < \lambda(n)`, and all the other solutions
+        can be canonicalzed in a form of `e_0 + k \lambda(n)`.
+
+        ``index`` specifies the `k` notation to yield any possible value
+        an RSA public key can have.
+
+        An example of computing any arbitrary RSA public key:
+
+        >>> from sympy.crypto.crypto import rsa_public_key
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=0)
+        (3233, 17)
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=1)
+        (3233, 797)
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=2)
+        (3233, 1577)
+
+    multipower : bool, optional
+        Any pair of non-distinct primes found in the RSA specification
+        will restrict the domain of the cryptosystem, as noted in the
+        explanation of the parameter ``args``.
+
+        SymPy RSA key generator may give a warning before dispatching it
+        as a multi-power RSA, however, you can disable the warning if
+        you pass ``True`` to this keyword.
+
+    Returns
+    =======
+
+    (n, e) : int, int
+        `n` is a product of any arbitrary number of primes given as
+        the argument.
+
+        `e` is relatively prime (coprime) to the Euler totient
+        `\phi(n)`.
+
+    False
+        Returned if less than two arguments are given, or `e` is
+        not relatively prime to the modulus.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import rsa_public_key
+
+    A public key of a two-prime RSA:
+
+    >>> p, q, e = 3, 5, 7
+    >>> rsa_public_key(p, q, e)
+    (15, 7)
+    >>> rsa_public_key(p, q, 30)
+    False
+
+    A public key of a multiprime RSA:
+
+    >>> primes = [2, 3, 5, 7, 11, 13]
+    >>> e = 7
+    >>> args = primes + [e]
+    >>> rsa_public_key(*args)
+    (30030, 7)
+
+    Notes
+    =====
+
+    Although the RSA can be generalized over any modulus `n`, using
+    two large primes had became the most popular specification because a
+    product of two large primes is usually the hardest to factor
+    relatively to the digits of `n` can have.
+
+    However, it may need further understanding of the time complexities
+    of each prime-factoring algorithms to verify the claim.
+
+    See Also
+    ========
+
+    rsa_private_key
+    encipher_rsa
+    decipher_rsa
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
+
+    .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf
+
+    .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf
+
+    .. [4] https://www.itiis.org/digital-library/manuscript/1381
+    """
+    return _rsa_key(*args, public=True, private=False, **kwargs)
+
+
+def rsa_private_key(*args, **kwargs):
+    r"""Return the RSA *private key* pair, `(n, d)`
+
+    Parameters
+    ==========
+
+    args : naturals
+        The keyword is identical to the ``args`` in
+        :meth:`rsa_public_key`.
+
+    totient : bool, optional
+        If ``'Euler'``, it uses Euler's totient convention `\phi(n)`
+        which is :meth:`sympy.functions.combinatorial.numbers.totient` in SymPy.
+
+        If ``'Carmichael'``, it uses Carmichael's totient convention
+        `\lambda(n)` which is
+        :meth:`sympy.functions.combinatorial.numbers.reduced_totient` in SymPy.
+
+        There can be some output differences for private key generation
+        as examples below.
+
+        Example using Euler's totient:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Euler')
+        (3233, 2753)
+
+        Example using Carmichael's totient:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael')
+        (3233, 413)
+
+    index : nonnegative integer, optional
+        Returns an arbitrary solution of a RSA private key at the index
+        specified at `0, 1, 2, \dots`. This parameter needs to be
+        specified along with ``totient='Carmichael'``.
+
+        RSA private exponent is a non-unique solution of
+        `e d \mod \lambda(n) = 1` and it is possible in any form of
+        `d + k \lambda(n)`, where `d` is an another
+        already-computed private exponent, and `\lambda` is a
+        Carmichael's totient function, and `k` is any integer.
+
+        However, considering only the positive cases, there can be
+        a principal solution of a RSA private exponent `d_0` in
+        `0 < d_0 < \lambda(n)`, and all the other solutions
+        can be canonicalzed in a form of `d_0 + k \lambda(n)`.
+
+        ``index`` specifies the `k` notation to yield any possible value
+        an RSA private key can have.
+
+        An example of computing any arbitrary RSA private key:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=0)
+        (3233, 413)
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=1)
+        (3233, 1193)
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=2)
+        (3233, 1973)
+
+    multipower : bool, optional
+        The keyword is identical to the ``multipower`` in
+        :meth:`rsa_public_key`.
+
+    Returns
+    =======
+
+    (n, d) : int, int
+        `n` is a product of any arbitrary number of primes given as
+        the argument.
+
+        `d` is the inverse of `e` (mod `\phi(n)`) where `e` is the
+        exponent given, and `\phi` is a Euler totient.
+
+    False
+        Returned if less than two arguments are given, or `e` is
+        not relatively prime to the totient of the modulus.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import rsa_private_key
+
+    A private key of a two-prime RSA:
+
+    >>> p, q, e = 3, 5, 7
+    >>> rsa_private_key(p, q, e)
+    (15, 7)
+    >>> rsa_private_key(p, q, 30)
+    False
+
+    A private key of a multiprime RSA:
+
+    >>> primes = [2, 3, 5, 7, 11, 13]
+    >>> e = 7
+    >>> args = primes + [e]
+    >>> rsa_private_key(*args)
+    (30030, 823)
+
+    See Also
+    ========
+
+    rsa_public_key
+    encipher_rsa
+    decipher_rsa
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
+
+    .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf
+
+    .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf
+
+    .. [4] https://www.itiis.org/digital-library/manuscript/1381
+    """
+    return _rsa_key(*args, public=False, private=True, **kwargs)
+
+
+def _encipher_decipher_rsa(i, key, factors=None):
+    n, d = key
+    if not factors:
+        return pow(i, d, n)
+
+    def _is_coprime_set(l):
+        is_coprime_set = True
+        for i in range(len(l)):
+            for j in range(i+1, len(l)):
+                if gcd(l[i], l[j]) != 1:
+                    is_coprime_set = False
+                    break
+        return is_coprime_set
+
+    prod = reduce(lambda i, j: i*j, factors)
+    if prod == n and _is_coprime_set(factors):
+        return _decipher_rsa_crt(i, d, factors)
+    return _encipher_decipher_rsa(i, key, factors=None)
+
+
+def encipher_rsa(i, key, factors=None):
+    r"""Encrypt the plaintext with RSA.
+
+    Parameters
+    ==========
+
+    i : integer
+        The plaintext to be encrypted for.
+
+    key : (n, e) where n, e are integers
+        `n` is the modulus of the key and `e` is the exponent of the
+        key. The encryption is computed by `i^e \bmod n`.
+
+        The key can either be a public key or a private key, however,
+        the message encrypted by a public key can only be decrypted by
+        a private key, and vice versa, as RSA is an asymmetric
+        cryptography system.
+
+    factors : list of coprime integers
+        This is identical to the keyword ``factors`` in
+        :meth:`decipher_rsa`.
+
+    Notes
+    =====
+
+    Some specifications may make the RSA not cryptographically
+    meaningful.
+
+    For example, `0`, `1` will remain always same after taking any
+    number of exponentiation, thus, should be avoided.
+
+    Furthermore, if `i^e < n`, `i` may easily be figured out by taking
+    `e` th root.
+
+    And also, specifying the exponent as `1` or in more generalized form
+    as `1 + k \lambda(n)` where `k` is an nonnegative integer,
+    `\lambda` is a carmichael totient, the RSA becomes an identity
+    mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_rsa
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+
+    Public Key Encryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> encipher_rsa(msg, puk)
+    3
+
+    Private Key Encryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> msg = 12
+    >>> encipher_rsa(msg, prk)
+    3
+
+    Encryption using chinese remainder theorem:
+
+    >>> encipher_rsa(msg, prk, factors=[p, q])
+    3
+    """
+    return _encipher_decipher_rsa(i, key, factors=factors)
+
+
+def decipher_rsa(i, key, factors=None):
+    r"""Decrypt the ciphertext with RSA.
+
+    Parameters
+    ==========
+
+    i : integer
+        The ciphertext to be decrypted for.
+
+    key : (n, d) where n, d are integers
+        `n` is the modulus of the key and `d` is the exponent of the
+        key. The decryption is computed by `i^d \bmod n`.
+
+        The key can either be a public key or a private key, however,
+        the message encrypted by a public key can only be decrypted by
+        a private key, and vice versa, as RSA is an asymmetric
+        cryptography system.
+
+    factors : list of coprime integers
+        As the modulus `n` created from RSA key generation is composed
+        of arbitrary prime factors
+        `n = {p_1}^{k_1}{p_2}^{k_2}\dots{p_n}^{k_n}` where
+        `p_1, p_2, \dots, p_n` are distinct primes and
+        `k_1, k_2, \dots, k_n` are positive integers, chinese remainder
+        theorem can be used to compute `i^d \bmod n` from the
+        fragmented modulo operations like
+
+        .. math::
+            i^d \bmod {p_1}^{k_1}, i^d \bmod {p_2}^{k_2}, \dots,
+            i^d \bmod {p_n}^{k_n}
+
+        or like
+
+        .. math::
+            i^d \bmod {p_1}^{k_1}{p_2}^{k_2},
+            i^d \bmod {p_3}^{k_3}, \dots ,
+            i^d \bmod {p_n}^{k_n}
+
+        as long as every moduli does not share any common divisor each
+        other.
+
+        The raw primes used in generating the RSA key pair can be a good
+        option.
+
+        Note that the speed advantage of using this is only viable for
+        very large cases (Like 2048-bit RSA keys) since the
+        overhead of using pure Python implementation of
+        :meth:`sympy.ntheory.modular.crt` may overcompensate the
+        theoretical speed advantage.
+
+    Notes
+    =====
+
+    See the ``Notes`` section in the documentation of
+    :meth:`encipher_rsa`
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_rsa, encipher_rsa
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+
+    Public Key Encryption and Decryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> new_msg = encipher_rsa(msg, prk)
+    >>> new_msg
+    3
+    >>> decipher_rsa(new_msg, puk)
+    12
+
+    Private Key Encryption and Decryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> new_msg = encipher_rsa(msg, puk)
+    >>> new_msg
+    3
+    >>> decipher_rsa(new_msg, prk)
+    12
+
+    Decryption using chinese remainder theorem:
+
+    >>> decipher_rsa(new_msg, prk, factors=[p, q])
+    12
+
+    See Also
+    ========
+
+    encipher_rsa
+    """
+    return _encipher_decipher_rsa(i, key, factors=factors)
+
+
+#################### kid krypto (kid RSA) #############################
+
+
+def kid_rsa_public_key(a, b, A, B):
+    r"""
+    Kid RSA is a version of RSA useful to teach grade school children
+    since it does not involve exponentiation.
+
+    Explanation
+    ===========
+
+    Alice wants to talk to Bob. Bob generates keys as follows.
+    Key generation:
+
+    * Select positive integers `a, b, A, B` at random.
+    * Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`,
+      `n = (e d - 1)//M`.
+    * The *public key* is `(n, e)`. Bob sends these to Alice.
+    * The *private key* is `(n, d)`, which Bob keeps secret.
+
+    Encryption: If `p` is the plaintext message then the
+    ciphertext is `c = p e \pmod n`.
+
+    Decryption: If `c` is the ciphertext message then the
+    plaintext is `p = c d \pmod n`.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import kid_rsa_public_key
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> kid_rsa_public_key(a, b, A, B)
+    (369, 58)
+
+    """
+    M = a*b - 1
+    e = A*M + a
+    d = B*M + b
+    n = (e*d - 1)//M
+    return n, e
+
+
+def kid_rsa_private_key(a, b, A, B):
+    """
+    Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`,
+    `n = (e d - 1) / M`. The *private key* is `d`, which Bob
+    keeps secret.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import kid_rsa_private_key
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> kid_rsa_private_key(a, b, A, B)
+    (369, 70)
+
+    """
+    M = a*b - 1
+    e = A*M + a
+    d = B*M + b
+    n = (e*d - 1)//M
+    return n, d
+
+
+def encipher_kid_rsa(msg, key):
+    """
+    Here ``msg`` is the plaintext and ``key`` is the public key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_kid_rsa, kid_rsa_public_key)
+    >>> msg = 200
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> key = kid_rsa_public_key(a, b, A, B)
+    >>> encipher_kid_rsa(msg, key)
+    161
+
+    """
+    n, e = key
+    return (msg*e) % n
+
+
+def decipher_kid_rsa(msg, key):
+    """
+    Here ``msg`` is the plaintext and ``key`` is the private key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     kid_rsa_public_key, kid_rsa_private_key,
+    ...     decipher_kid_rsa, encipher_kid_rsa)
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> d = kid_rsa_private_key(a, b, A, B)
+    >>> msg = 200
+    >>> pub = kid_rsa_public_key(a, b, A, B)
+    >>> pri = kid_rsa_private_key(a, b, A, B)
+    >>> ct = encipher_kid_rsa(msg, pub)
+    >>> decipher_kid_rsa(ct, pri)
+    200
+
+    """
+    n, d = key
+    return (msg*d) % n
+
+
+#################### Morse Code ######################################
+
+morse_char = {
+    ".-": "A", "-...": "B",
+    "-.-.": "C", "-..": "D",
+    ".": "E", "..-.": "F",
+    "--.": "G", "....": "H",
+    "..": "I", ".---": "J",
+    "-.-": "K", ".-..": "L",
+    "--": "M", "-.": "N",
+    "---": "O", ".--.": "P",
+    "--.-": "Q", ".-.": "R",
+    "...": "S", "-": "T",
+    "..-": "U", "...-": "V",
+    ".--": "W", "-..-": "X",
+    "-.--": "Y", "--..": "Z",
+    "-----": "0", ".----": "1",
+    "..---": "2", "...--": "3",
+    "....-": "4", ".....": "5",
+    "-....": "6", "--...": "7",
+    "---..": "8", "----.": "9",
+    ".-.-.-": ".", "--..--": ",",
+    "---...": ":", "-.-.-.": ";",
+    "..--..": "?", "-....-": "-",
+    "..--.-": "_", "-.--.": "(",
+    "-.--.-": ")", ".----.": "'",
+    "-...-": "=", ".-.-.": "+",
+    "-..-.": "/", ".--.-.": "@",
+    "...-..-": "$", "-.-.--": "!"}
+char_morse = {v: k for k, v in morse_char.items()}
+
+
+def encode_morse(msg, sep='|', mapping=None):
+    """
+    Encodes a plaintext into popular Morse Code with letters
+    separated by ``sep`` and words by a double ``sep``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encode_morse
+    >>> msg = 'ATTACK RIGHT FLANK'
+    >>> encode_morse(msg)
+    '.-|-|-|.-|-.-.|-.-||.-.|..|--.|....|-||..-.|.-..|.-|-.|-.-'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morse_code
+
+    """
+
+    mapping = mapping or char_morse
+    assert sep not in mapping
+    word_sep = 2*sep
+    mapping[" "] = word_sep
+    suffix = msg and msg[-1] in whitespace
+
+    # normalize whitespace
+    msg = (' ' if word_sep else '').join(msg.split())
+    # omit unmapped chars
+    chars = set(''.join(msg.split()))
+    ok = set(mapping.keys())
+    msg = translate(msg, None, ''.join(chars - ok))
+
+    morsestring = []
+    words = msg.split()
+    for word in words:
+        morseword = []
+        for letter in word:
+            morseletter = mapping[letter]
+            morseword.append(morseletter)
+
+        word = sep.join(morseword)
+        morsestring.append(word)
+
+    return word_sep.join(morsestring) + (word_sep if suffix else '')
+
+
+def decode_morse(msg, sep='|', mapping=None):
+    """
+    Decodes a Morse Code with letters separated by ``sep``
+    (default is '|') and words by `word_sep` (default is '||)
+    into plaintext.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decode_morse
+    >>> mc = '--|---|...-|.||.|.-|...|-'
+    >>> decode_morse(mc)
+    'MOVE EAST'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morse_code
+
+    """
+
+    mapping = mapping or morse_char
+    word_sep = 2*sep
+    characterstring = []
+    words = msg.strip(word_sep).split(word_sep)
+    for word in words:
+        letters = word.split(sep)
+        chars = [mapping[c] for c in letters]
+        word = ''.join(chars)
+        characterstring.append(word)
+    rv = " ".join(characterstring)
+    return rv
+
+
+#################### LFSRs  ##########################################
+
+
+@doctest_depends_on(ground_types=['python', 'gmpy'])
+def lfsr_sequence(key, fill, n):
+    r"""
+    This function creates an LFSR sequence.
+
+    Parameters
+    ==========
+
+    key : list
+        A list of finite field elements, `[c_0, c_1, \ldots, c_k].`
+
+    fill : list
+        The list of the initial terms of the LFSR sequence,
+        `[x_0, x_1, \ldots, x_k].`
+
+    n
+        Number of terms of the sequence that the function returns.
+
+    Returns
+    =======
+
+    L
+        The LFSR sequence defined by
+        `x_{n+1} = c_k x_n + \ldots + c_0 x_{n-k}`, for
+        `n \leq k`.
+
+    Notes
+    =====
+
+    S. Golomb [G]_ gives a list of three statistical properties a
+    sequence of numbers `a = \{a_n\}_{n=1}^\infty`,
+    `a_n \in \{0,1\}`, should display to be considered
+    "random". Define the autocorrelation of `a` to be
+
+    .. math::
+
+        C(k) = C(k,a) = \lim_{N\rightarrow \infty} {1\over N}\sum_{n=1}^N (-1)^{a_n + a_{n+k}}.
+
+    In the case where `a` is periodic with period
+    `P` then this reduces to
+
+    .. math::
+
+        C(k) = {1\over P}\sum_{n=1}^P (-1)^{a_n + a_{n+k}}.
+
+    Assume `a` is periodic with period `P`.
+
+    - balance:
+
+      .. math::
+
+        \left|\sum_{n=1}^P(-1)^{a_n}\right| \leq 1.
+
+    - low autocorrelation:
+
+       .. math::
+
+         C(k) = \left\{ \begin{array}{cc} 1,& k = 0,\\ \epsilon, & k \ne 0. \end{array} \right.
+
+      (For sequences satisfying these first two properties, it is known
+      that `\epsilon = -1/P` must hold.)
+
+    - proportional runs property: In each period, half the runs have
+      length `1`, one-fourth have length `2`, etc.
+      Moreover, there are as many runs of `1`'s as there are of
+      `0`'s.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import lfsr_sequence
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> lfsr_sequence(key, fill, 10)
+    [1 mod 2, 1 mod 2, 0 mod 2, 1 mod 2, 0 mod 2,
+    1 mod 2, 1 mod 2, 0 mod 2, 0 mod 2, 1 mod 2]
+
+    References
+    ==========
+
+    .. [G] Solomon Golomb, Shift register sequences, Aegean Park Press,
+       Laguna Hills, Ca, 1967
+
+    """
+    if not isinstance(key, list):
+        raise TypeError("key must be a list")
+    if not isinstance(fill, list):
+        raise TypeError("fill must be a list")
+    p = key[0].modulus()
+    F = FF(p)
+    s = fill
+    k = len(fill)
+    L = []
+    for i in range(n):
+        s0 = s[:]
+        L.append(s[0])
+        s = s[1:k]
+        x = sum(int(key[i]*s0[i]) for i in range(k))
+        s.append(F(x))
+    return L       # use [int(x) for x in L] for int version
+
+
+def lfsr_autocorrelation(L, P, k):
+    """
+    This function computes the LFSR autocorrelation function.
+
+    Parameters
+    ==========
+
+    L
+        A periodic sequence of elements of `GF(2)`.
+        L must have length larger than P.
+
+    P
+        The period of L.
+
+    k : int
+        An integer `k` (`0 < k < P`).
+
+    Returns
+    =======
+
+    autocorrelation
+        The k-th value of the autocorrelation of the LFSR L.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     lfsr_sequence, lfsr_autocorrelation)
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_autocorrelation(s, 15, 7)
+    -1/15
+    >>> lfsr_autocorrelation(s, 15, 0)
+    1
+
+    """
+    if not isinstance(L, list):
+        raise TypeError("L (=%s) must be a list" % L)
+    P = int(P)
+    k = int(k)
+    L0 = L[:P]     # slices makes a copy
+    L1 = L0 + L0[:k]
+    L2 = [(-1)**(int(L1[i]) + int(L1[i + k])) for i in range(P)]
+    tot = sum(L2)
+    return Rational(tot, P)
+
+
+def lfsr_connection_polynomial(s):
+    """
+    This function computes the LFSR connection polynomial.
+
+    Parameters
+    ==========
+
+    s
+        A sequence of elements of even length, with entries in a finite
+        field.
+
+    Returns
+    =======
+
+    C(x)
+        The connection polynomial of a minimal LFSR yielding s.
+
+        This implements the algorithm in section 3 of J. L. Massey's
+        article [M]_.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     lfsr_sequence, lfsr_connection_polynomial)
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**4 + x + 1
+    >>> fill = [F(1), F(0), F(0), F(1)]
+    >>> key = [F(1), F(1), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + 1
+    >>> fill = [F(1), F(0), F(1)]
+    >>> key = [F(1), F(1), F(0)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + x**2 + 1
+    >>> fill = [F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + x + 1
+
+    References
+    ==========
+
+    .. [M] James L. Massey, "Shift-Register Synthesis and BCH Decoding."
+        IEEE Trans. on Information Theory, vol. 15(1), pp. 122-127,
+        Jan 1969.
+
+    """
+    # Initialization:
+    p = s[0].modulus()
+    x = Symbol("x")
+    C = 1*x**0
+    B = 1*x**0
+    m = 1
+    b = 1*x**0
+    L = 0
+    N = 0
+    while N < len(s):
+        if L > 0:
+            dC = Poly(C).degree()
+            r = min(L + 1, dC + 1)
+            coeffsC = [C.subs(x, 0)] + [C.coeff(x**i)
+                for i in range(1, dC + 1)]
+            d = (int(s[N]) + sum(coeffsC[i]*int(s[N - i])
+                for i in range(1, r))) % p
+        if L == 0:
+            d = int(s[N])*x**0
+        if d == 0:
+            m += 1
+            N += 1
+        if d > 0:
+            if 2*L > N:
+                C = (C - d*((b**(p - 2)) % p)*x**m*B).expand()
+                m += 1
+                N += 1
+            else:
+                T = C
+                C = (C - d*((b**(p - 2)) % p)*x**m*B).expand()
+                L = N + 1 - L
+                m = 1
+                b = d
+                B = T
+                N += 1
+    dC = Poly(C).degree()
+    coeffsC = [C.subs(x, 0)] + [C.coeff(x**i) for i in range(1, dC + 1)]
+    return sum(coeffsC[i] % p*x**i for i in range(dC + 1)
+        if coeffsC[i] is not None)
+
+
+#################### ElGamal  #############################
+
+
+def elgamal_private_key(digit=10, seed=None):
+    r"""
+    Return three number tuple as private key.
+
+    Explanation
+    ===========
+
+    Elgamal encryption is based on the mathematical problem
+    called the Discrete Logarithm Problem (DLP). For example,
+
+    `a^{b} \equiv c \pmod p`
+
+    In general, if ``a`` and ``b`` are known, ``ct`` is easily
+    calculated. If ``b`` is unknown, it is hard to use
+    ``a`` and ``ct`` to get ``b``.
+
+    Parameters
+    ==========
+
+    digit : int
+        Minimum number of binary digits for key.
+
+    Returns
+    =======
+
+    tuple : (p, r, d)
+        p = prime number.
+
+        r = primitive root.
+
+        d = random number.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import elgamal_private_key
+    >>> from sympy.ntheory import is_primitive_root, isprime
+    >>> a, b, _ = elgamal_private_key()
+    >>> isprime(a)
+    True
+    >>> is_primitive_root(b, a)
+    True
+
+    """
+    randrange = _randrange(seed)
+    p = nextprime(2**digit)
+    return p, primitive_root(p), randrange(2, p)
+
+
+def elgamal_public_key(key):
+    r"""
+    Return three number tuple as public key.
+
+    Parameters
+    ==========
+
+    key : (p, r, e)
+        Tuple generated by ``elgamal_private_key``.
+
+    Returns
+    =======
+
+    tuple : (p, r, e)
+        `e = r**d \bmod p`
+
+        `d` is a random number in private key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import elgamal_public_key
+    >>> elgamal_public_key((1031, 14, 636))
+    (1031, 14, 212)
+
+    """
+    p, r, e = key
+    return p, r, pow(r, e, p)
+
+
+def encipher_elgamal(i, key, seed=None):
+    r"""
+    Encrypt message with public key.
+
+    Explanation
+    ===========
+
+    ``i`` is a plaintext message expressed as an integer.
+    ``key`` is public key (p, r, e). In order to encrypt
+    a message, a random number ``a`` in ``range(2, p)``
+    is generated and the encryped message is returned as
+    `c_{1}` and `c_{2}` where:
+
+    `c_{1} \equiv r^{a} \pmod p`
+
+    `c_{2} \equiv m e^{a} \pmod p`
+
+    Parameters
+    ==========
+
+    msg
+        int of encoded message.
+
+    key
+        Public key.
+
+    Returns
+    =======
+
+    tuple : (c1, c2)
+        Encipher into two number.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_elgamal, elgamal_private_key, elgamal_public_key
+    >>> pri = elgamal_private_key(5, seed=[3]); pri
+    (37, 2, 3)
+    >>> pub = elgamal_public_key(pri); pub
+    (37, 2, 8)
+    >>> msg = 36
+    >>> encipher_elgamal(msg, pub, seed=[3])
+    (8, 6)
+
+    """
+    p, r, e = key
+    if i < 0 or i >= p:
+        raise ValueError(
+            'Message (%s) should be in range(%s)' % (i, p))
+    randrange = _randrange(seed)
+    a = randrange(2, p)
+    return pow(r, a, p), i*pow(e, a, p) % p
+
+
+def decipher_elgamal(msg, key):
+    r"""
+    Decrypt message with private key.
+
+    `msg = (c_{1}, c_{2})`
+
+    `key = (p, r, d)`
+
+    According to extended Eucliden theorem,
+    `u c_{1}^{d} + p n = 1`
+
+    `u \equiv 1/{{c_{1}}^d} \pmod p`
+
+    `u c_{2} \equiv \frac{1}{c_{1}^d} c_{2} \equiv \frac{1}{r^{ad}} c_{2} \pmod p`
+
+    `\frac{1}{r^{ad}} m e^a \equiv \frac{1}{r^{ad}} m {r^{d a}} \equiv m \pmod p`
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_elgamal
+    >>> from sympy.crypto.crypto import encipher_elgamal
+    >>> from sympy.crypto.crypto import elgamal_private_key
+    >>> from sympy.crypto.crypto import elgamal_public_key
+
+    >>> pri = elgamal_private_key(5, seed=[3])
+    >>> pub = elgamal_public_key(pri); pub
+    (37, 2, 8)
+    >>> msg = 17
+    >>> decipher_elgamal(encipher_elgamal(msg, pub), pri) == msg
+    True
+
+    """
+    p, _, d = key
+    c1, c2 = msg
+    u = pow(c1, -d, p)
+    return u * c2 % p
+
+
+################ Diffie-Hellman Key Exchange  #########################
+
+def dh_private_key(digit=10, seed=None):
+    r"""
+    Return three integer tuple as private key.
+
+    Explanation
+    ===========
+
+    Diffie-Hellman key exchange is based on the mathematical problem
+    called the Discrete Logarithm Problem (see ElGamal).
+
+    Diffie-Hellman key exchange is divided into the following steps:
+
+    *   Alice and Bob agree on a base that consist of a prime ``p``
+        and a primitive root of ``p`` called ``g``
+    *   Alice choses a number ``a`` and Bob choses a number ``b`` where
+        ``a`` and ``b`` are random numbers in range `[2, p)`. These are
+        their private keys.
+    *   Alice then publicly sends Bob `g^{a} \pmod p` while Bob sends
+        Alice `g^{b} \pmod p`
+    *   They both raise the received value to their secretly chosen
+        number (``a`` or ``b``) and now have both as their shared key
+        `g^{ab} \pmod p`
+
+    Parameters
+    ==========
+
+    digit
+        Minimum number of binary digits required in key.
+
+    Returns
+    =======
+
+    tuple : (p, g, a)
+        p = prime number.
+
+        g = primitive root of p.
+
+        a = random number from 2 through p - 1.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import dh_private_key
+    >>> from sympy.ntheory import isprime, is_primitive_root
+    >>> p, g, _ = dh_private_key()
+    >>> isprime(p)
+    True
+    >>> is_primitive_root(g, p)
+    True
+    >>> p, g, _ = dh_private_key(5)
+    >>> isprime(p)
+    True
+    >>> is_primitive_root(g, p)
+    True
+
+    """
+    p = nextprime(2**digit)
+    g = primitive_root(p)
+    randrange = _randrange(seed)
+    a = randrange(2, p)
+    return p, g, a
+
+
+def dh_public_key(key):
+    r"""
+    Return three number tuple as public key.
+
+    This is the tuple that Alice sends to Bob.
+
+    Parameters
+    ==========
+
+    key : (p, g, a)
+        A tuple generated by ``dh_private_key``.
+
+    Returns
+    =======
+
+    tuple : int, int, int
+        A tuple of `(p, g, g^a \mod p)` with `p`, `g` and `a` given as
+        parameters.s
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import dh_private_key, dh_public_key
+    >>> p, g, a = dh_private_key();
+    >>> _p, _g, x = dh_public_key((p, g, a))
+    >>> p == _p and g == _g
+    True
+    >>> x == pow(g, a, p)
+    True
+
+    """
+    p, g, a = key
+    return p, g, pow(g, a, p)
+
+
+def dh_shared_key(key, b):
+    """
+    Return an integer that is the shared key.
+
+    This is what Bob and Alice can both calculate using the public
+    keys they received from each other and their private keys.
+
+    Parameters
+    ==========
+
+    key : (p, g, x)
+        Tuple `(p, g, x)` generated by ``dh_public_key``.
+
+    b
+        Random number in the range of `2` to `p - 1`
+        (Chosen by second key exchange member (Bob)).
+
+    Returns
+    =======
+
+    int
+        A shared key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     dh_private_key, dh_public_key, dh_shared_key)
+    >>> prk = dh_private_key();
+    >>> p, g, x = dh_public_key(prk);
+    >>> sk = dh_shared_key((p, g, x), 1000)
+    >>> sk == pow(x, 1000, p)
+    True
+
+    """
+    p, _, x = key
+    if 1 >= b or b >= p:
+        raise ValueError(filldedent('''
+            Value of b should be greater 1 and less
+            than prime %s.''' % p))
+
+    return pow(x, b, p)
+
+
+################ Goldwasser-Micali Encryption  #########################
+
+
+def _legendre(a, p):
+    """
+    Returns the legendre symbol of a and p
+    assuming that p is a prime.
+
+    i.e. 1 if a is a quadratic residue mod p
+        -1 if a is not a quadratic residue mod p
+         0 if a is divisible by p
+
+    Parameters
+    ==========
+
+    a : int
+        The number to test.
+
+    p : prime
+        The prime to test ``a`` against.
+
+    Returns
+    =======
+
+    int
+        Legendre symbol (a / p).
+
+    """
+    sig = pow(a, (p - 1)//2, p)
+    if sig == 1:
+        return 1
+    elif sig == 0:
+        return 0
+    else:
+        return -1
+
+
+def _random_coprime_stream(n, seed=None):
+    randrange = _randrange(seed)
+    while True:
+        y = randrange(n)
+        if gcd(y, n) == 1:
+            yield y
+
+
+def gm_private_key(p, q, a=None):
+    r"""
+    Check if ``p`` and ``q`` can be used as private keys for
+    the Goldwasser-Micali encryption. The method works
+    roughly as follows.
+
+    Explanation
+    ===========
+
+    #. Pick two large primes $p$ and $q$.
+    #. Call their product $N$.
+    #. Given a message as an integer $i$, write $i$ in its bit representation $b_0, \dots, b_n$.
+    #. For each $k$,
+
+     if $b_k = 0$:
+        let $a_k$ be a random square
+        (quadratic residue) modulo $p q$
+        such that ``jacobi_symbol(a, p*q) = 1``
+     if $b_k = 1$:
+        let $a_k$ be a random non-square
+        (non-quadratic residue) modulo $p q$
+        such that ``jacobi_symbol(a, p*q) = 1``
+
+    returns $\left[a_1, a_2, \dots\right]$
+
+    $b_k$ can be recovered by checking whether or not
+    $a_k$ is a residue. And from the $b_k$'s, the message
+    can be reconstructed.
+
+    The idea is that, while ``jacobi_symbol(a, p*q)``
+    can be easily computed (and when it is equal to $-1$ will
+    tell you that $a$ is not a square mod $p q$), quadratic
+    residuosity modulo a composite number is hard to compute
+    without knowing its factorization.
+
+    Moreover, approximately half the numbers coprime to $p q$ have
+    :func:`~.jacobi_symbol` equal to $1$ . And among those, approximately half
+    are residues and approximately half are not. This maximizes the
+    entropy of the code.
+
+    Parameters
+    ==========
+
+    p, q, a
+        Initialization variables.
+
+    Returns
+    =======
+
+    tuple : (p, q)
+        The input value ``p`` and ``q``.
+
+    Raises
+    ======
+
+    ValueError
+        If ``p`` and ``q`` are not distinct odd primes.
+
+    """
+    if p == q:
+        raise ValueError("expected distinct primes, "
+                         "got two copies of %i" % p)
+    elif not isprime(p) or not isprime(q):
+        raise ValueError("first two arguments must be prime, "
+                         "got %i of %i" % (p, q))
+    elif p == 2 or q == 2:
+        raise ValueError("first two arguments must not be even, "
+                         "got %i of %i" % (p, q))
+    return p, q
+
+
+def gm_public_key(p, q, a=None, seed=None):
+    """
+    Compute public keys for ``p`` and ``q``.
+    Note that in Goldwasser-Micali Encryption,
+    public keys are randomly selected.
+
+    Parameters
+    ==========
+
+    p, q, a : int, int, int
+        Initialization variables.
+
+    Returns
+    =======
+
+    tuple : (a, N)
+        ``a`` is the input ``a`` if it is not ``None`` otherwise
+        some random integer coprime to ``p`` and ``q``.
+
+        ``N`` is the product of ``p`` and ``q``.
+
+    """
+
+    p, q = gm_private_key(p, q)
+    N = p * q
+
+    if a is None:
+        randrange = _randrange(seed)
+        while True:
+            a = randrange(N)
+            if _legendre(a, p) == _legendre(a, q) == -1:
+                break
+    else:
+        if _legendre(a, p) != -1 or _legendre(a, q) != -1:
+            return False
+    return (a, N)
+
+
+def encipher_gm(i, key, seed=None):
+    """
+    Encrypt integer 'i' using public_key 'key'
+    Note that gm uses random encryption.
+
+    Parameters
+    ==========
+
+    i : int
+        The message to encrypt.
+
+    key : (a, N)
+        The public key.
+
+    Returns
+    =======
+
+    list : list of int
+        The randomized encrypted message.
+
+    """
+    if i < 0:
+        raise ValueError(
+            "message must be a non-negative "
+            "integer: got %d instead" % i)
+    a, N = key
+    bits = []
+    while i > 0:
+        bits.append(i % 2)
+        i //= 2
+
+    gen = _random_coprime_stream(N, seed)
+    rev = reversed(bits)
+    encode = lambda b: next(gen)**2*pow(a, b) % N
+    return [ encode(b) for b in rev ]
+
+
+
+def decipher_gm(message, key):
+    """
+    Decrypt message 'message' using public_key 'key'.
+
+    Parameters
+    ==========
+
+    message : list of int
+        The randomized encrypted message.
+
+    key : (p, q)
+        The private key.
+
+    Returns
+    =======
+
+    int
+        The encrypted message.
+
+    """
+    p, q = key
+    res = lambda m, p: _legendre(m, p) > 0
+    bits = [res(m, p) * res(m, q) for m in message]
+    m = 0
+    for b in bits:
+        m <<= 1
+        m += not b
+    return m
+
+
+
+########### RailFence Cipher #############
+
+def encipher_railfence(message,rails):
+    """
+    Performs Railfence Encryption on plaintext and returns ciphertext
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_railfence
+    >>> message = "hello world"
+    >>> encipher_railfence(message,3)
+    'horel ollwd'
+
+    Parameters
+    ==========
+
+    message : string, the message to encrypt.
+    rails : int, the number of rails.
+
+    Returns
+    =======
+
+    The Encrypted string message.
+
+    References
+    ==========
+    .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher
+
+    """
+    r = list(range(rails))
+    p = cycle(r + r[-2:0:-1])
+    return ''.join(sorted(message, key=lambda i: next(p)))
+
+
+def decipher_railfence(ciphertext,rails):
+    """
+    Decrypt the message using the given rails
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_railfence
+    >>> decipher_railfence("horel ollwd",3)
+    'hello world'
+
+    Parameters
+    ==========
+
+    message : string, the message to encrypt.
+    rails : int, the number of rails.
+
+    Returns
+    =======
+
+    The Decrypted string message.
+
+    """
+    r = list(range(rails))
+    p = cycle(r + r[-2:0:-1])
+
+    idx = sorted(range(len(ciphertext)), key=lambda i: next(p))
+    res = [''] * len(ciphertext)
+    for i, c in zip(idx, ciphertext):
+        res[i] = c
+    return ''.join(res)
+
+
+################ Blum-Goldwasser cryptosystem  #########################
+
+def bg_private_key(p, q):
+    """
+    Check if p and q can be used as private keys for
+    the Blum-Goldwasser cryptosystem.
+
+    Explanation
+    ===========
+
+    The three necessary checks for p and q to pass
+    so that they can be used as private keys:
+
+        1. p and q must both be prime
+        2. p and q must be distinct
+        3. p and q must be congruent to 3 mod 4
+
+    Parameters
+    ==========
+
+    p, q
+        The keys to be checked.
+
+    Returns
+    =======
+
+    p, q
+        Input values.
+
+    Raises
+    ======
+
+    ValueError
+        If p and q do not pass the above conditions.
+
+    """
+
+    if not isprime(p) or not isprime(q):
+        raise ValueError("the two arguments must be prime, "
+                         "got %i and %i" %(p, q))
+    elif p == q:
+        raise ValueError("the two arguments must be distinct, "
+                         "got two copies of %i. " %p)
+    elif (p - 3) % 4 != 0 or (q - 3) % 4 != 0:
+        raise ValueError("the two arguments must be congruent to 3 mod 4, "
+                         "got %i and %i" %(p, q))
+    return p, q
+
+def bg_public_key(p, q):
+    """
+    Calculates public keys from private keys.
+
+    Explanation
+    ===========
+
+    The function first checks the validity of
+    private keys passed as arguments and
+    then returns their product.
+
+    Parameters
+    ==========
+
+    p, q
+        The private keys.
+
+    Returns
+    =======
+
+    N
+        The public key.
+
+    """
+    p, q = bg_private_key(p, q)
+    N = p * q
+    return N
+
+def encipher_bg(i, key, seed=None):
+    """
+    Encrypts the message using public key and seed.
+
+    Explanation
+    ===========
+
+    ALGORITHM:
+        1. Encodes i as a string of L bits, m.
+        2. Select a random element r, where 1 < r < key, and computes
+           x = r^2 mod key.
+        3. Use BBS pseudo-random number generator to generate L random bits, b,
+        using the initial seed as x.
+        4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L.
+        5. x_L = x^(2^L) mod key.
+        6. Return (c, x_L)
+
+    Parameters
+    ==========
+
+    i
+        Message, a non-negative integer
+
+    key
+        The public key
+
+    Returns
+    =======
+
+    Tuple
+        (encrypted_message, x_L)
+
+    Raises
+    ======
+
+    ValueError
+        If i is negative.
+
+    """
+
+    if i < 0:
+        raise ValueError(
+            "message must be a non-negative "
+            "integer: got %d instead" % i)
+
+    enc_msg = []
+    while i > 0:
+        enc_msg.append(i % 2)
+        i //= 2
+    enc_msg.reverse()
+    L = len(enc_msg)
+
+    r = _randint(seed)(2, key - 1)
+    x = r**2 % key
+    x_L = pow(int(x), int(2**L), int(key))
+
+    rand_bits = []
+    for _ in range(L):
+        rand_bits.append(x % 2)
+        x = x**2 % key
+
+    encrypt_msg = [m ^ b for (m, b) in zip(enc_msg, rand_bits)]
+
+    return (encrypt_msg, x_L)
+
+def decipher_bg(message, key):
+    """
+    Decrypts the message using private keys.
+
+    Explanation
+    ===========
+
+    ALGORITHM:
+        1. Let, c be the encrypted message, y the second number received,
+        and p and q be the private keys.
+        2. Compute, r_p = y^((p+1)/4 ^ L) mod p and
+        r_q = y^((q+1)/4 ^ L) mod q.
+        3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N.
+        4. From, recompute the bits using the BBS generator, as in the
+        encryption algorithm.
+        5. Compute original message by XORing c and b.
+
+    Parameters
+    ==========
+
+    message
+        Tuple of encrypted message and a non-negative integer.
+
+    key
+        Tuple of private keys.
+
+    Returns
+    =======
+
+    orig_msg
+        The original message
+
+    """
+
+    p, q = key
+    encrypt_msg, y = message
+    public_key = p * q
+    L = len(encrypt_msg)
+    p_t = ((p + 1)/4)**L
+    q_t = ((q + 1)/4)**L
+    r_p = pow(int(y), int(p_t), int(p))
+    r_q = pow(int(y), int(q_t), int(q))
+
+    x = (q * invert(q, p) * r_p + p * invert(p, q) * r_q) % public_key
+
+    orig_bits = []
+    for _ in range(L):
+        orig_bits.append(x % 2)
+        x = x**2 % public_key
+
+    orig_msg = 0
+    for (m, b) in zip(encrypt_msg, orig_bits):
+        orig_msg = orig_msg * 2
+        orig_msg += (m ^ b)
+
+    return orig_msg

lib/python3.12/site-packages/sympy/crypto/tests/test_crypto.py

@@ -0,0 +1,562 @@
+from sympy.core import symbols
+from sympy.crypto.crypto import (cycle_list,
+      encipher_shift, encipher_affine, encipher_substitution,
+      check_and_join, encipher_vigenere, decipher_vigenere,
+      encipher_hill, decipher_hill, encipher_bifid5, encipher_bifid6,
+      bifid5_square, bifid6_square, bifid5, bifid6,
+      decipher_bifid5, decipher_bifid6, encipher_kid_rsa,
+      decipher_kid_rsa, kid_rsa_private_key, kid_rsa_public_key,
+      decipher_rsa, rsa_private_key, rsa_public_key, encipher_rsa,
+      lfsr_connection_polynomial, lfsr_autocorrelation, lfsr_sequence,
+      encode_morse, decode_morse, elgamal_private_key, elgamal_public_key,
+      encipher_elgamal, decipher_elgamal, dh_private_key, dh_public_key,
+      dh_shared_key, decipher_shift, decipher_affine, encipher_bifid,
+      decipher_bifid, bifid_square, padded_key, uniq, decipher_gm,
+      encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg,
+      bg_private_key, bg_public_key, encipher_rot13, decipher_rot13,
+      encipher_atbash, decipher_atbash, NonInvertibleCipherWarning,
+      encipher_railfence, decipher_railfence)
+from sympy.external.gmpy import gcd
+from sympy.matrices import Matrix
+from sympy.ntheory import isprime, is_primitive_root
+from sympy.polys.domains import FF
+
+from sympy.testing.pytest import raises, warns
+
+from sympy.core.random import randrange
+
+def test_encipher_railfence():
+    assert encipher_railfence("hello world",2) == "hlowrdel ol"
+    assert encipher_railfence("hello world",3) == "horel ollwd"
+    assert encipher_railfence("hello world",4) == "hwe olordll"
+
+def test_decipher_railfence():
+    assert decipher_railfence("hlowrdel ol",2) == "hello world"
+    assert decipher_railfence("horel ollwd",3) == "hello world"
+    assert decipher_railfence("hwe olordll",4) == "hello world"
+
+
+def test_cycle_list():
+    assert cycle_list(3, 4) == [3, 0, 1, 2]
+    assert cycle_list(-1, 4) == [3, 0, 1, 2]
+    assert cycle_list(1, 4) == [1, 2, 3, 0]
+
+
+def test_encipher_shift():
+    assert encipher_shift("ABC", 0) == "ABC"
+    assert encipher_shift("ABC", 1) == "BCD"
+    assert encipher_shift("ABC", -1) == "ZAB"
+    assert decipher_shift("ZAB", -1) == "ABC"
+
+def test_encipher_rot13():
+    assert encipher_rot13("ABC") == "NOP"
+    assert encipher_rot13("NOP") == "ABC"
+    assert decipher_rot13("ABC") == "NOP"
+    assert decipher_rot13("NOP") == "ABC"
+
+
+def test_encipher_affine():
+    assert encipher_affine("ABC", (1, 0)) == "ABC"
+    assert encipher_affine("ABC", (1, 1)) == "BCD"
+    assert encipher_affine("ABC", (-1, 0)) == "AZY"
+    assert encipher_affine("ABC", (-1, 1), symbols="ABCD") == "BAD"
+    assert encipher_affine("123", (-1, 1), symbols="1234") == "214"
+    assert encipher_affine("ABC", (3, 16)) == "QTW"
+    assert decipher_affine("QTW", (3, 16)) == "ABC"
+
+def test_encipher_atbash():
+    assert encipher_atbash("ABC") == "ZYX"
+    assert encipher_atbash("ZYX") == "ABC"
+    assert decipher_atbash("ABC") == "ZYX"
+    assert decipher_atbash("ZYX") == "ABC"
+
+def test_encipher_substitution():
+    assert encipher_substitution("ABC", "BAC", "ABC") == "BAC"
+    assert encipher_substitution("123", "1243", "1234") == "124"
+
+
+def test_check_and_join():
+    assert check_and_join("abc") == "abc"
+    assert check_and_join(uniq("aaabc")) == "abc"
+    assert check_and_join("ab c".split()) == "abc"
+    assert check_and_join("abc", "a", filter=True) == "a"
+    raises(ValueError, lambda: check_and_join('ab', 'a'))
+
+
+def test_encipher_vigenere():
+    assert encipher_vigenere("ABC", "ABC") == "ACE"
+    assert encipher_vigenere("ABC", "ABC", symbols="ABCD") == "ACA"
+    assert encipher_vigenere("ABC", "AB", symbols="ABCD") == "ACC"
+    assert encipher_vigenere("AB", "ABC", symbols="ABCD") == "AC"
+    assert encipher_vigenere("A", "ABC", symbols="ABCD") == "A"
+
+
+def test_decipher_vigenere():
+    assert decipher_vigenere("ABC", "ABC") == "AAA"
+    assert decipher_vigenere("ABC", "ABC", symbols="ABCD") == "AAA"
+    assert decipher_vigenere("ABC", "AB", symbols="ABCD") == "AAC"
+    assert decipher_vigenere("AB", "ABC", symbols="ABCD") == "AA"
+    assert decipher_vigenere("A", "ABC", symbols="ABCD") == "A"
+
+
+def test_encipher_hill():
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert encipher_hill("ABCD", A) == "CFIV"
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert encipher_hill("ABCD", A) == "ABCD"
+    assert encipher_hill("ABCD", A, symbols="ABCD") == "ABCD"
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert encipher_hill("ABCD", A, symbols="ABCD") == "CBAB"
+    assert encipher_hill("AB", A, symbols="ABCD") == "CB"
+    # message length, n, does not need to be a multiple of k;
+    # it is padded
+    assert encipher_hill("ABA", A) == "CFGC"
+    assert encipher_hill("ABA", A, pad="Z") == "CFYV"
+
+
+def test_decipher_hill():
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert decipher_hill("CFIV", A) == "ABCD"
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert decipher_hill("ABCD", A) == "ABCD"
+    assert decipher_hill("ABCD", A, symbols="ABCD") == "ABCD"
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert decipher_hill("CBAB", A, symbols="ABCD") == "ABCD"
+    assert decipher_hill("CB", A, symbols="ABCD") == "AB"
+    # n does not need to be a multiple of k
+    assert decipher_hill("CFA", A) == "ABAA"
+
+
+def test_encipher_bifid5():
+    assert encipher_bifid5("AB", "AB") == "AB"
+    assert encipher_bifid5("AB", "CD") == "CO"
+    assert encipher_bifid5("ab", "c") == "CH"
+    assert encipher_bifid5("a bc", "b") == "BAC"
+
+
+def test_bifid5_square():
+    A = bifid5
+    f = lambda i, j: symbols(A[5*i + j])
+    M = Matrix(5, 5, f)
+    assert bifid5_square("") == M
+
+
+def test_decipher_bifid5():
+    assert decipher_bifid5("AB", "AB") == "AB"
+    assert decipher_bifid5("CO", "CD") == "AB"
+    assert decipher_bifid5("ch", "c") == "AB"
+    assert decipher_bifid5("b ac", "b") == "ABC"
+
+
+def test_encipher_bifid6():
+    assert encipher_bifid6("AB", "AB") == "AB"
+    assert encipher_bifid6("AB", "CD") == "CP"
+    assert encipher_bifid6("ab", "c") == "CI"
+    assert encipher_bifid6("a bc", "b") == "BAC"
+
+
+def test_decipher_bifid6():
+    assert decipher_bifid6("AB", "AB") == "AB"
+    assert decipher_bifid6("CP", "CD") == "AB"
+    assert decipher_bifid6("ci", "c") == "AB"
+    assert decipher_bifid6("b ac", "b") == "ABC"
+
+
+def test_bifid6_square():
+    A = bifid6
+    f = lambda i, j: symbols(A[6*i + j])
+    M = Matrix(6, 6, f)
+    assert bifid6_square("") == M
+
+
+def test_rsa_public_key():
+    assert rsa_public_key(2, 3, 1) == (6, 1)
+    assert rsa_public_key(5, 3, 3) == (15, 3)
+
+    with warns(NonInvertibleCipherWarning):
+        assert rsa_public_key(2, 2, 1) == (4, 1)
+        assert rsa_public_key(8, 8, 8) is False
+
+
+def test_rsa_private_key():
+    assert rsa_private_key(2, 3, 1) == (6, 1)
+    assert rsa_private_key(5, 3, 3) == (15, 3)
+    assert rsa_private_key(23,29,5) == (667,493)
+
+    with warns(NonInvertibleCipherWarning):
+        assert rsa_private_key(2, 2, 1) == (4, 1)
+        assert rsa_private_key(8, 8, 8) is False
+
+
+def test_rsa_large_key():
+    # Sample from
+    # http://www.herongyang.com/Cryptography/JCE-Public-Key-RSA-Private-Public-Key-Pair-Sample.html
+    p = int('101565610013301240713207239558950144682174355406589305284428666'\
+        '903702505233009')
+    q = int('894687191887545488935455605955948413812376003053143521429242133'\
+        '12069293984003')
+    e = int('65537')
+    d = int('893650581832704239530398858744759129594796235440844479456143566'\
+        '6999402846577625762582824202269399672579058991442587406384754958587'\
+        '400493169361356902030209')
+    assert rsa_public_key(p, q, e) == (p*q, e)
+    assert rsa_private_key(p, q, e) == (p*q, d)
+
+
+def test_encipher_rsa():
+    puk = rsa_public_key(2, 3, 1)
+    assert encipher_rsa(2, puk) == 2
+    puk = rsa_public_key(5, 3, 3)
+    assert encipher_rsa(2, puk) == 8
+
+    with warns(NonInvertibleCipherWarning):
+        puk = rsa_public_key(2, 2, 1)
+        assert encipher_rsa(2, puk) == 2
+
+
+def test_decipher_rsa():
+    prk = rsa_private_key(2, 3, 1)
+    assert decipher_rsa(2, prk) == 2
+    prk = rsa_private_key(5, 3, 3)
+    assert decipher_rsa(8, prk) == 2
+
+    with warns(NonInvertibleCipherWarning):
+        prk = rsa_private_key(2, 2, 1)
+        assert decipher_rsa(2, prk) == 2
+
+
+def test_mutltiprime_rsa_full_example():
+    # Test example from
+    # https://iopscience.iop.org/article/10.1088/1742-6596/995/1/012030
+    puk = rsa_public_key(2, 3, 5, 7, 11, 13, 7)
+    prk = rsa_private_key(2, 3, 5, 7, 11, 13, 7)
+    assert puk == (30030, 7)
+    assert prk == (30030, 823)
+
+    msg = 10
+    encrypted = encipher_rsa(2 * msg - 15, puk)
+    assert encrypted == 18065
+    decrypted = (decipher_rsa(encrypted, prk) + 15) / 2
+    assert decrypted == msg
+
+    # Test example from
+    # https://www.scirp.org/pdf/JCC_2018032215502008.pdf
+    puk1 = rsa_public_key(53, 41, 43, 47, 41)
+    prk1 = rsa_private_key(53, 41, 43, 47, 41)
+    puk2 = rsa_public_key(53, 41, 43, 47, 97)
+    prk2 = rsa_private_key(53, 41, 43, 47, 97)
+
+    assert puk1 == (4391633, 41)
+    assert prk1 == (4391633, 294041)
+    assert puk2 == (4391633, 97)
+    assert prk2 == (4391633, 455713)
+
+    msg = 12321
+    encrypted = encipher_rsa(encipher_rsa(msg, puk1), puk2)
+    assert encrypted == 1081588
+    decrypted = decipher_rsa(decipher_rsa(encrypted, prk2), prk1)
+    assert decrypted == msg
+
+
+def test_rsa_crt_extreme():
+    p = int(
+        '10177157607154245068023861503693082120906487143725062283406501' \
+        '54082258226204046999838297167140821364638180697194879500245557' \
+        '65445186962893346463841419427008800341257468600224049986260471' \
+        '92257248163014468841725476918639415726709736077813632961290911' \
+        '0256421232977833028677441206049309220354796014376698325101693')
+
+    q = int(
+        '28752342353095132872290181526607275886182793241660805077850801' \
+        '75689512797754286972952273553128181861830576836289738668745250' \
+        '34028199691128870676414118458442900035778874482624765513861643' \
+        '27966696316822188398336199002306588703902894100476186823849595' \
+        '103239410527279605442148285816149368667083114802852804976893')
+
+    r = int(
+        '17698229259868825776879500736350186838850961935956310134378261' \
+        '89771862186717463067541369694816245225291921138038800171125596' \
+        '07315449521981157084370187887650624061033066022458512942411841' \
+        '18747893789972315277160085086164119879536041875335384844820566' \
+        '0287479617671726408053319619892052000850883994343378882717849')
+
+    s = int(
+        '68925428438585431029269182233502611027091755064643742383515623' \
+        '64321310582896893395529367074942808353187138794422745718419645' \
+        '28291231865157212604266903677599180789896916456120289112752835' \
+        '98502265889669730331688206825220074713977607415178738015831030' \
+        '364290585369150502819743827343552098197095520550865360159439'
+    )
+
+    t = int(
+        '69035483433453632820551311892368908779778144568711455301541094' \
+        '31487047642322695357696860925747923189635033183069823820910521' \
+        '71172909106797748883261493224162414050106920442445896819806600' \
+        '15448444826108008217972129130625571421904893252804729877353352' \
+        '739420480574842850202181462656251626522910618936534699566291'
+    )
+
+    e = 65537
+    puk = rsa_public_key(p, q, r, s, t, e)
+    prk = rsa_private_key(p, q, r, s, t, e)
+
+    plaintext = 1000
+    ciphertext_1 = encipher_rsa(plaintext, puk)
+    ciphertext_2 = encipher_rsa(plaintext, puk, [p, q, r, s, t])
+    assert ciphertext_1 == ciphertext_2
+    assert decipher_rsa(ciphertext_1, prk) == \
+        decipher_rsa(ciphertext_1, prk, [p, q, r, s, t])
+
+
+def test_rsa_exhaustive():
+    p, q = 61, 53
+    e = 17
+    puk = rsa_public_key(p, q, e, totient='Carmichael')
+    prk = rsa_private_key(p, q, e, totient='Carmichael')
+
+    for msg in range(puk[0]):
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_rsa_multiprime_exhanstive():
+    primes = [3, 5, 7, 11]
+    e = 7
+    args = primes + [e]
+    puk = rsa_public_key(*args, totient='Carmichael')
+    prk = rsa_private_key(*args, totient='Carmichael')
+    n = puk[0]
+
+    for msg in range(n):
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_rsa_multipower_exhanstive():
+    primes = [5, 5, 7]
+    e = 7
+    args = primes + [e]
+    puk = rsa_public_key(*args, multipower=True)
+    prk = rsa_private_key(*args, multipower=True)
+    n = puk[0]
+
+    for msg in range(n):
+        if gcd(msg, n) != 1:
+            continue
+
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_kid_rsa_public_key():
+    assert kid_rsa_public_key(1, 2, 1, 1) == (5, 2)
+    assert kid_rsa_public_key(1, 2, 2, 1) == (8, 3)
+    assert kid_rsa_public_key(1, 2, 1, 2) == (7, 2)
+
+
+def test_kid_rsa_private_key():
+    assert kid_rsa_private_key(1, 2, 1, 1) == (5, 3)
+    assert kid_rsa_private_key(1, 2, 2, 1) == (8, 3)
+    assert kid_rsa_private_key(1, 2, 1, 2) == (7, 4)
+
+
+def test_encipher_kid_rsa():
+    assert encipher_kid_rsa(1, (5, 2)) == 2
+    assert encipher_kid_rsa(1, (8, 3)) == 3
+    assert encipher_kid_rsa(1, (7, 2)) == 2
+
+
+def test_decipher_kid_rsa():
+    assert decipher_kid_rsa(2, (5, 3)) == 1
+    assert decipher_kid_rsa(3, (8, 3)) == 1
+    assert decipher_kid_rsa(2, (7, 4)) == 1
+
+
+def test_encode_morse():
+    assert encode_morse('ABC') == '.-|-...|-.-.'
+    assert encode_morse('SMS ') == '...|--|...||'
+    assert encode_morse('SMS\n') == '...|--|...||'
+    assert encode_morse('') == ''
+    assert encode_morse(' ') == '||'
+    assert encode_morse(' ', sep='`') == '``'
+    assert encode_morse(' ', sep='``') == '````'
+    assert encode_morse('!@#$%^&*()_+') == '-.-.--|.--.-.|...-..-|-.--.|-.--.-|..--.-|.-.-.'
+    assert encode_morse('12345') == '.----|..---|...--|....-|.....'
+    assert encode_morse('67890') == '-....|--...|---..|----.|-----'
+
+
+def test_decode_morse():
+    assert decode_morse('-.-|.|-.--') == 'KEY'
+    assert decode_morse('.-.|..-|-.||') == 'RUN'
+    raises(KeyError, lambda: decode_morse('.....----'))
+
+
+def test_lfsr_sequence():
+    raises(TypeError, lambda: lfsr_sequence(1, [1], 1))
+    raises(TypeError, lambda: lfsr_sequence([1], 1, 1))
+    F = FF(2)
+    assert lfsr_sequence([F(1)], [F(1)], 2) == [F(1), F(1)]
+    assert lfsr_sequence([F(0)], [F(1)], 2) == [F(1), F(0)]
+    F = FF(3)
+    assert lfsr_sequence([F(1)], [F(1)], 2) == [F(1), F(1)]
+    assert lfsr_sequence([F(0)], [F(2)], 2) == [F(2), F(0)]
+    assert lfsr_sequence([F(1)], [F(2)], 2) == [F(2), F(2)]
+
+
+def test_lfsr_autocorrelation():
+    raises(TypeError, lambda: lfsr_autocorrelation(1, 2, 3))
+    F = FF(2)
+    s = lfsr_sequence([F(1), F(0)], [F(0), F(1)], 5)
+    assert lfsr_autocorrelation(s, 2, 0) == 1
+    assert lfsr_autocorrelation(s, 2, 1) == -1
+
+
+def test_lfsr_connection_polynomial():
+    F = FF(2)
+    x = symbols("x")
+    s = lfsr_sequence([F(1), F(0)], [F(0), F(1)], 5)
+    assert lfsr_connection_polynomial(s) == x**2 + 1
+    s = lfsr_sequence([F(1), F(1)], [F(0), F(1)], 5)
+    assert lfsr_connection_polynomial(s) == x**2 + x + 1
+
+
+def test_elgamal_private_key():
+    a, b, _ = elgamal_private_key(digit=100)
+    assert isprime(a)
+    assert is_primitive_root(b, a)
+    assert len(bin(a)) >= 102
+
+
+def test_elgamal():
+    dk = elgamal_private_key(5)
+    ek = elgamal_public_key(dk)
+    P = ek[0]
+    assert P - 1 == decipher_elgamal(encipher_elgamal(P - 1, ek), dk)
+    raises(ValueError, lambda: encipher_elgamal(P, dk))
+    raises(ValueError, lambda: encipher_elgamal(-1, dk))
+
+
+def test_dh_private_key():
+    p, g, _ = dh_private_key(digit = 100)
+    assert isprime(p)
+    assert is_primitive_root(g, p)
+    assert len(bin(p)) >= 102
+
+
+def test_dh_public_key():
+    p1, g1, a = dh_private_key(digit = 100)
+    p2, g2, ga = dh_public_key((p1, g1, a))
+    assert p1 == p2
+    assert g1 == g2
+    assert ga == pow(g1, a, p1)
+
+
+def test_dh_shared_key():
+    prk = dh_private_key(digit = 100)
+    p, _, ga = dh_public_key(prk)
+    b = randrange(2, p)
+    sk = dh_shared_key((p, _, ga), b)
+    assert sk == pow(ga, b, p)
+    raises(ValueError, lambda: dh_shared_key((1031, 14, 565), 2000))
+
+
+def test_padded_key():
+    assert padded_key('b', 'ab') == 'ba'
+    raises(ValueError, lambda: padded_key('ab', 'ace'))
+    raises(ValueError, lambda: padded_key('ab', 'abba'))
+
+
+def test_bifid():
+    raises(ValueError, lambda: encipher_bifid('abc', 'b', 'abcde'))
+    assert encipher_bifid('abc', 'b', 'abcd') == 'bdb'
+    raises(ValueError, lambda: decipher_bifid('bdb', 'b', 'abcde'))
+    assert encipher_bifid('bdb', 'b', 'abcd') == 'abc'
+    raises(ValueError, lambda: bifid_square('abcde'))
+    assert bifid5_square("B") == \
+        bifid5_square('BACDEFGHIKLMNOPQRSTUVWXYZ')
+    assert bifid6_square('B0') == \
+        bifid6_square('B0ACDEFGHIJKLMNOPQRSTUVWXYZ123456789')
+
+
+def test_encipher_decipher_gm():
+    ps = [131, 137, 139, 149, 151, 157, 163, 167,
+          173, 179, 181, 191, 193, 197, 199]
+    qs = [89, 97, 101, 103, 107, 109, 113, 127,
+          131, 137, 139, 149, 151, 157, 47]
+    messages = [
+        0, 32855, 34303, 14805, 1280, 75859, 38368,
+        724, 60356, 51675, 76697, 61854, 18661,
+    ]
+    for p, q in zip(ps, qs):
+        pri = gm_private_key(p, q)
+        for msg in messages:
+            pub = gm_public_key(p, q)
+            enc = encipher_gm(msg, pub)
+            dec = decipher_gm(enc, pri)
+            assert dec == msg
+
+
+def test_gm_private_key():
+    raises(ValueError, lambda: gm_public_key(13, 15))
+    raises(ValueError, lambda: gm_public_key(0, 0))
+    raises(ValueError, lambda: gm_public_key(0, 5))
+    assert 17, 19 == gm_public_key(17, 19)
+
+
+def test_gm_public_key():
+    assert 323 == gm_public_key(17, 19)[1]
+    assert 15  == gm_public_key(3, 5)[1]
+    raises(ValueError, lambda: gm_public_key(15, 19))
+
+def test_encipher_decipher_bg():
+    ps = [67, 7, 71, 103, 11, 43, 107, 47,
+          79, 19, 83, 23, 59, 127, 31]
+    qs = qs = [7, 71, 103, 11, 43, 107, 47,
+               79, 19, 83, 23, 59, 127, 31, 67]
+    messages = [
+        0, 328, 343, 148, 1280, 758, 383,
+        724, 603, 516, 766, 618, 186,
+    ]
+
+    for p, q in zip(ps, qs):
+        pri = bg_private_key(p, q)
+        for msg in messages:
+            pub = bg_public_key(p, q)
+            enc = encipher_bg(msg, pub)
+            dec = decipher_bg(enc, pri)
+            assert dec == msg
+
+def test_bg_private_key():
+    raises(ValueError, lambda: bg_private_key(8, 16))
+    raises(ValueError, lambda: bg_private_key(8, 8))
+    raises(ValueError, lambda: bg_private_key(13, 17))
+    assert 23, 31 == bg_private_key(23, 31)
+
+def test_bg_public_key():
+    assert 5293 == bg_public_key(67, 79)
+    assert 713 == bg_public_key(23, 31)
+    raises(ValueError, lambda: bg_private_key(13, 17))

lib/python3.12/site-packages/sympy/external/__init__.py

@@ -0,0 +1,20 @@
+"""
+Unified place for determining if external dependencies are installed or not.
+
+You should import all external modules using the import_module() function.
+
+For example
+
+>>> from sympy.external import import_module
+>>> numpy = import_module('numpy')
+
+If the resulting library is not installed, or if the installed version
+is less than a given minimum version, the function will return None.
+Otherwise, it will return the library. See the docstring of
+import_module() for more information.
+
+"""
+
+from sympy.external.importtools import import_module
+
+__all__ = ['import_module']

lib/python3.12/site-packages/sympy/external/gmpy.py

@@ -0,0 +1,341 @@
+import os
+from ctypes import c_long, sizeof
+from functools import reduce
+from typing import Tuple as tTuple, Type
+from warnings import warn
+
+from sympy.external import import_module
+
+from .pythonmpq import PythonMPQ
+
+from .ntheory import (
+    bit_scan1 as python_bit_scan1,
+    bit_scan0 as python_bit_scan0,
+    remove as python_remove,
+    factorial as python_factorial,
+    sqrt as python_sqrt,
+    sqrtrem as python_sqrtrem,
+    gcd as python_gcd,
+    lcm as python_lcm,
+    gcdext as python_gcdext,
+    is_square as python_is_square,
+    invert as python_invert,
+    legendre as python_legendre,
+    jacobi as python_jacobi,
+    kronecker as python_kronecker,
+    iroot as python_iroot,
+    is_fermat_prp as python_is_fermat_prp,
+    is_euler_prp as python_is_euler_prp,
+    is_strong_prp as python_is_strong_prp,
+    is_fibonacci_prp as python_is_fibonacci_prp,
+    is_lucas_prp as python_is_lucas_prp,
+    is_selfridge_prp as python_is_selfridge_prp,
+    is_strong_lucas_prp as python_is_strong_lucas_prp,
+    is_strong_selfridge_prp as python_is_strong_selfridge_prp,
+    is_bpsw_prp as python_is_bpsw_prp,
+    is_strong_bpsw_prp as python_is_strong_bpsw_prp,
+)
+
+
+__all__ = [
+    # GROUND_TYPES is either 'gmpy' or 'python' depending on which is used. If
+    # gmpy is installed then it will be used unless the environment variable
+    # SYMPY_GROUND_TYPES is set to something other than 'auto', 'gmpy', or
+    # 'gmpy2'.
+    'GROUND_TYPES',
+
+    # If HAS_GMPY is 0, no supported version of gmpy is available. Otherwise,
+    # HAS_GMPY will be 2 for gmpy2 if GROUND_TYPES is 'gmpy'. It used to be
+    # possible for HAS_GMPY to be 1 for gmpy but gmpy is no longer supported.
+    'HAS_GMPY',
+
+    # SYMPY_INTS is a tuple containing the base types for valid integer types.
+    # This is either (int,) or (int, type(mpz(0))) depending on GROUND_TYPES.
+    'SYMPY_INTS',
+
+    # MPQ is either gmpy.mpq or the Python equivalent from
+    # sympy.external.pythonmpq
+    'MPQ',
+
+    # MPZ is either gmpy.mpz or int.
+    'MPZ',
+
+    'bit_scan1',
+    'bit_scan0',
+    'remove',
+    'factorial',
+    'sqrt',
+    'is_square',
+    'sqrtrem',
+    'gcd',
+    'lcm',
+    'gcdext',
+    'invert',
+    'legendre',
+    'jacobi',
+    'kronecker',
+    'iroot',
+    'is_fermat_prp',
+    'is_euler_prp',
+    'is_strong_prp',
+    'is_fibonacci_prp',
+    'is_lucas_prp',
+    'is_selfridge_prp',
+    'is_strong_lucas_prp',
+    'is_strong_selfridge_prp',
+    'is_bpsw_prp',
+    'is_strong_bpsw_prp',
+]
+
+
+#
+# Tested python-flint version. Future versions might work but we will only use
+# them if explicitly requested by SYMPY_GROUND_TYPES=flint.
+#
+_PYTHON_FLINT_VERSION_NEEDED = ["0.6", "0.7", "0.8", "0.9"]
+
+
+def _flint_version_okay(flint_version):
+    major, minor = flint_version.split('.')[:2]
+    flint_ver = f'{major}.{minor}'
+    return flint_ver in _PYTHON_FLINT_VERSION_NEEDED
+
+#
+# We will only use gmpy2 >= 2.0.0
+#
+_GMPY2_MIN_VERSION = '2.0.0'
+
+
+def _get_flint(sympy_ground_types):
+    if sympy_ground_types not in ('auto', 'flint'):
+        return None
+
+    try:
+        import flint
+        # Earlier versions of python-flint may not have __version__.
+        from flint import __version__ as _flint_version
+    except ImportError:
+        if sympy_ground_types == 'flint':
+            warn("SYMPY_GROUND_TYPES was set to flint but python-flint is not "
+                 "installed. Falling back to other ground types.")
+        return None
+
+    if _flint_version_okay(_flint_version):
+        return flint
+    elif sympy_ground_types == 'auto':
+        return None
+    else:
+        warn(f"Using python-flint {_flint_version} because SYMPY_GROUND_TYPES "
+             f"is set to flint but this version of SymPy is only tested "
+             f"with python-flint versions {_PYTHON_FLINT_VERSION_NEEDED}.")
+        return flint
+
+
+def _get_gmpy2(sympy_ground_types):
+    if sympy_ground_types not in ('auto', 'gmpy', 'gmpy2'):
+        return None
+
+    gmpy = import_module('gmpy2', min_module_version=_GMPY2_MIN_VERSION,
+            module_version_attr='version', module_version_attr_call_args=())
+
+    if sympy_ground_types != 'auto' and gmpy is None:
+        warn("gmpy2 library is not installed, switching to 'python' ground types")
+
+    return gmpy
+
+
+#
+# SYMPY_GROUND_TYPES can be flint, gmpy, gmpy2, python or auto (default)
+#
+_SYMPY_GROUND_TYPES = os.environ.get('SYMPY_GROUND_TYPES', 'auto').lower()
+_flint = None
+_gmpy = None
+
+#
+# First handle auto-detection of flint/gmpy2. We will prefer flint if available
+# or otherwise gmpy2 if available and then lastly the python types.
+#
+if _SYMPY_GROUND_TYPES in ('auto', 'flint'):
+    _flint = _get_flint(_SYMPY_GROUND_TYPES)
+    if _flint is not None:
+        _SYMPY_GROUND_TYPES = 'flint'
+    else:
+        _SYMPY_GROUND_TYPES = 'auto'
+
+if _SYMPY_GROUND_TYPES in ('auto', 'gmpy', 'gmpy2'):
+    _gmpy = _get_gmpy2(_SYMPY_GROUND_TYPES)
+    if _gmpy is not None:
+        _SYMPY_GROUND_TYPES = 'gmpy'
+    else:
+        _SYMPY_GROUND_TYPES = 'python'
+
+if _SYMPY_GROUND_TYPES not in ('flint', 'gmpy', 'python'):
+    warn("SYMPY_GROUND_TYPES environment variable unrecognised. "
+         "Should be 'auto', 'flint', 'gmpy', 'gmpy2' or 'python'.")
+    _SYMPY_GROUND_TYPES = 'python'
+
+#
+# At this point _SYMPY_GROUND_TYPES is either flint, gmpy or python. The blocks
+# below define the values exported by this module in each case.
+#
+
+#
+# In gmpy2 and flint, there are functions that take a long (or unsigned long)
+# argument. That is, it is not possible to input a value larger than that.
+#
+LONG_MAX = (1 << (8*sizeof(c_long) - 1)) - 1
+
+#
+# Type checkers are confused by what SYMPY_INTS is. There may be a better type
+# hint for this like Type[Integral] or something.
+#
+SYMPY_INTS: tTuple[Type, ...]
+
+if _SYMPY_GROUND_TYPES == 'gmpy':
+
+    assert _gmpy is not None
+
+    flint = None
+    gmpy = _gmpy
+
+    HAS_GMPY = 2
+    GROUND_TYPES = 'gmpy'
+    SYMPY_INTS = (int, type(gmpy.mpz(0)))
+    MPZ = gmpy.mpz
+    MPQ = gmpy.mpq
+
+    bit_scan1 = gmpy.bit_scan1
+    bit_scan0 = gmpy.bit_scan0
+    remove = gmpy.remove
+    factorial = gmpy.fac
+    sqrt = gmpy.isqrt
+    is_square = gmpy.is_square
+    sqrtrem = gmpy.isqrt_rem
+    gcd = gmpy.gcd
+    lcm = gmpy.lcm
+    gcdext = gmpy.gcdext
+    invert = gmpy.invert
+    legendre = gmpy.legendre
+    jacobi = gmpy.jacobi
+    kronecker = gmpy.kronecker
+
+    def iroot(x, n):
+        # In the latest gmpy2, the threshold for n is ULONG_MAX,
+        # but adjust to the older one.
+        if n <= LONG_MAX:
+            return gmpy.iroot(x, n)
+        return python_iroot(x, n)
+
+    is_fermat_prp = gmpy.is_fermat_prp
+    is_euler_prp = gmpy.is_euler_prp
+    is_strong_prp = gmpy.is_strong_prp
+    is_fibonacci_prp = gmpy.is_fibonacci_prp
+    is_lucas_prp = gmpy.is_lucas_prp
+    is_selfridge_prp = gmpy.is_selfridge_prp
+    is_strong_lucas_prp = gmpy.is_strong_lucas_prp
+    is_strong_selfridge_prp = gmpy.is_strong_selfridge_prp
+    is_bpsw_prp = gmpy.is_bpsw_prp
+    is_strong_bpsw_prp = gmpy.is_strong_bpsw_prp
+
+elif _SYMPY_GROUND_TYPES == 'flint':
+
+    assert _flint is not None
+
+    flint = _flint
+    gmpy = None
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'flint'
+    SYMPY_INTS = (int, flint.fmpz) # type: ignore
+    MPZ = flint.fmpz # type: ignore
+    MPQ = flint.fmpq # type: ignore
+
+    bit_scan1 = python_bit_scan1
+    bit_scan0 = python_bit_scan0
+    remove = python_remove
+    factorial = python_factorial
+
+    def sqrt(x):
+        return flint.fmpz(x).isqrt()
+
+    def is_square(x):
+        if x < 0:
+            return False
+        return flint.fmpz(x).sqrtrem()[1] == 0
+
+    def sqrtrem(x):
+        return flint.fmpz(x).sqrtrem()
+
+    def gcd(*args):
+        return reduce(flint.fmpz.gcd, args, flint.fmpz(0))
+
+    def lcm(*args):
+        return reduce(flint.fmpz.lcm, args, flint.fmpz(1))
+
+    gcdext = python_gcdext
+    invert = python_invert
+    legendre = python_legendre
+
+    def jacobi(x, y):
+        if y <= 0 or not y % 2:
+            raise ValueError("y should be an odd positive integer")
+        return flint.fmpz(x).jacobi(y)
+
+    kronecker = python_kronecker
+
+    def iroot(x, n):
+        if n <= LONG_MAX:
+            y = flint.fmpz(x).root(n)
+            return y, y**n == x
+        return python_iroot(x, n)
+
+    is_fermat_prp = python_is_fermat_prp
+    is_euler_prp = python_is_euler_prp
+    is_strong_prp = python_is_strong_prp
+    is_fibonacci_prp = python_is_fibonacci_prp
+    is_lucas_prp = python_is_lucas_prp
+    is_selfridge_prp = python_is_selfridge_prp
+    is_strong_lucas_prp = python_is_strong_lucas_prp
+    is_strong_selfridge_prp = python_is_strong_selfridge_prp
+    is_bpsw_prp = python_is_bpsw_prp
+    is_strong_bpsw_prp = python_is_strong_bpsw_prp
+
+elif _SYMPY_GROUND_TYPES == 'python':
+
+    flint = None
+    gmpy = None
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'python'
+    SYMPY_INTS = (int,)
+    MPZ = int
+    MPQ = PythonMPQ
+
+    bit_scan1 = python_bit_scan1
+    bit_scan0 = python_bit_scan0
+    remove = python_remove
+    factorial = python_factorial
+    sqrt = python_sqrt
+    is_square = python_is_square
+    sqrtrem = python_sqrtrem
+    gcd = python_gcd
+    lcm = python_lcm
+    gcdext = python_gcdext
+    invert = python_invert
+    legendre = python_legendre
+    jacobi = python_jacobi
+    kronecker = python_kronecker
+    iroot = python_iroot
+    is_fermat_prp = python_is_fermat_prp
+    is_euler_prp = python_is_euler_prp
+    is_strong_prp = python_is_strong_prp
+    is_fibonacci_prp = python_is_fibonacci_prp
+    is_lucas_prp = python_is_lucas_prp
+    is_selfridge_prp = python_is_selfridge_prp
+    is_strong_lucas_prp = python_is_strong_lucas_prp
+    is_strong_selfridge_prp = python_is_strong_selfridge_prp
+    is_bpsw_prp = python_is_bpsw_prp
+    is_strong_bpsw_prp = python_is_strong_bpsw_prp
+
+else:
+    assert False

lib/python3.12/site-packages/sympy/external/importtools.py

@@ -0,0 +1,187 @@
+"""Tools to assist importing optional external modules."""
+
+import sys
+import re
+
+# Override these in the module to change the default warning behavior.
+# For example, you might set both to False before running the tests so that
+# warnings are not printed to the console, or set both to True for debugging.
+
+WARN_NOT_INSTALLED = None  # Default is False
+WARN_OLD_VERSION = None  # Default is True
+
+
+def __sympy_debug():
+    # helper function from sympy/__init__.py
+    # We don't just import SYMPY_DEBUG from that file because we don't want to
+    # import all of SymPy just to use this module.
+    import os
+    debug_str = os.getenv('SYMPY_DEBUG', 'False')
+    if debug_str in ('True', 'False'):
+        return eval(debug_str)
+    else:
+        raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
+                           debug_str)
+
+if __sympy_debug():
+    WARN_OLD_VERSION = True
+    WARN_NOT_INSTALLED = True
+
+
+_component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+def version_tuple(vstring):
+    # Parse a version string to a tuple e.g. '1.2' -> (1, 2)
+    # Simplified from distutils.version.LooseVersion which was deprecated in
+    # Python 3.10.
+    components = []
+    for x in _component_re.split(vstring):
+        if x and x != '.':
+            try:
+                x = int(x)
+            except ValueError:
+                pass
+            components.append(x)
+    return tuple(components)
+
+
+def import_module(module, min_module_version=None, min_python_version=None,
+        warn_not_installed=None, warn_old_version=None,
+        module_version_attr='__version__', module_version_attr_call_args=None,
+        import_kwargs={}, catch=()):
+    """
+    Import and return a module if it is installed.
+
+    If the module is not installed, it returns None.
+
+    A minimum version for the module can be given as the keyword argument
+    min_module_version.  This should be comparable against the module version.
+    By default, module.__version__ is used to get the module version.  To
+    override this, set the module_version_attr keyword argument.  If the
+    attribute of the module to get the version should be called (e.g.,
+    module.version()), then set module_version_attr_call_args to the args such
+    that module.module_version_attr(*module_version_attr_call_args) returns the
+    module's version.
+
+    If the module version is less than min_module_version using the Python <
+    comparison, None will be returned, even if the module is installed. You can
+    use this to keep from importing an incompatible older version of a module.
+
+    You can also specify a minimum Python version by using the
+    min_python_version keyword argument.  This should be comparable against
+    sys.version_info.
+
+    If the keyword argument warn_not_installed is set to True, the function will
+    emit a UserWarning when the module is not installed.
+
+    If the keyword argument warn_old_version is set to True, the function will
+    emit a UserWarning when the library is installed, but cannot be imported
+    because of the min_module_version or min_python_version options.
+
+    Note that because of the way warnings are handled, a warning will be
+    emitted for each module only once.  You can change the default warning
+    behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION
+    in sympy.external.importtools.  By default, WARN_NOT_INSTALLED is False and
+    WARN_OLD_VERSION is True.
+
+    This function uses __import__() to import the module.  To pass additional
+    options to __import__(), use the import_kwargs keyword argument.  For
+    example, to import a submodule A.B, you must pass a nonempty fromlist option
+    to __import__.  See the docstring of __import__().
+
+    This catches ImportError to determine if the module is not installed.  To
+    catch additional errors, pass them as a tuple to the catch keyword
+    argument.
+
+    Examples
+    ========
+
+    >>> from sympy.external import import_module
+
+    >>> numpy = import_module('numpy')
+
+    >>> numpy = import_module('numpy', min_python_version=(2, 7),
+    ... warn_old_version=False)
+
+    >>> numpy = import_module('numpy', min_module_version='1.5',
+    ... warn_old_version=False) # numpy.__version__ is a string
+
+    >>> # gmpy does not have __version__, but it does have gmpy.version()
+
+    >>> gmpy = import_module('gmpy', min_module_version='1.14',
+    ... module_version_attr='version', module_version_attr_call_args=(),
+    ... warn_old_version=False)
+
+    >>> # To import a submodule, you must pass a nonempty fromlist to
+    >>> # __import__().  The values do not matter.
+    >>> p3 = import_module('mpl_toolkits.mplot3d',
+    ... import_kwargs={'fromlist':['something']})
+
+    >>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened
+    >>> matplotlib = import_module('matplotlib',
+    ... import_kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,))
+
+    """
+    # keyword argument overrides default, and global variable overrides
+    # keyword argument.
+    warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None
+        else warn_old_version or True)
+    warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None
+        else warn_not_installed or False)
+
+    import warnings
+
+    # Check Python first so we don't waste time importing a module we can't use
+    if min_python_version:
+        if sys.version_info < min_python_version:
+            if warn_old_version:
+                warnings.warn("Python version is too old to use %s "
+                    "(%s or newer required)" % (
+                        module, '.'.join(map(str, min_python_version))),
+                    UserWarning, stacklevel=2)
+            return
+
+    try:
+        mod = __import__(module, **import_kwargs)
+
+        ## there's something funny about imports with matplotlib and py3k. doing
+        ##    from matplotlib import collections
+        ## gives python's stdlib collections module. explicitly re-importing
+        ## the module fixes this.
+        from_list = import_kwargs.get('fromlist', ())
+        for submod in from_list:
+            if submod == 'collections' and mod.__name__ == 'matplotlib':
+                __import__(module + '.' + submod)
+    except ImportError:
+        if warn_not_installed:
+            warnings.warn("%s module is not installed" % module, UserWarning,
+                    stacklevel=2)
+        return
+    except catch as e:
+        if warn_not_installed:
+            warnings.warn(
+                "%s module could not be used (%s)" % (module, repr(e)),
+                stacklevel=2)
+        return
+
+    if min_module_version:
+        modversion = getattr(mod, module_version_attr)
+        if module_version_attr_call_args is not None:
+            modversion = modversion(*module_version_attr_call_args)
+        if version_tuple(modversion) < version_tuple(min_module_version):
+            if warn_old_version:
+                # Attempt to create a pretty string version of the version
+                if isinstance(min_module_version, str):
+                    verstr = min_module_version
+                elif isinstance(min_module_version, (tuple, list)):
+                    verstr = '.'.join(map(str, min_module_version))
+                else:
+                    # Either don't know what this is.  Hopefully
+                    # it's something that has a nice str version, like an int.
+                    verstr = str(min_module_version)
+                warnings.warn("%s version is too old to use "
+                    "(%s or newer required)" % (module, verstr),
+                    UserWarning, stacklevel=2)
+            return
+
+    return mod

lib/python3.12/site-packages/sympy/external/ntheory.py

@@ -0,0 +1,637 @@
+# sympy.external.ntheory
+#
+# This module provides pure Python implementations of some number theory
+# functions that are alternately used from gmpy2 if it is installed.
+
+import sys
+import math
+
+import mpmath.libmp as mlib
+
+
+_small_trailing = [0] * 256
+for j in range(1, 8):
+    _small_trailing[1 << j :: 1 << (j + 1)] = [j] * (1 << (7 - j))
+
+
+def bit_scan1(x, n=0):
+    if not x:
+        return
+    x = abs(x >> n)
+    low_byte = x & 0xFF
+    if low_byte:
+        return _small_trailing[low_byte] + n
+
+    t = 8 + n
+    x >>= 8
+    # 2**m is quick for z up through 2**30
+    z = x.bit_length() - 1
+    if x == 1 << z:
+        return z + t
+
+    if z < 300:
+        # fixed 8-byte reduction
+        while not x & 0xFF:
+            x >>= 8
+            t += 8
+    else:
+        # binary reduction important when there might be a large
+        # number of trailing 0s
+        p = z >> 1
+        while not x & 0xFF:
+            while x & ((1 << p) - 1):
+                p >>= 1
+            x >>= p
+            t += p
+    return t + _small_trailing[x & 0xFF]
+
+
+def bit_scan0(x, n=0):
+    return bit_scan1(x + (1 << n), n)
+
+
+def remove(x, f):
+    if f < 2:
+        raise ValueError("factor must be > 1")
+    if x == 0:
+        return 0, 0
+    if f == 2:
+        b = bit_scan1(x)
+        return x >> b, b
+    m = 0
+    y, rem = divmod(x, f)
+    while not rem:
+        x = y
+        m += 1
+        if m > 5:
+            pow_list = [f**2]
+            while pow_list:
+                _f = pow_list[-1]
+                y, rem = divmod(x, _f)
+                if not rem:
+                    m += 1 << len(pow_list)
+                    x = y
+                    pow_list.append(_f**2)
+                else:
+                    pow_list.pop()
+        y, rem = divmod(x, f)
+    return x, m
+
+
+def factorial(x):
+    """Return x!."""
+    return int(mlib.ifac(int(x)))
+
+
+def sqrt(x):
+    """Integer square root of x."""
+    return int(mlib.isqrt(int(x)))
+
+
+def sqrtrem(x):
+    """Integer square root of x and remainder."""
+    s, r = mlib.sqrtrem(int(x))
+    return (int(s), int(r))
+
+
+if sys.version_info[:2] >= (3, 9):
+    # As of Python 3.9 these can take multiple arguments
+    gcd = math.gcd
+    lcm = math.lcm
+
+else:
+    # Until python 3.8 is no longer supported
+    from functools import reduce
+
+
+    def gcd(*args):
+        """gcd of multiple integers."""
+        return reduce(math.gcd, args, 0)
+
+
+    def lcm(*args):
+        """lcm of multiple integers."""
+        if 0 in args:
+            return 0
+        return reduce(lambda x, y: x*y//math.gcd(x, y), args, 1)
+
+
+def _sign(n):
+    if n < 0:
+        return -1, -n
+    return 1, n
+
+
+def gcdext(a, b):
+    if not a or not b:
+        g = abs(a) or abs(b)
+        if not g:
+            return (0, 0, 0)
+        return (g, a // g, b // g)
+
+    x_sign, a = _sign(a)
+    y_sign, b = _sign(b)
+    x, r = 1, 0
+    y, s = 0, 1
+
+    while b:
+        q, c = divmod(a, b)
+        a, b = b, c
+        x, r = r, x - q*r
+        y, s = s, y - q*s
+
+    return (a, x * x_sign, y * y_sign)
+
+
+def is_square(x):
+    """Return True if x is a square number."""
+    if x < 0:
+        return False
+
+    # Note that the possible values of y**2 % n for a given n are limited.
+    # For example, when n=4, y**2 % n can only take 0 or 1.
+    # In other words, if x % 4 is 2 or 3, then x is not a square number.
+    # Mathematically, it determines if it belongs to the set {y**2 % n},
+    # but implementationally, it can be realized as a logical conjunction
+    # with an n-bit integer.
+    # see https://mersenneforum.org/showpost.php?p=110896
+    # def magic(n):
+    #     s = {y**2 % n for y in range(n)}
+    #     s = set(range(n)) - s
+    #     return sum(1 << bit for bit in s)
+    # >>> print(hex(magic(128)))
+    # 0xfdfdfdedfdfdfdecfdfdfdedfdfcfdec
+    # >>> print(hex(magic(99)))
+    # 0x5f6f9ffb6fb7ddfcb75befdec
+    # >>> print(hex(magic(91)))
+    # 0x6fd1bfcfed5f3679d3ebdec
+    # >>> print(hex(magic(85)))
+    # 0xdef9ae771ffe3b9d67dec
+    if 0xfdfdfdedfdfdfdecfdfdfdedfdfcfdec & (1 << (x & 127)):
+        return False  # e.g. 2, 3
+    m = x % 765765 # 765765 = 99 * 91 * 85
+    if 0x5f6f9ffb6fb7ddfcb75befdec & (1 << (m % 99)):
+        return False  # e.g. 17, 68
+    if 0x6fd1bfcfed5f3679d3ebdec & (1 << (m % 91)):
+        return False  # e.g. 97, 388
+    if 0xdef9ae771ffe3b9d67dec & (1 << (m % 85)):
+        return False  # e.g. 793, 1408
+    return mlib.sqrtrem(int(x))[1] == 0
+
+
+def invert(x, m):
+    """Modular inverse of x modulo m.
+
+    Returns y such that x*y == 1 mod m.
+
+    Uses ``math.pow`` but reproduces the behaviour of ``gmpy2.invert``
+    which raises ZeroDivisionError if no inverse exists.
+    """
+    try:
+        return pow(x, -1, m)
+    except ValueError:
+        raise ZeroDivisionError("invert() no inverse exists")
+
+
+def legendre(x, y):
+    """Legendre symbol (x / y).
+
+    Following the implementation of gmpy2,
+    the error is raised only when y is an even number.
+    """
+    if y <= 0 or not y % 2:
+        raise ValueError("y should be an odd prime")
+    x %= y
+    if not x:
+        return 0
+    if pow(x, (y - 1) // 2, y) == 1:
+        return 1
+    return -1
+
+
+def jacobi(x, y):
+    """Jacobi symbol (x / y)."""
+    if y <= 0 or not y % 2:
+        raise ValueError("y should be an odd positive integer")
+    x %= y
+    if not x:
+        return int(y == 1)
+    if y == 1 or x == 1:
+        return 1
+    if gcd(x, y) != 1:
+        return 0
+    j = 1
+    while x != 0:
+        while x % 2 == 0 and x > 0:
+            x >>= 1
+            if y % 8 in [3, 5]:
+                j = -j
+        x, y = y, x
+        if x % 4 == y % 4 == 3:
+            j = -j
+        x %= y
+    return j
+
+
+def kronecker(x, y):
+    """Kronecker symbol (x / y)."""
+    if gcd(x, y) != 1:
+        return 0
+    if y == 0:
+        return 1
+    sign = -1 if y < 0 and x < 0 else 1
+    y = abs(y)
+    s = bit_scan1(y)
+    y >>= s
+    if s % 2 and x % 8 in [3, 5]:
+        sign = -sign
+    return sign * jacobi(x, y)
+
+
+def iroot(y, n):
+    if y < 0:
+        raise ValueError("y must be nonnegative")
+    if n < 1:
+        raise ValueError("n must be positive")
+    if y in (0, 1):
+        return y, True
+    if n == 1:
+        return y, True
+    if n == 2:
+        x, rem = mlib.sqrtrem(y)
+        return int(x), not rem
+    if n >= y.bit_length():
+        return 1, False
+    # Get initial estimate for Newton's method. Care must be taken to
+    # avoid overflow
+    try:
+        guess = int(y**(1./n) + 0.5)
+    except OverflowError:
+        exp = math.log2(y)/n
+        if exp > 53:
+            shift = int(exp - 53)
+            guess = int(2.0**(exp - shift) + 1) << shift
+        else:
+            guess = int(2.0**exp)
+    if guess > 2**50:
+        # Newton iteration
+        xprev, x = -1, guess
+        while 1:
+            t = x**(n - 1)
+            xprev, x = x, ((n - 1)*x + y//t)//n
+            if abs(x - xprev) < 2:
+                break
+    else:
+        x = guess
+    # Compensate
+    t = x**n
+    while t < y:
+        x += 1
+        t = x**n
+    while t > y:
+        x -= 1
+        t = x**n
+    return x, t == y
+
+
+def is_fermat_prp(n, a):
+    if a < 2:
+        raise ValueError("is_fermat_prp() requires 'a' greater than or equal to 2")
+    if n < 1:
+        raise ValueError("is_fermat_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    a %= n
+    if gcd(n, a) != 1:
+        raise ValueError("is_fermat_prp() requires gcd(n,a) == 1")
+    return pow(a, n - 1, n) == 1
+
+
+def is_euler_prp(n, a):
+    if a < 2:
+        raise ValueError("is_euler_prp() requires 'a' greater than or equal to 2")
+    if n < 1:
+        raise ValueError("is_euler_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    a %= n
+    if gcd(n, a) != 1:
+        raise ValueError("is_euler_prp() requires gcd(n,a) == 1")
+    return pow(a, n >> 1, n) == jacobi(a, n) % n
+
+
+def _is_strong_prp(n, a):
+    s = bit_scan1(n - 1)
+    a = pow(a, n >> s, n)
+    if a == 1 or a == n - 1:
+        return True
+    for _ in range(s - 1):
+        a = pow(a, 2, n)
+        if a == n - 1:
+            return True
+        if a == 1:
+            return False
+    return False
+
+
+def is_strong_prp(n, a):
+    if a < 2:
+        raise ValueError("is_strong_prp() requires 'a' greater than or equal to 2")
+    if n < 1:
+        raise ValueError("is_strong_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    a %= n
+    if gcd(n, a) != 1:
+        raise ValueError("is_strong_prp() requires gcd(n,a) == 1")
+    return _is_strong_prp(n, a)
+
+
+def _lucas_sequence(n, P, Q, k):
+    r"""Return the modular Lucas sequence (U_k, V_k, Q_k).
+
+    Explanation
+    ===========
+
+    Given a Lucas sequence defined by P, Q, returns the kth values for
+    U and V, along with Q^k, all modulo n. This is intended for use with
+    possibly very large values of n and k, where the combinatorial functions
+    would be completely unusable.
+
+    .. math ::
+        U_k = \begin{cases}
+             0 & \text{if } k = 0\\
+             1 & \text{if } k = 1\\
+             PU_{k-1} - QU_{k-2} & \text{if } k > 1
+        \end{cases}\\
+        V_k = \begin{cases}
+             2 & \text{if } k = 0\\
+             P & \text{if } k = 1\\
+             PV_{k-1} - QV_{k-2} & \text{if } k > 1
+        \end{cases}
+
+    The modular Lucas sequences are used in numerous places in number theory,
+    especially in the Lucas compositeness tests and the various n + 1 proofs.
+
+    Parameters
+    ==========
+
+    n : int
+        n is an odd number greater than or equal to 3
+    P : int
+    Q : int
+        D determined by D = P**2 - 4*Q is non-zero
+    k : int
+        k is a nonnegative integer
+
+    Returns
+    =======
+
+    U, V, Qk : (int, int, int)
+        `(U_k \bmod{n}, V_k \bmod{n}, Q^k \bmod{n})`
+
+    Examples
+    ========
+
+    >>> from sympy.external.ntheory import _lucas_sequence
+    >>> N = 10**2000 + 4561
+    >>> sol = U, V, Qk = _lucas_sequence(N, 3, 1, N//2); sol
+    (0, 2, 1)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lucas_sequence
+
+    """
+    if k == 0:
+        return (0, 2, 1)
+    D = P**2 - 4*Q
+    U = 1
+    V = P
+    Qk = Q % n
+    if Q == 1:
+        # Optimization for extra strong tests.
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            V = (V*V - 2) % n
+            if b == "1":
+                U, V = U*P + V, V*P + U*D
+                if U & 1:
+                    U += n
+                if V & 1:
+                    V += n
+                U, V = U >> 1, V >> 1
+    elif P == 1 and Q == -1:
+        # Small optimization for 50% of Selfridge parameters.
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            if Qk == 1:
+                V = (V*V - 2) % n
+            else:
+                V = (V*V + 2) % n
+                Qk = 1
+            if b == "1":
+                # new_U = (U + V) // 2
+                # new_V = (5*U + V) // 2 = 2*U + new_U
+                U, V  = U + V, U << 1
+                if U & 1:
+                    U += n
+                U >>= 1
+                V += U
+                Qk = -1
+        Qk %= n
+    elif P == 1:
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            V = (V*V - 2*Qk) % n
+            Qk *= Qk
+            if b == "1":
+                # new_U = (U + V) // 2
+                # new_V = new_U - 2*Q*U
+                U, V  = U + V, (Q*U) << 1
+                if U & 1:
+                    U += n
+                U >>= 1
+                V = U - V
+                Qk *= Q
+            Qk %= n
+    else:
+        # The general case with any P and Q.
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            V = (V*V - 2*Qk) % n
+            Qk *= Qk
+            if b == "1":
+                U, V = U*P + V, V*P + U*D
+                if U & 1:
+                    U += n
+                if V & 1:
+                    V += n
+                U, V = U >> 1, V >> 1
+                Qk *= Q
+            Qk %= n
+    return (U % n, V % n, Qk)
+
+
+def is_fibonacci_prp(n, p, q):
+    d = p**2 - 4*q
+    if d == 0 or p <= 0 or q not in [1, -1]:
+        raise ValueError("invalid values for p,q in is_fibonacci_prp()")
+    if n < 1:
+        raise ValueError("is_fibonacci_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _lucas_sequence(n, p, q, n)[1] == p % n
+
+
+def is_lucas_prp(n, p, q):
+    d = p**2 - 4*q
+    if d == 0:
+        raise ValueError("invalid values for p,q in is_lucas_prp()")
+    if n < 1:
+        raise ValueError("is_lucas_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    if gcd(n, q*d) not in [1, n]:
+        raise ValueError("is_lucas_prp() requires gcd(n,2*q*D) == 1")
+    return _lucas_sequence(n, p, q, n - jacobi(d, n))[0] == 0
+
+
+def _is_selfridge_prp(n):
+    """Lucas compositeness test with the Selfridge parameters for n.
+
+    Explanation
+    ===========
+
+    The Lucas compositeness test checks whether n is a prime number.
+    The test can be run with arbitrary parameters ``P`` and ``Q``, which also change the performance of the test.
+    So, which parameters are most effective for running the Lucas compositeness test?
+    As an algorithm for determining ``P`` and ``Q``, Selfridge proposed method A [1]_ page 1401
+    (Since two methods were proposed, referred to simply as A and B in the paper,
+    we will refer to one of them as "method A").
+
+    method A fixes ``P = 1``. Then, ``D`` defined by ``D = P**2 - 4Q`` is varied from 5, -7, 9, -11, 13, and so on,
+    with the first ``D`` being ``jacobi(D, n) == -1``. Once ``D`` is determined,
+    ``Q`` is determined to be ``(P**2 - D)//4``.
+
+    References
+    ==========
+
+    .. [1] Robert Baillie, Samuel S. Wagstaff, Lucas Pseudoprimes,
+           Math. Comp. Vol 35, Number 152 (1980), pp. 1391-1417,
+           https://doi.org/10.1090%2FS0025-5718-1980-0583518-6
+           http://mpqs.free.fr/LucasPseudoprimes.pdf
+
+    """
+    for D in range(5, 1_000_000, 2):
+        if D & 2: # if D % 4 == 3
+            D = -D
+        j = jacobi(D, n)
+        if j == -1:
+            return _lucas_sequence(n, 1, (1-D) // 4, n + 1)[0] == 0
+        if j == 0 and D % n:
+            return False
+        # When j == -1 is hard to find, suspect a square number
+        if D == 13 and is_square(n):
+            return False
+    raise ValueError("appropriate value for D cannot be found in is_selfridge_prp()")
+
+
+def is_selfridge_prp(n):
+    if n < 1:
+        raise ValueError("is_selfridge_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_selfridge_prp(n)
+
+
+def is_strong_lucas_prp(n, p, q):
+    D = p**2 - 4*q
+    if D == 0:
+        raise ValueError("invalid values for p,q in is_strong_lucas_prp()")
+    if n < 1:
+        raise ValueError("is_selfridge_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    if gcd(n, q*D) not in [1, n]:
+        raise ValueError("is_strong_lucas_prp() requires gcd(n,2*q*D) == 1")
+    j = jacobi(D, n)
+    s = bit_scan1(n - j)
+    U, V, Qk = _lucas_sequence(n, p, q, (n - j) >> s)
+    if U == 0 or V == 0:
+        return True
+    for _ in range(s - 1):
+        V = (V*V - 2*Qk) % n
+        if V == 0:
+            return True
+        Qk = pow(Qk, 2, n)
+    return False
+
+
+def _is_strong_selfridge_prp(n):
+    for D in range(5, 1_000_000, 2):
+        if D & 2: # if D % 4 == 3
+            D = -D
+        j = jacobi(D, n)
+        if j == -1:
+            s = bit_scan1(n + 1)
+            U, V, Qk = _lucas_sequence(n, 1, (1-D) // 4, (n + 1) >> s)
+            if U == 0 or V == 0:
+                return True
+            for _ in range(s - 1):
+                V = (V*V - 2*Qk) % n
+                if V == 0:
+                    return True
+                Qk = pow(Qk, 2, n)
+            return False
+        if j == 0 and D % n:
+            return False
+        # When j == -1 is hard to find, suspect a square number
+        if D == 13 and is_square(n):
+            return False
+    raise ValueError("appropriate value for D cannot be found in is_strong_selfridge_prp()")
+
+
+def is_strong_selfridge_prp(n):
+    if n < 1:
+        raise ValueError("is_strong_selfridge_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_strong_selfridge_prp(n)
+
+
+def is_bpsw_prp(n):
+    if n < 1:
+        raise ValueError("is_bpsw_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_strong_prp(n, 2) and _is_selfridge_prp(n)
+
+
+def is_strong_bpsw_prp(n):
+    if n < 1:
+        raise ValueError("is_strong_bpsw_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_strong_prp(n, 2) and _is_strong_selfridge_prp(n)

lib/python3.12/site-packages/sympy/external/pythonmpq.py

@@ -0,0 +1,341 @@
+"""
+PythonMPQ: Rational number type based on Python integers.
+
+This class is intended as a pure Python fallback for when gmpy2 is not
+installed. If gmpy2 is installed then its mpq type will be used instead. The
+mpq type is around 20x faster. We could just use the stdlib Fraction class
+here but that is slower:
+
+    from fractions import Fraction
+    from sympy.external.pythonmpq import PythonMPQ
+    nums = range(1000)
+    dens = range(5, 1005)
+    rats = [Fraction(n, d) for n, d in zip(nums, dens)]
+    sum(rats) # <--- 24 milliseconds
+    rats = [PythonMPQ(n, d) for n, d in zip(nums, dens)]
+    sum(rats) # <---  7 milliseconds
+
+Both mpq and Fraction have some awkward features like the behaviour of
+division with // and %:
+
+    >>> from fractions import Fraction
+    >>> Fraction(2, 3) % Fraction(1, 4)
+    1/6
+
+For the QQ domain we do not want this behaviour because there should be no
+remainder when dividing rational numbers. SymPy does not make use of this
+aspect of mpq when gmpy2 is installed. Since this class is a fallback for that
+case we do not bother implementing e.g. __mod__ so that we can be sure we
+are not using it when gmpy2 is installed either.
+"""
+
+
+import operator
+from math import gcd
+from decimal import Decimal
+from fractions import Fraction
+import sys
+from typing import Tuple as tTuple, Type
+
+
+# Used for __hash__
+_PyHASH_MODULUS = sys.hash_info.modulus
+_PyHASH_INF = sys.hash_info.inf
+
+
+class PythonMPQ:
+    """Rational number implementation that is intended to be compatible with
+    gmpy2's mpq.
+
+    Also slightly faster than fractions.Fraction.
+
+    PythonMPQ should be treated as immutable although no effort is made to
+    prevent mutation (since that might slow down calculations).
+    """
+    __slots__ = ('numerator', 'denominator')
+
+    def __new__(cls, numerator, denominator=None):
+        """Construct PythonMPQ with gcd computation and checks"""
+        if denominator is not None:
+            #
+            # PythonMPQ(n, d): require n and d to be int and d != 0
+            #
+            if isinstance(numerator, int) and isinstance(denominator, int):
+                # This is the slow part:
+                divisor = gcd(numerator, denominator)
+                numerator //= divisor
+                denominator //= divisor
+                return cls._new_check(numerator, denominator)
+        else:
+            #
+            # PythonMPQ(q)
+            #
+            # Here q can be PythonMPQ, int, Decimal, float, Fraction or str
+            #
+            if isinstance(numerator, int):
+                return cls._new(numerator, 1)
+            elif isinstance(numerator, PythonMPQ):
+                return cls._new(numerator.numerator, numerator.denominator)
+
+            # Let Fraction handle Decimal/float conversion and str parsing
+            if isinstance(numerator, (Decimal, float, str)):
+                numerator = Fraction(numerator)
+            if isinstance(numerator, Fraction):
+                return cls._new(numerator.numerator, numerator.denominator)
+        #
+        # Reject everything else. This is more strict than mpq which allows
+        # things like mpq(Fraction, Fraction) or mpq(Decimal, any). The mpq
+        # behaviour is somewhat inconsistent so we choose to accept only a
+        # more strict subset of what mpq allows.
+        #
+        raise TypeError("PythonMPQ() requires numeric or string argument")
+
+    @classmethod
+    def _new_check(cls, numerator, denominator):
+        """Construct PythonMPQ, check divide by zero and canonicalize signs"""
+        if not denominator:
+            raise ZeroDivisionError(f'Zero divisor {numerator}/{denominator}')
+        elif denominator < 0:
+            numerator = -numerator
+            denominator = -denominator
+        return cls._new(numerator, denominator)
+
+    @classmethod
+    def _new(cls, numerator, denominator):
+        """Construct PythonMPQ efficiently (no checks)"""
+        obj = super().__new__(cls)
+        obj.numerator = numerator
+        obj.denominator = denominator
+        return obj
+
+    def __int__(self):
+        """Convert to int (truncates towards zero)"""
+        p, q = self.numerator, self.denominator
+        if p < 0:
+            return -(-p//q)
+        return p//q
+
+    def __float__(self):
+        """Convert to float (approximately)"""
+        return self.numerator / self.denominator
+
+    def __bool__(self):
+        """True/False if nonzero/zero"""
+        return bool(self.numerator)
+
+    def __eq__(self, other):
+        """Compare equal with PythonMPQ, int, float, Decimal or Fraction"""
+        if isinstance(other, PythonMPQ):
+            return (self.numerator == other.numerator
+                and self.denominator == other.denominator)
+        elif isinstance(other, self._compatible_types):
+            return self.__eq__(PythonMPQ(other))
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        """hash - same as mpq/Fraction"""
+        try:
+            dinv = pow(self.denominator, -1, _PyHASH_MODULUS)
+        except ValueError:
+            hash_ = _PyHASH_INF
+        else:
+            hash_ = hash(hash(abs(self.numerator)) * dinv)
+        result = hash_ if self.numerator >= 0 else -hash_
+        return -2 if result == -1 else result
+
+    def __reduce__(self):
+        """Deconstruct for pickling"""
+        return type(self), (self.numerator, self.denominator)
+
+    def __str__(self):
+        """Convert to string"""
+        if self.denominator != 1:
+            return f"{self.numerator}/{self.denominator}"
+        else:
+            return f"{self.numerator}"
+
+    def __repr__(self):
+        """Convert to string"""
+        return f"MPQ({self.numerator},{self.denominator})"
+
+    def _cmp(self, other, op):
+        """Helper for lt/le/gt/ge"""
+        if not isinstance(other, self._compatible_types):
+            return NotImplemented
+        lhs = self.numerator * other.denominator
+        rhs = other.numerator * self.denominator
+        return op(lhs, rhs)
+
+    def __lt__(self, other):
+        """self < other"""
+        return self._cmp(other, operator.lt)
+
+    def __le__(self, other):
+        """self <= other"""
+        return self._cmp(other, operator.le)
+
+    def __gt__(self, other):
+        """self > other"""
+        return self._cmp(other, operator.gt)
+
+    def __ge__(self, other):
+        """self >= other"""
+        return self._cmp(other, operator.ge)
+
+    def __abs__(self):
+        """abs(q)"""
+        return self._new(abs(self.numerator), self.denominator)
+
+    def __pos__(self):
+        """+q"""
+        return self
+
+    def __neg__(self):
+        """-q"""
+        return self._new(-self.numerator, self.denominator)
+
+    def __add__(self, other):
+        """q1 + q2"""
+        if isinstance(other, PythonMPQ):
+            #
+            # This is much faster than the naive method used in the stdlib
+            # fractions module. Not sure where this method comes from
+            # though...
+            #
+            # Compare timings for something like:
+            #   nums = range(1000)
+            #   rats = [PythonMPQ(n, d) for n, d in zip(nums[:-5], nums[5:])]
+            #   sum(rats) # <-- time this
+            #
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            g = gcd(aq, bq)
+            if g == 1:
+                p = ap*bq + aq*bp
+                q = bq*aq
+            else:
+                q1, q2 = aq//g, bq//g
+                p, q = ap*q2 + bp*q1, q1*q2
+                g2 = gcd(p, g)
+                p, q = (p // g2), q * (g // g2)
+
+        elif isinstance(other, int):
+            p = self.numerator + self.denominator * other
+            q = self.denominator
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __radd__(self, other):
+        """z1 + q2"""
+        if isinstance(other, int):
+            p = self.numerator + self.denominator * other
+            q = self.denominator
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __sub__(self ,other):
+        """q1 - q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            g = gcd(aq, bq)
+            if g == 1:
+                p = ap*bq - aq*bp
+                q = bq*aq
+            else:
+                q1, q2 = aq//g, bq//g
+                p, q = ap*q2 - bp*q1, q1*q2
+                g2 = gcd(p, g)
+                p, q = (p // g2), q * (g // g2)
+        elif isinstance(other, int):
+            p = self.numerator - self.denominator*other
+            q = self.denominator
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __rsub__(self, other):
+        """z1 - q2"""
+        if isinstance(other, int):
+            p = self.denominator * other - self.numerator
+            q = self.denominator
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __mul__(self, other):
+        """q1 * q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            x1 = gcd(ap, bq)
+            x2 = gcd(bp, aq)
+            p, q = ((ap//x1)*(bp//x2), (aq//x2)*(bq//x1))
+        elif isinstance(other, int):
+            x = gcd(other, self.denominator)
+            p = self.numerator*(other//x)
+            q = self.denominator//x
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __rmul__(self, other):
+        """z1 * q2"""
+        if isinstance(other, int):
+            x = gcd(self.denominator, other)
+            p = self.numerator*(other//x)
+            q = self.denominator//x
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __pow__(self, exp):
+        """q ** z"""
+        p, q = self.numerator, self.denominator
+
+        if exp < 0:
+            p, q, exp = q, p, -exp
+
+        return self._new_check(p**exp, q**exp)
+
+    def __truediv__(self, other):
+        """q1 / q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            x1 = gcd(ap, bp)
+            x2 = gcd(bq, aq)
+            p, q = ((ap//x1)*(bq//x2), (aq//x2)*(bp//x1))
+        elif isinstance(other, int):
+            x = gcd(other, self.numerator)
+            p = self.numerator//x
+            q = self.denominator*(other//x)
+        else:
+            return NotImplemented
+
+        return self._new_check(p, q)
+
+    def __rtruediv__(self, other):
+        """z / q"""
+        if isinstance(other, int):
+            x = gcd(self.numerator, other)
+            p = self.denominator*(other//x)
+            q = self.numerator//x
+            return self._new_check(p, q)
+        else:
+            return NotImplemented
+
+    _compatible_types: tTuple[Type, ...] = ()
+
+#
+# These are the types that PythonMPQ will interoperate with for operations
+# and comparisons such as ==, + etc. We define this down here so that we can
+# include PythonMPQ in the list as well.
+#
+PythonMPQ._compatible_types = (PythonMPQ, int, Decimal, Fraction)

lib/python3.12/site-packages/sympy/external/tests/test_autowrap.py

@@ -0,0 +1,313 @@
+import sympy
+import tempfile
+import os
+from sympy.core.mod import Mod
+from sympy.core.relational import Eq
+from sympy.core.symbol import symbols
+from sympy.external import import_module
+from sympy.tensor import IndexedBase, Idx
+from sympy.utilities.autowrap import autowrap, ufuncify, CodeWrapError
+from sympy.testing.pytest import skip
+
+numpy = import_module('numpy', min_module_version='1.6.1')
+Cython = import_module('Cython', min_module_version='0.15.1')
+f2py = import_module('numpy.f2py', import_kwargs={'fromlist': ['f2py']})
+
+f2pyworks = False
+if f2py:
+    try:
+        autowrap(symbols('x'), 'f95', 'f2py')
+    except (CodeWrapError, ImportError, OSError):
+        f2pyworks = False
+    else:
+        f2pyworks = True
+
+a, b, c = symbols('a b c')
+n, m, d = symbols('n m d', integer=True)
+A, B, C = symbols('A B C', cls=IndexedBase)
+i = Idx('i', m)
+j = Idx('j', n)
+k = Idx('k', d)
+
+
+def has_module(module):
+    """
+    Return True if module exists, otherwise run skip().
+
+    module should be a string.
+    """
+    # To give a string of the module name to skip(), this function takes a
+    # string.  So we don't waste time running import_module() more than once,
+    # just map the three modules tested here in this dict.
+    modnames = {'numpy': numpy, 'Cython': Cython, 'f2py': f2py}
+
+    if modnames[module]:
+        if module == 'f2py' and not f2pyworks:
+            skip("Couldn't run f2py.")
+        return True
+    skip("Couldn't import %s." % module)
+
+#
+# test runners used by several language-backend combinations
+#
+
+def runtest_autowrap_twice(language, backend):
+    f = autowrap((((a + b)/c)**5).expand(), language, backend)
+    g = autowrap((((a + b)/c)**4).expand(), language, backend)
+
+    # check that autowrap updates the module name.  Else, g gives the same as f
+    assert f(1, -2, 1) == -1.0
+    assert g(1, -2, 1) == 1.0
+
+
+def runtest_autowrap_trace(language, backend):
+    has_module('numpy')
+    trace = autowrap(A[i, i], language, backend)
+    assert trace(numpy.eye(100)) == 100
+
+
+def runtest_autowrap_matrix_vector(language, backend):
+    has_module('numpy')
+    x, y = symbols('x y', cls=IndexedBase)
+    expr = Eq(y[i], A[i, j]*x[j])
+    mv = autowrap(expr, language, backend)
+
+    # compare with numpy's dot product
+    M = numpy.random.rand(10, 20)
+    x = numpy.random.rand(20)
+    y = numpy.dot(M, x)
+    assert numpy.sum(numpy.abs(y - mv(M, x))) < 1e-13
+
+
+def runtest_autowrap_matrix_matrix(language, backend):
+    has_module('numpy')
+    expr = Eq(C[i, j], A[i, k]*B[k, j])
+    matmat = autowrap(expr, language, backend)
+
+    # compare with numpy's dot product
+    M1 = numpy.random.rand(10, 20)
+    M2 = numpy.random.rand(20, 15)
+    M3 = numpy.dot(M1, M2)
+    assert numpy.sum(numpy.abs(M3 - matmat(M1, M2))) < 1e-13
+
+
+def runtest_ufuncify(language, backend):
+    has_module('numpy')
+    a, b, c = symbols('a b c')
+    fabc = ufuncify([a, b, c], a*b + c, backend=backend)
+    facb = ufuncify([a, c, b], a*b + c, backend=backend)
+    grid = numpy.linspace(-2, 2, 50)
+    b = numpy.linspace(-5, 4, 50)
+    c = numpy.linspace(-1, 1, 50)
+    expected = grid*b + c
+    numpy.testing.assert_allclose(fabc(grid, b, c), expected)
+    numpy.testing.assert_allclose(facb(grid, c, b), expected)
+
+
+def runtest_issue_10274(language, backend):
+    expr = (a - b + c)**(13)
+    tmp = tempfile.mkdtemp()
+    f = autowrap(expr, language, backend, tempdir=tmp,
+                 helpers=('helper', a - b + c, (a, b, c)))
+    assert f(1, 1, 1) == 1
+
+    for file in os.listdir(tmp):
+        if not (file.startswith("wrapped_code_") and file.endswith(".c")):
+            continue
+
+        with open(tmp + '/' + file) as fil:
+            lines = fil.readlines()
+            assert lines[0] == "/******************************************************************************\n"
+            assert "Code generated with SymPy " + sympy.__version__ in lines[1]
+            assert lines[2:] == [
+                " *                                                                            *\n",
+                " *              See http://www.sympy.org/ for more information.               *\n",
+                " *                                                                            *\n",
+                " *                      This file is part of 'autowrap'                       *\n",
+                " ******************************************************************************/\n",
+                "#include " + '"' + file[:-1]+ 'h"' + "\n",
+                "#include <math.h>\n",
+                "\n",
+                "double helper(double a, double b, double c) {\n",
+                "\n",
+                "   double helper_result;\n",
+                "   helper_result = a - b + c;\n",
+                "   return helper_result;\n",
+                "\n",
+                "}\n",
+                "\n",
+                "double autofunc(double a, double b, double c) {\n",
+                "\n",
+                "   double autofunc_result;\n",
+                "   autofunc_result = pow(helper(a, b, c), 13);\n",
+                "   return autofunc_result;\n",
+                "\n",
+                "}\n",
+                ]
+
+
+def runtest_issue_15337(language, backend):
+    has_module('numpy')
+    # NOTE : autowrap was originally designed to only accept an iterable for
+    # the kwarg "helpers", but in issue 10274 the user mistakenly thought that
+    # if there was only a single helper it did not need to be passed via an
+    # iterable that wrapped the helper tuple. There were no tests for this
+    # behavior so when the code was changed to accept a single tuple it broke
+    # the original behavior. These tests below ensure that both now work.
+    a, b, c, d, e = symbols('a, b, c, d, e')
+    expr = (a - b + c - d + e)**13
+    exp_res = (1. - 2. + 3. - 4. + 5.)**13
+
+    f = autowrap(expr, language, backend, args=(a, b, c, d, e),
+                 helpers=('f1', a - b + c, (a, b, c)))
+    numpy.testing.assert_allclose(f(1, 2, 3, 4, 5), exp_res)
+
+    f = autowrap(expr, language, backend, args=(a, b, c, d, e),
+                 helpers=(('f1', a - b, (a, b)), ('f2', c - d, (c, d))))
+    numpy.testing.assert_allclose(f(1, 2, 3, 4, 5), exp_res)
+
+
+def test_issue_15230():
+    has_module('f2py')
+
+    x, y = symbols('x, y')
+    expr = Mod(x, 3.0) - Mod(y, -2.0)
+    f = autowrap(expr, args=[x, y], language='F95')
+    exp_res = float(expr.xreplace({x: 3.5, y: 2.7}).evalf())
+    assert abs(f(3.5, 2.7) - exp_res) < 1e-14
+
+    x, y = symbols('x, y', integer=True)
+    expr = Mod(x, 3) - Mod(y, -2)
+    f = autowrap(expr, args=[x, y], language='F95')
+    assert f(3, 2) == expr.xreplace({x: 3, y: 2})
+
+#
+# tests of language-backend combinations
+#
+
+# f2py
+
+
+def test_wrap_twice_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_twice('f95', 'f2py')
+
+
+def test_autowrap_trace_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_trace('f95', 'f2py')
+
+
+def test_autowrap_matrix_vector_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_matrix_vector('f95', 'f2py')
+
+
+def test_autowrap_matrix_matrix_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_matrix_matrix('f95', 'f2py')
+
+
+def test_ufuncify_f95_f2py():
+    has_module('f2py')
+    runtest_ufuncify('f95', 'f2py')
+
+
+def test_issue_15337_f95_f2py():
+    has_module('f2py')
+    runtest_issue_15337('f95', 'f2py')
+
+# Cython
+
+
+def test_wrap_twice_c_cython():
+    has_module('Cython')
+    runtest_autowrap_twice('C', 'cython')
+
+
+def test_autowrap_trace_C_Cython():
+    has_module('Cython')
+    runtest_autowrap_trace('C99', 'cython')
+
+
+def test_autowrap_matrix_vector_C_cython():
+    has_module('Cython')
+    runtest_autowrap_matrix_vector('C99', 'cython')
+
+
+def test_autowrap_matrix_matrix_C_cython():
+    has_module('Cython')
+    runtest_autowrap_matrix_matrix('C99', 'cython')
+
+
+def test_ufuncify_C_Cython():
+    has_module('Cython')
+    runtest_ufuncify('C99', 'cython')
+
+
+def test_issue_10274_C_cython():
+    has_module('Cython')
+    runtest_issue_10274('C89', 'cython')
+
+
+def test_issue_15337_C_cython():
+    has_module('Cython')
+    runtest_issue_15337('C89', 'cython')
+
+
+def test_autowrap_custom_printer():
+    has_module('Cython')
+
+    from sympy.core.numbers import pi
+    from sympy.utilities.codegen import C99CodeGen
+    from sympy.printing.c import C99CodePrinter
+
+    class PiPrinter(C99CodePrinter):
+        def _print_Pi(self, expr):
+            return "S_PI"
+
+    printer = PiPrinter()
+    gen = C99CodeGen(printer=printer)
+    gen.preprocessor_statements.append('#include "shortpi.h"')
+
+    expr = pi * a
+
+    expected = (
+        '#include "%s"\n'
+        '#include <math.h>\n'
+        '#include "shortpi.h"\n'
+        '\n'
+        'double autofunc(double a) {\n'
+        '\n'
+        '   double autofunc_result;\n'
+        '   autofunc_result = S_PI*a;\n'
+        '   return autofunc_result;\n'
+        '\n'
+        '}\n'
+    )
+
+    tmpdir = tempfile.mkdtemp()
+    # write a trivial header file to use in the generated code
+    with open(os.path.join(tmpdir, 'shortpi.h'), 'w') as f:
+        f.write('#define S_PI 3.14')
+
+    func = autowrap(expr, backend='cython', tempdir=tmpdir, code_gen=gen)
+
+    assert func(4.2) == 3.14 * 4.2
+
+    # check that the generated code is correct
+    for filename in os.listdir(tmpdir):
+        if filename.startswith('wrapped_code') and filename.endswith('.c'):
+            with open(os.path.join(tmpdir, filename)) as f:
+                lines = f.readlines()
+                expected = expected % filename.replace('.c', '.h')
+                assert ''.join(lines[7:]) == expected
+
+
+# Numpy
+
+def test_ufuncify_numpy():
+    # This test doesn't use Cython, but if Cython works, then there is a valid
+    # C compiler, which is needed.
+    has_module('Cython')
+    runtest_ufuncify('C99', 'numpy')

lib/python3.12/site-packages/sympy/external/tests/test_codegen.py

@@ -0,0 +1,379 @@
+# This tests the compilation and execution of the source code generated with
+# utilities.codegen. The compilation takes place in a temporary directory that
+# is removed after the test. By default the test directory is always removed,
+# but this behavior can be changed by setting the environment variable
+# SYMPY_TEST_CLEAN_TEMP to:
+#   export SYMPY_TEST_CLEAN_TEMP=always   : the default behavior.
+#   export SYMPY_TEST_CLEAN_TEMP=success  : only remove the directories of working tests.
+#   export SYMPY_TEST_CLEAN_TEMP=never    : never remove the directories with the test code.
+# When a directory is not removed, the necessary information is printed on
+# screen to find the files that belong to the (failed) tests. If a test does
+# not fail, py.test captures all the output and you will not see the directories
+# corresponding to the successful tests. Use the --nocapture option to see all
+# the output.
+
+# All tests below have a counterpart in utilities/test/test_codegen.py. In the
+# latter file, the resulting code is compared with predefined strings, without
+# compilation or execution.
+
+# All the generated Fortran code should conform with the Fortran 95 standard,
+# and all the generated C code should be ANSI C, which facilitates the
+# incorporation in various projects. The tests below assume that the binary cc
+# is somewhere in the path and that it can compile ANSI C code.
+
+from sympy.abc import x, y, z
+from sympy.external import import_module
+from sympy.testing.pytest import skip
+from sympy.utilities.codegen import codegen, make_routine, get_code_generator
+import sys
+import os
+import tempfile
+import subprocess
+
+
+pyodide_js = import_module('pyodide_js')
+
+# templates for the main program that will test the generated code.
+
+main_template = {}
+main_template['F95'] = """
+program main
+  include "codegen.h"
+  integer :: result;
+  result = 0
+
+  %(statements)s
+
+  call exit(result)
+end program
+"""
+
+main_template['C89'] = """
+#include "codegen.h"
+#include <stdio.h>
+#include <math.h>
+
+int main() {
+  int result = 0;
+
+  %(statements)s
+
+  return result;
+}
+"""
+main_template['C99'] = main_template['C89']
+# templates for the numerical tests
+
+numerical_test_template = {}
+numerical_test_template['C89'] = """
+  if (fabs(%(call)s)>%(threshold)s) {
+    printf("Numerical validation failed: %(call)s=%%e threshold=%(threshold)s\\n", %(call)s);
+    result = -1;
+  }
+"""
+numerical_test_template['C99'] = numerical_test_template['C89']
+
+numerical_test_template['F95'] = """
+  if (abs(%(call)s)>%(threshold)s) then
+    write(6,"('Numerical validation failed:')")
+    write(6,"('%(call)s=',e15.5,'threshold=',e15.5)") %(call)s, %(threshold)s
+    result = -1;
+  end if
+"""
+# command sequences for supported compilers
+
+compile_commands = {}
+compile_commands['cc'] = [
+    "cc -c codegen.c -o codegen.o",
+    "cc -c main.c -o main.o",
+    "cc main.o codegen.o -lm -o test.exe"
+]
+
+compile_commands['gfortran'] = [
+    "gfortran -c codegen.f90 -o codegen.o",
+    "gfortran -ffree-line-length-none -c main.f90 -o main.o",
+    "gfortran main.o codegen.o -o test.exe"
+]
+
+compile_commands['g95'] = [
+    "g95 -c codegen.f90 -o codegen.o",
+    "g95 -ffree-line-length-huge -c main.f90 -o main.o",
+    "g95 main.o codegen.o -o test.exe"
+]
+
+compile_commands['ifort'] = [
+    "ifort -c codegen.f90 -o codegen.o",
+    "ifort -c main.f90 -o main.o",
+    "ifort main.o codegen.o -o test.exe"
+]
+
+combinations_lang_compiler = [
+    ('C89', 'cc'),
+    ('C99', 'cc'),
+    ('F95', 'ifort'),
+    ('F95', 'gfortran'),
+    ('F95', 'g95')
+]
+
+
+def try_run(commands):
+    """Run a series of commands and only return True if all ran fine."""
+    if pyodide_js:
+        return False
+    with open(os.devnull, 'w') as null:
+        for command in commands:
+            retcode = subprocess.call(command, stdout=null, shell=True,
+                    stderr=subprocess.STDOUT)
+            if retcode != 0:
+                return False
+    return True
+
+
+def run_test(label, routines, numerical_tests, language, commands, friendly=True):
+    """A driver for the codegen tests.
+
+       This driver assumes that a compiler ifort is present in the PATH and that
+       ifort is (at least) a Fortran 90 compiler. The generated code is written in
+       a temporary directory, together with a main program that validates the
+       generated code. The test passes when the compilation and the validation
+       run correctly.
+    """
+
+    # Check input arguments before touching the file system
+    language = language.upper()
+    assert language in main_template
+    assert language in numerical_test_template
+
+    # Check that environment variable makes sense
+    clean = os.getenv('SYMPY_TEST_CLEAN_TEMP', 'always').lower()
+    if clean not in ('always', 'success', 'never'):
+        raise ValueError("SYMPY_TEST_CLEAN_TEMP must be one of the following: 'always', 'success' or 'never'.")
+
+    # Do all the magic to compile, run and validate the test code
+    # 1) prepare the temporary working directory, switch to that dir
+    work = tempfile.mkdtemp("_sympy_%s_test" % language, "%s_" % label)
+    oldwork = os.getcwd()
+    os.chdir(work)
+
+    # 2) write the generated code
+    if friendly:
+        # interpret the routines as a name_expr list and call the friendly
+        # function codegen
+        codegen(routines, language, "codegen", to_files=True)
+    else:
+        code_gen = get_code_generator(language, "codegen")
+        code_gen.write(routines, "codegen", to_files=True)
+
+    # 3) write a simple main program that links to the generated code, and that
+    #    includes the numerical tests
+    test_strings = []
+    for fn_name, args, expected, threshold in numerical_tests:
+        call_string = "%s(%s)-(%s)" % (
+            fn_name, ",".join(str(arg) for arg in args), expected)
+        if language == "F95":
+            call_string = fortranize_double_constants(call_string)
+            threshold = fortranize_double_constants(str(threshold))
+        test_strings.append(numerical_test_template[language] % {
+            "call": call_string,
+            "threshold": threshold,
+        })
+
+    if language == "F95":
+        f_name = "main.f90"
+    elif language.startswith("C"):
+        f_name = "main.c"
+    else:
+        raise NotImplementedError(
+            "FIXME: filename extension unknown for language: %s" % language)
+
+    with open(f_name, "w") as f:
+        f.write(
+            main_template[language] % {'statements': "".join(test_strings)})
+
+    # 4) Compile and link
+    compiled = try_run(commands)
+
+    # 5) Run if compiled
+    if compiled:
+        executed = try_run(["./test.exe"])
+    else:
+        executed = False
+
+    # 6) Clean up stuff
+    if clean == 'always' or (clean == 'success' and compiled and executed):
+        def safe_remove(filename):
+            if os.path.isfile(filename):
+                os.remove(filename)
+        safe_remove("codegen.f90")
+        safe_remove("codegen.c")
+        safe_remove("codegen.h")
+        safe_remove("codegen.o")
+        safe_remove("main.f90")
+        safe_remove("main.c")
+        safe_remove("main.o")
+        safe_remove("test.exe")
+        os.chdir(oldwork)
+        os.rmdir(work)
+    else:
+        print("TEST NOT REMOVED: %s" % work, file=sys.stderr)
+        os.chdir(oldwork)
+
+    # 7) Do the assertions in the end
+    assert compiled, "failed to compile %s code with:\n%s" % (
+        language, "\n".join(commands))
+    assert executed, "failed to execute %s code from:\n%s" % (
+        language, "\n".join(commands))
+
+
+def fortranize_double_constants(code_string):
+    """
+    Replaces every literal float with literal doubles
+    """
+    import re
+    pattern_exp = re.compile(r'\d+(\.)?\d*[eE]-?\d+')
+    pattern_float = re.compile(r'\d+\.\d*(?!\d*d)')
+
+    def subs_exp(matchobj):
+        return re.sub('[eE]', 'd', matchobj.group(0))
+
+    def subs_float(matchobj):
+        return "%sd0" % matchobj.group(0)
+
+    code_string = pattern_exp.sub(subs_exp, code_string)
+    code_string = pattern_float.sub(subs_float, code_string)
+
+    return code_string
+
+
+def is_feasible(language, commands):
+    # This test should always work, otherwise the compiler is not present.
+    routine = make_routine("test", x)
+    numerical_tests = [
+        ("test", ( 1.0,), 1.0, 1e-15),
+        ("test", (-1.0,), -1.0, 1e-15),
+    ]
+    try:
+        run_test("is_feasible", [routine], numerical_tests, language, commands,
+                 friendly=False)
+        return True
+    except AssertionError:
+        return False
+
+valid_lang_commands = []
+invalid_lang_compilers = []
+for lang, compiler in combinations_lang_compiler:
+    commands = compile_commands[compiler]
+    if is_feasible(lang, commands):
+        valid_lang_commands.append((lang, commands))
+    else:
+        invalid_lang_compilers.append((lang, compiler))
+
+# We test all language-compiler combinations, just to report what is skipped
+
+def test_C89_cc():
+    if ("C89", 'cc') in invalid_lang_compilers:
+        skip("`cc' command didn't work as expected (C89)")
+
+
+def test_C99_cc():
+    if ("C99", 'cc') in invalid_lang_compilers:
+        skip("`cc' command didn't work as expected (C99)")
+
+
+def test_F95_ifort():
+    if ("F95", 'ifort') in invalid_lang_compilers:
+        skip("`ifort' command didn't work as expected")
+
+
+def test_F95_gfortran():
+    if ("F95", 'gfortran') in invalid_lang_compilers:
+        skip("`gfortran' command didn't work as expected")
+
+
+def test_F95_g95():
+    if ("F95", 'g95') in invalid_lang_compilers:
+        skip("`g95' command didn't work as expected")
+
+# Here comes the actual tests
+
+
+def test_basic_codegen():
+    numerical_tests = [
+        ("test", (1.0, 6.0, 3.0), 21.0, 1e-15),
+        ("test", (-1.0, 2.0, -2.5), -2.5, 1e-15),
+    ]
+    name_expr = [("test", (x + y)*z)]
+    for lang, commands in valid_lang_commands:
+        run_test("basic_codegen", name_expr, numerical_tests, lang, commands)
+
+
+def test_intrinsic_math1_codegen():
+    # not included: log10
+    from sympy.core.evalf import N
+    from sympy.functions import ln
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+    from sympy.functions.elementary.integers import (ceiling, floor)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, tan)
+    name_expr = [
+        ("test_fabs", abs(x)),
+        ("test_acos", acos(x)),
+        ("test_asin", asin(x)),
+        ("test_atan", atan(x)),
+        ("test_cos", cos(x)),
+        ("test_cosh", cosh(x)),
+        ("test_log", log(x)),
+        ("test_ln", ln(x)),
+        ("test_sin", sin(x)),
+        ("test_sinh", sinh(x)),
+        ("test_sqrt", sqrt(x)),
+        ("test_tan", tan(x)),
+        ("test_tanh", tanh(x)),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval in 0.2, 0.5, 0.8:
+            expected = N(expr.subs(x, xval))
+            numerical_tests.append((name, (xval,), expected, 1e-14))
+    for lang, commands in valid_lang_commands:
+        if lang.startswith("C"):
+            name_expr_C = [("test_floor", floor(x)), ("test_ceil", ceiling(x))]
+        else:
+            name_expr_C = []
+        run_test("intrinsic_math1", name_expr + name_expr_C,
+                 numerical_tests, lang, commands)
+
+
+def test_instrinsic_math2_codegen():
+    # not included: frexp, ldexp, modf, fmod
+    from sympy.core.evalf import N
+    from sympy.functions.elementary.trigonometric import atan2
+    name_expr = [
+        ("test_atan2", atan2(x, y)),
+        ("test_pow", x**y),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval, yval in (0.2, 1.3), (0.5, -0.2), (0.8, 0.8):
+            expected = N(expr.subs(x, xval).subs(y, yval))
+            numerical_tests.append((name, (xval, yval), expected, 1e-14))
+    for lang, commands in valid_lang_commands:
+        run_test("intrinsic_math2", name_expr, numerical_tests, lang, commands)
+
+
+def test_complicated_codegen():
+    from sympy.core.evalf import N
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = [
+        ("test1", ((sin(x) + cos(y) + tan(z))**7).expand()),
+        ("test2", cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval, yval, zval in (0.2, 1.3, -0.3), (0.5, -0.2, 0.0), (0.8, 2.1, 0.8):
+            expected = N(expr.subs(x, xval).subs(y, yval).subs(z, zval))
+            numerical_tests.append((name, (xval, yval, zval), expected, 1e-12))
+    for lang, commands in valid_lang_commands:
+        run_test(
+            "complicated_codegen", name_expr, numerical_tests, lang, commands)

lib/python3.12/site-packages/sympy/external/tests/test_gmpy.py

@@ -0,0 +1,12 @@
+from sympy.external.gmpy import LONG_MAX, iroot
+from sympy.testing.pytest import raises
+
+
+def test_iroot():
+    assert iroot(2, LONG_MAX) == (1, False)
+    assert iroot(2, LONG_MAX + 1) == (1, False)
+    for x in range(3):
+        assert iroot(x, 1) == (x, True)
+    raises(ValueError, lambda: iroot(-1, 1))
+    raises(ValueError, lambda: iroot(0, 0))
+    raises(ValueError, lambda: iroot(0, -1))

lib/python3.12/site-packages/sympy/external/tests/test_importtools.py

@@ -0,0 +1,40 @@
+from sympy.external import import_module
+from sympy.testing.pytest import warns
+
+# fixes issue that arose in addressing issue 6533
+def test_no_stdlib_collections():
+    '''
+    make sure we get the right collections when it is not part of a
+    larger list
+    '''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['cm', 'collections']},
+        min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_no_stdlib_collections2():
+    '''
+    make sure we get the right collections when it is not part of a
+    larger list
+    '''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['collections']},
+        min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_no_stdlib_collections3():
+    '''make sure we get the right collections with no catch'''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['cm', 'collections']},
+        min_module_version='1.1.0')
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_min_module_version_python3_basestring_error():
+    with warns(UserWarning):
+        import_module('mpmath', min_module_version='1000.0.1')

lib/python3.12/site-packages/sympy/external/tests/test_ntheory.py

@@ -0,0 +1,307 @@
+from itertools import permutations
+
+from sympy.external.ntheory import (bit_scan1, remove, bit_scan0, is_fermat_prp,
+                                    is_euler_prp, is_strong_prp, gcdext, _lucas_sequence,
+                                    is_fibonacci_prp, is_lucas_prp, is_selfridge_prp,
+                                    is_strong_lucas_prp, is_strong_selfridge_prp,
+                                    is_bpsw_prp, is_strong_bpsw_prp)
+from sympy.testing.pytest import raises
+
+
+def test_bit_scan1():
+    assert bit_scan1(0) is None
+    assert bit_scan1(1) == 0
+    assert bit_scan1(-1) == 0
+    assert bit_scan1(2) == 1
+    assert bit_scan1(7) == 0
+    assert bit_scan1(-7) == 0
+    for i in range(100):
+        assert bit_scan1(1 << i) == i
+        assert bit_scan1((1 << i) * 31337) == i
+    for i in range(500):
+        n = (1 << 500) + (1 << i)
+        assert bit_scan1(n) == i
+    assert bit_scan1(1 << 1000001) == 1000001
+    assert bit_scan1((1 << 273956)*7**37) == 273956
+    # issue 12709
+    for i in range(1, 10):
+        big = 1 << i
+        assert bit_scan1(-big) == bit_scan1(big)
+
+
+def test_bit_scan0():
+    assert bit_scan0(-1) is None
+    assert bit_scan0(0) == 0
+    assert bit_scan0(1) == 1
+    assert bit_scan0(-2) == 0
+
+
+def test_remove():
+    raises(ValueError, lambda: remove(1, 1))
+    assert remove(0, 3) == (0, 0)
+    for f in range(2, 10):
+        for y in range(2, 1000):
+            for z in [1, 17, 101, 1009]:
+                assert remove(z*f**y, f) == (z, y)
+
+
+def test_gcdext():
+    assert gcdext(0, 0) == (0, 0, 0)
+    assert gcdext(3, 0) == (3, 1, 0)
+    assert gcdext(0, 4) == (4, 0, 1)
+
+    for n in range(1, 10):
+        assert gcdext(n, 1) == gcdext(-n, 1) == (1, 0, 1)
+        assert gcdext(n, -1) == gcdext(-n, -1) == (1, 0, -1)
+        assert gcdext(n, n) == gcdext(-n, n) == (n, 0, 1)
+        assert gcdext(n, -n) == gcdext(-n, -n) == (n, 0, -1)
+
+    for n in range(2, 10):
+        assert gcdext(1, n) == gcdext(1, -n) == (1, 1, 0)
+        assert gcdext(-1, n) == gcdext(-1, -n) == (1, -1, 0)
+
+    for a, b in permutations([2**5, 3, 5, 7**2, 11], 2):
+        g, x, y = gcdext(a, b)
+        assert g == a*x + b*y == 1
+
+
+def test_is_fermat_prp():
+    # invalid input
+    raises(ValueError, lambda: is_fermat_prp(0, 10))
+    raises(ValueError, lambda: is_fermat_prp(5, 1))
+
+    # n = 1
+    assert not is_fermat_prp(1, 3)
+
+    # n is prime
+    assert is_fermat_prp(2, 4)
+    assert is_fermat_prp(3, 2)
+    assert is_fermat_prp(11, 3)
+    assert is_fermat_prp(2**31-1, 5)
+
+    # A001567
+    pseudorpime = [341, 561, 645, 1105, 1387, 1729, 1905, 2047,
+                   2465, 2701, 2821, 3277, 4033, 4369, 4371, 4681]
+    for n in pseudorpime:
+        assert is_fermat_prp(n, 2)
+
+    # A020136
+    pseudorpime = [15, 85, 91, 341, 435, 451, 561, 645, 703, 1105,
+                   1247, 1271, 1387, 1581, 1695, 1729, 1891, 1905]
+    for n in pseudorpime:
+        assert is_fermat_prp(n, 4)
+
+
+def test_is_euler_prp():
+    # invalid input
+    raises(ValueError, lambda: is_euler_prp(0, 10))
+    raises(ValueError, lambda: is_euler_prp(5, 1))
+
+    # n = 1
+    assert not is_euler_prp(1, 3)
+
+    # n is prime
+    assert is_euler_prp(2, 4)
+    assert is_euler_prp(3, 2)
+    assert is_euler_prp(11, 3)
+    assert is_euler_prp(2**31-1, 5)
+
+    # A047713
+    pseudorpime = [561, 1105, 1729, 1905, 2047, 2465, 3277, 4033,
+                   4681, 6601, 8321, 8481, 10585, 12801, 15841]
+    for n in pseudorpime:
+        assert is_euler_prp(n, 2)
+
+    # A048950
+    pseudorpime = [121, 703, 1729, 1891, 2821, 3281, 7381, 8401,
+                   8911, 10585, 12403, 15457, 15841, 16531, 18721]
+    for n in pseudorpime:
+        assert is_euler_prp(n, 3)
+
+
+def test_is_strong_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_prp(0, 10))
+    raises(ValueError, lambda: is_strong_prp(5, 1))
+
+    # n = 1
+    assert not is_strong_prp(1, 3)
+
+    # n is prime
+    assert is_strong_prp(2, 4)
+    assert is_strong_prp(3, 2)
+    assert is_strong_prp(11, 3)
+    assert is_strong_prp(2**31-1, 5)
+
+    # A001262
+    pseudorpime = [2047, 3277, 4033, 4681, 8321, 15841, 29341,
+                   42799, 49141, 52633, 65281, 74665, 80581]
+    for n in pseudorpime:
+        assert is_strong_prp(n, 2)
+
+    # A020229
+    pseudorpime = [121, 703, 1891, 3281, 8401, 8911, 10585, 12403,
+                   16531, 18721, 19345, 23521, 31621, 44287, 47197]
+    for n in pseudorpime:
+        assert is_strong_prp(n, 3)
+
+
+def test_lucas_sequence():
+    def lucas_u(P, Q, length):
+        array = [0] * length
+        array[1] = 1
+        for k in range(2, length):
+            array[k] = P * array[k - 1] - Q * array[k - 2]
+        return array
+
+    def lucas_v(P, Q, length):
+        array = [0] * length
+        array[0] = 2
+        array[1] = P
+        for k in range(2, length):
+            array[k] = P * array[k - 1] - Q * array[k - 2]
+        return array
+
+    length = 20
+    for P in range(-10, 10):
+        for Q in range(-10, 10):
+            D = P**2 - 4*Q
+            if D == 0:
+                continue
+            us = lucas_u(P, Q, length)
+            vs = lucas_v(P, Q, length)
+            for n in range(3, 100, 2):
+                for k in range(length):
+                    U, V, Qk = _lucas_sequence(n, P, Q, k)
+                    assert U == us[k] % n
+                    assert V == vs[k] % n
+                    assert pow(Q, k, n) == Qk
+
+
+def test_is_fibonacci_prp():
+    # invalid input
+    raises(ValueError, lambda: is_fibonacci_prp(3, 2, 1))
+    raises(ValueError, lambda: is_fibonacci_prp(3, -5, 1))
+    raises(ValueError, lambda: is_fibonacci_prp(3, 5, 2))
+    raises(ValueError, lambda: is_fibonacci_prp(0, 5, -1))
+
+    # n = 1
+    assert not is_fibonacci_prp(1, 3, 1)
+
+    # n is prime
+    assert is_fibonacci_prp(2, 5, 1)
+    assert is_fibonacci_prp(3, 6, -1)
+    assert is_fibonacci_prp(11, 7, 1)
+    assert is_fibonacci_prp(2**31-1, 8, -1)
+
+    # A005845
+    pseudorpime = [705, 2465, 2737, 3745, 4181, 5777, 6721,
+                   10877, 13201, 15251, 24465, 29281, 34561]
+    for n in pseudorpime:
+        assert is_fibonacci_prp(n, 1, -1)
+
+
+def test_is_lucas_prp():
+    # invalid input
+    raises(ValueError, lambda: is_lucas_prp(3, 2, 1))
+    raises(ValueError, lambda: is_lucas_prp(0, 5, -1))
+    raises(ValueError, lambda: is_lucas_prp(15, 3, 1))
+
+    # n = 1
+    assert not is_lucas_prp(1, 3, 1)
+
+    # n is prime
+    assert is_lucas_prp(2, 5, 2)
+    assert is_lucas_prp(3, 6, -1)
+    assert is_lucas_prp(11, 7, 5)
+    assert is_lucas_prp(2**31-1, 8, -3)
+
+    # A081264
+    pseudorpime = [323, 377, 1891, 3827, 4181, 5777, 6601, 6721,
+                   8149, 10877, 11663, 13201, 13981, 15251, 17119]
+    for n in pseudorpime:
+        assert is_lucas_prp(n, 1, -1)
+
+
+def test_is_selfridge_prp():
+    # invalid input
+    raises(ValueError, lambda: is_selfridge_prp(0))
+
+    # n = 1
+    assert not is_selfridge_prp(1)
+
+    # n is prime
+    assert is_selfridge_prp(2)
+    assert is_selfridge_prp(3)
+    assert is_selfridge_prp(11)
+    assert is_selfridge_prp(2**31-1)
+
+    # A217120
+    pseudorpime = [323, 377, 1159, 1829, 3827, 5459, 5777, 9071,
+                   9179, 10877, 11419, 11663, 13919, 14839, 16109]
+    for n in pseudorpime:
+        assert is_selfridge_prp(n)
+
+
+def test_is_strong_lucas_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_lucas_prp(3, 2, 1))
+    raises(ValueError, lambda: is_strong_lucas_prp(0, 5, -1))
+    raises(ValueError, lambda: is_strong_lucas_prp(15, 3, 1))
+
+    # n = 1
+    assert not is_strong_lucas_prp(1, 3, 1)
+
+    # n is prime
+    assert is_strong_lucas_prp(2, 5, 2)
+    assert is_strong_lucas_prp(3, 6, -1)
+    assert is_strong_lucas_prp(11, 7, 5)
+    assert is_strong_lucas_prp(2**31-1, 8, -3)
+
+
+def test_is_strong_selfridge_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_selfridge_prp(0))
+
+    # n = 1
+    assert not is_strong_selfridge_prp(1)
+
+    # n is prime
+    assert is_strong_selfridge_prp(2)
+    assert is_strong_selfridge_prp(3)
+    assert is_strong_selfridge_prp(11)
+    assert is_strong_selfridge_prp(2**31-1)
+
+    # A217255
+    pseudorpime = [5459, 5777, 10877, 16109, 18971, 22499, 24569,
+                   25199, 40309, 58519, 75077, 97439, 100127, 113573]
+    for n in pseudorpime:
+        assert is_strong_selfridge_prp(n)
+
+
+def test_is_bpsw_prp():
+    # invalid input
+    raises(ValueError, lambda: is_bpsw_prp(0))
+
+    # n = 1
+    assert not is_bpsw_prp(1)
+
+    # n is prime
+    assert is_bpsw_prp(2)
+    assert is_bpsw_prp(3)
+    assert is_bpsw_prp(11)
+    assert is_bpsw_prp(2**31-1)
+
+
+def test_is_strong_bpsw_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_bpsw_prp(0))
+
+    # n = 1
+    assert not is_strong_bpsw_prp(1)
+
+    # n is prime
+    assert is_strong_bpsw_prp(2)
+    assert is_strong_bpsw_prp(3)
+    assert is_strong_bpsw_prp(11)
+    assert is_strong_bpsw_prp(2**31-1)

lib/python3.12/site-packages/sympy/external/tests/test_numpy.py

@@ -0,0 +1,335 @@
+# This testfile tests SymPy <-> NumPy compatibility
+
+# Don't test any SymPy features here. Just pure interaction with NumPy.
+# Always write regular SymPy tests for anything, that can be tested in pure
+# Python (without numpy). Here we test everything, that a user may need when
+# using SymPy with NumPy
+from sympy.external.importtools import version_tuple
+from sympy.external import import_module
+
+numpy = import_module('numpy')
+if numpy:
+    array, matrix, ndarray = numpy.array, numpy.matrix, numpy.ndarray
+else:
+    #bin/test will not execute any tests now
+    disabled = True
+
+
+from sympy.core.numbers import (Float, Integer, Rational)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.matrices.dense import (Matrix, list2numpy, matrix2numpy, symarray)
+from sympy.utilities.lambdify import lambdify
+import sympy
+
+import mpmath
+from sympy.abc import x, y, z
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.utilities.exceptions import ignore_warnings
+from sympy.testing.pytest import raises
+
+
+# first, systematically check, that all operations are implemented and don't
+# raise an exception
+
+
+def test_systematic_basic():
+    def s(sympy_object, numpy_array):
+        _ = [sympy_object + numpy_array,
+        numpy_array + sympy_object,
+        sympy_object - numpy_array,
+        numpy_array - sympy_object,
+        sympy_object * numpy_array,
+        numpy_array * sympy_object,
+        sympy_object / numpy_array,
+        numpy_array / sympy_object,
+        sympy_object ** numpy_array,
+        numpy_array ** sympy_object]
+    x = Symbol("x")
+    y = Symbol("y")
+    sympy_objs = [
+        Rational(2, 3),
+        Float("1.3"),
+        x,
+        y,
+        pow(x, y)*y,
+        Integer(5),
+        Float(5.5),
+    ]
+    numpy_objs = [
+        array([1]),
+        array([3, 8, -1]),
+        array([x, x**2, Rational(5)]),
+        array([x/y*sin(y), 5, Rational(5)]),
+    ]
+    for x in sympy_objs:
+        for y in numpy_objs:
+            s(x, y)
+
+
+# now some random tests, that test particular problems and that also
+# check that the results of the operations are correct
+
+def test_basics():
+    one = Rational(1)
+    zero = Rational(0)
+    assert array(1) == array(one)
+    assert array([one]) == array([one])
+    assert array([x]) == array([x])
+    assert array(x) == array(Symbol("x"))
+    assert array(one + x) == array(1 + x)
+
+    X = array([one, zero, zero])
+    assert (X == array([one, zero, zero])).all()
+    assert (X == array([one, 0, 0])).all()
+
+
+def test_arrays():
+    one = Rational(1)
+    zero = Rational(0)
+    X = array([one, zero, zero])
+    Y = one*X
+    X = array([Symbol("a") + Rational(1, 2)])
+    Y = X + X
+    assert Y == array([1 + 2*Symbol("a")])
+    Y = Y + 1
+    assert Y == array([2 + 2*Symbol("a")])
+    Y = X - X
+    assert Y == array([0])
+
+
+def test_conversion1():
+    a = list2numpy([x**2, x])
+    #looks like an array?
+    assert isinstance(a, ndarray)
+    assert a[0] == x**2
+    assert a[1] == x
+    assert len(a) == 2
+    #yes, it's the array
+
+
+def test_conversion2():
+    a = 2*list2numpy([x**2, x])
+    b = list2numpy([2*x**2, 2*x])
+    assert (a == b).all()
+
+    one = Rational(1)
+    zero = Rational(0)
+    X = list2numpy([one, zero, zero])
+    Y = one*X
+    X = list2numpy([Symbol("a") + Rational(1, 2)])
+    Y = X + X
+    assert Y == array([1 + 2*Symbol("a")])
+    Y = Y + 1
+    assert Y == array([2 + 2*Symbol("a")])
+    Y = X - X
+    assert Y == array([0])
+
+
+def test_list2numpy():
+    assert (array([x**2, x]) == list2numpy([x**2, x])).all()
+
+
+def test_Matrix1():
+    m = Matrix([[x, x**2], [5, 2/x]])
+    assert (array(m.subs(x, 2)) == array([[2, 4], [5, 1]])).all()
+    m = Matrix([[sin(x), x**2], [5, 2/x]])
+    assert (array(m.subs(x, 2)) == array([[sin(2), 4], [5, 1]])).all()
+
+
+def test_Matrix2():
+    m = Matrix([[x, x**2], [5, 2/x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        assert (matrix(m.subs(x, 2)) == matrix([[2, 4], [5, 1]])).all()
+    m = Matrix([[sin(x), x**2], [5, 2/x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        assert (matrix(m.subs(x, 2)) == matrix([[sin(2), 4], [5, 1]])).all()
+
+
+def test_Matrix3():
+    a = array([[2, 4], [5, 1]])
+    assert Matrix(a) == Matrix([[2, 4], [5, 1]])
+    assert Matrix(a) != Matrix([[2, 4], [5, 2]])
+    a = array([[sin(2), 4], [5, 1]])
+    assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
+
+
+def test_Matrix4():
+    with ignore_warnings(PendingDeprecationWarning):
+        a = matrix([[2, 4], [5, 1]])
+    assert Matrix(a) == Matrix([[2, 4], [5, 1]])
+    assert Matrix(a) != Matrix([[2, 4], [5, 2]])
+    with ignore_warnings(PendingDeprecationWarning):
+        a = matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
+
+
+def test_Matrix_sum():
+    M = Matrix([[1, 2, 3], [x, y, x], [2*y, -50, z*x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        m = matrix([[2, 3, 4], [x, 5, 6], [x, y, z**2]])
+    assert M + m == Matrix([[3, 5, 7], [2*x, y + 5, x + 6], [2*y + x, y - 50, z*x + z**2]])
+    assert m + M == Matrix([[3, 5, 7], [2*x, y + 5, x + 6], [2*y + x, y - 50, z*x + z**2]])
+    assert M + m == M.add(m)
+
+
+def test_Matrix_mul():
+    M = Matrix([[1, 2, 3], [x, y, x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        m = matrix([[2, 4], [x, 6], [x, z**2]])
+    assert M*m == Matrix([
+        [         2 + 5*x,        16 + 3*z**2],
+        [2*x + x*y + x**2, 4*x + 6*y + x*z**2],
+    ])
+
+    assert m*M == Matrix([
+        [   2 + 4*x,      4 + 4*y,      6 + 4*x],
+        [       7*x,    2*x + 6*y,          9*x],
+        [x + x*z**2, 2*x + y*z**2, 3*x + x*z**2],
+    ])
+    a = array([2])
+    assert a[0] * M == 2 * M
+    assert M * a[0] == 2 * M
+
+
+def test_Matrix_array():
+    class matarray:
+        def __array__(self, dtype=object, copy=None):
+            if copy is not None and not copy:
+                raise TypeError("Cannot implement copy=False when converting Matrix to ndarray")
+            from numpy import array
+            return array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    matarr = matarray()
+    assert Matrix(matarr) == Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+
+
+def test_matrix2numpy():
+    a = matrix2numpy(Matrix([[1, x**2], [3*sin(x), 0]]))
+    assert isinstance(a, ndarray)
+    assert a.shape == (2, 2)
+    assert a[0, 0] == 1
+    assert a[0, 1] == x**2
+    assert a[1, 0] == 3*sin(x)
+    assert a[1, 1] == 0
+
+
+def test_matrix2numpy_conversion():
+    a = Matrix([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]])
+    b = array([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]])
+    assert (matrix2numpy(a) == b).all()
+    assert matrix2numpy(a).dtype == numpy.dtype('object')
+
+    c = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='int8')
+    d = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='float64')
+    assert c.dtype == numpy.dtype('int8')
+    assert d.dtype == numpy.dtype('float64')
+
+
+def test_issue_3728():
+    assert (Rational(1, 2)*array([2*x, 0]) == array([x, 0])).all()
+    assert (Rational(1, 2) + array(
+        [2*x, 0]) == array([2*x + Rational(1, 2), Rational(1, 2)])).all()
+    assert (Float("0.5")*array([2*x, 0]) == array([Float("1.0")*x, 0])).all()
+    assert (Float("0.5") + array(
+        [2*x, 0]) == array([2*x + Float("0.5"), Float("0.5")])).all()
+
+
+@conserve_mpmath_dps
+def test_lambdify():
+    mpmath.mp.dps = 16
+    sin02 = mpmath.mpf("0.198669330795061215459412627")
+    f = lambdify(x, sin(x), "numpy")
+    prec = 1e-15
+    assert -prec < f(0.2) - sin02 < prec
+
+    # if this succeeds, it can't be a numpy function
+
+    if version_tuple(numpy.__version__) >= version_tuple('1.17'):
+        with raises(TypeError):
+            f(x)
+    else:
+        with raises(AttributeError):
+            f(x)
+
+
+def test_lambdify_matrix():
+    f = lambdify(x, Matrix([[x, 2*x], [1, 2]]), [{'ImmutableMatrix': numpy.array}, "numpy"])
+    assert (f(1) == array([[1, 2], [1, 2]])).all()
+
+
+def test_lambdify_matrix_multi_input():
+    M = sympy.Matrix([[x**2, x*y, x*z],
+                      [y*x, y**2, y*z],
+                      [z*x, z*y, z**2]])
+    f = lambdify((x, y, z), M, [{'ImmutableMatrix': numpy.array}, "numpy"])
+
+    xh, yh, zh = 1.0, 2.0, 3.0
+    expected = array([[xh**2, xh*yh, xh*zh],
+                      [yh*xh, yh**2, yh*zh],
+                      [zh*xh, zh*yh, zh**2]])
+    actual = f(xh, yh, zh)
+    assert numpy.allclose(actual, expected)
+
+
+def test_lambdify_matrix_vec_input():
+    X = sympy.DeferredVector('X')
+    M = Matrix([
+        [X[0]**2, X[0]*X[1], X[0]*X[2]],
+        [X[1]*X[0], X[1]**2, X[1]*X[2]],
+        [X[2]*X[0], X[2]*X[1], X[2]**2]])
+    f = lambdify(X, M, [{'ImmutableMatrix': numpy.array}, "numpy"])
+
+    Xh = array([1.0, 2.0, 3.0])
+    expected = array([[Xh[0]**2, Xh[0]*Xh[1], Xh[0]*Xh[2]],
+                      [Xh[1]*Xh[0], Xh[1]**2, Xh[1]*Xh[2]],
+                      [Xh[2]*Xh[0], Xh[2]*Xh[1], Xh[2]**2]])
+    actual = f(Xh)
+    assert numpy.allclose(actual, expected)
+
+
+def test_lambdify_transl():
+    from sympy.utilities.lambdify import NUMPY_TRANSLATIONS
+    for sym, mat in NUMPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert mat in numpy.__dict__
+
+
+def test_symarray():
+    """Test creation of numpy arrays of SymPy symbols."""
+
+    import numpy as np
+    import numpy.testing as npt
+
+    syms = symbols('_0,_1,_2')
+    s1 = symarray("", 3)
+    s2 = symarray("", 3)
+    npt.assert_array_equal(s1, np.array(syms, dtype=object))
+    assert s1[0] == s2[0]
+
+    a = symarray('a', 3)
+    b = symarray('b', 3)
+    assert not(a[0] == b[0])
+
+    asyms = symbols('a_0,a_1,a_2')
+    npt.assert_array_equal(a, np.array(asyms, dtype=object))
+
+    # Multidimensional checks
+    a2d = symarray('a', (2, 3))
+    assert a2d.shape == (2, 3)
+    a00, a12 = symbols('a_0_0,a_1_2')
+    assert a2d[0, 0] == a00
+    assert a2d[1, 2] == a12
+
+    a3d = symarray('a', (2, 3, 2))
+    assert a3d.shape == (2, 3, 2)
+    a000, a120, a121 = symbols('a_0_0_0,a_1_2_0,a_1_2_1')
+    assert a3d[0, 0, 0] == a000
+    assert a3d[1, 2, 0] == a120
+    assert a3d[1, 2, 1] == a121
+
+
+def test_vectorize():
+    assert (numpy.vectorize(
+        sin)([1, 2, 3]) == numpy.array([sin(1), sin(2), sin(3)])).all()

lib/python3.12/site-packages/sympy/external/tests/test_pythonmpq.py

@@ -0,0 +1,176 @@
+"""
+test_pythonmpq.py
+
+Test the PythonMPQ class for consistency with gmpy2's mpq type. If gmpy2 is
+installed run the same tests for both.
+"""
+from fractions import Fraction
+from decimal import Decimal
+import pickle
+from typing import Callable, List, Tuple, Type
+
+from sympy.testing.pytest import raises
+
+from sympy.external.pythonmpq import PythonMPQ
+
+#
+# If gmpy2 is installed then run the tests for both mpq and PythonMPQ.
+# That should ensure consistency between the implementation here and mpq.
+#
+rational_types: List[Tuple[Callable, Type, Callable, Type]]
+rational_types = [(PythonMPQ, PythonMPQ, int, int)]
+try:
+    from gmpy2 import mpq, mpz
+    rational_types.append((mpq, type(mpq(1)), mpz, type(mpz(1))))
+except ImportError:
+    pass
+
+
+def test_PythonMPQ():
+    #
+    # Test PythonMPQ and also mpq if gmpy/gmpy2 is installed.
+    #
+    for Q, TQ, Z, TZ in rational_types:
+
+        def check_Q(q):
+            assert isinstance(q, TQ)
+            assert isinstance(q.numerator, TZ)
+            assert isinstance(q.denominator, TZ)
+            return q.numerator, q.denominator
+
+        # Check construction from different types
+        assert check_Q(Q(3)) == (3, 1)
+        assert check_Q(Q(3, 5)) == (3, 5)
+        assert check_Q(Q(Q(3, 5))) == (3, 5)
+        assert check_Q(Q(0.5)) == (1, 2)
+        assert check_Q(Q('0.5')) == (1, 2)
+        assert check_Q(Q(Fraction(3, 5))) == (3, 5)
+
+        # https://github.com/aleaxit/gmpy/issues/327
+        if Q is PythonMPQ:
+            assert check_Q(Q(Decimal('0.6'))) == (3, 5)
+
+        # Invalid types
+        raises(TypeError, lambda: Q([]))
+        raises(TypeError, lambda: Q([], []))
+
+        # Check normalisation of signs
+        assert check_Q(Q(2, 3)) == (2, 3)
+        assert check_Q(Q(-2, 3)) == (-2, 3)
+        assert check_Q(Q(2, -3)) == (-2, 3)
+        assert check_Q(Q(-2, -3)) == (2, 3)
+
+        # Check gcd calculation
+        assert check_Q(Q(12, 8)) == (3, 2)
+
+        # __int__/__float__
+        assert int(Q(5, 3)) == 1
+        assert int(Q(-5, 3)) == -1
+        assert float(Q(5, 2)) == 2.5
+        assert float(Q(-5, 2)) == -2.5
+
+        # __str__/__repr__
+        assert str(Q(2, 1)) == "2"
+        assert str(Q(1, 2)) == "1/2"
+        if Q is PythonMPQ:
+            assert repr(Q(2, 1)) == "MPQ(2,1)"
+            assert repr(Q(1, 2)) == "MPQ(1,2)"
+        else:
+            assert repr(Q(2, 1)) == "mpq(2,1)"
+            assert repr(Q(1, 2)) == "mpq(1,2)"
+
+        # __bool__
+        assert bool(Q(1, 2)) is True
+        assert bool(Q(0)) is False
+
+        # __eq__/__ne__
+        assert (Q(2, 3) == Q(2, 3)) is True
+        assert (Q(2, 3) == Q(2, 5)) is False
+        assert (Q(2, 3) != Q(2, 3)) is False
+        assert (Q(2, 3) != Q(2, 5)) is True
+
+        # __hash__
+        assert hash(Q(3, 5)) == hash(Fraction(3, 5))
+
+        # __reduce__
+        q = Q(2, 3)
+        assert pickle.loads(pickle.dumps(q)) == q
+
+        # __ge__/__gt__/__le__/__lt__
+        assert (Q(1, 3) < Q(2, 3)) is True
+        assert (Q(2, 3) < Q(2, 3)) is False
+        assert (Q(2, 3) < Q(1, 3)) is False
+        assert (Q(-2, 3) < Q(1, 3)) is True
+        assert (Q(1, 3) < Q(-2, 3)) is False
+
+        assert (Q(1, 3) <= Q(2, 3)) is True
+        assert (Q(2, 3) <= Q(2, 3)) is True
+        assert (Q(2, 3) <= Q(1, 3)) is False
+        assert (Q(-2, 3) <= Q(1, 3)) is True
+        assert (Q(1, 3) <= Q(-2, 3)) is False
+
+        assert (Q(1, 3) > Q(2, 3)) is False
+        assert (Q(2, 3) > Q(2, 3)) is False
+        assert (Q(2, 3) > Q(1, 3)) is True
+        assert (Q(-2, 3) > Q(1, 3)) is False
+        assert (Q(1, 3) > Q(-2, 3)) is True
+
+        assert (Q(1, 3) >= Q(2, 3)) is False
+        assert (Q(2, 3) >= Q(2, 3)) is True
+        assert (Q(2, 3) >= Q(1, 3)) is True
+        assert (Q(-2, 3) >= Q(1, 3)) is False
+        assert (Q(1, 3) >= Q(-2, 3)) is True
+
+        # __abs__/__pos__/__neg__
+        assert abs(Q(2, 3)) == abs(Q(-2, 3)) == Q(2, 3)
+        assert +Q(2, 3) == Q(2, 3)
+        assert -Q(2, 3) == Q(-2, 3)
+
+        # __add__/__radd__
+        assert Q(2, 3) + Q(5, 7) == Q(29, 21)
+        assert Q(2, 3) + 1 == Q(5, 3)
+        assert 1 + Q(2, 3) == Q(5, 3)
+        raises(TypeError, lambda: [] + Q(1))
+        raises(TypeError, lambda: Q(1) + [])
+
+        # __sub__/__rsub__
+        assert Q(2, 3) - Q(5, 7) == Q(-1, 21)
+        assert Q(2, 3) - 1 == Q(-1, 3)
+        assert 1 - Q(2, 3) == Q(1, 3)
+        raises(TypeError, lambda: [] - Q(1))
+        raises(TypeError, lambda: Q(1) - [])
+
+        # __mul__/__rmul__
+        assert Q(2, 3) * Q(5, 7) == Q(10, 21)
+        assert Q(2, 3) * 1 == Q(2, 3)
+        assert 1 * Q(2, 3) == Q(2, 3)
+        raises(TypeError, lambda: [] * Q(1))
+        raises(TypeError, lambda: Q(1) * [])
+
+        # __pow__/__rpow__
+        assert Q(2, 3) ** 2 == Q(4, 9)
+        assert Q(2, 3) ** 1 == Q(2, 3)
+        assert Q(-2, 3) ** 2 == Q(4, 9)
+        assert Q(-2, 3) ** -1 == Q(-3, 2)
+        if Q is PythonMPQ:
+            raises(TypeError, lambda: 1 ** Q(2, 3))
+            raises(TypeError, lambda: Q(1, 4) ** Q(1, 2))
+        raises(TypeError, lambda: [] ** Q(1))
+        raises(TypeError, lambda: Q(1) ** [])
+
+        # __div__/__rdiv__
+        assert Q(2, 3) / Q(5, 7) == Q(14, 15)
+        assert Q(2, 3) / 1 == Q(2, 3)
+        assert 1 / Q(2, 3) == Q(3, 2)
+        raises(TypeError, lambda: [] / Q(1))
+        raises(TypeError, lambda: Q(1) / [])
+        raises(ZeroDivisionError, lambda: Q(1, 2) / Q(0))
+
+        # __divmod__
+        if Q is PythonMPQ:
+            raises(TypeError, lambda: Q(2, 3) // Q(1, 3))
+            raises(TypeError, lambda: Q(2, 3) % Q(1, 3))
+            raises(TypeError, lambda: 1 // Q(1, 3))
+            raises(TypeError, lambda: 1 % Q(1, 3))
+            raises(TypeError, lambda: Q(2, 3) // 1)
+            raises(TypeError, lambda: Q(2, 3) % 1)

lib/python3.12/site-packages/sympy/external/tests/test_scipy.py

@@ -0,0 +1,35 @@
+# This testfile tests SymPy <-> SciPy compatibility
+
+# Don't test any SymPy features here. Just pure interaction with SciPy.
+# Always write regular SymPy tests for anything, that can be tested in pure
+# Python (without scipy). Here we test everything, that a user may need when
+# using SymPy with SciPy
+
+from sympy.external import import_module
+
+scipy = import_module('scipy')
+if not scipy:
+    #bin/test will not execute any tests now
+    disabled = True
+
+from sympy.functions.special.bessel import jn_zeros
+
+
+def eq(a, b, tol=1e-6):
+    for x, y in zip(a, b):
+        if not (abs(x - y) < tol):
+            return False
+    return True
+
+
+def test_jn_zeros():
+    assert eq(jn_zeros(0, 4, method="scipy"),
+            [3.141592, 6.283185, 9.424777, 12.566370])
+    assert eq(jn_zeros(1, 4, method="scipy"),
+            [4.493409, 7.725251, 10.904121, 14.066193])
+    assert eq(jn_zeros(2, 4, method="scipy"),
+            [5.763459, 9.095011, 12.322940, 15.514603])
+    assert eq(jn_zeros(3, 4, method="scipy"),
+            [6.987932, 10.417118, 13.698023, 16.923621])
+    assert eq(jn_zeros(4, 4, method="scipy"),
+            [8.182561, 11.704907, 15.039664, 18.301255])

lib/python3.12/site-packages/sympy/integrals/benchmarks/bench_integrate.py

@@ -0,0 +1,21 @@
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.trigonometric import sin
+from sympy.integrals.integrals import integrate
+
+x = Symbol('x')
+
+
+def bench_integrate_sin():
+    integrate(sin(x), x)
+
+
+def bench_integrate_x1sin():
+    integrate(x**1*sin(x), x)
+
+
+def bench_integrate_x2sin():
+    integrate(x**2*sin(x), x)
+
+
+def bench_integrate_x3sin():
+    integrate(x**3*sin(x), x)