def descendant_subgroups(S, C, R1_c_list, x, R2, N, Y):
A_dict = C.A_dict
A_dict_inv = C.A_dict_inv
if C.is_complete():
# if C is complete then it only needs to test
# whether the relators in R2 are satisfied
for w, alpha in product(R2, C.omega):
if not C.scan_check(alpha, w):
return
# relators in R2 are satisfied, append the table to list
S.append(C)
else:
# find the first undefined entry in Coset Table
for alpha, x in product(range(len(C.table)), C.A):
if C.table[alpha][A_dict[x]] is None:
# this is "x" in pseudo-code (using "y" makes it clear)
undefined_coset, undefined_gen = alpha, x
break
# for filling up the undefine entry we try all possible values
# of β ∈ Ω or β = n where β^(undefined_gen^-1) is undefined
reach = C.omega + [C.n]
for beta in reach:
if beta < N:
if beta == C.n or C.table[beta][
A_dict_inv[undefined_gen]] is None:
try_descendant(S, C, R1_c_list, R2, N, undefined_coset, \
undefined_gen, beta, Y)
def descendant_subgroups(S, C, R1_c_list, x, R2, N, Y):
A_dict = C.A_dict
A_dict_inv = C.A_dict_inv
if C.is_complete():
# if C is complete then it only needs to test
# whether the relators in R2 are satisfied
for w, alpha in product(R2, C.omega):
if not C.scan_check(alpha, w):
return
# relators in R2 are satisfied, append the table to list
S.append(C)
else:
# find the first undefined entry in Coset Table
for alpha, x in product(range(len(C.table)), C.A):
if C.table[alpha][A_dict[x]] is None:
# this is "x" in pseudo-code (using "y" makes it clear)
undefined_coset, undefined_gen = alpha, x
break
# for filling up the undefine entry we try all possible values
# of β ∈ Ω or β = n where β^(undefined_gen^-1) is undefined
reach = C.omega + [C.n]
for beta in reach:
if beta < N:
if beta == C.n or C.table[beta][A_dict_inv[undefined_gen]] is None:
try_descendant(S, C, R1_c_list, R2, N, undefined_coset, \
undefined_gen, beta, Y)
def update(f, sugar, P):
"""Add f with sugar ``sugar`` to S, update P."""
if not f:
return P
k = len(S)
S.append(f)
Sugars.append(sugar)
LMf = sdm_LM(f)
def removethis(pair):
i, j, s, t = pair
if LMf[0] != t[0]:
return False
tik = sdm_monomial_lcm(LMf, sdm_LM(S[i]))
tjk = sdm_monomial_lcm(LMf, sdm_LM(S[j]))
return tik != t and tjk != t and sdm_monomial_divides(tik, t) and \
sdm_monomial_divides(tjk, t)
# apply the chain criterion
P = [p for p in P if not removethis(p)]
# new-pair set
N = [(i, k, Ssugar(i, k), sdm_monomial_lcm(LMf, sdm_LM(S[i])))
for i in range(k) if LMf[0] == sdm_LM(S[i])[0]]
# TODO apply the product criterion?
N.sort(key=ourkey)
remove = set()
for i, p in enumerate(N):
for j in range(i + 1, len(N)):
if sdm_monomial_divides(p[3], N[j][3]):
remove.add(j)
# TODO mergesort?
P.extend(reversed([p for i, p in enumerate(N) if not i in remove]))
P.sort(key=ourkey, reverse=True)
# NOTE reverse-sort, because we want to pop from the end
return P
def update(f, sugar, P):
"""Add f with sugar ``sugar`` to S, update P."""
if not f:
return P
k = len(S)
S.append(f)
Sugars.append(sugar)
LMf = sdm_LM(f)
def removethis(pair):
i, j, s, t = pair
if LMf[0] != t[0]:
return False
tik = sdm_monomial_lcm(LMf, sdm_LM(S[i]))
tjk = sdm_monomial_lcm(LMf, sdm_LM(S[j]))
return tik != t and tjk != t and sdm_monomial_divides(tik, t) and \
sdm_monomial_divides(tjk, t)
# apply the chain criterion
P = [p for p in P if not removethis(p)]
# new-pair set
N = [(i, k, Ssugar(i, k), sdm_monomial_lcm(LMf, sdm_LM(S[i])))
for i in range(k) if LMf[0] == sdm_LM(S[i])[0]]
# TODO apply the product criterion?
N.sort(key=ourkey)
remove = set()
for i, p in enumerate(N):
for j in range(i + 1, len(N)):
if sdm_monomial_divides(p[3], N[j][3]):
remove.add(j)
# TODO mergesort?
P.extend(reversed([p for i, p in enumerate(N) if not i in remove]))
P.sort(key=ourkey, reverse=True)
# NOTE reverse-sort, because we want to pop from the end
return P
def sdm_groebner(G, NF, O, K):
"""
Compute a minimal standard basis of ``G`` with respect to order ``O``.
The algorithm uses a normal form ``NF``, for example ``sdm_nf_mora``.
The ground field is assumed to be ``K``, and monomials ordered according
to ``O``.
Let `N` denote the submodule generated by elements of `G`. A standard
basis for `N` is a subset `S` of `N`, such that `in(S) = in(N)`, where for
any subset `X` of `F`, `in(X)` denotes the submodule generated by the
initial forms of elements of `X`. [SCA, defn 2.3.2]
A standard basis is called minimal if no subset of it is a standard basis.
One may show that standard bases are always generating sets.
Minimal standard bases are not unique. This algorithm computes a
deterministic result, depending on the particular order of `G`.
See [SCA, algorithm 2.3.8, and remark 1.6.3].
"""
# First compute a standard basis
S = [f for f in G if f]
P = list(combinations(S, 2))
def prune(P, S, h):
"""
Prune the pair-set by applying the chain criterion
[SCA, remark 2.5.11].
"""
remove = set()
retain = set()
for (a, b, c) in permutations(S, 3):
A = sdm_LM(a)
B = sdm_LM(b)
C = sdm_LM(c)
if len(set([A[0], B[0], C[0]])) != 1 or not h in [a, b, c] or \
any(tuple(x) in retain for x in [a, b, c]):
continue
if monomial_divides(B[1:], monomial_lcm(A[1:], C[1:])):
remove.add((tuple(a), tuple(c)))
retain.update([tuple(b), tuple(c), tuple(a)])
return [(f, g) for (f, g) in P if (h not in [f, g]) or \
((tuple(f), tuple(g)) not in remove and \
(tuple(g), tuple(f)) not in remove)]
while P:
# TODO better data structures!!!
#print len(P), len(S)
# Use the "normal selection strategy"
lcms = [(i, sdm_LM(f)[:1] + monomial_lcm(sdm_LM(f)[1:], sdm_LM(g)[1:])) for \
i, (f, g) in enumerate(P)]
i = min(lcms, key=lambda x: O(x[1]))[0]
f, g = P.pop(i)
h = NF(sdm_spoly(f, g, O, K), S, O, K)
if h:
S.append(h)
P.extend((h, f) for f in S if sdm_LM(h)[0] == sdm_LM(f)[0])
P = prune(P, S, h)
# Now interreduce it. (TODO again, better data structures)
S = set(tuple(f) for f in S)
for a, b in permutations(S, 2):
A = sdm_LM(list(a))
B = sdm_LM(list(b))
if sdm_monomial_divides(A, B) and b in S and a in S:
S.remove(b)
return sorted((list(f) for f in S), key=lambda f: O(sdm_LM(f)),
reverse=True)
def sdm_groebner(G, NF, O, K):
"""
Compute a minimal standard basis of ``G`` with respect to order ``O``.
The algorithm uses a normal form ``NF``, for example ``sdm_nf_mora``.
The ground field is assumed to be ``K``, and monomials ordered according
to ``O``.
Let `N` denote the submodule generated by elements of `G`. A standard
basis for `N` is a subset `S` of `N`, such that `in(S) = in(N)`, where for
any subset `X` of `F`, `in(X)` denotes the submodule generated by the
initial forms of elements of `X`. [SCA, defn 2.3.2]
A standard basis is called minimal if no subset of it is a standard basis.
One may show that standard bases are always generating sets.
Minimal standard bases are not unique. This algorithm computes a
deterministic result, depending on the particular order of `G`.
See [SCA, algorithm 2.3.8, and remark 1.6.3].
"""
# First compute a standard basis
S = [f for f in G if f]
P = list(combinations(S, 2))
def prune(P, S, h):
"""
Prune the pair-set by applying the chain criterion
[SCA, remark 2.5.11].
"""
remove = set()
retain = set()
for (a, b, c) in permutations(S, 3):
A = sdm_LM(a)
B = sdm_LM(b)
C = sdm_LM(c)
if len(set([A[0], B[0], C[0]])) != 1 or not h in [a, b, c] or \
any(tuple(x) in retain for x in [a, b, c]):
continue
if monomial_divides(B[1:], monomial_lcm(A[1:], C[1:])):
remove.add((tuple(a), tuple(c)))
retain.update([tuple(b), tuple(c), tuple(a)])
return [(f, g) for (f, g) in P if (h not in [f, g]) or \
((tuple(f), tuple(g)) not in remove and \
(tuple(g), tuple(f)) not in remove)]
while P:
# TODO better data structures!!!
#print len(P), len(S)
# Use the "normal selection strategy"
lcms = [(i, sdm_LM(f)[:1] + monomial_lcm(sdm_LM(f)[1:], sdm_LM(g)[1:])) for \
i, (f, g) in enumerate(P)]
i = min(lcms, key=lambda x: O(x[1]))[0]
f, g = P.pop(i)
h = NF(sdm_spoly(f, g, O, K), S, O, K)
if h:
S.append(h)
P.extend((h, f) for f in S if sdm_LM(h)[0] == sdm_LM(f)[0])
P = prune(P, S, h)
# Now interreduce it. (TODO again, better data structures)
S = set(tuple(f) for f in S)
for a, b in permutations(S, 2):
A = sdm_LM(list(a))
B = sdm_LM(list(b))
if sdm_monomial_divides(A, B) and b in S and a in S:
S.remove(b)
return sorted((list(f) for f in S),
key=lambda f: O(sdm_LM(f)),
reverse=True)
