Functions for nice tree decomposition and its labelling

[guojing0]

This PR intends to add two new functions:

1. make_nice_tree_decomposition takes a graph and its tree decomposition. It returns a nice tree decomposition.
2. label_nice_tree_decomposition takes a tree decomposition, assumed to be nice. It returns the same result, with vertices labelled accordingly.

📝 Checklist

• The title is concise, informative, and self-explanatory.
• 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 accordingly.

⌛ Dependencies

[dcoudert]

If you need, I have a code that takes a tree decomposition and returns a nice tree decomposition. It is not optimized but it can be useful. I had in my todo list to add it to Sagemath, as well as other methods...

[guojing0]

If you need, I have a code that takes a tree decomposition and returns a nice tree decomposition. It is not optimized but it can be useful. I had in my todo list to add it to Sagemath, as well as other methods...

Merci pour la suggestion. But at least for the nice tree decomposition one, I would like to implement it myself first.

What other methods do you have in mind? The ones mentioned in TODO in the code files?

Also, by "optimization", do you mean at the level of math/algo or code (like making the tree more balanced?)

[dcoudert]

What other methods do you have in mind? The ones mentioned in TODO in the code files?

approximation of tree length based on BFS layering. I have a code for computing the "leveled tree" or "layered tree" as proposed by Chepoi et al. I need to add it and extend it to get a tree decomposition. The same can be done using lex-M and MCS-M.

Also, by "optimization", do you mean at the level of math/algo or code (like making the tree more balanced?)

Make it faster at least.

[guojing0]

approximation of tree length based on BFS layering. I have a code for computing the "leveled tree" or "layered tree" as proposed by Chepoi et al. I need to add it and extend it to get a tree decomposition. The same can be done using lex-M and MCS-M.

Sounds interesting.

Currently I don't know too much about these, but can check the literatures.

[guojing0]

If you need, I have a code that takes a tree decomposition and returns a nice tree decomposition. It is not optimized but it can be useful. I had in my todo list to add it to Sagemath, as well as other methods...

May I see the code for reference, or improve upon it...?

[dcoudert]

My code is below. I hope it is correct

def nice_tree_decomposition(T):
    r"""
    Return a *nice* tree-decomposition of the tree-decomposition `T`.

    https://kam.mff.cuni.cz/~ashutosh/lectures/lec06.pdf

    A *nice* tree-decomposition is a rooted binary tree with four types of
    nodes:
    - Leaf nodes have no children and bag size 1;
    - Introduce nodes have one child. The child has the same vertices as the
      parent with one deleted;
    - Forget nodes have one child. The child has the same vertices as the parent
      with one added.
    - Join nodes have two children, both identical to the parent.

    .. WARNING::

        This method assumes that the vertices of the input tree `T` are hashable
        and have attribute ``issuperset``, e.g., ``frozenset`` or
        :class:`~sage.sets.set.Set_object_enumerated_with_category`.

    INPUT:

    - ``T`` -- a tree-decomposition
    """
    from sage.graphs.graph import Graph
    if not isinstance(T, Graph):
        raise ValueError("T must be a tree-decomposition")

    name = "Nice tree-decomposition of {}".format(T.name())
    if not T:
        return Graph(name=name)

    # P1: The tree is rooted.
    # We choose a root and orient the edges in root to leaves direction.
    leaves = [u for u in T if T.degree(u) == 1]
    root = leaves.pop()
    from sage.graphs.digraph import DiGraph
    DT = DiGraph(T.breadth_first_search(start=root, edges=True),
                 format='list_of_edges')

    # We relabel the graph in range 0..|T|-1
    bag_to_int = DT.relabel(inplace=True, return_map=True)
    # get the new name of the root
    root = bag_to_int[root]
    # and force bags to be of type Set to simplify the code
    bag = {ui: Set(u) for u, ui in bag_to_int.items()}

    # P2: The root and the leaves have empty bags.
    # To do so, we add to each leaf node l of DT a children with empty bag.
    # We also add a new root with empty bag.
    root, old_root = DT.add_vertex(), root
    DT.add_edge(root, old_root)
    bag[root] = Set()
    for vi, u in enumerate(leaves, start=root + 1):
        DT.add_edge(bag_to_int[u], vi)
        bag[vi] = Set()

    # P3: Ensure that each vertex of DT has at most 2 children.
    # If b has k > 2 children (c1, c2, ..., c_k). We disconnect (c1, ... ck-1)
    # from b, introduce k - 2 new vertices (b1, b2, .., bk-2), make ci the
    # children of bi for 1 <= i <= k-2, make ck-1 the second children of bk-2,
    # make bi the second children of b_i-1, and finally make b1 the second
    # children of b. Each vertex bi has the same bag has b.
    for ui in list(DT):  # the list(..) is needed since we modify DT
        if DT.out_degree(ui) > 2:
            children = DT.neighbors_out(ui)
            children.pop()  # one vertex remains a child of ui
            DT.delete_edges((ui, vi) for v in children)
            new_vertices = [DT.add_vertex() for _ in range(len(children) - 1)]
            DT.add_edge(ui, new_vertices[0])
            DT.add_path(new_vertices)
            DT.add_edges(zip(new_vertices, children))
            DT.add_edge(new_vertices[-1], children[-1])
            bag.update((vi, bag[ui]) for vi in new_vertices)

    # P4: If b has 2 children c1 and c2, then bag[b] == bag[c1] == bag[c2]
    for ui in list(DT):
        if DT.out_degree(ui) < 2:
            continue
        for vi in DT.neighbor_out_iterator(ui):
            if bag[ui] != bag[vi]:
                DT.delete_edge(ui, vi)
                wi = DT.add_vertex()
                DT.add_path([ui, wi, vi])
                bag[wi] = bag[ui]

    # P5: if b has a single child c, then one of the following conditions holds:
    #       (i)  bag[c] is a subset of bag[b] and |bag[b]| == |bag[c]| + 1
    #       (ii) bag[b] is a subset of bag[c] and |bag[c]| == |bag[b]| + 1

    def add_path_of_introduce(ui, vi):
        """
        Replace arc (ui, vi) by a path of introduce vertices.
        """
        if len(bag[ui]) + 1 == len(bag[vi]):
            return
        diff = list(bag[vi] - bag[ui])
        diff.pop()  # when all vertices are added, we are on vi
        xi = ui
        for w in diff:
            wi = DT.add_vertex()
            bag[wi] = bag[xi].union(Set((w,)))
            DT.add_edge(xi, wi)
            xi = wi
        DT.add_edge(xi, vi)
        DT.delete_edge(ui, vi)

    def add_path_of_forget(ui, vi):
        """
        Replace arc (ui, vi) by a path of forget vertices.
        """
        if len(bag[vi]) + 1 == len(bag[ui]):
            return
        diff = list(bag[ui] - bag[vi])
        diff.pop()  # when all vertices are removed, we are on vi
        xi = ui
        for w in diff:
            wi = DT.add_vertex()
            bag[wi] = bag[xi] - Set((w,))
            DT.add_edge(xi, wi)
            xi = wi
        DT.add_edge(xi, vi)
        DT.delete_edge(ui, vi)

    for ui in list(DT):
        if DT.out_degree(ui) != 1:
            continue
        
        vi = next(DT.neighbor_out_iterator(ui))
        bag_ui, bag_vi = bag[ui], bag[vi]

        if bag_ui == bag_vi:
            # We can merge the vertices
            if DT.in_degree(ui) == 1:
                parent = next(DT.neighbor_in_iterator(ui))
                DT.add_edge(parent, vi)
            else:
                root = vi
            DT.delete_vertex(ui)

        elif bag_ui.issubset(bag_vi):
            add_path_of_introduce(ui, vi)

        elif bag_vi.issubset(bag_ui):
            add_path_of_forget(ui, vi)

        else:
            # We must first forget some nodes and then introduce new nodes
            wi = DT.add_vertex()
            bag[wi] = bag[ui] & bag[vi]
            DT.add_path([ui, wi, vi])
            DT.delete_edge(ui, vi)
            add_path_of_forget(ui, wi)
            add_path_of_introduce(wi, vi)

    # We now return the result
    nice = Graph(DT, name=name)
    nice.relabel(inplace=True,
                 perm={u: (i, bag[u]) for i, u in enumerate(nice.breadth_first_search(start=root))})
    return nice

[guojing0]

@dcoudert Thank you for the reviews and suggestions. I didn't think you would review and comment until I add the label needs_review. I was working on CoCalc web-based VS code, so I pushed the codes for back-up.

[dcoudert]

You should add examples for which we can check that the solution is what we expect.

[guojing0]

You should add examples for which we can check that the solution is what we expect.

Do intend to.

[dcoudert]

May be you can add parameter nice to method treewidth in order to return a nice tree decomposition ?

[guojing0]

May be you can add parameter nice to method treewidth in order to return a nice tree decomposition ?

I agree with your suggestion. Just added. For some reason treewidth doesn't capture nice even if it's set to True. Will dig into the issue later.

[dcoudert]

For some reason treewidth doesn't capture nice even if it's set to True. Will dig into the issue later.

This is certainly due to the use of clique separators. Make sure to transform the result before returning the result.

[guojing0]

For some reason treewidth doesn't capture nice even if it's set to True. Will dig into the issue later.

This is certainly due to the use of clique separators. Make sure to transform the result before returning the result.

I have uploaded the latest code. I don't think this is the case. The following was run with the latest code. As you can see on line 786, I have print(nice), which was set to True, but it printed False.

The nice tree decomp of the Petersen graph should have 28 nodes.

sage: graphs.PetersenGraph().treewidth(certificate=True, nice=True)
False
Tree decomposition: Graph on 6 vertices

[dcoudert]

You forgot to pass the parameter to a call

diff --git a/src/sage/graphs/graph_decompositions/tree_decomposition.pyx b/src/sage/graphs/graph_decompositions/tree_decomposition.pyx
index 8ce5c433c9..f18f419c0c 100644
--- a/src/sage/graphs/graph_decompositions/tree_decomposition.pyx
+++ b/src/sage/graphs/graph_decompositions/tree_decomposition.pyx
@@ -702,7 +702,7 @@ def treewidth(g, k=None, kmin=None, certificate=False, algorithm=None, nice=Fals
     # Forcing k to be defined
     if k is None:
         for i in range(max(kmin, g.clique_number() - 1, min(g.degree())), g.order()):
-            ans = g.treewidth(algorithm=algorithm, k=i, certificate=certificate)
+            ans = g.treewidth(algorithm=algorithm, k=i, certificate=certificate, nice=nice)
             if ans:
                 return ans if certificate else i

[guojing0]

You are right; I thought it was caused by line 693.

[guojing0]

sage: import sage.graphs.graph_decompositions.tdlib as tdlib
....: 
---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In [2], line 1
----> 1 import sage.graphs.graph_decompositions.tdlib as tdlib

ModuleNotFoundError: No module named 'sage.graphs.graph_decompositions.tdlib'

I am thinking about testing the changes with tdlib. But after I read relevant documentations, it seems that tdlib is only bundled with a distribution called sagemath-tdlib.

So I was wondering if you have any suggestions? Also, one of the TO-DO items is upgrade tdlib to 0.9.0 :trac: 30813 -- are there any significant changes, such as performance?

[guojing0]

@dcoudert I am not sure if this is the right place to ask, if not, I will either email or resort to other channel(s): As continuation of this PR, I am working on some functionality related to homomorphism counting. I am aware that Sage already has has_homomorphism_to function, but it only returns one homomorphism even if multiple exist.

It seems that this function was/is implemented with some LP solver. Would it be possible to extend it to support returning all homomorphisms?

[dcoudert]

@dcoudert I am not sure if this is the right place to ask, if not, I will either email or resort to other channel(s): As continuation of this PR, I am working on some functionality related to homomorphism counting. I am aware that Sage already has has_homomorphism_to function, but it only returns one homomorphism even if multiple exist.

It seems that this function was/is implemented with some LP solver. Would it be possible to extend it to support returning all homomorphisms?

It's better to open a specific issue to discuss that. It is certainly possible.

[dcoudert]

Can you try to clean this PR. it has conflicts.

[guojing0]

@dcoudert I am not sure if this is the right place to ask, if not, I will either email or resort to other channel(s): As continuation of this PR, I am working on some functionality related to homomorphism counting. I am aware that Sage already has has_homomorphism_to function, but it only returns one homomorphism even if multiple exist.
It seems that this function was/is implemented with some LP solver. Would it be possible to extend it to support returning all homomorphisms?

It's better to open a specific issue to discuss that. It is certainly possible.

Done: #36717

[github-actions]

Documentation preview for this PR (built with commit 2df952d; changes) is ready! 🎉

[antonio-rojas]

This is causing a test failure on Arch:

File "/usr/lib/python3.11/site-packages/sage/graphs/graph_decompositions/tree_decomposition.pyx", line 1037, in sage.graphs.graph_decompositions.tree_decomposition.label_nice_tree_decomposition
Failed example:
    for node in sorted(label_TD):
        print(node, label_TD.get_vertex(node))
Expected:
    (0, {}) root
    (1, {0}) forget
    (2, {0, 1}) intro
    (3, {0}) forget
    (4, {0, 4}) join
    (5, {0, 4}) intro
    (6, {0, 4}) intro
    (7, {0}) forget
    (8, {0}) forget
    (9, {0, 3}) intro
    (10, {0, 2}) intro
    (11, {3}) intro
    (12, {2}) intro
    (13, {}) leaf
    (14, {}) leaf
Got:
    (0, {}) root
    (1, {0}) forget
    (2, {0, 4}) intro
    (3, {0}) forget
    (4, {0, 1}) join
    (5, {0, 1}) intro
    (6, {0, 1}) intro
    (7, {0}) forget
    (8, {0}) forget
    (9, {0, 2}) intro
    (10, {0, 3}) intro
    (11, {2}) intro
    (12, {3}) intro
    (13, {}) leaf
    (14, {}) leaf

[guojing0]

@antonio-rojas There's indeed a bug in this code, I have fixed it in #36846. Does the new PR fix your issue?

[antonio-rojas]

@antonio-rojas There's indeed a bug in this code, I have fixed it in #36846. Does the new PR fix your issue?

No, I'm getting the exact same failure with #36846

[dcoudert]

@guojing0, can you modify the test in #36846 to make it more robust (may be using a smaller graph). We can always decide to add it tag # random or # not tested..
Take also the opportunity to double check that labels are correctly set.

[guojing0]

@dcoudert Done in #36846, also use the claw instead of $K_{1, 4}$.