inverseOfMap -- inverse of a birational map between projective varieties

Synopsis

Usage:

psi = inverseOfMap(g)

psi = inverseOfMap(phi)
Inputs:
- g, a ring map, corresponding to a birational map $f : X \to Y$
- phi, an instance of the type RationalMapping, a rational map between projective varieties $f : X \to Y$
Optional inputs:
- Verbosity => an integer, default value 1, if 0 then silence the function, if 1 then generate informative output which can be used to adjust strategies, if > 1 then generate a detailed description of the execution
- CheckBirational => a Boolean value, default value true, whether to check birationality (if it is not birational, and CheckBirational is set to true, then an error will be thrown)
- AssumeDominant => a Boolean value, default value false, whether to assume a rational map of schemes is dominant, if set to true it can speed up computation
- Strategy => a symbol, default value HybridStrategy, choose the strategy to use: HybridStrategy, SimisStrategy, or ReesStrategy
- HybridLimit => an integer, default value 15, within HybridStrategy, the option HybridLimit controls how often SimisStrategy and ReesStrategy are used, larger numbers means SimisStrategy will be executed longer
- MinorsLimit => an integer, default value null, how many submatrices of a variant of the Jacobian dual matrix to consider before switching to a different strategy
- QuickRank => a Boolean value, default value true, whether to compute rank via the package FastMinors
Outputs:
- psi, an instance of the type RationalMapping, inverse function of the birational map

Description

Given a rational map $f : X \to Y$, inverseOfMap computes the inverse of the induced map $X \to \overline{f(X)}$, provided it is birational." The target and source must be varieties; their defining ideals must be prime.

If AssumeDominant is set to true (default is false) then it assumes that the rational map of projective 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 that 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, then an error will be thrown if you are not using SimisStrategy. The option HybridLimit controls HybridStrategy. Larger values of HybridLimit (the default value is 15) will mean that SimisStrategy is executed longer, smaller values will mean that ReesStrategy will be switched to sooner.

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, Verbosity=>0)

o4 = Proj S - - - > Proj R   {-b*c, -a*c, -a*b}

o4 : RationalMapping

Notice that removal of the leading minus signs would 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, Verbosity=>0)

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

o9 : RationalMapping

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, Verbosity=>0)
     -- used 0.329498 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 = Proj Q - - - > Proj 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 : RationalMapping

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 : ident = rationalMapping map(S, S)

o18 = Proj S - - - > Proj S   {u, v, w}

o18 : RationalMapping

i19 : h = rationalMapping(R, S, F);

i20 : g = inverseOfMap(h, Verbosity=>0)

                                   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
o20 = Proj S - - - > Proj 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 }

o20 : RationalMapping

i21 : h*g == ident

o21 = true

Caveat

The current implementation of this function works only for irreducible varieties. Also see the function inverseMap in the package Cremona, which for some maps from projective space is faster. Additionally, also compare with the function invertBirationalMap of the package Parametrization.

Ways to use inverseOfMap :

inverseOfMap(RationalMapping)
inverseOfMap(RingMap)

For the programmer

The object inverseOfMap is a method function with options.