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)
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)
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
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
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))
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)