order = int(16)
n = int(gap.NrSmallGroups(order))
for i in range(1, n+1):
    G = gap.SmallGroup(order, i)
    if not G.IsAbelian():
        print("G_"+str(i)+" = " + str(gap.StructureDescription(G)))

# i = 13

%run -i FPENAG.py

G = gap.SmallGroup(16,13)
[ ag, bg, cg ] = G.GeneratorsSmallest()
kG = gap.GroupRing(GF(2), G)
f = gap.Embedding(G, kG)
[ a, b, c ] = [ gap.Image(f, x) for x in [ ag, bg, cg] ]
id = gap.Image(f, ag^0)

# 1 + a + c, 1 + b + c, 1 + a + b are all units of order 4 in the group algebra
# (we check this below). Hence, if F_2[G]/I fully realizes G, then each maps to
# an element of G whose order is at most 4 in the quotient.

print((id + a + c).Order(), (id + b + c).Order(), (id + a + b).Order())

# Grab the elements of G with order at most 4.
O4 = []
for g in G.Elements():
    if g.Order() <= 4:
        O4 +=[g]
O4 = [gap.Image(f, t) for t in O4]

# For all possible choices u, v, w of elements of order at most 4,
# consider F_2[G]/(1 + a + c + u, 1 + b + c + v, 1 + a + b + w).
#
# If the unit group of the quotient is greater than 16, then flag it;
# there is more work to be done (the ideal I may not be large enough).
#
# If the unit group has order 16 and G embeds in the quotient, then
# we have achieved realizability and we check full realizability.
#
# If G does not embed in the quotient, then we ignore the case because
# if G is FR then there is an ideal where G does embed in the quotient.
#
# If the unit group has order less than 16, then the ring does not even
# realize the group.

for u in O4:
    for v in O4:
        for w in O4:
            gens = [id + a + c + u, id + b + c + v, id + a + b + w]
            I = gap.Ideal(kG, gens)
            X = kG/I

            qOrder = X.Units().Order()

            if qOrder > 16: # Never happens, fortunately.
                print("For", u, v, w, "the unit group is too large. More work is required.")
                print()
            elif qOrder == 16 and GEmbeds(G, f, id, I):
                analyzekGmodI(G, f, id, I, X, gens, skipFRCheck=False)
                print()
            # If the order of the unit group is less than 16 or if G doesn't embed in the quotient, then the
            # ring doesn't fully realize G.

%run -i FPENAG.py

G = gap.SmallGroup(16,3)
[cg, ag, bg, jjj] = G.Generators()
gens = [cg, ag, bg]
kG = gap.GroupRing(GF(2), G)
f = gap.Embedding(G, kG)

# c generates C_4, a, b generate C_2 x C_2.

[c, a, b] = [ gap.Image(f, x) for x in gens ]
id = gap.Image(f, cg^0)

Jgens = [id + a + c + a*c, id + c + c^2 + c^3]
J = gap.Ideal(kG, Jgens)
kGmodJ = kG/J
analyzekGmodI(G, f, id, J, kGmodJ, Jgens)

%run -i FPENAG.py

G = gap.SmallGroup(16,4)
[ ag, bg] = G.GeneratorsSmallest()
kG = gap.GroupRing(GF(2), G)
f = gap.Embedding(G, kG)
[ a, b] = [ gap.Image(f, x) for x in [ ag, bg] ]
id = gap.Image(f, ag^0)

# 1 + a + b and 1 + b^2 + a are units in the group algebra
# of order 4.

(id + a + b).Order(), (id + b^2 + a).Order()

# Check all possible values of 1 + a + b, 1 + b^2 + a in the
# quotient. See the case i = 13 above fore more strategic
# details.

for ug in G.Elements():
    for vg in G.Elements():
        u = gap.Image(f, ug)
        v = gap.Image(f, vg)
        # Ignore some degenerate cases with the below if clause.
        if u!= u^0 and u!= a and u!=b and v!=v^0 and v!= b^2 and v!=a:
            gens = [id + a + b + u, id + b^2 + a + v]
            I = gap.Ideal(kG, gens)
            X = kG/I
            qOrder = X.Units().Order()
            if qOrder > 16: # Fortunately, this case never happens.
                print()
                print("For", ug, vg, "the unit group is too large. More generators are required.")
                analyzekGmodI(G, f, id, I, X, gens)
            elif qOrder == 16 and GEmbeds(G, f, id, I):
                analyzekGmodI(G, f, id, I, X, gens, skipFRCheck=False)
                print()
            # If the order of the unit group is less than 16 or if G doesn't embed in the quotient, then the
            # ring doesn't fully realize G.