Пример #1
0
def _polynom_irreduzibel(f: PolynomringElement, primzahl_test=None):
    import Extension.Primzahl as primzahl
    from Extension.PolynomRestklassenring import PolynomRestklassenring, PolynomRestklassenringElement

    if not primzahl_test:
        primzahl_test = primzahl.miller_rabin

    if not f.basisring.ist_endlicher_koerper():
        raise TypeError('Bassisring muss endlicher Körper sein')
    if f.grad == 0:
        return False

    KX_f = PolynomRestklassenring(f)
    var = PolynomRestklassenringElement(f.ring.variable, KX_f)

    n = [int(f.grad / p) for p in _primzahlen(f.grad, primzahl_test)]

    if isinstance(f.basisring, PolynomRestklassenring):
        q = f.basisring.modulus.basisring.modulus**f.basisring.modulus.grad
    else:
        q = f.basisring.modulus

    for i in range(0, len(n)):
        h = (((var**q)**n[i]) - var)
        g, _, _ = Polynomring.ExtGGT(f, h.wert, False)
        if g.grad != 0:
            return False

    g = ((var**(q**f.grad)) - var)
    if g == var.ring.null:
        return True
    return False
 def invers(self):
     print(self.wert)
     print(self.ring.modulus)
     _, u, _ = Polynomring.ExtGGT(self.wert, self.ring.modulus)
     if u != 1:
         raise RuntimeError("GGT von Wert und Modulus nicht 1")
     return PolynomRestklassenringElement(u, self.ring)
def _polynomring_ext_ggt(self: Polynomring, a: PolynomringElement,
                         b: PolynomringElement):
    if not (isinstance(a, PolynomringElement)
            and isinstance(b, PolynomringElement)):
        raise TypeError('Argumente nicht vom Typ PolynomringElement')

    if a.ring != self or b.ring != self:
        raise TypeError('PolynomringElement nicht im Polynomring')

    return Polynomring.ExtGGT(a, b)
Пример #4
0
def endlicher_koerper(p,
                      n=None,
                      variablenname='x',
                      primzahl_test=Primzahl.miller_rabin):
    if isinstance(p, Ring):
        if p.ist_endlicher_koerper():
            R = p
        else:
            raise TypeError('Erstes Argument muss ein endlicher Körper sein')
    else:
        if not n:
            q = p
            for exp in range(2, int(math.log(q, 2)) + 1):
                basis = decimal.Decimal(q)**(decimal.Decimal(1) /
                                             decimal.Decimal(exp))
                if basis % 1 == 0 and primzahl_test(int(basis)):
                    p = int(basis)
                    n = exp
                    break
            else:
                if primzahl_test(p):
                    n = 1
                else:
                    raise TypeError(
                        'Erstes Argument muss Primzahl oder Primpotenz sein')
        elif not primzahl_test(p):
            raise TypeError('p ist keine Primzahl')
        R = GanzzahlRestklassenring(p)
    if n < 1:
        raise TypeError('n ist keine natürliche Zahl')

    if n == 1:
        return R

    RX = Polynomring(R, variablenname)

    koeffizienten = [RX.basisring.null] * (n + 1)

    random.seed(0)
    while True:
        koeffizienten[random.randint(0, n)] = RX.basisring.zufaellig()

        if koeffizienten[-1] == RX.basisring.null:
            koeffizienten[-1] += RX.basisring.eins

        f = PolynomringElement(koeffizienten, RX)
        if f.irreduzibel(primzahl_test):
            return PolynomRestklassenring(f)
Пример #5
0
def aks(n):
    from Extension.PolynomRestklassenring import PolynomRestklassenring

    if not isinstance(n, int):
        raise TypeError('Argumente nicht vom Typ int')

    if n <= 1:
        return False

    for a in range(2, math.ceil(math.sqrt(n))):
        b = 2
        while a**b <= n:
            if n == a**b:
                return False
            b += 1

    r = 1
    while _ord(r, n) <= math.log2(n)**2:
        r += 1

    for a in range(2, r + 1):
        ggt = Ganzzahlring.ext_ggT(a, n)[0]

        if ggt > 1 and ggt < n:
            return False

    if n <= r:
        return True

    K_X_n = Polynomring(GanzzahlRestklassenring(n))
    K_X_n_f = PolynomRestklassenring(K_X_n.variable**r - K_X_n.eins)

    for a in range(1, math.floor(math.sqrt(_phi(r)) * math.log2(n) + 1)):
        if K_X_n_f.element(
            [a, 1])**n != K_X_n_f.erzeuger**n + K_X_n_f.element([a]):
            return False

    return True
Пример #6
0
import numpy as np
from Tocas import Polynomring, PolynomringElement, Z
from Extension import endlicher_koerper
#Wiedemann algorithm

R_X = Polynomring(Z)


def wiedemann(A, b):
    #nonsingular square case (n x n)
    listOfMatrices = []
    n = len(A)
    for i in range(0, 2 * n - 1):
        listOfMatrices.append(A ^ i * b)

    k = 0
    g0 = PolynomringElement([1], R_X)

    return 0


#compute A^i * b for i = 0,1,...,2n-1
Пример #7
0
import project_path
from Tocas import Polynomring, PolynomringElement, Z, GanzzahlRestklassenring, GanzzahlRestklassenringElement
from Extension.Projekt import Berlekamp_Massey as FR
from Extension import endlicher_koerper
from Extension.PolynomRestklassenring import PolynomRestklassenring, PolynomRestklassenringElement
import Extension.polynomring_extension
import Poly
import Modular
import Algorithms

F = GanzzahlRestklassenring(7)
FX = Polynomring(F)
g = PolynomringElement([1, 0, 1], FX)
FX_g = PolynomRestklassenring(g)

sequenz = [1, 4, 2, 4, 5, 2, 2, 1, 3, 4]
print(g.irreduzibel())
print(FX_g.ist_endlicher_koerper())
C = PolynomRestklassenringElement([1], FX_g)
print(FX_g)
#FR.berlekamp_massey(sequenz,FX_g)
field = Modular.Modular(101)
polyRing = Poly.Poly(field)
B = [field.one()]
print(B)
print(polyRing.timesXPower(B, 6))
Пример #8
0
def berleMassey(seq, K):
    """Berlekamp Massey Algorithmus findet kleinstes Polynom welches gegebene Sequenz aus endlichem Koerper berechnet, sowie die lineare Komplexitaet der Sequenz.
    
    Args: 
        seq                  (list): Die zu berechnende Sequenz
        K (GanzzahlRestklassenring): Endlicher Koerper des zu Berechnenden Polynoms 
    
    Returns:
        PolynomringElement: Zurueckgegebenes Polynom berechnet gegebene Sequenz

    Raises:
        RuntimeError: Wenn K kein endlicher Koerper
                      Wenn K nicht uerber Primzahl
    """

    tStart = time.time()  #: Laufzeitberechnung intialisieren

    if (not K.ist_endlicher_koerper()):  # Testen ob K endlicher_koerper
        raise RuntimeError("Berlekamp Massey nur auf endlichen Koerpern.")

    P = Polynomring(K)

    if (type(K) == GanzzahlRestklassenring):
        raise RuntimeError("Nur über GanzzahlRestklassenringe implementiert.")

    C = PolynomringElement([K.eins], P)  # Aktuelles Rueckkopplungspolynom
    B = PolynomringElement(
        [K.eins],
        P)  # Rueckkopplungspolynom, bei letzten laengenaenderung des LFSR
    m = 1  # Anzahl Iterationen seit letzter laengenaenderung des LSFR
    L = 0  # Aktuelle Laenge des LFSR
    b = K.eins  # wert Diskrepanz der letzten laengenaenderung des LFSR
    N = 0  # Aktuell betrachtete Elemente aus Sequenz

    for N in range(len(seq)):  # Durchlaufe alle Elemente der gegebenen Sequenz

        d = diskrepanz(
            C, seq, N, K
        )  # Berechnet Diskrepanz der erechneten Sequenz zur gegbenen Sequenz
        if (
                d == K.null
        ):  # Falls die Diskrepanz null betraegt wurde Sequenz korrekt durch das Polynom C beschrieben
            m = m + 1  # somit kann mit dem naechsten Element fortgefuehrt werden
        else:  # Falls nicht, muss das Polynom C angepasst werden
            if 2 * L > N:  # Groesse des aktuellen LFSR L reicht aus
                # falls L gleich oder mehr als halb so gross wie aktuell betrachtete seq-laenge
                C = C - (
                    d / b).wert * P.variable**m * B  # C = C - (d/b) * x**m * B
                m = m + 1  # L bleibt gleich --> m erhoehen

            else:  # LFSR zu klein und muss vergroessert werden

                T = (
                    d / b
                ).wert * P.variable**m * B  # Ergenis in T zwischenspeichern
                B = C
                C = C - T
                L = N + 1 - L  # Anpassung der laenge des LFSR
                b = d  # Bei Anpassung alte Diskrepanz in b
                m = 1  # zuruecksetzen der Iterationenen seit L vergroessert wurde

    C = reverseKoeffizienten(C)
    return C, L
 def invers(self):
     _, u, _ = Polynomring.ExtGGT(self.wert, self.ring.modulus)
     return PolynomRestklassenringElement(u, self.ring)