Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
An implementation in SAGE of the construction given in Hence it is possible to determine the configuration of the quiver and the representation required to represent the projective variety as a quiver Grassmannian
# determine the linear equation of a hypersurface under the d-uple embedding
def getLinearEquation(equation):
d =
monomials = getMonomials(equation.parent(), d)
coefficients = [equation.monomial_coefficient(monomial) for monomial in monomials]
ring = PolynomialRing(QQ, 'x', len(coefficients))
return sum(c * x for c, x in zip(coefficients, ring.gens()))
# determine the maximum degree of a list of (homogeneous) equations
def getMaximalDegree(equations):
return max([ for equation in equations])
# get all monomials of a given degree in the polynomial ring
def getMonomials(ring, degree):
# by sorting and reversing we get the same order as on the bourbaki code
degrees = reversed(sorted(WeightedIntegerVectors(degree, [1] * ring.ngens())))
return [prod(x^d for x, d in zip(ring.gens(), exponents)) for exponents in degrees]
def getQuadraticEquations(ring, n, d):
monomialsMatrix = transpose(matrix(getMonomials(ring, d - 1))) * matrix(ring.gens())
monomials = getMonomials(ring, d)
variablesRing = PolynomialRing(QQ, 'x', binomial(n + d, d) + 1)
getVariable = lambda i, j: variablesRing.gens()[monomials.index(monomialsMatrix[i, j])]
variablesMatrix = matrix(variablesRing, monomialsMatrix.nrows(), monomialsMatrix.ncols(), lambda i, j: getVariable(i, j))
# if one is interested in the quadratic equations
# print variablesMatrix.minors(2)
return variablesMatrix.columns()
# add factors of the first variable to make sure the degree of all the equations is the same
def sameDegreeHomogeneous(equations):
d = getMaximalDegree(equations)
result = []
for (i, equation) in enumerate(equations):
result.append(equation * equation.parent().gen(0)^(d -
return result
# determine all the information on the quiver Grassmannian associated to a variety
def printQuiverGrassmannian(variety):
space = variety.ambient_space()
ring = space.coordinate_ring()
# determining the numbers
n = space.ngens() - 1
d = getMaximalDegree(variety.defining_polynomials())
M = binomial(n + d, d) - 1
print "Considering the projective variety of dimension {} in PG({}, Q) defined by".format(variety.dimension(), n)
for equation in variety.defining_polynomials():
print "\t{}".format(equation)
print "The same equations, all of the same degree (d = {})".format(d)
equations = sameDegreeHomogeneous(variety.defining_polynomials())
for equation in equations:
print "\t{}".format(equation)
print "The dimension vector is (1, {}, {})".format(M + 1, binomial(n + d - 1, d - 1))
print "The {} morphism(s) defining the variety (i.e. the maps 2->1) are".format(len(equations))
for equation in variety.defining_polynomials():
print "\t{}".format(getLinearEquation(equation))
print "The {} morphisms defining the d-uple embedding (i.e. the maps 2->3) are described by".format(n + 1)
for morphism in getQuadraticEquations(ring, n, d):
print "\t{}".format(morphism)
P.<x,y,z> = ProjectiveSpace(2, QQ)
E = P.subscheme([x^3-y^2*z+z^3]) # elliptic curve example
print ""
F = P.subscheme([x^3*y+y^3*z+z^3*x]) # Klein quartic
print ""
P.<x,y,z,w> = ProjectiveSpace(3, QQ)
Q = P.subscheme([x^4+y^4+x*y*z*w+z^2*w^2-w^4]) # Fermat quartic
print ""
P = ProjectiveSpace(4, QQ, 'x')
C = P.subscheme([sum(P.coordinate_ring().gens()), sum([x^3 for x in P.coordinate_ring().gens()])]) # Clebsch surface
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment