def change_basis(iqf_lst, involution='identity'):
'''
This method allows us to change coordinates of the
ideal generated by "iqf_lst" so that
the antiholomorphic involution defined by "involution"
becomes complex conjugation.
Parameters
----------
iqf_lst: list<MARing>
A list of elements in the subring NF[x0,...,x8]
of "MARing.R" where NF denotes the Gaussian
rationals QQ(I) with I^2=-1.
involution: str
Either one of the following strings:
'identity', 'leftright', 'rotate', 'diagonal'.
Returns
-------
We consider the input "iqf_lst" as a map.
We compose this map composed with the map corresponding to
<identity>, <leftright>, <rotate> or <diagonal>.
We return a list of elements in NF[x0,...,x8] that
represents the composition.
Notes
-----
A double Segre surface in projective 8-space P^8 is represented
by a toric parametrization whose completion to P^1xP^1 is provided
by "get_pmz_lst":
(s,u) |-->
(1:s:s^{-1}:u:u^{-1}:s*u:s^{-1}*u^{-1}:s*u^{-1}:s^{-1}*u)
=
(x0:x1:x2:x3:x4:x5:x6:x7:x8)
We can put the exponents of the monomials in a lattice
where x0 corresponds to coordinate (0,0), x6 to (-1,-1)
x5 to (1,1) and x8 to (-1,1):
x8 x3 x5
x2 x0 x1
x6 x4 x7
An antiholomorphic involution, that preserves the toric structure,
acts on the above lattice as a unimodular involution:
identity_*: ( a, b ) |--> ( a, b)
leftright_*: ( a, b ) |--> (-a, b)
rotate_*: ( a, b ) |--> (-a,-b)
diagonal_*: ( a, b ) |--> ( b, a)
These unimodular lattice involutions induce an involution on P^8.
We compose the toric parametrization of the double Segre surface
with the one of the following maps in order to make the antiholomorphic
involution that acts on P^8, equal to complex conjugation.
identity: (x0:...:x8) |--> (x0:...:x8)
leftright: x3 |--> x3,
x0 |--> x0,
x4 |--> x4,
x1 |--> x1 + I*x2,
x2 |--> x1 - I*x2,
x5 |--> x5 + I*x8,
x8 |--> x5 - I*x8,
x7 |--> x7 + I*x6,
x6 |--> x7 - I*x6
rotate: x0 |--> x0,
x1 |--> x1 + I*x2, x2 |--> x1 - I*x2,
x3 |--> x3 + I*x4, x4 |--> x3 - I*x4,
x5 |--> x5 + I*x6, x6 |--> x5 - I*x6,
x7 |--> x7 + I*x8, x8 |--> x7 - I*x8
diagonal: x5 |--> x5,
x0 |--> x0,
x6 |--> x6,
x3 |--> x3 + I*x1,
x1 |--> x3 - I*x1,
x8 |--> x8 + I*x7,
x7 |--> x8 - I*x7,
x2 |--> x2 + I*x4,
x4 |--> x2 - I*x4
'''
I = ring('I')
x = x0, x1, x2, x3, x4, x5, x6, x7, x8 = MARing.x()
z = z0, z1, z2, z3, z4, z5, z6, z7, z8 = MARing.z()
dct = {}
dct['identity'] = {x[i]: z[i] for i in range(9)}
dct['rotate'] = {
x0: z0,
x1: z1 + I * z2,
x2: z1 - I * z2,
x3: z3 + I * z4,
x4: z3 - I * z4,
x5: z5 + I * z6,
x6: z5 - I * z6,
x7: z7 + I * z8,
x8: z7 - I * z8
}
dct['leftright'] = {
x0: z0,
x3: z3,
x4: z4,
x5: z5 + I * z8,
x8: z5 - I * z8,
x1: z1 + I * z2,
x2: z1 - I * z2,
x7: z7 + I * z6,
x6: z7 - I * z6
}
dct['diagonal'] = {
x0: z0,
x6: z6,
x5: z5,
x3: z3 + I * z1,
x1: z3 - I * z1,
x8: z8 + I * z7,
x7: z8 - I * z7,
x2: z2 + I * z4,
x4: z2 - I * z4
}
zx_dct = {z[i]: x[i] for i in range(9)}
new_lst = [iqf.subs(dct[involution]).subs(zx_dct) for iqf in iqf_lst]
return new_lst
def change_basis(iqf_lst):
'''
Parameters
----------
iqf_lst : list
A list of elements in the subring NF[x0,...,x5]
of "MARing.R" where NF denotes the Gaussian
rationals QQ(I) with I^2=-1.
Returns
-------
list
The input "iqf_lst" where we make the following substitution
for each polynomial
x0 |--> x0,
x1 |--> x1,
x2 |--> x2 + I*x3,
x3 |--> x2 - I*x3,
x4 |--> x4 + I*x5,
x5 |--> x4 - I*x5.
Notes
-----
We consider a toric parametrization of the Veronese surface:
(s,t)
|-->
(1 : s*t : s : t : s^2 : t^2 )
=
(x0 : x1 : x2 : x3 : x4 : x5 )
We can put the exponents of the monomials in a lattice
where x0 corresponds to coordinate (0,0), x4 to (2,0)
and x5 to (0,2):
x5 x7 x8
x3 x1 x6
x0 x2 x4
The monomial parametrization of the Veronese corresponds to the
following lattice polygon:
*
* *
* * *
An antiholomorphic involution acts on the above lattice polygon
as a unimodular involution:
( a, b ) |--> ( b, a)
This unimodular lattice involutions induce an involution on P^5:
x0 |--> x0,
x1 |--> x1,
x2 |--> x2 + I*x3,
x3 |--> x2 - I*x3,
x4 |--> x4 + I*x5,
x5 |--> x4 - I*x5,
'''
I = ring('I')
x = x0, x1, x2, x3, x4, x5 = MARing.x()[:6]
z = z0, z1, z2, z3, z4, z5 = MARing.z()[:6]
dct = {
x0: z0,
x1: z1,
x2: z2 + I * z3,
x3: z2 - I * z3,
x4: z4 + I * z5,
x5: z4 - I * z5
}
zx_dct = {z[i]: x[i] for i in range(6)}
new_lst = [iqf.subs(dct).subs(zx_dct) for iqf in iqf_lst]
return new_lst