----------------------------------------------------------------
-- PrintLn;
-- PrintLn '  POINTS.COC  by G. de Dominicis and M. Kreuzer ' 
-- PrintLn 'Help Points; gives a listing of available functions';
----------------------------------------------------------------

// Date created: 18/7/95
// Last modification: 23/7/97
// Version: 1.1
// CoCoA Version: 3.02
// Author(s): G. de Dominicis, M. Kreuzer



Define Points() End;

Define Help_Points()
   PrintLn 'POINTS.COC: functions for sets of points in projective space';
   PrintLn 'General Functions: FindFirstNonZero(L), Homcomp(M,N),';
   PrintLn '  Hilbmod(M,N), Hilb(M,N), Alpha(I), Is_hom(F), Putcoeffs(F,N),';
   PrintLn '  Getcoeffs(N), Soc(M), HSoc(M,N), Annmod(M,F), Ann(M)';
   PrintLn 'Functions for creating ideals of points: Genpt(N),';
   PrintLn '  Genpts(S,N), Genci(L), Idopt(L), Idopts(M)';
   PrintLn 'Kaehler differentials: KD(I), SocKD(I), HSocKD(I)';
   PrintLn '  RelKD(I,L), HSocRelKD(I,L), BarKD(I,L)';
   PrintLn 'Differents: Kdiff(I), HKdiff(I), RelKdiff(I,L),';
   PrintLn '  HRelKdiff(I,L), Ndiff(I), RelNdiff(I).';
End;

----------------------------------------------------------------
//  General Functions
----------------------------------------------------------------

Define PoincareMod(M)

   G:=Transposed(Mat(LT(M)));
   PSS:=Sum([SPToPoly(PSer_Num(Poincare(CurrentRing/Ideal(G[I]))))| I In 
   1..Len(G)]);
   Return PSeries(PSS,NumIndets())

End;     


Define HilbertMod(M)

   Global DH_PS := PoincareMod(M);
   Return PSer_Hilbert(DH_PS)

End;

Define FindFirstNonzero(L)
   For I:=1 To Len(L) Do
     If L[I]<>0 Then Return I End;
   End;
Return 0
End;

Define Help_FindFirstNonzero()
   PrintLn 'FindFirstNonzero ( L : List ) : Int';
   PrintLn 'returns the index of the first nonzero element of L.';
   PrintLn 'Remark: If all elements of L are zero, it returns zero.';
End;

-------------------------------------------------------------------

Define Homcomp(M,N)
   L:=Gens(M);
   Maxid:=Ideal([Indet(I) | I In 1..NumIndets()]);
   Result:=[];
   For I:=1 To Len(L) Do
      F:=FindFirstNonzero(Cast(L[I],LIST));
      D:=Deg(L[I,F]);
      If D<N Then
         Tlist:=Gens(Maxid^(N-D));
         For J:=1 To Len(Tlist) Do
            Append(Result,L[I]*Tlist[J])
         End
      End;
      If D=N Then Append(Result,L[I]) End
   End;
   Result:=Cast(Result,MODULE);
   Result:=Interreduced(Result);
Return Gens(Result)
End;

Define Help_Homcomp()
   PrintLn 'Homcomp( M : Module, N: Int ) : List';
   PrintLn 'returns a list of homogeneous vectors of polynomials which form';
   PrintLn 'a basis of the N-th homogeneous component of the submodule M.';
   PrintLn 'Remark: M should be generated by homog. vectors of polynomials.'
End;

-------------------------------------------------------------------


Define Hilbmod(M,N)
  G:=Transposed(Mat(LT(M)));
  Return Sum([Hilbert(CurrentRing/Ideal(G[I]),N)| I In 1..Len(G)]);
End;


Define Help_Hilbmod()
   PrintLn 'Hilbmod( M : Module, N: Int ) : Int';
   PrintLn 'returns the N-th value of the Hilbert function of the';
   PrintLn 'quotient module represented by M.'
End;

----------------------------------------------------------------

Define Hilb(M,N)
  G:=Transposed(Mat(LT(M)));
  H:=[Ideal(G[I])| I In 1..Len(G) And Ideal(G[I])<>Ideal(1)];
  V:=NewList(N+1,0);
  For C:=0 To N Do
     V[C+1]:=Sum([Hilbert(CurrentRing/H[I],C)| I In 1..Len(H)]);
  End;
  Return V;
End;


Define HilbertFree(M,N)
   H:=[Hilbmod(M,I)|I In 0..N];
   M:=Mat(M);
   P:=[Len(M[1])*Bin(NumIndets()+I-1,I)| I In 0..N];
   Return P-H
End;


Define Help_Hilb()
   PrintLn 'Hilb( M : Module , N : Int ) : List';
   PrintLn 'returns the first N values of the Hilbert function';
   PrintLn 'of the quotient module represented by M.';
End;

-------------------------------------------------------------------

Define Alpha(I)
  G:=Cast(Gens(I),LIST);
  For J:=1 To Len(G) Do G[J]:=Deg(G[J]) End;
Return Min(G)
End;

Define Help_Alpha()
   PrintLn 'Alpha( I : Ideal ) : Int';
   PrintLn 'returns the smallest degree of a polynomial in the ideal I.';
   PrintLn 'Remark: the ideal I should be homogeneous.'
End;

-------------------------------------------------------------------

Define Is_hom(F)
Return F=Homogenized(Indet(1),F)
End;

Define Help_Is_hom()
   PrintLn 'Is_hom( F : Poly ) : Bool';
   PrintLn 'returns TRUE, if F is homogeneous, and FALSE otherwise.';
End;

----------------------------------------------------------------

Define PutCoeffs(F,N)
    D:=DensePoly(Deg(F));
    For I:=N+1 To NumIndets() Do D:=Subst(D,Indet(I),Poly(0)) End;
    L:=Monomials(D);
    Global MyCoeffList:=NewList(Len(L));
    Global DN:=[Deg(F),N];
    For I:=1 To Len(L) Do Global MyCoeffList[I]:=CoeffOfTerm(L[I],F) End;
End;

Define Help_PutCoeffs()
   PrintLn 'PutCoeffs( F : Poly , N : Int ) : Null';
   PrintLn 'puts the list of coefficients of the terms of F involving';
   PrintLn 'only the first N variables into a list "MyCoeffList" in the';
   PrintLn 'Global Memory. The global variable "DN" contains [Deg(F),N].';
   PrintLn 'Remark: F should be a homogeneous polynomial.';
End;

----------------------------------------------------------------

Define GetCoeffs(Start)
  D:=DensePoly(DN[1]);
  N:=DN[2];
  If Start+N-1>NumIndets() Then Return Error('Too few variables') End;
  For I:=Start+N To NumIndets() Do
    D:=Subst(D,Indet(I),Poly(0))
  End;
  For I:=1 To Start-1 Do
    D:=Subst(D,Indet(I),Poly(0))
  End;
  L:=Monomials(D);
  F:=Poly(0);
  For I:=1 To Len(MyCoeffList) Do F:=F+Poly(MyCoeffList[I])*L[I] End;
Return F
End;

Define Help_GetCoeffs()
   PrintLn 'GetCoeffs( N : Int ) : Poly';
   PrintLn 'recreates a polynomial in a (possibly different) ring from';
   PrintLn 'the list "MyCoeffList" using DN[2] variables, starting with';
   PrintLn 'variable number N.';
   PrintLn 'Remark: CurrentRing must have at least N+DN[2]-1 variables.';
End;

----------------------------------------------------------------

Define Soc(M)
   N:=NumIndets();
   G:=Gens(M);
   NN:=Len(G[1]);
   A:=NewList(N);
   For J:=1 To N Do
      A[J]:=NewMat(NN,NN,0);
      For J1:=1 To NN Do A[J,J1,J1]:=Indet(J) End;
      A[J]:=Cast(A[J],MODULE);
      A[J]:=Intersection(A[J],M);
      A[J]:=Gens(A[J]);
      B:=NewList(Len(A[J]));
      For J1:=1 To Len(A[J]) Do
         Temp:=Cast(A[J,J1],LIST);
         For J2:=1 To Len(Temp) Do
            Temp[J2]:=Div(Temp[J2],Indet(J))
         End;
         Temp:=Cast(Temp,VECTOR);
         B[J1]:=Temp
      End;
      A[J]:=Cast(B,MODULE);
      Print '[',J,']'
   End;
   S:=A[1];
   For J:=2 To N Do
      S:=Intersection(S,A[J]);
      Print '[',J,']'
   End;
   S:=Minimalized(S);
   PrintLn;
Return S
End;

Define Help_Soc()
   PrintLn 'Soc( M : Module ) : Module';
   PrintLn 'returns the module representing the socle of the quotient';
   PrintLn 'module represented by M. In particular, M<Soc(M).';
End;

----------------------------------------------------------------

Define HSoc(M,N)
  S:=Soc(M);
  H:=NewList(N,0);
  For I:=1 To N Do
    H[I]:=Hilbmod(M,I-1)-Hilbmod(S,I-1);
    PrintLn 'H(Socle,',I-1,') = ',H[I]
  End;
Return H
End;

Define Help_HSoc()
   PrintLn 'HSoc( M : Module , N : Int ) : List';
   PrintLn 'returns the first N values of the Hilbert function';
   PrintLn 'of the socle of M, considered as a submodule of M.';
End;

----------------------------------------------------------------

Define Annmod(M,F)
   G:=Gens(M);
   N:=Len(G[1]);
   A:=NewMat(N,N,0);
   For J1:=1 To N Do A[J1,J1]:=F End;
   A:=Cast(A,MODULE);
   A:=Intersection(A,M);
   A:=Gens(A);
   B:=NewList(Len(A));
   For J1:=1 To Len(A) Do
      Temp:=Cast(A[J1],LIST);
      For J2:=1 To Len(Temp) Do
         Temp[J2]:=Div(Temp[J2],F)
      End;
      Temp:=Cast(Temp,VECTOR);
      B[J1]:=Temp
   End;
   A:=Cast(B,MODULE);
Return A
End;

Define Help_Annmod()
   PrintLn 'Annmod( M : Module , F : Poly ) : Module';
   PrintLn 'returns the module representing the submodule of the';
   PrintLn 'quotient module represented by M which is annihilated by F.';
   PrintLn 'Remark: M<Annmod(M,F) ';
End;

----------------------------------------------------------------

Define Ann(M)
   G:=Gens(M);
   L:=Len(G[1]);
   F:=NewMat(L,L,Poly(0));
   For I:=1 To L Do F[I,I]:=Poly(1) End;
   F:=Cast(F,MODULE);
Return M:F
End;

Define Help_Ann()
   PrintLn 'Ann( M : Module ) : Ideal';
   PrintLn 'returns the annihilator ideal of the quotient module';
   PrintLn 'represented by M.';
End;

----------------------------------------------------------------
// Functions for Creating Ideals of Points
----------------------------------------------------------------

Define Genpt(N)
   F:=DensePoly(1);
   L:=NewList(N);
   For I:=1 To N Do L[I]:=Randomized(F) End;
Return Ideal(L)
End;

Define Help_Genpt()
   PrintLn 'Genpt ( N : Int ) : Ideal';
   PrintLn 'returns the ideal of a generic point in P^N.';
   PrintLn 'Remark: CurrentRing should have N+1 indeterminates.'
End;

-------------------------------------------------------------------

Define Genpts(S,N)
   P:=Ideal(Poly(1));
   For I:=1 To S Do
      P:=Intersection(P,Genpt(N))
   End;
Return P
End;

Define Help_Genpts()
   PrintLn 'Genpts( S: Int , N : Int ) : Ideal';
   PrintLn 'returns the ideal of S generic points in P^N.';
   PrintLn 'Remark: CurrentRing should have N+1 indeterminates.'
End;

-------------------------------------------------------------------

Define Genci(L)
   LL:=Len(L);
   If LL<> NumIndets()-1 Then Return Ideal(Poly(0)) End;
   C:=NewList(LL);
   For I:=1 To LL Do
     LI:=L[I];
     C[I]:=Randomized(DensePoly(LI))
  End;
Return Ideal(C)
End;

Define Help_Genci()
   PrintLn 'Genci( L: List ) : Ideal';
   PrintLn 'returns the ideal of a generic 0-dimensional complete';
   PrintLn 'intersection of type L=[C1, ..., Cn].';
   PrintLn 'Remark: CurrentRing should have Len(L)+1 indeterminates,';
   PrintLn 'otherwise the ideal (0) is returned.'
End;

-------------------------------------------------------------------

Define Idopt(P)
   L:=NewList(Len(P)-1);
   F:=FindFirstNonzero(P);
   If F=0 Then Return Ideal(Poly(0)) End;
   If F>1 Then
      For I:=1 To F-1 Do L[I]:=Indet(I) End
   End;
   If F<Len(P) Then
      For I:=F+1 To Len(P) Do
         L[I-1]:=P[I]*Indet(F)-P[F]*Indet(I)
      End
   End;
Return Ideal(L)
End;

Define Help_Idopt()
   PrintLn 'Idopt( P : List ) : Ideal';
   PrintLn 'returns the vanishing ideal of the point P=[P0,...,Pn] in P^n.';
   PrintLn 'Remarks: a) P is given by a list of coordinates,';
   PrintLn '         b) CurrentRing should have Len(P) indeterminates.'
End;

-------------------------------------------------------------------

Define Idopts(M)
  I:=Ideal(Poly(1));
  For J:=1 To Len(M) Do I:=Intersection(I,Idopt(M[J])) End;
Return I
End;

Define Help_Idopts()
   PrintLn 'Idopts( M : Mat ) : Ideal';
   PrintLn 'returns the vanishing ideal of the set of points in P^n';
   PrintLn 'given by the rows of the matrix M.';
   PrintLn 'Remarks: a) CurrentRing should have Len(M[1]) indeterminates,';
   PrintLn '         b) the computation uses the intersection method.';
End;

-------------------------------------------------------------------
// Kaehler Differentials
-------------------------------------------------------------------

Define KD(I)
   G:=Gens(I);
   L:=Len(G);
   N:=NumIndets();
   M:=NewMat(L*N+L,N,0);
   For I1:=1 To N Do For I2:=1 To L Do
      M[L*(I1-1)+I2,I1]:=G[I2];
      M[L*N+I2,I1]:=Der(G[I2],Indet(I1))
   End End;
  Return Cast(M,MODULE)
End;

Define Help_KD()
   PrintLn 'KD( I : Ideal ) : Module';
   PrintLn 'returns the first module of Kaehler differentials';
   PrintLn 'of R:=CurrentRing/I over the base field.'
End;

-------------------------------------------------------------------

Define SocKD(I)
   N:=NumIndets();
   A:=NewList(N);
   M:=KD(I);
   For J:=1 To N Do
      A[J]:=NewMat(N,N,0);
      For J1:=1 To N Do A[J,J1,J1]:=Indet(J) End;
      A[J]:=Cast(A[J],MODULE);
      A[J]:=Intersection(A[J],M);
      A[J]:=Gens(A[J]);
      B:=NewList(Len(A[J]));
      For J1:=1 To Len(A[J]) Do
         Temp:=Cast(A[J,J1],LIST);
         For J2:=1 To Len(Temp) Do
            Temp[J2]:=Div(Temp[J2],Indet(J))
         End;
         Temp:=Cast(Temp,VECTOR);
         B[J1]:=Temp
      End;
      A[J]:=Cast(B,MODULE);
      Print '[',J,']';
   End;
   PrintLn;
   S:=A[1];
   For J:=2 To N Do
      S:=Intersection(S,A[J]);
      Print '[',J,']'
   End;
   S:=Minimalized(S);
Return S
End;

Define Help_SocKD()
   PrintLn 'SocKD( I: Ideal ) : Module';
   PrintLn 'returns the module representing the socle of KD(I).';
   PrintLn 'In particular, KD(I)<SocKD(I).';
End;

----------------------------------------------------------------

Define HSocKD(I,N)
   M:=KD(I);
   PrintLn 'KD computed, Hilbert function:';
   HM:=Hilb(M,N);
   Delete M;
   S:=SocKD(I);
   PrintLn 'SocKD computed, Hilbert function:';
   HS:=Hilb(S,N);
   H:=NewList(N,0);
   For J:=1 To N Do H[J]:=HM[J]-HS[J] End;
Return H
End;

Define Help_HSocKD()
   PrintLn 'HSocKD( I : Ideal , N : Int ) : List';
   PrintLn 'returns the list of the first N values of the Hilbert function';
   PrintLn 'of the socle of KD(I), considered as a submodule of KD(I).';
End;

----------------------------------------------------------------

Define HAnn(I,L,N)
   M:=KD(I);
   PrintLn 'KD computed, Hilbert function:';
   HM:=Hilb(M,N);
   S:=Annmod(M,L);
   Delete M;
   PrintLn 'Annmod computed, Hilbert function:';
   HS:=Hilb(S,N);
   H:=NewList(N,0);
   For J:=1 To N Do H[J]:=HM[J]-HS[J] End;
Return H
End;

Define Help_HAnn()
   PrintLn 'HAnn( I : Ideal , F: Poly, N : Int ) : List';
   PrintLn 'returns the list of the first N values of the Hilbert function';
   PrintLn 'of the Ann_KD(I)(L) , considered as a submodule of KD(I).';
End;


----------------------------------------------------------------

Define RelKD(I,L)
   M:=KD(I);
   M:=Gens(M);
   For J:=1 To Len(M) Do M[J]:=Cast(M[J],LIST) End;
   DL:=NewList(Len(M[1]),Poly(0));
   For J:=1 To Len(DL) Do DL[J]:=Der(L,Indet(J)) End;
   Append(M,DL);
Return Cast(M,MODULE)
End;

Define Help_RelKD(I,L)
   PrintLn 'RelKD( I : Ideal , L : Poly ) : Module';
   PrintLn 'returns the first module of Kaehler differentials of';
   PrintLn 'CurrentRing/I over K[L], where K is the base field and';
   PrintLn 'shoudl be a linear nonzerodivisor of CurrentRing/I.';
End;

----------------------------------------------------------------

Define HSocRelKD(I,L,N)
   M:=RelKD(I,L);
   PrintLn 'RelKD computed, Hilbert function:';
   HM:=Hilb(M,N);
   S:=Soc(M);
   Delete M;
   PrintLn 'SocRelKD computed, Hilbert function:';
   HS:=Hilb(S,N);
   H:=NewList(N,0);
   For J:=1 To N Do H[J]:=HM[J]-HS[J] End;
Return H
End;

Define Help_HSocRelKD()
   PrintLn 'HSocRelKD( I : Ideal , L : Poly , N : Int ) : List';
   PrintLn 'returns a list of the first N values of the Hilbert function';
   PrintLn 'of the socle of RelKD(I,L) considered as a submodule ';
   PrintLn 'of that module.';
End;

Define DiffHRelKD(I,L,F,N)
  M:=RelKD(I,L);
  A:=Annmod(M,F);
  S:=Soc(M);
  Return Hilb(A,N)-Hilb(S,N);
End;


---------------------------------------------------------------

Define BarKD(I,L)
Return KD(I+Ideal(L))
End;

Define Help_BarKD()
   PrintLn 'BarKD( I : Ideal , L : Poly ) : Module';
   PrintLn 'returns the first module of Kaehler differentials ';
   PrintLn 'of CurrentRing / I + (L).';
End;

---------------------------------------------------------------
// Torsion of Kaehler differentials
----------------------------------------------------------------


Define MaxIdeal()
  Return Ideal([Indet(I)|I In 1..NumIndets])
End;

Define TKD(I)
  M1:=Mat(KD(I));
  M2:=Mat(Syz(MaxIdeal));
  Return Module(Concat(M1,M2))
End;

Define Help_TKD()
   PrintLn 'TKD( I : Ideal ) : Module';
   PrintLn 'returns the torsion of KD(I) as a submodule of KD(I)';
End;

Define HTKD(I,N)
   Return Hilb(KD(I),N)-Hilb(TKD(I),N)
End;


Define Help_HTKD()
   PrintLn 'HTKD( I : Ideal, N: Integer ) : Module';
   PrintLn 'returns the first n values of the hilbert function of';
   PrintLn ' the torsion of KD(I) as a submodule of KD(I)';
End;




Define SAnnKD(I)
   L:=Randomized(DensePoly(1));
   Sigma:=Len(HVector(CurrentRing()/I))-2;
Return Annmod(KD(I),L^(2*Sigma+3))
End;

Define HTKD2(I,N)
   L:=NewList(N);
   Om:=KD(I);
   Tors:=SAnnKD(I);
   For J:=1 To N Do    
      L[J]:=Hilbmod(Om,J-1)-Hilbmod(Tors,J-1);
      PrintLn 'H(',J,') = ',L[J];
   End;
Return L
End;
   
Define Help_HTKD2()
   PrintLn 'HTKD2( I : Ideal, N: Integer ) : Module';
   PrintLn 'returns the first n values of the hilbert function of';
   PrintLn ' the torsion of KD(I) as a submodule of KD(I)';
End;

------------------------------------------------------------------------
// Grad_R(I) module: hilbert function and minimal system of generators
------------------------------------------------------------------------

Define Grad(I)
    Return KD(I)
End;

Define MuGrad(I)
    Return  Len(Minimalized(I))
End;

Define HGrad(I,N)
    F:=GBasis(I);
    H:=[Hilbert(CurrentRing/I,C)|C In 0..N];
    Return NumIndets()*H-Hilb(KD(I),N);
End;


---------------------------------------------------------------
// Various Differents
----------------------------------------------------------------

Define Kdiff(I)
   J:=Jacobian(Gens(I));
   M:=Minors(NumIndets()-1,J);
   J:=Cast(M,IDEAL);
Return Interreduced(I+J)
End;

Define Help_Kdiff()
   PrintLn 'Kdiff( I : Ideal ) : Ideal';
   PrintLn 'returns the Kaehler different of CurrentRing/I'
End;

----------------------------------------------------------------

Define HKdiff(I)
   J:=Jacobian(Gens(I));
   M:=Minors(NumIndets()-1,J);
   J:=Cast(M,IDEAL);
   J:=Interreduced(I+J);
   V:=HVector(CurrentRing/J);
   D:=Dim(CurrentRing/J);
   PrintLn 'Dim = ',D,', Hvector= ',V;
Return V
End;

Define Help_HKdiff()
   PrintLn 'HKdiff( I : Ideal ) : List';
   PrintLn 'prints the dimension and returns the Hilbert function of';
   PrintLn 'of CurrentRing / Kdiff(I)'
End;

----------------------------------------------------------------

Define RelKdiff(I,L)
   J:=Jacobian(Gens(I));
   J:=Cast(J,LIST);
   DL:=NewList(NumIndets(),Poly(0));
   For JJ:=1 To Len(DL) Do DL[JJ]:=Der(L,Indet(JJ)) End;
   Append(J,DL);
   J:=Cast(J,MAT);
   K:=Minors(NumIndets(),J);
   K:=Cast(K,IDEAL);
   K:=K+I;
   K:=Interreduced(K);
Return K
End;

Define Help_RelKdiff()
   PrintLn 'RelKdiff( I : Ideal , L : Poly ) : Ideal )';
   PrintLn 'returns the Kaehler different of CurrentRing / I';
   PrintLn 'as an algebra over K[L].';
   PrintLn 'Remark: L should be a linear nzd of CurrentRing / I.';
End;

----------------------------------------------------------------

Define HRelKdiff(I,L);
   K:=RelKdiff(I,L);
   HV:=HVector(CurrentRing/K);
   PrintLn 'dim(R/DK) = ',Dim(CurrentRing/K);
Return HV
End;

Define Help_HRelKdiff()
   PrintLn 'HRelKdiff( I : Ideal , L : Poly ) : List';
   PrintLn 'prints the dimension and returns the Hilbert function';
   PrintLn 'of CurrentRing / RelKdiff(I,L).';
End;

----------------------------------------------------------------

Define AnnRelKdiff(I,L,F) 
   M:=RelKdiff(I,L);
   Return Annmod(M,F)
End;


Define HAnnRelKdiff(I,L,F,N)
   M:=RelKdiff(I,L);
   -- PrintLn 'RelKdiff computed, Hilbert function:';
   HM:=Hilb(M,N);
   A:=Annmod(M,F);
   -- PrintLn 'HAnnRelKdiff+HRelKdiff computed:';
   HA:=Hilb(A,N);
   Return HM-HA
End;


----------------------------------------------------------------

Define Ndiff(I)
--
-- First we create a ring for the tensor product
--
   N:=NumIndets();
   P:=Characteristic();
   If P=0 Then T::=Q[x[1..N],y[1..N]]
          Else T::=Z/(P)[x[1..N],y[1..N]] End;
--
-- Next we move I to T in two different ways
--
   G:=Gens(I);
   Global LG:=Len(G);
   T:: G1:=NewList(LG);
   T:: G2:=NewList(LG);
   For J:=1 To LG Do
      PutCoeffs(G[J],N);
      T:: G1[J]:=GetCoeffs(1);
      T:: G2[J]:=GetCoeffs(DN[2]+1);
   End;
   Delete Global LG;
--
-- Now we compute the Annihilator in T
--
   T:: II:=Ideal(G1)+Ideal(G2);
   T:: A:=Ideal(Poly(1));
   For J:=1 To DN[2] Do
      T:: Temp:=Ideal(y[J]-x[J]);
      T:: Col:= II : Temp;
      T:: A:=Intersection(A,Col)
   End;
--
-- Finally we map A back to the original ring
--
   For J:=1 To DN[2] Do T:: A:=Subst(A,y[J],x[J]) End;
   T:: Global LA:=Len(Gens(A));
   T:: A:=Gens(A);
   Result:=NewList(LA);
   For J:=1 To LA Do
      T:: PutCoeffs(A[J],DN[2]);
      Result[J]:=GetCoeffs(1);
   End;
   Delete Global LA;
--
-- Mopping up oerations
--
   Delete Global MyCoeffList;
   Delete Global DN;
   Destroy T;
Return Ideal(Result)
End;

Define Help_Ndiff()
   PrintLn 'Ndiff( I : Ideal ) : Ideal';
   PrintLn 'returns the Noether different of CurrentRing / I.';
End;

----------------------------------------------------------------

Define RelNdiff(I)
--
-- Note: We assume that the first variable is a nzd mod I
--
-- First we create a ring for the tensor product --
--
   N:=NumIndets()-1;
   P:=Characteristic();
   If P=0 Then T::=Q[t,x[1..N],y[1..N]]
          Else T::=Z/(P)[t,x[1..N],y[1..N]] End;
   T:: NN:=Div(NumIndets()-1,2);
--
-- Next we move I to T in two different ways --
--
   G:=Gens(I);
   Global LG:=Len(G);
   T:: G1:=NewList(LG);
   T:: G2:=NewList(LG);
   For J:=1 To LG Do
      PutCoeffs(G[J],N+1);
      T:: G1[J]:=GetCoeffs(1);
      T:: G2[J]:=G1[J];
      For JJ:=1 To N Do
         T:: G2[J]:=Subst(G2[J],x[JJ],y[JJ])
      End;
   End;
   Delete Global LG;
--
-- Now we compute the Annihilator in T
--
   T:: II:=Ideal(G1)+Ideal(G2);
   T:: A:=Ideal(Poly(1));
   For J:=1 To N Do
      T:: Temp:=Ideal(y[J]-x[J]);
      T:: Col:= II : Temp;
      T:: A:=Intersection(A,Col)
   End;
--
-- Finally we map A back to the original ring
--
   For J:=1 To N Do T:: A:=Subst(A,y[J],x[J]) End;
   T:: A:=Interreduced(A);
   T:: Global LA:=Len(Gens(A));
   T:: A:=Gens(A);
   Result:=NewList(LA);
   For J:=1 To LA Do
      T:: PutCoeffs(A[J],NN+1);
      Result[J]:=GetCoeffs(1);
   End;
   Delete Global LA;
--
-- Mopping up operations
--
   Delete Global MyCoeffList;
   Delete Global DN;
   Destroy T;
Return Ideal(Result)
End;

Define Help_RelNdiff()
   PrintLn 'RelNdiff( I : Ideal ) : Ideal';
   PrintLn 'returns the Noether different of CurrentRing / I';
   PrintLn 'as an algebra over K[Indet(1)].';
   PrintLn 'Remark: We assume that Indet(1) is a nzd in CurrentRing/I.';
End;


-------------- THE END --------------------