def endlicher_koerper(p: int, n: int):
if n <= 1:
Z = GanzzahlRestklassenring(p)
values = [i for i in range(p)]
if is_prime_field(p, values, p):
for value in values:
Z.elements.append(GanzzahlRestklassenringElement(value, p))
return Z
else:
raise TypeError("Es ist ein Primkoerper!")
else:
Z = GanzRestklassenring(p)
P = PolynomRestklassenring(Z)
modulus = PolynomringElement([1 for i in range(n + 1)])
PolyRest = PolynomRestklassenring(modulus)
ele_list = get_p_pow_n_elements(p, n, P)
for ele in ele_list:
poly = PolynomringElement(ele, P)
PolyRest.elements.append(
PolynomRestklassenringElement(poly, PolyRest))
return PolyRest
"""
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 get_p_pow_n_elements(p, n, ring):
from itertools import product
rest = []
for rest_polynom in product(range(p), repeat=n):
#rest.append(list(rest_polynom))
rest.append(PolynomringElement(list(rest_polynom), ring))
return rest
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
def _polynom_div(a: PolynomringElement, b: PolynomringElement):
"""Polynomdivision ohne Rest"""
a_koeffizienten = copy.copy(a.koeffizienten.koeffizienten)
b_koeffizienten = b.koeffizienten.koeffizienten
q_koeffizienten = []
while a_koeffizienten and len(a_koeffizienten) >= len(b_koeffizienten):
t = a_koeffizienten[-1] / b_koeffizienten[-1]
q_koeffizienten = [t] + q_koeffizienten
for i in range(len(b_koeffizienten)):
a_koeffizienten[len(a_koeffizienten) - len(b_koeffizienten) +
i] -= t * b_koeffizienten[i]
del a_koeffizienten[-1]
q = PolynomringElement(q_koeffizienten, a.ring)
r = PolynomringElement(a_koeffizienten, a.ring)
return q, r
def get_rest_from_polynomring(polynom):
from itertools import product
if not isinstance(polynom.ring.basisring, GanzzahlRestklassenring):
raise TypeError("Ich brauche ein Ganzzahlrestklassenring")
rest = []
degree = polynom.grad
ring = polynom.ring
modulus_degree = polynom.ring.basisring.modulus
n_pow_n = modulus_degree**degree
print(modulus_degree)
for rest_polynom in product(range(modulus_degree), repeat=degree):
#rest.append(list(rest_polynom))
rest.append(PolynomringElement(list(rest_polynom), ring))
return rest
def reverseKoeffizienten(C):
"""Kehrt Koeffizientenliste um
C = PolynomringElement([1,1,0,1],K) := 1 + x + x**3
>>> reverseKoeffizienten(C)
---> [1,0,1,1] := x + x**2 + x**3
Args:
C (PolynomringElement): PolynomringElement, dessen Koeffizienten umgekehrt werden sollen
Return:
PolynomringElement: Gibt PolynomringElement mit Koeffizienten in umgekehrter Reihenfolge zurueck
"""
anzahlKoeffizienten = C.koeffizienten.laenge
reverseList = [0] * anzahlKoeffizienten
for i in range(anzahlKoeffizienten):
reverseList[anzahlKoeffizienten - 1 - i] = C.koeffizienten[i]
return PolynomringElement(reverseList, C.ring)
def rabin_test_reducible(polynom):
# monic polynomial f of degree n
# p_1, ..., p_k all distinct prime divisors of n
from .polynomring_extension import _polynomring_ext_ggt
from Tocas import PolynomringElement
from .PolynomRestklassenring import PolynomRestklassenringElement
if not isinstance(polynom.ring.basisring, GanzzahlRestklassenring):
raise TypeError("Nur GanzahlRestklassenring als Basisring erlaubt.")
try:
q = polynom.ring.basisring.modulus
except AttributeError:
raise Attribute("Der Rabit-Test braucht ein Galoi-Feld als Basisring.")
n = polynom.grad
x = PolynomringElement([0, 1], polynom.ring)
f = polynom
p_x = []
k = primes(n)
for j, l in enumerate(k):
v = int(n / l)
if v not in p_x:
p_x.append(v)
for i in p_x:
print(x, q, i, f)
h = (((x**q)**i) - x) % f
print(h)
a, u, v = _polynomring_ext_ggt(f.ring, f, h)
ggt = a * u + h * v
print("Erstes G: ", ggt)
if ggt != f.ring.eins:
return True
g = ((((x)**q)**n) - x) % f
print("Zweites G: ", g)
return g != g.ring.null
def __init__(self, p, r: PolynomRestklassenring):
self.ring = r
if isinstance(p, PolynomRestklassenringElement):
if p.ring.modulus.basisring != r.modulus.basisring:
raise RuntimeError(
"Polynom und Ring nicht vom selben Basisring.")
if p.ring.modulus % self.ring.modulus == self.ring.modulus.ring.null:
self.wert = p.wert % self.ring.modulus
else:
raise RuntimeError("Die Moduli passen nicht zusammen.")
else:
if not isinstance(p, PolynomringElement):
p = PolynomringElement(p, r.modulus.ring)
self.wert = p % self.ring.modulus
self._frier()
if i == 0:
result += '1'
else:
result += 'x^%s' % str(i)
if i != lis[-1]:
result += ' + '
return result
R_X = Polynomring(Z)
a = 2
b = 2
f = PolynomringElement([1, 0, 0, 1], R_X)
g = PolynomringElement([1], R_X)
if (f.koeffizienten.laenge > g.koeffizienten.laenge):
help_koeff = [0] * f.koeffizienten.laenge
else:
help_koeff = [0] * g.koeffizienten.laenge
for i in range(0, g.koeffizienten.laenge):
help_koeff[a - b + i] = 1
def xor_list(list1, list2):
temp = list1
for i in range(0, len(list1)):
if ((list1[i] == 1 or list2[i] == 1) and list1[i] != list2[i]):
temp[i] = 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