Implementation of concepts related to fundamental theorem of semidistributive lattices

[Hey-Ya7]

This PR implements key concepts from Reading, Speyer, and Thomas' 2024 paper, "The fundamental theorem of finite semidistributive lattices" . Specifically, it adds the following methods to the file src/sage/graphs/digraph.py :

• right_orthogonal() and left_orthogonal() : these compute the right and left orthogonal sets of some subset of vertices of a directed graph. These sets are defined on page 3 of the aforementioned paper, although they are not explicitly named.
• maximal_orthogonal_pairs_lattice() : this computes the lattice of maximal orthogonal pairs, an object also defined on page 3 of the paper and that has been studied before in different contexts (i.e. Markowsky's representation theorem)
• surjective_edges() and injective_edges() : these compute the "onto" and "into" relations as defined in the paper (also on page 3). The paper considers the factorization of an arbitrary reflexive binary relation; here, we consider the representation of the relation as a directed graph, which can also be seen as defining the relation as x -> y if x = y or xy is an edge.
• is_two_acyclic_factorization_system() : checks whether a directed graph forms a two-acyclic factorization system. as before, this is defined and discussed in detail in the paper.

The main motivation behind all this is the Fundamental Theorem of Semidistributive Lattices, which says that any finite semidistributive lattice is isomorphic to some lattice of orthogonal pairs of a two-acyclic factorization system.

📝 Checklist

• The title is concise and informative.
• The description explains in detail what this PR is about.
• I have linked a relevant issue or discussion.
• I have created tests covering the changes.
• I have updated the documentation and checked the documentation preview.

⌛ Dependencies

I am unaware of any PRs that this implementation depends on.

[fchapoton]

Le plugin "Lint" est pas content, merci de corriger tout ca.

[github-actions]

Documentation preview for this PR (built with commit 76a6204; changes) is ready! 🎉
This preview will update shortly after each push to this PR.

[dcoudert]

Thank you for contributing Sagemath.

However, I don't think these methods should be added to DiGraph. These methods are very specific to lattices and so should be somewhere in src/combinat/posets/....

Below are some commets on your code. Similar comments apply to method is_two_acyclic_factorization_system.

[dcoudert]

X -> `X`

[dcoudert]

you can use l = set(self) (several times in your code)

[dcoudert]

same as above

[dcoudert]

place the comments above the declaration of pairs. It makes it easier to respect the 80 columns mode.

[mantepse]

also, please avoid Set in library code.

[Hey-Ya7]

I will need to use some kind of set-like object that is immutable as the algorithm involves indexing a dictionary by some right orthogonal set, would frozenset() be preferred in this case, or is that also depreciated?

[fchapoton]

frozenset is fine

[dcoudert]

-        next_pairs = [Set(self.vertices())]
-        while next_pairs != []:
+        next_pairs = [Set(self)]
+        while next_pairs:
            new_pairs = []
            for rt in next_pairs:
                covering_pairs = []
-                for x in self.vertex_iterator():
+                for x in self:
                    if x in pairs[rt]:
                        continue
                    # calculate the new right orthogonal by removing vertices
                    new_rt = rt.difference(self.neighbors_out(x))
                    new_rt = new_rt.difference([x])
                    covering_pairs.append(new_rt)
                    if new_rt in pairs:
                        # merge all left components with the same right orthogonal
                        pairs[new_rt] = pairs[new_rt].union(pairs[rt])
                    else:
                        pairs[new_rt] = pairs[rt]
                        new_pairs.append(new_rt)
                    pairs[new_rt] = pairs[new_rt].union(Set({x}))
                # generate the upper covers
                for new_rt in covering_pairs:
                    if rt != new_rt:
-                       G.add_vertex(new_rt)
                        G.add_edge(rt, new_rt)
            next_pairs = new_pairs
        if labels == "left":
            G.relabel(lambda v: pairs[v])
        elif labels != "right":
            G.relabel(lambda v: (pairs[v], v))
        from sage.combinat.posets.lattices import LatticePoset
        return LatticePoset(G)

[dcoudert]

        E = []
        for x, y in self.edge_iterator(labels=False):
            if x != y:
                if all(self.has_edge(x, z) for z in self.neighbors_out(y)):
                    E.append((x, y))
            elif loops:
                E.append((x, y))
        return E

[dcoudert]

        E = []
        for y, z in self.edge_iterator(labels=False):
            if y != z:
                if all(self.has_edge(x, z) for x in self.neighbors_in(y)):
                    E.append((y, z))
            elif loops:
                E.append((y, z))
        return E

[fchapoton]

We now have a category of Semidistributive lattices in place, in src/sage/categories/lattice_posets.py. Maybe this would be the place to put some of these as methods of semidistributive lattices ?

[Hey-Ya7]

Thank you very much for your comments @dcoudert, I have modified my code following your suggestions; however I am unsure where to put these methods. I agree that these methods should probably be somewhere in the combinat/posets folder, but there doesn't really seem to be an appropriate file to add these to - I don't think these would fit well in neither posets.py nor lattices.py as they don't make sense as poset/lattice/semilattice methods.
@fchapoton For the same reason, I don't quite see which methods I could put as methods of semidistributive lattices, as of the 6 methods here, 5 do not operate on nor construct a lattice, and the only constructor isn't guaranteed to give a semidistributive lattice.

I am currently considering to perhaps create a new file under combinat/posets and transfer these methods there, and changing them from class methods to functions taking a DiGraph object as argument. Would this be an acceptable way to implement these changes?

[fchapoton]

Oui, an independant file somewhere in combinat/posets seems to be a reasonable idea.

It could be named "semidistributivity.py" maybe.

[fchapoton]

there is a wrong change in the file digraph.py

[fchapoton]

you can try to sort the doctest to make it reproducible, or just check the length

[Hey-Ya7]

Sorting the list seems to have fixed it, although I'm not sure what's causing the [g-o] test error.

[fchapoton]

the failure in libs/ecl is unrelated and happens currently in most pull requests

[fchapoton]

please do not use comments, but write them in documentation main text

[fchapoton]

J'ai fait quelques suggestions. Il faut les ajouter au "batch" puis "commiter l'ensemble"