Skip to content
New issue

Have a question about this project? # for a free GitHub account to open an issue and contact its maintainers and the community.

#

By clicking “#”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? # to your account

minor details in invariant_theory (pep8) #39606

Open
wants to merge 1 commit into
base: develop
Choose a base branch
from
Open

minor details in invariant_theory (pep8) #39606

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions src/sage/rings/asymptotic/asymptotic_ring.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2971,8 +2971,8 @@ def symbolic_expression(self, R=None):
from sage.symbolic.ring import SR
R = SR

return self.substitute(dict((g, R(R.var(str(g))))
for g in self.parent().gens()),
return self.substitute({g: R(R.var(str(g)))
for g in self.parent().gens()},
domain=R)

_symbolic_ = symbolic_expression # will be used by SR._element_constructor_
Expand Down
121 changes: 61 additions & 60 deletions src/sage/rings/invariants/invariant_theory.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -118,7 +118,7 @@


######################################################################
def _guess_variables(polynomial, *args):
def _guess_variables(polynomial, *args) -> tuple:
"""
Return the polynomial variables.

Expand Down Expand Up @@ -275,16 +275,16 @@ def transvectant(f, g, h=1, scale='default'):
from sage.functions.other import binomial, factorial
if scale == 'default':
scalar = factorial(f._d-h) * factorial(g._d-h) \
* R(factorial(f._d)*factorial(g._d))**(-1)
* R(factorial(f._d)*factorial(g._d))**(-1)
elif scale == 'none':
scalar = 1
else:
raise ValueError('unknown scale type: %s' % scale)

def diff(j):
df = f.form().derivative(x,j).derivative(y,h-j)
dg = g.form().derivative(x,h-j).derivative(y,j)
return (-1)**j * binomial(h,j) * df * dg
df = f.form().derivative(x, j).derivative(y, h-j)
dg = g.form().derivative(x, h-j).derivative(y, j)
return (-1)**j * binomial(h, j) * df * dg
tv = scalar * sum([diff(j) for j in range(h+1)])
if tv.parent() is not R:
S = tv.parent()
Expand Down Expand Up @@ -367,7 +367,7 @@ def diff(p, d):
dp_dz = d*p - sum(x*dp_dx for x, dp_dx in zip(variables, grad))
grad.append(dp_dz)
return grad
jac = [diff(p,d) for p,d in args]
jac = [diff(p, d) for p, d in args]
return matrix(self._ring, jac).det()

def ring(self):
Expand Down Expand Up @@ -607,7 +607,7 @@ def _check_covariant(self, method_name, g=None, invariant=False):
g = random_matrix(F, self._n, algorithm='unimodular')
v = vector(self.variables())
g_v = g * v
transform = dict( (v[i], g_v[i]) for i in range(self._n) )
transform = {v[i]: g_v[i] for i in range(self._n)}
# The covariant of the transformed polynomial
g_self = self.__class__(self._n, self._d, self.form().subs(transform), self.variables())
cov_g = getattr(g_self, method_name)()
Expand Down Expand Up @@ -916,7 +916,7 @@ def transformed(self, g):
from sage.modules.free_module_element import vector
v = vector(self._ring, self._variables)
g_v = vector(self._ring, g*v)
transform = dict( (v[i], g_v[i]) for i in range(self._n) )
transform = {v[i]: g_v[i] for i in range(self._n)}
# The covariant of the transformed polynomial
return self.__class__(self._n, self._d,
self.form().subs(transform), self.variables())
Expand Down Expand Up @@ -1123,12 +1123,12 @@ def matrix(self):
coeff = self.scaled_coeffs()
A = matrix(self._ring, self._n)
for i in range(self._n):
A[i,i] = coeff[i]
A[i, i] = coeff[i]
ij = self._n
for i in range(self._n):
for j in range(i+1, self._n):
A[i,j] = coeff[ij]
A[j,i] = coeff[ij]
A[i, j] = coeff[ij]
A[j, i] = coeff[ij]
ij += 1
return A

Expand Down Expand Up @@ -1259,7 +1259,7 @@ def dual(self):
else:
var = self._variables[0:-1] + (1, )
n = self._n
p = sum([ sum([ Aadj[i,j]*var[i]*var[j] for i in range(n) ]) for j in range(n)])
p = sum(Aadj[i, j] * var[i] * var[j] for i in range(n) for j in range(n))
return invariant_theory.quadratic_form(p, self.variables())

def as_QuadraticForm(self):
Expand Down Expand Up @@ -2539,7 +2539,7 @@ def monomials(self):
(x^2, y^2, z^2, x*y, x*z, y*z)
"""
R = self._ring
x,y,z = self._x, self._y, self._z
x, y, z = self._x, self._y, self._z
if self._homogeneous:
return (x**2, y**2, z**2, x*y, x*z, y*z)
else:
Expand Down Expand Up @@ -2714,7 +2714,7 @@ def monomials(self):
(x^3, y^3, z^3, x^2*y, x^2*z, x*y^2, y^2*z, x*z^2, y*z^2, x*y*z)
"""
R = self._ring
x,y,z = self._x, self._y, self._z
x, y, z = self._x, self._y, self._z
if self._homogeneous:
return (x**3, y**3, z**3, x**2*y, x**2*z, x*y**2,
y**2*z, x*z**2, y*z**2, x*y*z)
Expand Down Expand Up @@ -2804,14 +2804,14 @@ def S_invariant(self):
sage: cubic.S_invariant()
-1/1296
"""
a,b,c,a2,a3,b1,b3,c1,c2,m = self.scaled_coeffs()
S = ( a*b*c*m-(b*c*a2*a3+c*a*b1*b3+a*b*c1*c2)
- m*(a*b3*c2+b*c1*a3+c*a2*b1)
+ (a*b1*c2**2+a*c1*b3**2+b*a2*c1**2+b*c2*a3**2+c*b3*a2**2+c*a3*b1**2)
- m**4+2*m**2*(b1*c1+c2*a2+a3*b3)
- 3*m*(a2*b3*c1+a3*b1*c2)
- (b1**2*c1**2+c2**2*a2**2+a3**2*b3**2)
+ (c2*a2*a3*b3+a3*b3*b1*c1+b1*c1*c2*a2) )
a, b, c, a2, a3, b1, b3, c1, c2, m = self.scaled_coeffs()
S = (a*b*c*m-(b*c*a2*a3+c*a*b1*b3+a*b*c1*c2)
- m*(a*b3*c2+b*c1*a3+c*a2*b1)
+ (a*b1*c2**2+a*c1*b3**2+b*a2*c1**2+b*c2*a3**2+c*b3*a2**2+c*a3*b1**2)
- m**4+2*m**2*(b1*c1+c2*a2+a3*b3)
- 3*m*(a2*b3*c1+a3*b1*c2)
- (b1**2*c1**2+c2**2*a2**2+a3**2*b3**2)
+ (c2*a2*a3*b3+a3*b3*b1*c1+b1*c1*c2*a2))
return S

def T_invariant(self):
Expand All @@ -2830,38 +2830,38 @@ def T_invariant(self):
sage: cubic.T_invariant()
-t^6 - t^3 + 1
"""
a,b,c,a2,a3,b1,b3,c1,c2,m = self.scaled_coeffs()
T = ( a**2*b**2*c**2-6*a*b*c*(a*b3*c2+b*c1*a3+c*a2*b1)
- 20*a*b*c*m**3+12*a*b*c*m*(b1*c1+c2*a2+a3*b3)
+ 6*a*b*c*(a2*b3*c1+a3*b1*c2) +
4*(a**2*b*c2**3+a**2*c*b3**3+b**2*c*a3**3 +
b**2*a*c1**3+c**2*a*b1**3+c**2*b*a2**3)
+ 36*m**2*(b*c*a2*a3+c*a*b1*b3+a*b*c1*c2)
- 24*m*(b*c*b1*a3**2+b*c*c1*a2**2+c*a*c2*b1**2+c*a*a2*b3**2+a*b*a3*c2**2 +
a, b, c, a2, a3, b1, b3, c1, c2, m = self.scaled_coeffs()
T = (a**2*b**2*c**2-6*a*b*c*(a*b3*c2+b*c1*a3+c*a2*b1)
- 20*a*b*c*m**3+12*a*b*c*m*(b1*c1+c2*a2+a3*b3)
+ 6*a*b*c*(a2*b3*c1+a3*b1*c2) +
4*(a**2*b*c2**3+a**2*c*b3**3+b**2*c*a3**3 +
b**2*a*c1**3+c**2*a*b1**3+c**2*b*a2**3)
+ 36*m**2*(b*c*a2*a3+c*a*b1*b3+a*b*c1*c2)
- 24*m*(b*c*b1*a3**2+b*c*c1*a2**2+c*a*c2*b1**2+c*a*a2*b3**2+a*b*a3*c2**2 +
a*b*b3*c1**2)
- 3*(a**2*b3**2*c2**2+b**2*c1**2*a3**2+c**2*a2**2*b1**2) +
18*(b*c*b1*c1*a2*a3+c*a*c2*a2*b3*b1+a*b*a3*b3*c1*c2)
- 12*(b*c*c2*a3*a2**2+b*c*b3*a2*a3**2+c*a*c1*b3*b1**2 +
- 3*(a**2*b3**2*c2**2+b**2*c1**2*a3**2+c**2*a2**2*b1**2) +
18*(b*c*b1*c1*a2*a3+c*a*c2*a2*b3*b1+a*b*a3*b3*c1*c2)
- 12*(b*c*c2*a3*a2**2+b*c*b3*a2*a3**2+c*a*c1*b3*b1**2 +
c*a*a3*b1*b3**2+a*b*a2*c1*c2**2+a*b*b1*c2*c1**2)
- 12*m**3*(a*b3*c2+b*c1*a3+c*a2*b1)
+ 12*m**2*(a*b1*c2**2+a*c1*b3**2+b*a2*c1**2 +
- 12*m**3*(a*b3*c2+b*c1*a3+c*a2*b1)
+ 12*m**2*(a*b1*c2**2+a*c1*b3**2+b*a2*c1**2 +
b*c2*a3**2+c*b3*a2**2+c*a3*b1**2)
- 60*m*(a*b1*b3*c1*c2+b*c1*c2*a2*a3+c*a2*a3*b1*b3)
+ 12*m*(a*a2*b3*c2**2+a*a3*c2*b3**2+b*b3*c1*a3**2 +
- 60*m*(a*b1*b3*c1*c2+b*c1*c2*a2*a3+c*a2*a3*b1*b3)
+ 12*m*(a*a2*b3*c2**2+a*a3*c2*b3**2+b*b3*c1*a3**2 +
b*b1*a3*c1**2+c*c1*a2*b1**2+c*c2*b1*a2**2)
+ 6*(a*b3*c2+b*c1*a3+c*a2*b1)*(a2*b3*c1+a3*b1*c2)
+ 24*(a*b1*b3**2*c1**2+a*c1*c2**2*b1**2+b*c2*c1**2*a2**2
+ 6*(a*b3*c2+b*c1*a3+c*a2*b1)*(a2*b3*c1+a3*b1*c2)
+ 24*(a*b1*b3**2*c1**2+a*c1*c2**2*b1**2+b*c2*c1**2*a2**2
+ b*a2*a3**2*c2**2+c*a3*a2**2*b3**2+c*b3*b1**2*a3**2)
- 12*(a*a2*b1*c2**3+a*a3*c1*b3**3+b*b3*c2*a3**3+b*b1*a2*c1**3
- 12*(a*a2*b1*c2**3+a*a3*c1*b3**3+b*b3*c2*a3**3+b*b1*a2*c1**3
+ c*c1*a3*b1**3+c*c2*b3*a2**3)
- 8*m**6+24*m**4*(b1*c1+c2*a2+a3*b3)-36*m**3*(a2*b3*c1+a3*b1*c2)
- 12*m**2*(b1*c1*c2*a2+c2*a2*a3*b3+a3*b3*b1*c1)
- 24*m**2*(b1**2*c1**2+c2**2*a2**2+a3**2*b3**2)
+ 36*m*(a2*b3*c1+a3*b1*c2)*(b1*c1+c2*a2+a3*b3)
+ 8*(b1**3*c1**3+c2**3*a2**3+a3**3*b3**3)
- 27*(a2**2*b3**2*c1**2+a3**2*b1**2*c2**2)-6*b1*c1*c2*a2*a3*b3
- 12*(b1**2*c1**2*c2*a2+b1**2*c1**2*a3*b3+c2**2*a2**2*a3*b3 +
c2**2*a2**2*b1*c1+a3**2*b3**2*b1*c1+a3**2*b3**2*c2*a2) )
- 8*m**6+24*m**4*(b1*c1+c2*a2+a3*b3)-36*m**3*(a2*b3*c1+a3*b1*c2)
- 12*m**2*(b1*c1*c2*a2+c2*a2*a3*b3+a3*b3*b1*c1)
- 24*m**2*(b1**2*c1**2+c2**2*a2**2+a3**2*b3**2)
+ 36*m*(a2*b3*c1+a3*b1*c2)*(b1*c1+c2*a2+a3*b3)
+ 8*(b1**3*c1**3+c2**3*a2**3+a3**3*b3**3)
- 27*(a2**2*b3**2*c1**2+a3**2*b1**2*c2**2)-6*b1*c1*c2*a2*a3*b3
- 12*(b1**2*c1**2*c2*a2+b1**2*c1**2*a3*b3+c2**2*a2**2*a3*b3 +
c2**2*a2**2*b1*c1+a3**2*b3**2*b1*c1+a3**2*b3**2*c2*a2))
return T

@cached_method
Expand Down Expand Up @@ -2896,18 +2896,17 @@ def polar_conic(self):
"""
a30, a03, a00, a21, a20, a12, a02, a10, a01, a11 = self.coeffs()
if self._homogeneous:
x,y,z = self.variables()
x, y, z = self.variables()
else:
x,y,z = (self._x, self._y, 1)
x, y, z = (self._x, self._y, 1)
F = self._ring.base_ring()
A00 = 3*x*a30 + y*a21 + z*a20
A11 = x*a12 + 3*y*a03 + z*a02
A22 = x*a10 + y*a01 + 3*z*a00
A01 = x*a21 + y*a12 + 1/F(2)*z*a11
A02 = x*a20 + 1/F(2)*y*a11 + z*a10
A12 = 1/F(2)*x*a11 + y*a02 + z*a01
polar = matrix(self._ring, [[A00, A01, A02],[A01, A11, A12],[A02, A12, A22]])
return polar
return matrix(self._ring, [[A00, A01, A02], [A01, A11, A12], [A02, A12, A22]])

@cached_method
def Hessian(self):
Expand Down Expand Up @@ -2942,7 +2941,9 @@ def Hessian(self):
Uyy = 2*x*a12 + 6*y*a03 + 2*z*a02
Uyz = x*a11 + 2*y*a02 + 2*z*a01
Uzz = 2*x*a10 + 2*y*a01 + 6*z*a00
H = matrix(self._ring, [[Uxx, Uxy, Uxz],[Uxy, Uyy, Uyz],[Uxz, Uyz, Uzz]])
H = matrix(self._ring, [[Uxx, Uxy, Uxz],
[Uxy, Uyy, Uyz],
[Uxz, Uyz, Uzz]])
F = self._ring.base_ring()
return 1/F(216) * H.det()

Expand Down Expand Up @@ -2970,11 +2971,11 @@ def Theta_covariant(self):
6952
"""
U_conic = self.polar_conic().adjugate()
U_coeffs = ( U_conic[0,0], U_conic[1,1], U_conic[2,2],
U_conic[0,1], U_conic[0,2], U_conic[1,2] )
U_coeffs = (U_conic[0, 0], U_conic[1, 1], U_conic[2, 2],
U_conic[0, 1], U_conic[0, 2], U_conic[1, 2])
H_conic = TernaryCubic(3, 3, self.Hessian(), self.variables()).polar_conic().adjugate()
H_coeffs = ( H_conic[0,0], H_conic[1,1], H_conic[2,2],
H_conic[0,1], H_conic[0,2], H_conic[1,2] )
H_coeffs = (H_conic[0, 0], H_conic[1, 1], H_conic[2, 2],
H_conic[0, 1], H_conic[0, 2], H_conic[1, 2])
quadratic = TernaryQuadratic(3, 2, self._ring.zero(), self.variables())
F = self._ring.base_ring()
return 1/F(9) * _covariant_conic(U_coeffs, H_coeffs, quadratic.monomials())
Expand Down Expand Up @@ -3257,7 +3258,7 @@ def _check_covariant(self, method_name, g=None, invariant=False):
g = random_matrix(F, self._n, algorithm='unimodular')
v = vector(self.variables())
g_v = g*v
transform = dict( (v[i], g_v[i]) for i in range(self._n) )
transform = {v[i]: g_v[i] for i in range(self._n)}
# The covariant of the transformed form
transformed = [f.transformed(transform) for f in self._forms]
g_self = self.__class__(transformed)
Expand Down Expand Up @@ -4357,9 +4358,9 @@ def binary_form_from_invariants(self, degree, invariants, variables=None, as_for
from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
K = FractionField(Sequence(list(invariants)).universe())
if variables is None:
x,z = PolynomialRing(K, 'x,z').gens()
x, z = PolynomialRing(K, 'x,z').gens()
elif len(variables) == 2:
x,z = variables
x, z = variables
else:
raise ValueError('incorrect number of variables provided, '
'exactly two variables should be provided')
Expand Down
Loading