inverseOfMap -- Computes the inverse map of a given birational map between projective varieties. Returns an error if the map is not birational onto its image.

Synopsis

Usage:

f = inverseOfMap(I, J, L)

f = inverseOfMap(R, S, L)

f = inverseOfMap(g)
Inputs:
- I, an ideal, Defining ideal of source
- J, an ideal, Defining ideal of target
- L, a list, List of polynomials that define the coordinates of your birational map
- g, a ring map, Your birational map $f : X \to Y$.
Optional inputs:
- AssumeDominant => ..., default value false, If true, certain functions assume that the map from X to Y is dominant.
- CheckBirational => ..., default value true, If true, functions will check birationality.
- HybridLimit => ..., default value 15, An option to control HybridStrategy
- MinorsCount => ..., default value null, An option controlling the behavior of isBirational and inverseOfMap (and other functions which call those).
- QuickRank => ..., default value true, An option for computing how rank is computed
- Strategy => ..., default value HybridStrategy, Determines the desired Strategy in each function.
- Verbose => ..., default value true, generate informative output
Outputs:
- f, a ring map, Inverse function of your birational map, $f(X) \to X$.

Description

Given a map $f : X \to Y$, this finds the inverse of your birational map $f(X) \to X$ (if it is birational onto its image). The target and source must be varieties, in particular their defining ideals must be prime.

If AssumeDominant is set to true (default is false) then it assumes that the map of varieties is dominant, otherwise the function will compute the image by finding the kernel of $f$.

The Strategy option can be set to HybridStrategy (default), SimisStrategy, ReesStrategy, or SaturationStrategy. Note SimisStrategy will never terminate for non-birational maps. If CheckBirational is set to false (default is true), then no check for birationality will be done. If it is set to true and the map is not birational, an error will be thrown if you are not using SimisStrategy. The option HybridLimit can weight the HybridStrategy between ReesStrategy and SimisStrategy, the default value is 15 and increasing it will weight towards SimisStrategy.

i1 : R = ZZ/7[x,y,z];

i2 : S = ZZ/7[a,b,c];

i3 : h = map(R, S, {y*z, x*z, x*y});

o3 : RingMap R <--- S

i4 : inverseOfMap (h, Verbose=>false)

o4 = map (S, R, {-b*c, -a*c, -a*b})

o4 : RingMap S <--- R

Notice that the leading minus signs do not change the projective map. Next let us compute the inverse of the blowup of $P^2$ at a point.

i5 : P5 = QQ[a..f];

i6 : M = matrix{{a,b,c},{d,e,f}};

              2        3
o6 : Matrix P5  <--- P5

i7 : blowUpSubvar = P5/(minors(2, M)+ideal(b - d));

i8 : h = map(blowUpSubvar, QQ[x,y,z],{a, b, c});

o8 : RingMap blowUpSubvar <--- QQ[x..z]

i9 : g = inverseOfMap(h, Verbose=>false)

                                    2 2     3     2      3   4   3
o9 = map (QQ[x..z], blowUpSubvar, {x y , x*y , x*y z, x*y , y , y z})

o9 : RingMap QQ[x..z] <--- blowUpSubvar

i10 : baseLocusOfMap(g)

o10 = ideal (y, x)

o10 : Ideal of QQ[x..z]

i11 : baseLocusOfMap(h)

o11 = ideal 1

o11 : Ideal of blowUpSubvar

The next example, is a Birational map on $\mathbb{P}^4$.

i12 : Q=QQ[x,y,z,t,u];

i13 : phi=map(Q,Q,matrix{{x^5,y*x^4,z*x^4+y^5,t*x^4+z^5,u*x^4+t^5}});

o13 : RingMap Q <--- Q

i14 : time inverseOfMap(phi,CheckBirational=>false)
Starting inverseOfMapSimis(SimisStrategy or HybridStrategy)
inverseOfMapSimis: About to find the image of the map.  If you know the image, 
        you may want to use the AssumeDominant option if this is slow.
inverseOfMapSimis: Found the image of the map.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 1}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 2}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 4}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 7}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 11}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 16}.
inverseOfMapSimis:  We give up.  Using the previous computations, we compute the whole 
        Groebner basis of the rees ideal.  Increase HybridLimit and rerun to avoid this.
inverseOfMapSimis: Found Jacobian dual matrix (or a weak form of it), it has  5 columns  and about  20 rows.
inverseOfMapSimis: Looking for a nonzero minor.
        If this fails, you may increase the attempts with MinorsCount => #
getSubmatrixOfRank: Trying to find a submatrix of rank at least: 4 with attempts = 10.  DetStrategy=>Rank
internalChooseMinor: Choosing GRevLexSmallestTerm
getSubmatrixOfRank: found one, in 1 attempts
inverseOfMapSimis: We found a nonzero minor.
     -- used 0.624672 seconds

                   125   124      120 5    124    100 25     104 20       108 15 2      112 10 3     116 5 4    120 5    124      125      4 120        8 115 2        12 110 3         16 105 4         20 100 5          24 95 6          28 90 7           32 85 8           36 80 9           40 75 10           44 70 11           48 65 12           52 60 13           56 55 14           60 50 15           64 45 16           68 40 17          72 35 18          76 30 19         80 25 20         84 20 21        88 15 22       92 10 23      96 5 24    100 25     24 100        28 95          32 90 2         36 85 3          40 80 4          44 75 5           48 70 6           52 65 7           56 60 8           60 55 9           64 50 10           68 45 11           72 40 12           76 35 13           80 30 14          84 25 15          88 20 16         92 15 17        96 10 18        100 5 19      104 20       48 75 2       52 70   2        56 65 2 2        60 60 3 2         64 55 4 2         68 50 5 2         72 45 6 2         76 40 7 2         80 35 8 2         84 30 9 2         88 25 10 2         92 20 11 2        96 15 12 2        100 10 13 2       104 5 14 2      108 15 2      72 50 3       76 45   3       80 40 2 3        84 35 3 3        88 30 4 3        92 25 5 3        96 20 6 3        100 15 7 3       104 10 8 3       108 5 9 3      112 10 3     96 25 4      100 20   4      104 15 2 4      108 10 3 4      112 5 4 4     116 5 4    120 5    124
o14 = map (Q, Q, {x   , x   y, - x   y  + x   z, x   y   - 5x   y  z + 10x   y  z  - 10x   y  z  + 5x   y z  - x   z  + x   t, - y    + 25x y   z - 300x y   z  + 2300x  y   z  - 12650x  y   z  + 53130x  y   z  - 177100x  y  z  + 480700x  y  z  - 1081575x  y  z  + 2042975x  y  z  - 3268760x  y  z   + 4457400x  y  z   - 5200300x  y  z   + 5200300x  y  z   - 4457400x  y  z   + 3268760x  y  z   - 2042975x  y  z   + 1081575x  y  z   - 480700x  y  z   + 177100x  y  z   - 53130x  y  z   + 12650x  y  z   - 2300x  y  z   + 300x  y  z   - 25x  y z   + x   z   - 5x  y   t + 100x  y  z*t - 950x  y  z t + 5700x  y  z t - 24225x  y  z t + 77520x  y  z t - 193800x  y  z t + 387600x  y  z t - 629850x  y  z t + 839800x  y  z t - 923780x  y  z  t + 839800x  y  z  t - 629850x  y  z  t + 387600x  y  z  t - 193800x  y  z  t + 77520x  y  z  t - 24225x  y  z  t + 5700x  y  z  t - 950x  y  z  t + 100x   y z  t - 5x   z  t - 10x  y  t  + 150x  y  z*t  - 1050x  y  z t  + 4550x  y  z t  - 13650x  y  z t  + 30030x  y  z t  - 50050x  y  z t  + 64350x  y  z t  - 64350x  y  z t  + 50050x  y  z t  - 30030x  y  z  t  + 13650x  y  z  t  - 4550x  y  z  t  + 1050x   y  z  t  - 150x   y z  t  + 10x   z  t  - 10x  y  t  + 100x  y  z*t  - 450x  y  z t  + 1200x  y  z t  - 2100x  y  z t  + 2520x  y  z t  - 2100x  y  z t  + 1200x   y  z t  - 450x   y  z t  + 100x   y z t  - 10x   z  t  - 5x  y  t  + 25x   y  z*t  - 50x   y  z t  + 50x   y  z t  - 25x   y z t  + 5x   z t  - x   t  + x   u})

o14 : RingMap Q <--- Q

Finally, we do an example of plane Cremona maps whose source is not minimally embedded.

i15 : R=QQ[x,y,z,t]/(z-2*t);

i16 : F = {y*z*(x-z)*(x-2*y), x*z*(y-z)*(x-2*y),y*x*(y-z)*(x-z)};

i17 : S = QQ[u,v,w];

i18 : h = map(R, S, F);

o18 : RingMap R <--- S

i19 : g = inverseOfMap h
Starting inverseOfMapSimis(SimisStrategy or HybridStrategy)
inverseOfMapSimis: About to find the image of the map.  If you know the image, 
        you may want to use the AssumeDominant option if this is slow.
inverseOfMapSimis: Found the image of the map.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 1}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 2}.
inverseOfMapSimis: About to check rank, if this is very slow, you may try turning QuickRank=>false.
inverseOfMapSimis: We computed enough of the Groebner basis.
inverseOfMapSimis: Found Jacobian dual matrix (or a weak form of it), it has  3 columns  and about  4 rows.
inverseOfMapSimis: Looking for a nonzero minor.
        If this fails, you may increase the attempts with MinorsCount => #
getSubmatrixOfRank: Trying to find a submatrix of rank at least: 2 with attempts = 10.  DetStrategy=>Rank
internalChooseMinor: Choosing GRevLexSmallest
getSubmatrixOfRank: found one, in 1 attempts
inverseOfMapSimis: We found a nonzero minor.

                    2 2     2          2      2 2          2     2 2    2 2     2          2      2 2         2     2 2    2 2     2          2      2 2         2     2 2   2 2     2          2      2 2         2     2 2
o19 = map (S, R, {2u v  - 8u v*w + 6u*v w + 8u w  - 12u*v*w  + 4v w , 2u v  - 6u v*w + 4u*v w + 4u w  - 6u*v*w  + 2v w , 2u v  - 6u v*w + 6u*v w + 4u w  - 8u*v*w  + 4v w , u v  - 3u v*w + 3u*v w + 2u w  - 4u*v*w  + 2v w })

o19 : RingMap S <--- R

i20 : use S;

i21 : (g*h)(u)*v==(g*h)(v)*u

o21 = true

i22 : (g*h)(u)*w==(g*h)(w)*u

o22 = true

i23 : (g*h)(v)*w==(g*h)(w)*v

o23 = true

Notice the last checks are just verifying that the composition g*h agrees with the identity.

Caveat

Only works for irreducible varieties right now. Also see the function inverseMap in the package Cremona, which for certain types of maps from projective space is sometimes faster. Additionally, also compare with the function invertBirationalMap of the package Parametrization.

Ways to use `inverseOfMap` :

"inverseOfMap(Ideal,Ideal,BasicList)"
"inverseOfMap(Ring,Ring,BasicList)"
"inverseOfMap(RingMap)"

For the programmer