copying lists, embedded multigraphs

edit

The thing is that when copying a list of lists, the inside lists are not copied but end up being the same lists as in the original list.

The workaround is to use deepcopy which recursively copies nested lists.

Here is a simpler illustration of that.

The problem with copying nested lists with copy:

sage: a = [[0, 0], [0, 0], [0, 0]]
sage: b = a.copy()
sage: b[0][0] = 1
sage: b
[[1, 0], [0, 0], [0, 0]]
sage: a
[[1, 0], [0, 0], [0, 0]]

How deepcopy avoids this problem:

sage: c =  [[0, 0], [0, 0], [0, 0]]
sage: d = deepcopy(c)
sage: d[0][0] = 1
sage: d
[[1, 0], [0, 0], [0, 0]]
sage: c
[[0, 0], [0, 0], [0, 0]]

Besides that, the code could be streamlined by iterating by values instead of by indices.

Suggestion: go through some of the tutorial at

• https://doc.sagemath.org/html/en/thematic_tutorials

in particular

• Programming in Python and Sage
• Comprehensions, iterators and iterables

Here is an attempt at making the code from the question more concise.

In this rewrite,

• edge_on_faces returns booleans rather than integers
• iterating by values insted of by index makes loop simpler
• vars are in string form since they are only used as such
• double comprehension avoids summing list when defining vars
• any avoids building the whole list if ot necessary
• raising an exception replaces returning the string 'error'
• copying Gf is done only once
• avoid summing lists and assigning to B; instead append to GGf and return it

Here we go. All that is missing is to fill in the documentation string for each function.

def edge_on_faces(j, S, Gf, G1, Gd, Gt):
    r"""
    Return whether ...
    """
    vars = [str(e[2]) for G in (G1, Gd, Gt) for e in G.edges()]
    return (0 <= j < len(vars)
            and any(str(e[2]) == vars[j] for n in S for e in Gf[n]))

def face_modification(i, Gf, G1, Gd, Gt):
    r"""
    Return ...
    """
    vars = [str(e[2]) for G in (G1, Gd, Gt) for e in G.edges()]
    l = [m for m in range(len(Gf)) if edge_on_faces(i, [m], Gf, G1, Gd, Gt)]
    # PF: list of two-faces in Gf that have edge i on their boundary
    GGf = deepcopy(Gf)
    PF = [GGf[e] for e in l]
    for p in PF:
        GGf.remove(p)
        for k in range(len(p)):
            if str(p[k][2]) == vars[i]:
                p.remove(p[k])
    if len(PF) == 2:
        GGf.append(PF[0] + PF[1])
        return GGf
    else:
        raise ValueError('unexpected situation in face_modification')

The changes should also make the code faster.

There might be ways to simplify further.

This part of the code modifies a list it is iterating on:

        for k in range(len(p)):
            if str(p[k][2]) == vars[i]:
                p.remove(p[k])

If vars[i] can occur only once in p it's all right; in that case one could exit the for loop as soon as the corresponding removal has been done: no need to keep checking the rest of the list.

If vars[i] can occur several times in p, the code as written may not be doing what was intended.