Skip to content

Commit

Permalink
sagemathgh-39606: minor details in invariant_theory (pep8)
Browse files Browse the repository at this point in the history 
    
some suggestions of ruff and pycodestyle in the 2 modified files

### 📝 Checklist

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
    
URL: sagemath#39606
Reported by: Frédéric Chapoton
Reviewer(s): David Coudert
  • Loading branch information
Release Manager committed Mar 1, 2025
2 parents b2d5eba + 1e3b07c commit 5eadcc6
Show file tree
Hide file tree
Showing 2 changed files with 63 additions and 62 deletions.
4 changes: 2 additions & 2 deletions src/sage/rings/asymptotic/asymptotic_ring.py
View file
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
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

0 comments on commit 5eadcc6

Please # to comment.