ringToAlgebraMap -- presents the target of a map of rings as an algebra over the source

Synopsis

Usage:

L = ringToAlgebraMap(f)

L = ringToAlgebraMap(f, n)
Inputs:
- f, a ring map,
- n, an integer,
Outputs:
- L, a list, the first entry is the target of f as an algebra over the source

Description

Given a ringmap map $f: A \to B$, this writes $B$ as $A[...]/J$. It returns the ring $A[...]/J$ as well as the isomorphism $B \to A[...]/J$. Consider the first example, a normalization of a cusp.

i1 : A = QQ[a,b]/ideal(a^2-b^3);

i2 : B = QQ[t];

i3 : f = map(B, A, {t^3, t^2});

o3 : RingMap B <-- A

i4 : (ringToAlgebraMap(f))#0

                     A[tRE1]
o4 = --------------------------------------
          2                              2
     (tRE1  - b, b*tRE1 - a, - a*tRE1 + b )

o4 : QuotientRing

i5 : (ringToAlgebraMap(f))#1

                          A[tRE1]
o5 = map (--------------------------------------, B, {tRE1})
               2                              2
          (tRE1  - b, b*tRE1 - a, - a*tRE1 + b )

                             A[tRE1]
o5 : RingMap -------------------------------------- <-- B
                  2                              2
             (tRE1  - b, b*tRE1 - a, - a*tRE1 + b )

The second input is used to specify an integer used for new variable enumeration and labeling. Here is another example where we consider the Frobenius map.

i6 : A = ZZ/5[x,y,z]/ideal(x^2-y*z);

i7 : B = ZZ/5[X,Y,Z]/ideal(X^2-Y*Z);

i8 : f = map(B, A, {X^5, Y^5, Z^5});

o8 : RingMap B <-- A

i9 : (ringToAlgebraMap(f))#0

                                                                                     A[XRE1, YRE1, ZRE1]
o9 = -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
          2                    3              2        3              2             2         3             2         3      5               2    2          5          3    3
     (XRE1  - YRE1*ZRE1, z*YRE1  - x*XRE1*ZRE1 , x*YRE1  - y*XRE1*ZRE1 , z*XRE1*YRE1  - x*ZRE1 , x*XRE1*YRE1  - y*ZRE1 , ZRE1  - z, XRE1*YRE1 ZRE1  - x, YRE1  - y, YRE1 ZRE1  - x*XRE1)

o9 : QuotientRing

i10 : (ringToAlgebraMap(f, 5))#0

                                                                                      A[XRE5, YRE5, ZRE5]
o10 = -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
           2                    3              2        3              2             2         3             2         3      5               2    2          5          3    3
      (XRE5  - YRE5*ZRE5, z*YRE5  - x*XRE5*ZRE5 , x*YRE5  - y*XRE5*ZRE5 , z*XRE5*YRE5  - x*ZRE5 , x*XRE5*YRE5  - y*ZRE5 , ZRE5  - z, XRE5*YRE5 ZRE5  - x, YRE5  - y, YRE5 ZRE5  - x*XRE5)

o10 : QuotientRing

Ways to use ringToAlgebraMap :

ringToAlgebraMap(RingMap)
ringToAlgebraMap(RingMap,ZZ)

For the programmer

The object ringToAlgebraMap is a method function.