def test_graded_sl3():
# ---------------------------------------------------------------
# slightly more explicit calculation than test_hilbert above
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
x = Poly("x", ring)
y = Poly("y", ring)
z = Poly("z", ring)
u = Poly("u", ring)
v = Poly("v", ring)
w = Poly("w", ring)
rel = x*u + y*v + z*w
rels = [rel]
rels = grobner(rels)
for a in range(4):
for b in range(4):
gens = []
for p in all_monomials([x, y, z], a, ring):
for q in all_monomials([u, v, w], b, ring):
rem = p*q
#gens.append(pq)
for rel in rels:
div, rem = rel.reduce(rem)
#print(pq, div, rem)
gens.append(rem)
basis = grobner(gens)
assert len(basis) == dim_sl3(a, b)
print(len(basis), end=' ', flush=True)
print()
def get_weights_sl3(a, b):
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
x = Poly("x", ring)
y = Poly("y", ring)
z = Poly("z", ring)
u = Poly("u", ring)
v = Poly("v", ring)
w = Poly("w", ring)
# See: Fulton & Harris, page 183
grades = {
# L_1, L_3
'x' : ( 0, 1),
'y' : (-1, -1),
'z' : ( 1, 0),
'u' : ( 0, -1),
'v' : ( 1, 1),
'w' : (-1, 0),
}
rel = x*u + y*v + z*w
rels = [rel]
rels = grobner(rels)
gens = []
for p in all_monomials([x, y, z], a, ring):
for q in all_monomials([u, v, w], b, ring):
rem = p*q
for rel in rels:
div, rem = rel.reduce(rem)
gens.append(rem)
basis = grobner(gens)
size = sage_grobner(gens)
assert size == len(basis)
weights = {}
for p in basis:
g = find_grade(grades, p)
weights[g] = weights.get(g, 0) + 1
return weights
def test_so5():
# Plucker embedding for SO(5) ~= SO(2,3)
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
a = Poly("a", ring)
b = Poly("b", ring)
c = Poly("c", ring)
d = Poly("d", ring)
# (2,3) space-time
u = Poly("u", ring) # time coord
v = Poly("v", ring) # time coord
x = Poly("x", ring) # space coord
y = Poly("y", ring) # space coord
z = Poly("z", ring) # space coord
# got from test_quaternion :
rels = [
u**2+v**2-x**2-y**2-z**2,
a*u + d*v -(a*x + c*z - d*y),
a*v - d*u -(a*y - b*z + d*x),
-b*u - c*v -(-b*x - c*y - d*z),
b*v - c*u -(-a*z - b*y + c*x),
]
rels = grobner(rels)
for idx in range(6):
for jdx in range(6):
gens = []
for p in all_monomials([a, b, c, d], idx, ring):
for q in all_monomials([u, v, x, y, z], jdx, ring):
rem = p*q
#for count in range(3):
while 1:
rem0 = rem
for rel in rels:
div, rem = rel.reduce(rem)
if rem == rem0:
break
gens.append(rem)
#print("gens:", len(gens))
n = sage_grobner(gens)
#basis = grobner(gens)
print("%3d"%n, end=' ', flush=True)
print()
def test_graded_1():
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
h = Poly("h", ring) # grade 1
x = Poly("x", ring) # grade 3
y = Poly("y", ring) # grade 5
lookup = {h:1, x:3, y:5}
rels = [
x**5 - y**3 - h**15, # grade == 15
]
print("rels:")
for rel in rels:
print(rel)
print()
rels = grobner(rels)
n = argv.get("n", 10)
grades = dict((i, []) for i in range(n))
for i in range(n):
for j in range(n):
for k in range(n):
g = 1*i + 3*j + 5*k
if g >= n:
continue
for mh in all_monomials([h], i, ring):
for mx in all_monomials([x], j, ring):
for my in all_monomials([y], k, ring):
rem = mh*mx*my
while 1:
rem0 = rem
for rel in rels:
div, rem = rel.reduce(rem)
if rem == rem0:
break
grades[g].append(rem)
for i in range(n):
gens = grades[i]
#basis = grobner(gens) if gens else []
#count = len(basis)
count = sage_grobner(gens)
print(count, end=",", flush=True)
print()
def test_graded_2():
if argv.rational:
ring = Q
elif argv.gf2:
ring = FiniteField(2)
else:
return
zero = Poly({}, ring)
one = Poly({():1}, ring)
h = Poly("h", ring)
x = Poly("x", ring)
y = Poly("y", ring)
z = Poly("z", ring)
lookup = {h:1, x:3, y:4, z:5}
vs = list(lookup.keys())
vs.sort(key = str)
print("vs", vs)
rels = [
#z*x + y*y,
#x**3 + z*y,
#z*z + y*x*h*h*h,
y*x*h,
#z*x*h, # grade 9
#z*z, # grade 10
#z*y*h,
]
print("rels:")
for rel in rels:
print(rel)
print()
rels = grobner(rels)
n = argv.get("n", 10)
grades = dict((i, []) for i in range(n))
for i in range(n):
for j in range(n):
for k in range(n):
#for l in range(n):
g = 1*i + 2*j + 3*k # + 5*l
if g >= n:
continue
for mh in all_monomials([h], i, ring):
for mx in all_monomials([x], j, ring):
for my in all_monomials([y], k, ring):
#for mz in all_monomials([z], l, ring):
rem = mh*mx*my #*mz
while 1:
rem0 = rem
for rel in rels:
div, rem = rel.reduce(rem)
if rem == rem0:
break
grades[g].append(rem)
for i in range(n):
gens = grades[i]
#print(gens)
if argv.sage:
count = sage_grobner(gens)
else:
basis = grobner(gens) if gens else []
count = len(basis)
print(count, end=",", flush=True)
print()
def get_weights_so5(idx=0, jdx=0):
# Plucker embedding for SO(5) ~= SO(2+3)
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
a = Poly("a", ring)
b = Poly("b", ring)
c = Poly("c", ring)
d = Poly("d", ring)
z = Poly("z", ring)
e = Poly("e", ring)
f = Poly("f", ring)
g = Poly("g", ring)
h = Poly("h", ring)
half = one/2
u = half*(e+g)
v = half*(f+h)
x = half*(e-g)
y = half*(h-f)
assert u**2+v**2-x**2-y**2-z**2 == e*g + f*h - z**2
# got from test_quaternion :
rels = [
e*g + f*h - z**2,
a*u + d*v -(a*x + c*z - d*y),
a*v - d*u -(a*y - b*z + d*x),
-b*u - c*v -(-b*x - c*y - d*z),
b*v - c*u -(-a*z - b*y + c*x),
]
print("rels:")
for rel in rels:
print(rel)
print()
rels = grobner(rels)
gens = []
for p in all_monomials([a, b, c, d], idx, ring):
for q in all_monomials([e, f, g, h, z], jdx, ring):
rem = p*q
#for count in range(3):
while 1:
rem0 = rem
for rel in rels:
div, rem = rel.reduce(rem)
if rem == rem0:
break
gens.append(rem)
#print("gens:", len(gens))
basis = grobner(gens)
for p in basis:
print(p)
n = sage_grobner(gens)
assert n == len(basis)
print("%3d"%n)
grades = {
# s q
'e' : ( 0, 1),
'b' : (-1, 1),
'f' : (-2, 1),
'a' : ( 1, 0),
'z' : ( 0, 0),
'd' : (-1, 0),
'h' : ( 2, -1),
'c' : ( 1, -1),
'g' : ( 0, -1),
}
weights = {}
for p in basis:
g = find_grade(grades, p)
weights[g] = weights.get(g, 0) + 1
return weights
def test_graded_sl4():
# See: Miller & Sturmfels, p276
ring = Q
zero = Poly({}, ring)
one = Poly({():1}, ring)
poly = lambda v : Poly(v, ring)
p1 = poly("p1")
p2 = poly("p2")
p3 = poly("p3")
p4 = poly("p4")
p12 = poly("p12")
p13 = poly("p13")
p14 = poly("p14")
p23 = poly("p23")
p24 = poly("p24")
p34 = poly("p34")
p123 = poly("p123")
p124 = poly("p124")
p134 = poly("p134")
p234 = poly("p234")
rels = [
p23*p1 - p13*p2 + p12*p3, p24*p1 - p14*p2 + p12*p4,
p34*p1 - p14*p3 + p13*p4, p34*p2 - p24*p3 + p23*p4,
p14*p23 - p13*p24 + p12*p34, p234*p1 - p134*p2 + p124*p3 - p123*p4,
p134*p12 - p124*p13 + p123*p14, p234*p12 - p124*p23 + p123*p24,
p234*p13 - p134*p23 + p123*p34, p234*p14 - p134*p24 + p124*p34,
]
rels = grobner(rels, verbose=True)
print("rels:", rels)
print()
grades = [
[p1, p2, p3, p4],
[p12, p13, p14, p23, p24, p34],
[p123, p124, p134, p234],
]
multi = argv.get("multi")
n = 5 if multi is None else sum(multi)+1
n = argv.get("n", n)
for g0 in range(n):
for g1 in range(n):
for g2 in range(n):
if multi is not None and (g0, g1, g2)!=multi:
#print(". ", end='')
continue
elif g0+g1+g2 > n-1:
print(". ", end='')
continue
gens = []
for m0 in all_monomials(grades[0], g0, ring):
for m1 in all_monomials(grades[1], g1, ring):
for m2 in all_monomials(grades[2], g2, ring):
m = m0*m1*m2
#for rel in rels:
# div, m = rel.reduce(m)
m = reduce_many(rels, m)
if m != 0:
gens.append(m)
print(len(gens), end=':', flush=True)
basis = grobner(gens)
lhs = len(basis)
rhs = (g0+1)*(g1+1)*(g2+1)*(g0+g1+2)*(g1+g2+2)*(g0+g1+g2+3)//12
assert lhs==rhs, ("%s != %s"%(lhs, rhs))
print(len(basis), end=' ', flush=True)
# basis.sort(key=str)
# heads = {}
# for p in basis:
# print(p.head, p)
# heads[p.head] = p
# print(len(heads))
# return
print()
print()