next | previous | forward | backward | up | top | index | toc | Macaulay2 web site
RationalMaps :: inverseOfMap

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

Description

Given a map f : X →Y, this finds the inverse of your birational map f(X) →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 P2 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, y, z]
i9 : g = inverseOfMap(h, Verbose=>false)

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

o9 : RingMap QQ[x, y, z] <--- blowUpSubvar
i10 : baseLocusOfMap(g)

o10 = ideal (y, x)

o10 : Ideal of QQ[x, y, z]
i11 : baseLocusOfMap(h)

o11 = ideal 1

o11 : Ideal of blowUpSubvar

The next example, is a Birational map on 4. The default option is slower than the follwoing setting

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, AssumeDominant=>true,CheckBirational=>false, MinorsCount=>100000)
Starting inverseOfMapSimis(SimisStrategy or HybridStrategy)
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 1}.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 2}.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 4}.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 7}.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 11}.
inverseOfMapSimis:  About to compute partial Groebner basis of rees ideal up to degree {1, 16}.
inverseOfMapSimis:  We give up, using all of 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
Starting nonZeroMinor, looking for rank: 4, we will run it 100000 times.  If this is slow, rerun with MinorsCount=>0.
nonZeroMinor: Found a nonzero minor
inverseOfMapSimis: We found a nonzero minor.
     -- used 1.80701 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 it and set AssumeDominant=>true 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 compute partial Groebner basis of rees ideal up to degree {1, 2}.
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
Starting nonZeroMinor, looking for rank: 2, we will run it 1000 times.  If this is slow, rerun with MinorsCount=>0.
nonZeroMinor: Found a nonzero minor
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 : (g*h)(u)*v==(g*h)(v)*u

o20 = true
i21 : (g*h)(u)*w==(g*h)(w)*u

o21 = true
i22 : (g*h)(v)*w==(g*h)(w)*v

o22 = true

Notice the last two 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 :