############## Dies ist KASH3-Code!!!!!!!! ############ ############## ############ ############## die Variable Q ist vordefiniert. Nicht benutzen !!! ############ ############################################################################### Q := RationalField(); Z := Integers(); L1 := NumberField(X^3-2); ### Erzeugt L1= Q(2^{1/3}) ### PL1 := PolynomialAlgebra(L1); f := Factorization(Element(PL1, X^3-2))[2][1]; L2 := NumberField(f); ### Erzeugt L2= Q(2^(1/3), zeta) mit zeta^3=1 ### ### Element(PL1, X^3-2) 'schiebt' das Polynom X^3-2 in die ### Polynomalgebra PL1 ### Damit erhaelt man eine Faktorisierung ueber L1 L3 := NumberField(Element(PolynomialAlgebra(L2), X^2-2)); ### Erzeugt Q(2^(1/3), zeta, sqrt(2)) ### F1 := NumberField(X^2-2); zeta := L1.1/L2.1; L := [L1.1, L1.1*zeta, L1.1*zeta^2]; alpha := zeta + L[2] + L3.1; PL3 := PolynomialAlgebra(L3); ############################# Definition of new type ################# NewType("HOM"); ###################################################################### MakeHom := function(CL1,CL2,CL_u,CL_b) local L1, L2, L_u, L_b, sigma; sigma := rec( type := HOM, L1 := CL1, L2 := CL2, L_u := CL_u, L_b := CL_b ); sigma.operations := rec( Print := function(z) Print("Homomorphism from ", z.L1, " to ", z.L2, ", maps ", z.L_u, " to ", z.L_b ); end ); return sigma; end; ### Ein Element vom Typ Hom ist ein Record; der erste Eintrag ist der Typ; die nachsten beiden sind Urbild- und Bildbereich. Dann kommt eine Liste von Erzeugern vom Urbildbereich und eine Liste mit Bildern der Erzeuger. ######### beispiel fuer einen Homomorphismus ########## L_u := [ L1.1 , L2.1, L3.1 ]; L_b := [ L2.1, L[2], L3.1 ]; K1 := L3; K2 := L3; zeta := L1.1/L2.1; L := [L1.1, L1.1*zeta, L1.1*zeta^2]; alpha := zeta + L[2] + L3.1; beta := L[1]; sigma := MakeHom(K1,K2,L_u,L_b); eta := MakeHom(L2,L2,[L1.1, L2.1], [L2.1, L1.1]); B := MakeHom(Q,Q,[1], [1]); MyGroundField := function(F) if F=Rationals() or F=Integers() then return(Rationals()); fi; return(GroundField(F)); end; ####################### Diese Funktion nicht benutzen ################## EvaluateElement := function(F1,F2,L_b,alpha) local NewL,l,n; if F1=Q and alpha in Q then l := [alpha]; else l := List(alpha); fi; NewL:= Apply([1..Length(L_b)-1], i-> L_b[i]); n := Length(L_b); if F1 <> Q then return(Evaluate(Element(PolynomialAlgebra(F2), Apply(l, i-> EvaluateElement(MyGroundField(Parent(i)),F2,NewL,i)) ),L_b[n])); else if alpha in Q then return(alpha); else return(Evaluate( Element(PolynomialAlgebra(F2), ElementToSequence(alpha)), L_b[n])); fi; fi; end; ########################################################################## ### sigma1 und sigma2 muessen vom Typ HOM sein, gibt sigma1(sigma2) zurueck; sigma2 kann auch ein Element aus ### dem Definitionsbereich von sigma1 sein ### ApplyHom verknuepft entweder zwei Homomorphismen oder wendet sigma1 auf ein algebraisches Element an ### wenn es im Definitonsbereich von sigma1 liegt ApplyHom := function(sigma1, sigma2) local ERG; if not( Type(sigma1)= HOM) then Print("Error in ApplyHom(sigma1, sigma2): sigma1 is not of type Hom \n"); return(FALSE); fi; if Type(sigma2)=HOM then if IsSubfield(sigma2.L2, sigma1.L1).base = FALSE then Print("Error in ApplyHom(sigma1, sigma2): image of sigma2 not in domain of sigma1 \n"); return(FALSE); fi; ERG := MakeHom(sigma2.L2, sigma1.L1, sigma2.L_u, Apply(sigma2.L_b, i-> ApplyHom(sigma1, i))); else if not(sigma2 in sigma1.L1) then Print("Error in ApplyHom(sigma1, sigma2): sigma2 not in sigma1.L1 \n"); return(FALSE); fi; ERG := EvaluateElement(sigma1.L1,sigma1.L2,sigma1.L_b,Element(sigma1.L1,sigma2)); fi; return(ERG); end; ######### Ein neuen Homomorphismus konstruieren: tau := ApplyHom(sigma,eta); A := MakeHom(L3,L3, [ L1.1, L2.1, L3.1 ], [ -L2.1 - L1.1 , L1.1, L3.1]); erg := ApplyHom(A,sigma); ###### ist Identitaet, also A = sigma^-1 f1 := Element(PL3, [1, L2.1, L1.1]); ###### f1 soll E1 erzeugen E1 := NumberField(f1); ###### Erzeugung von E1 ###### Berechnung von f^sigma l := Element(PL3,Apply(List(f1), i-> ApplyHom(sigma,i))); erg := Factorization(l);