##############                 Achtung:                            ############
##############                                                     ############      
############## die Variable Q ist vordefiniert. Nicht benutzen !!! ############
###############################################################################


Q     := RationalField();
Z     := Integers();



###################       Definition des neuen Typen     #################

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.






MyGroundField := function(F)

   if F=Rationals() or F=Integers() then
      return(Rationals());
   fi;

   return(GroundField(F));
end;

####################### Diese Funktion braucht ihr nicht #############################################################

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; die Funktion 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,Reversed(sigma1.L_b),Element(sigma1.L1,sigma2));

      fi;
 
      return(ERG);

end;



################# Beispiel   ######################
###################################################


P     := PolynomialAlgebra(Q);
      AssignNames_(P, ["t"]);
t     := P.1;
f     := t^3-2;
K     := NumberField(t^3-2);                                 ### Erzeugt L1= Q(2^{1/3}) mit alpha=2^(1/3)###
      AssignNames_(K, ["alpha"]);
alpha := K.1;
PK    := PolynomialAlgebra(K);
      AssignNames_(PK, ["T"]);
T     := PK.1;
f     := Factorisation( T^3-2)[2][1];
E     := NumberField( f);
      AssignNames_(E, ["beta"]);
beta  := E.1;
gamma := -ElementToSequence(Factorisation( Element(PolynomialAlgebra(E),f))[2][1])[1];
PE    := PolynomialAlgebra(E);
      AssignNames_(PE, ["S"]);
S     := PE.1;
zeta  := alpha/beta;       ## zeta ist die dritte Einheitswurzel

### Die Nullstellen von t^3-2 sind also alpha, beta und gamma. Alpha, beta und gamma sind im Zerfaellungskoerper E von t^3-2
###  dies koennt ihr z.B. sehen durch Eingabe von Factorisation(S^3-2);



################### Die Homomorphismen muessen immer ueber einen Zerfaellungskoerper definiert sein (hier E)    ###################
################### Den Zerfaellungskoerper konstruiert ihr durch sukzessives adjungieren der Nullstellen von f ###################
################### wie oben vorgefuehrt

### Beispiel fuer einen Homomorphismus von E nach E, wobei E der Zerfaellungskoerper von Q(2^(1/3)) ist: ###
psi   := MakeHom(E,E, [ beta, alpha], [ alpha, alpha*zeta]);     
erg1  := ApplyHom(psi, beta); # = alpha;
erg2  := ApplyHom(psi, alpha); # = alpha*zeta;


### Beispiel fuer einen Homomorphismus von K(2^{1/3}) nach K(zeta*2^{1/3}),wobei E der Zerfaellungskoerper von Q(2^(1/3)) ist:  ###

tau   := MakeHom(E,E, [beta, alpha], [ beta, zeta*alpha]);     
erg1  := ApplyHom(tau, beta);   ## = 1
erg2  := ApplyHom(tau, alpha);   ## = zeta*alpha = -beta-alpha;


### Beispiel fuer eine Verknuepfung von Homomorphismen: ##########

mu    := ApplyHom(psi, tau);


##### psi(beta)   = alpha;
##### psi(alpha)  = gamma;
##### psi(zeta^2) = zeta^2;
####  tau(alpha)    = gamma;
##### mu(alpha) = psi(tau(alpha)) = psi(gamma) = beta;