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)