Polynomial-delay generation of functional digraphs up to isomorphism

TL;DR

This paper presents a polynomial-delay, linear-space algorithm for generating all functional digraphs up to isomorphism, including connected and disconnected cases, useful for combinatorial enumeration and dynamical systems analysis.

Contribution

It introduces a novel reverse search algorithm for efficiently generating functional digraphs up to isomorphism with polynomial delay and linear space complexity.

Findings

Generates functional digraphs with O(n^2) delay

Handles both connected and disconnected digraphs

Operates with linear space complexity

Abstract

We describe a procedure for the generation of functional digraphs up to isomorphism; these are digraphs with uniform outdegree 1, also called mapping patterns, finite endofunctions, or finite discrete-time dynamical systems. This procedure is based on a reverse search algorithm for the generation of connected functional digraphs, which is then applied as a subroutine for the generation of arbitrary ones. Both algorithms output solutions with $O(n^2)$ delay and require linear space with respect to the number $n$ of vertices.

Equations

$$\mathrm{code}T=⟨|V|⟩{}^{⌢}\mathrm{code}{T}_1{}^{⌢}\cdots {}^{⌢}\mathrm{code}{T}_k$$

$$\mathrm{code}C=⟨\mathrm{code}{T}_1,\dots ,\mathrm{code}{T}_k⟩$$

$$⟨\mathrm{code}{T}_1,\dots ,\mathrm{code}{T}_k⟩\le ⟨\mathrm{code}{T}_{1+(1+r)\mathrm{mod}k},\dots ,\mathrm{code}{T}_{1+(k+r)\mathrm{mod}k}⟩.$$

$$\displaystyle\operatorname{merge}{\langle T_{1},T_{2},\ldots,T_{k}\rangle}=\big{\langle}\textstyle\sum_{i=1}^{k}|T_{i}|\big{\rangle}{}^{\frown}T_{2}{}^{\frown}\cdots{}^{\frown}T_{k}.$$

$$⟨T_1,T_2,T_3⟩=⟨⟨1⟩,⟨1⟩,⟨1⟩⟩.$$

$$⟨\mathrm{merge}⟨T_1,T_2⟩,T_3⟩=⟨⟨2,1⟩,⟨1⟩⟩$$

$$\mathrm{unmerge}T=⟨T_1,\dots ,T_k⟩$$

$$C^{\prime }=⟨T_1,\dots ,T_{h-1}⟩{}^{⌢}\mathrm{unmerge}{T}_h{}^{⌢}⟨T_{h+1},\dots ,T_k⟩$$

$$\mathrm{unmerge}{T}_h=⟨S_1,\dots ,S_{\ell }⟩$$

$$C_{\ell ,r}=⟨T_1,\dots ,T_{\ell -1},\mathrm{merge}⟨T_{\ell },\dots ,T_r⟩,T_{r+1},\dots ,T_k⟩$$

$$\displaystyle\operatorname{merges}{C}=\left\{C_{\ell,r}\middle|\begin{array}[]{c}1\leq\ell<r\leq k,\text{tree }T_{\ell}\text{ is trivial,}\\ \langle T_{\ell},\ldots,T_{r}\rangle\text{ is lexicographically nondecreasing,}\\ C_{\ell,r}\text{ is in canonical form, and }\operatorname{c-unmerge}C_{\ell,r}=C\end{array}\right\}.$$

$$⟨⟨1⟩,⟨2,1⟩,⟨3,2,1⟩⟩$$

$$=⟨⟨1⟩,⟨2,1⟩,\mathrm{merge}⟨⟨1⟩,⟨2,1⟩⟩⟩.$$

$$C_1=⟨⟨1⟩,⟨1⟩,⟨1⟩,⟨1⟩⟩$$

$$\displaystyle\operatorname{merges}{C_{1}}=\big{\{}\langle\langle 4,1,1,1\rangle\rangle,\langle\langle 1\rangle,\langle 3,1,1\rangle\rangle,\langle\langle 1\rangle,\langle 1\rangle,\langle 2,1\rangle\rangle\big{\}},$$

$$C_2=⟨⟨1⟩,⟨1⟩,⟨2,1⟩⟩$$

$$C_3=⟨⟨1⟩,⟨3,2,1⟩⟩$$

$$C_4=⟨⟨4,3,2,1⟩⟩$$

$$C_5=⟨⟨2,1⟩,⟨2,1⟩⟩$$

$$C_6=⟨⟨4,1,2,1⟩⟩$$

$$C_7=⟨⟨1⟩,⟨3,1,1⟩⟩$$

$$C_8=⟨⟨4,3,1,1⟩⟩$$

$$C_9=⟨⟨4,1,1,1⟩⟩$$

$$\max (\mathrm{merges}\underset{\text{n times}}{\underbrace{⟨⟨1⟩,\dots ,⟨1⟩⟩}})=⟨⟨n,\underset{\text{n−1 times}}{\underbrace{1,\dots ,1}}⟩⟩.$$

$$\mathrm{merges}\underset{\text{n times}}{\underbrace{⟨⟨1⟩,\dots ,⟨1⟩⟩}}=\left\{\begin{array}{c}⟨\underset{\text{n−2 times}}{\underbrace{⟨1⟩,\dots ,⟨1⟩}},⟨2,1⟩⟩,⟨\underset{\text{n−3 times}}{\underbrace{⟨1⟩,\dots ,⟨1⟩}},⟨3,1,1⟩⟩,\\ \dots ,\\ ⟨⟨1⟩,⟨n-1,\underset{\text{n−2 times}}{\underbrace{1,\dots ,1}}⟩⟩,⟨⟨n,\underset{\text{n−1 times}}{\underbrace{1,\dots ,1}}⟩⟩\end{array}\right\}$$

$$C=\min \{M\in \mathrm{merges}U:M>A\}$$

$$C=\min \{M\in \mathrm{merges}(c-unmergeC):M>A\}$$

$$A=\max \{M\in \mathrm{merges}(c-unmergeC):M<C\}$$

$$C=\min \{M\in \mathrm{merges}U:M>c-unmergeA\}$$

$$C=\min \{M\in \mathrm{merges}(c-unmergeC):M>c-unmergeA\}$$

$$c-unmergeA=\max \{M\in \mathrm{merges}(c-unmergeC):M<C\}.$$

Full text

1 Introduction and motivation

A finite, discrete-time dynamical system $(A,f)$, called in the following just a dynamical system for brevity, is simply a finite set $A$ of states together with a function $f\colon A\to A$ describing the evolution of the system in time. A dynamical system can be equivalently described by its transition digraph, which has $V=A$ as its set of vertices and $E=\{(a,f(a)):a\in A\}$ as its set of arcs, that is, each state has an outgoing edge pointing to the next state. Since the dynamical systems we are dealing with are deterministic, their transition digraphs are all and only the digraphs having uniform outdegree $1$, that is, functional digraphs.

The synchronous execution of two dynamical systems $A$ and $B$ gives a dynamical system $A\otimes B$, whose transition digraph is the direct product [8] of the transition digraphs of $A$ and $B$. This product, together with a disjoint union operation of sum, gives a semiring structure over dynamical systems up to isomorphism [6] with some interesting algebraic properties, notably the lack of unique factorisation into irreducible digraphs. In order to develop the theory of the semiring of dynamical systems, it is useful to be able to find examples and counterexamples to our conjectures, and this often requires us to be able to efficiently generate all functional digraphs of a given number $n$ of vertices up to isomorphism. Remark that the number of non-isomorphic functional digraphs over $n$ vertices (sequence A001372 on the OEIS [13]) is exponential, asymptotically $c\times d^{n}/\sqrt{n}$ for some constants $c$ and $d>1$ [12]; as a consequence, the kind of efficiency we must look for is the ability to generate the first output in polynomial time, and the delay between consecutive outputs must be polynomial as well.

Since the outdegree of each vertex is exactly $1$ and the number of vertices is finite, the general shape of a functional digraph is a disjoint union of connected components, each consisting of a limit cycle $\langle v_{1},\ldots,v_{k}\rangle$, where the vertices $v_{1},\ldots,v_{k}$ are the roots of $k$ directed unordered rooted trees (simply referred to as trees in the following), with the arcs pointing towards the root.

Enumeration and generation problems for some classes of graphs have been analysed in the literature. For instance, efficient isomorphism-free generation algorithms for rooted, unordered trees are well known, even requiring only amortised constant time [1], and there exist polynomial delay algorithms for the isomorphism-free generation of undirected graphs [7]. More general techniques for the generation of combinatorial objects have been described by McKay [10]. For a practical implementation of generators for several classes of graphs we refer the reader to software such as nauty and Traces [11].

However, the class of functional digraphs does not seem to have been considered yet from the point of view of efficient generation algorithms. Here we first propose a $O(n^{3})$-delay algorithm for the generation of connected functional digraphs, based on an isomorphism code (which avoids generating multiple isomorphic digraphs) and on a novel approach where the successor of the current digraph is obtained by merging trees having adjacent roots along the limit cycle. This algorithm is then used as a subroutine in order to generate all, non necessarily connected functional digraphs with the same $O(n^{3})$ delay.

2 Isomorphism codes for connected functional digraphs

In order to avoid generating multiple isomorphic functional digraphs, we first define a canonical representation based on an isomorphism code, which would also allow us to check in polynomial time whether two given functional digraphs are isomorphic when given by another representation (e.g., adjacency lists or matrices)111Since functional digraphs are planar, they can actually be checked for isomorphism in linear time [4] or in logarithmic space [5]..

Isomorphism codes for unordered rooted trees (which can be taken as directed with the arcs pointing towards the root, as is needed in our case) are well known in the literature; for instance, level sequences (sequences node depths given by a preorder traversal of the tree, arranged in lexicographic order) can be used for this purpose [1]. Here we adopt a solution described by Valiente [15], which has the additional property that the isomorphism code of a subtree is itself a valid tree isomorphism code.

Definition 1 (code of a tree).

Let $T=(V,E)$ be a tree. Then, the isomorphism code of $T$ is the sequence of integers

[TABLE]

where $T_{1},\ldots,T_{k}$ are the immediate subtrees of $T$, i.e., the subtrees having as roots the predecessors of the root of $T$, arranged in lexicographically nondecreasing order of code, and ⌢ denotes sequence concatenation. In particular, if $|V|=1$, i.e., if $T$ only consists of the root, then $\operatorname{code}{T}=\langle 1\rangle$.

For simplicity, in the rest of the paper, we identify a tree with its own code, i.e., we often write $T$ instead of $\operatorname{code}{T}$. Furthermore, we denote the number of vertices of a tree $T$ with the symbol $|T|$.

Since a connected functional digraph consists of a sequence of trees arranged along a cycle, and all rotations of the sequence are equivalent, we choose a canonical one as its isomorphism code.

Definition 2 (code of a connected functional digraph).

The isomorphism code of a connected functional digraph $C=(V,E)$ is the lexicographically minimal rotation

[TABLE]

of the sequence of isomorphism codes of its trees taken in order along the cycle, i.e., such that for all integer $r$ we have

[TABLE]

For brevity, we refer to connected functional digraphs as components and, as with trees, we identify a component $C$ with its own code. A valid code for a component $C$ is also called a canonical form of $C$; unless otherwise specified, in the rest of the paper we consider all components to be in canonical form. By $|C|$ we denote the number of vertices of component $C$.

Isomorphism codes for arbitrary (i.e., non necessarily connected) functional digraphs will be defined later, in Section 4.

3 Generation of connected functional digraphs

The enumeration of connected functional digraphs is based on the following tree merging operation, to be applied to at least two trees (with the first being trivial, i.e., only having a root node) adjacent along the cycle.

Definition 3 (tree merging).

Let $\langle T_{1},T_{2},\ldots,T_{k}\rangle$ be a sequence of trees such that $T_{1}$ is trivial. Then $\operatorname{merge}{\langle T_{1},T_{2},\ldots,T_{k}\rangle}$ is the tree obtained by connecting $T_{2},\ldots,T_{k}$ as immediate subtrees of $T_{1}$.

This operation could, in principle, be applied even if $T_{1}$ has more than one node, by adding $T_{2},\ldots,T_{k}$ as immediate subtrees to the root of $T_{1}$; however, as will be proved later, this is not needed for our purposes.

The following is an immediate consequence of the definition of the merging operation:

Proposition 1.

Let $\langle T_{1},T_{2},\ldots,T_{k}\rangle$ be a lexicographically nondecreasing sequence of trees with $T_{1}$ trivial. Then

[TABLE]

Notice that, even when starting from a valid component code and even when applying it to a lexicographically nondecreasing sequence of trees, this tree merging operation might produce invalid codes.

Example 1.

Consider the following component:

[TABLE]

By merging $T_{1}$ and $T_{2}$ we obtain

[TABLE]

which is not a valid code, since the rotation $\langle\langle 1\rangle,\langle 2,1\rangle\rangle$ is strictly inferior in lexicographic order.

It is thus necessary to check whether a code obtained by merging a nondecreasing sequence of adjacent trees of a component is indeed a valid code.

We can also define an inverse unmerging operation on trees.

Definition 4 (tree unmerging).

Given a tree $T$, we say that

[TABLE]

if and only if $\operatorname{merge}{\langle T_{1},\ldots,T_{k}\rangle}=T$.

Notice that there is only one way to unmerge a tree, i.e., detaching its immediate subtrees and putting them in a sequence after the trivial tree (i.e., the former root), and thus $\operatorname{unmerge}$ is indeed a well-defined function.

We can prove that unmerging trees in a component in canonical form in a left-to-right fashion always gives another canonical form.

Lemma 1.

Let $C=\langle T_{1},\ldots,T_{k}\rangle$ be a component in canonical form, and let $T_{h}$ be the leftmost nontrivial tree of $C$. Then

[TABLE]

is also a canonical form, i.e., it is the minimum of its own rotations, and contains strictly more trees than $C$. We call the resulting component $C^{\prime}$ the component-unmerge of $C$, in symbols $\operatorname{c-unmerge}{C}$.

Proof.

By hypothesis, $C$ begins with a sequence $\langle T_{1}\ldots,T_{h-1}\rangle$ of trivial trees of length $h-1$. The unmerging of $T_{h}$ has the form

[TABLE]

where $S_{1}$ is trivial. As a consequence, $C^{\prime}$ begins with a maximal sequence $X$ of trivial trees of length at least $h$: the original ones $\langle T_{1},\ldots,T_{h-1}\rangle$, together with $S_{1}$, obtained by detaching the root of $T_{h}$, and possibly other trivial trees following $S_{1}$.

A rotation of $C^{\prime}$ that is strictly inferior to $C^{\prime}$ would have to have another sequence $Y$ of trivial trees with $|Y|\geq|X|$ and $Y$ separated from $X$, i.e., with at least one intervening nontrivial tree. Such sequence $Y$ did not already exist in $C$, because otherwise the rotation of $C$ starting with $Y$ would be strictly less than $C$, contradicting the hypothesis that $C$ is a minimal rotation.

As a consequence, the supposed sequence $Y$ of trivial trees would have to be generated by the unmerging of $T_{h}$. But all trivial trees in $\operatorname{unmerge}T_{h}$ occur at the beginning of the sequence, since the subtrees of a tree are always sorted lexicographically, and are thus adjacent to the trivial trees $\langle T_{1}\ldots,T_{h-1},S_{1}\rangle$. As a consequence, $C^{\prime}$ is the minimal rotation and thus a canonical form.

Since the unmerging of any nontrivial tree produces at least two trees, the digraph $C^{\prime}$ has strictly more trees than $C$, which completes the proof. ∎

We can now define the set of merges of a given component.

Definition 5.

Let $C=\langle T_{1},\ldots,T_{k}\rangle$ be a component and let

[TABLE]

for $1\leq\ell<r\leq k$. Then, we denote the set of possible merges of $C$ by

[TABLE]

Notice that, since $\operatorname{c-unmerge}$ is a function, for distinct components $C_{1}$ and $C_{2}$ we always have $\operatorname{merges}C_{1}\cap\operatorname{merges}C_{2}=\varnothing$.

Example 2.

If we did not require $\operatorname{c-unmerge}C_{\ell,r}=C$ in Definition 5, the sets of merges of two distinct components would not be necessarily disjoint; for instance, both $\langle\langle 1\rangle,\langle 1\rangle,\langle 1\rangle,\langle 3,2,1\rangle\rangle$ and $\langle\langle 1\rangle,\langle 2,1\rangle,\langle 1\rangle,\langle 2,1\rangle\rangle$ would share an element:

[TABLE]

3.1 Algorithm for the generation of connected functional digraphs

We can now describe an algorithm generating all components over $n$ vertices by exploiting the notion of merging adjacent trees along the limit cycle.

Algorithm 1** (successor of a component).**

On input $C=\langle T_{1},\ldots,T_{k}\rangle$ with $|C|=n$ vertices:

1. LABEL:enumialg:connected-no-repetitions.1

If $\operatorname{merges}C\neq\varnothing$, then return $\min(\operatorname{merges}C)$. Otherwise go to step alg:connected-no-repetitions.2. 2. LABEL:enumialg:connected-no-repetitions.2

If all trees of $C$ are trivial, then go to step alg:connected-no-repetitions.3. Otherwise let $U=\operatorname{c-unmerge}{C}$ and, if the set $\{M\in\operatorname{merges}U:M>C\}$ is nonempty, then return the minimum of such set. Otherwise, set $C:=U$ and repeat step alg:connected-no-repetitions.2. 3. LABEL:enumialg:connected-no-repetitions.3

Return \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n+1~{}times}}, the first component over $n+1$ vertices.

Let us show the execution of Algorithm 1 on an example.

Example 3.

Let us compute all $9$ components over $n=4$ vertices. We begin with the cycle of length $n$:

[TABLE]

The set of merges of $C_{1}$ is

[TABLE]

The sequences $\langle\langle 2,1\rangle,\langle 1\rangle,\langle 1\rangle\rangle,\langle\langle 3,1,1\rangle,\langle 1\rangle\rangle$, and $\langle\langle 1\rangle,\langle 2,1\rangle,\langle 1\rangle\rangle$, while obtained by merging adjacent trees of $C_{1}$, are not valid codes of components, since they are not in canonical form (i.e, they are not their own minimal rotation).

In order to compute the next component, we take the lexicographically minimal $C_{2}\in\operatorname{merges}{C_{1}}$, namely

[TABLE]

We repeat this procedure twice, taking the minimum $C_{3}$ of $\operatorname{merges}C_{2}$ and $C_{4}$ of $\operatorname{merges}C_{3}$:

[TABLE]

We can not repeat these steps any further, since $\operatorname{merges}{C_{4}}=\varnothing$. Therefore, we compute $C_{3}=\operatorname{c-unmerge}{C_{4}}$ and try to obtain the lexicographically minimal $C_{5}$ such that $C_{5}\in\operatorname{merges}{C_{3}}$ and $C_{5}>C_{4}$. Such $C_{5}$ does not exist, since $C_{4}$ is the only element in $\operatorname{merges}{C_{3}}$, therefore we repeat the same process with $C_{2}=\operatorname{c-unmerge}{C_{3}}$. We try to obtain the lexicographically minimal $C_{5}$, such that $C_{5}\in\operatorname{merges}{C_{2}}$ and $C_{5}>C_{3}$. Indeed, such $C_{5}$ exists:

[TABLE]

Since $\operatorname{merges}{C_{5}}=\varnothing$, we try to obtain the lexicographically minimal component $C_{6}$ such that $C_{6}\in\operatorname{merges}{(\operatorname{c-unmerge}{C_{5}})}=\operatorname{merges}{C_{2}}$ and $C_{6}>C_{5}$. We obtain:

[TABLE]

We have $\operatorname{merges}{C_{6}}=\varnothing$ and there does not exist $C_{7}$ such that $C_{7}>C_{6}$ and $C_{7}\in\operatorname{merges}{C_{2}}$. Then, we look for $C_{7}$ as the next component such that $C_{7}\in\operatorname{merges}{(\operatorname{c-unmerge}{C_{2}})}=\operatorname{merges}{C_{1}}$ and $C_{7}>C_{2}$. Such $C_{7}$ exists:

[TABLE]

We compute the minimal of its merges:

[TABLE]

Since $C_{8}$ is the only element of $\operatorname{merges}{C_{7}}$, we compute $C_{9}\in\operatorname{merges}{(\operatorname{c-unmerge}{C_{7}})}=\operatorname{merges}{C_{1}}$ and $C_{9}>C_{7}$. Such $C_{9}$ exists:

[TABLE]

Here the generation for $n=4$ vertices halts, since $\operatorname{merges}C_{9}=\varnothing$ and $C_{9}$ is the lexicographic maximum of $\operatorname{merges}C_{1}$.

3.2 Proof of correctness

In this section we prove the correctness of Algorithm 1.

Lemma 2.

For each $n$ we have

[TABLE]

Proof.

For $n=1$ we have $\operatorname{merges}{\langle\langle 1\rangle\rangle}=\varnothing$ , i.e, there are no possible merges. For $n>1$

[TABLE]

All the other tree merges do not give valid codes, since they are not lexicographically minimal rotations. Indeed, the largest element in lexicographical order in this set is the only one that starts with $n$ and not $\langle 1\rangle$. ∎

Lemma 3.

Let $C$ be a component generated by Algorithm 1. Then, all components in $\operatorname{merges}C$ are also generated by Algorithm 1.

Proof.

By induction, we prove that if the statement is true for components $C$ having less than $k$ trees (hypothesis 1), then it is true for components having $k$ trees.

Suppose that $C$ has $k$ trees. If $\operatorname{merges}C$ is empty, there is nothing to prove; suppose then that $\operatorname{merges}C=\{C_{1},\ldots,C_{m}\}$ in increasing lexicographic order. Then, on input $C$ Algorithm 1 outputs $\min(\operatorname{merges}C)=C_{1}$ in step alg:connected-no-repetitions.1. Let us prove that, assuming that $C_{i}$ has been generated (hypothesis 2), then $C_{i+1}$ is also generated.

Let $D_{0}=C_{i}$ and let $D_{j+1}=\max(\operatorname{merges}D_{j})$ for all $j$ such that $\operatorname{merges}D_{j}\neq\varnothing$. Let $D$ be the unique $D_{j}$ with $\operatorname{merges}D_{j}=\varnothing$. Then $D_{0}=C_{i}$ is generated by hypothesis 3.2, and each $D_{j+1}$ by hypothesis 3.2, since all the merges of a component $D_{j}$ have strictly less trees than $D_{j}$ itself (by Lemma 1 and Definition 5), and $D_{0}=C_{i}$ has strictly less than $k$ trees, since $C_{i}\in\operatorname{merges}C$. In particular $D$ is generated.

It only remains to show that Algorithm 1 outputs $C_{i+1}$ on input $D$. This is indeed the case in step alg:connected-no-repetitions.2, since each $D_{j+1}$ is $\max(\operatorname{merges}D_{j})$ and thus $\{M\in\operatorname{merges}D_{j}:M>D_{j+1}\}=\varnothing$. The only $D_{j}$ for which this set is not empty is $D_{0}=C_{i}$, and $\min\{M\in\operatorname{merges}C:M>C_{i}\}=C_{i+1}$ by our hypothesis on the lexicographic ordering of $\operatorname{merges}C$.

By induction, all elements of $\operatorname{merges}C$ are then generated, which proves the statement for components $C$ of $k$ trees; once again by induction, this shows that the statement holds for all $k$ and concludes the proof. ∎

Lemma 4.

Suppose that cycle \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}} is generated by Algorithm 1, and let $C=\langle T_{1},\ldots,T_{k}\rangle$ be a component with $|C|=n$ and $k<n$ trees. Then $C$ is also generated by Algorithm 1.

Proof.

By reverse induction on $k$. Since $k<n$, component $C$ has at least one nontrivial tree, and thus $C^{\prime}=\operatorname{c-unmerge}C$ exists. We still have $|C^{\prime}|=n$ and its number of trees $k^{\prime}$ is strictly larger than $k$. Then $C^{\prime}$ is generated, either because $k^{\prime}=n$ (and thus C^{\prime}=\underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}}), or because $k^{\prime}<n$ and thus the induction hypothesis applies. But then $C$ is also generated by Lemma 3, since $C\in\operatorname{merges}C^{\prime}$. ∎

Theorem 3.1.

If Algorithm 1 is applied repeatedly, zero or more times, starting from $\langle\langle 1\rangle\rangle$, then all components are generated in increasing order of number of vertices.

In particular, by repeatedly applying Algorithm 1 starting from the component C=\underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}}, i.e., the cycle of length $n$, and stopping before reaching \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n+1~{}times}}, then we obtain all components over $n$ vertices.

Proof.

It suffices to prove that all cycles \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}} are generated, and the result will then follow from Lemma 4. We prove that by induction on $n$. The cycle $\langle\langle 1\rangle\rangle$ is the initial component, and thus it is generated even before applying Algorithm 1.

Let $n>1$ and C=\langle\langle n-1,\underbrace{1,\ldots,1}_{\text{n-2~{}times}}\rangle\rangle. Then $|C|=n-1$; by induction hypothesis the cycle \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n-1~{}times}} is generated, and thus $C$ is also generated by Lemma 4. On input $C$, Algorithm 1 behaves as follows. No merge of $C$ at all can be performed in step alg:connected-no-repetitions.1, since there is only one tree. The algorithm in step alg:connected-no-repetitions.2 unmerges this tree, giving U=\underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n-1~{}times}}. Since $C=\max(\operatorname{merges}{U})$ by Lemma 2, the algorithm sets $C:=U$ and repeats step alg:connected-no-repetitions.2. Since all trees are now trivial, the algorithm returns \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}} in step alg:connected-no-repetitions.3.

In order to show that all components over $n$ vertices are obtained by repeated application of Algorithm 1 starting from \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}}, it suffices to notice that all components over $n$ vertices are generated after all components over $n-1$ vertices (if any) and before all components over $n+1$ vertices. Indeed, in steps alg:connected-no-repetitions.1 and alg:connected-no-repetitions.2 the number of vertices never changes, since the only operations are tree merging and unmerging; the only operation increasing the number of vertices happens in step alg:connected-no-repetitions.3, when we start generating larger components. ∎

The following lemma shows that the maximum number of iterations of step alg:connected-no-repetitions.2 is actually independent of the size of the component.

Lemma 5.

On input a component $C=\langle T_{1},\ldots,T_{k}\rangle$ such that $\operatorname{merges}{C}=\varnothing$, its successor is obtained by executing step alg:connected-no-repetitions.2 of Algorithm 1 at most twice.

Proof.

Since $\operatorname{merges}{C}=\varnothing$, trees $T_{1},\ldots,T_{k}$ are nontrivial, therefore the successor of $C$ is obtained either in step alg:connected-no-repetitions.2 or in step alg:connected-no-repetitions.3. We first compute $U=\operatorname{c-unmerge}C=\langle\langle 1\rangle,T^{\prime}_{2},\ldots,T^{\prime}_{k^{\prime}}\rangle$ by unmerging the leftmost nontrivial tree $T_{1}$ of $C$, which gives a trivial tree in the first position. If all other trees of $U$ are also trivial, then the successor is returned in step alg:connected-no-repetitions.3.

Otherwise, if the set $\{M\in\operatorname{merges}U:M>C\}$ is nonempty, then we return its minimum, and the successor of $C$ is thus obtained by executing step alg:connected-no-repetitions.2 of Algorithm 1 only once.

Otherwise, we set $C:=U=\langle\langle 1\rangle,T^{\prime}_{2},\ldots,T^{\prime}_{k^{\prime}}\rangle$ and repeat step alg:connected-no-repetitions.2 a second time. Now, by unmerging the leftmost nontrivial tree of $C$ we recompute $U=\langle\langle 1\rangle,\langle 1\rangle,T^{\prime\prime}_{3},\ldots,T^{\prime\prime}_{k^{\prime\prime}}\rangle$, which begins with at least two trivial trees (the second trivial tree is either $T_{2}^{\prime}$, or obtained by unmerging it). Then, there exists at least one component $M$ obtained from $U$ by merging adjacent trees, namely $M=\langle T\rangle$ with $T=\operatorname{merge}{\langle\langle 1\rangle,\langle 1\rangle,T^{\prime\prime}_{3},\ldots,T^{\prime\prime}_{k^{\prime\prime}}\rangle}$; furthermore, we have $M>C$ since $C$ begins with a trivial tree and $M$ with a nontrivial one. Then we return $M$ as the output of Algorithm 1. ∎

We still need to prove that no component is generated multiple times by Algorithm 1.

Lemma 6.

Algorithm 1 never outputs the same cycle C=\underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}} twice.

Proof.

The component $C=\langle\langle 1\rangle\rangle$ is never output by Algorithm 1, since it is not the merge of any component (and thus it is not generated in step alg:connected-no-repetitions.1 or alg:connected-no-repetitions.2) and it is too small to be generated in step alg:connected-no-repetitions.3.

All cycles of length $n>1$ are generated in step alg:connected-no-repetitions.3 from a smaller component: they can not be a result of merges in steps alg:connected-no-repetitions.1 or alg:connected-no-repetitions.2, since all their trees are trivial. The component $C=\langle\langle 1\rangle,\langle 1\rangle\rangle$ is thus generated in step alg:connected-no-repetitions.3 from a component of size $1$. But there is only one such component, namely $\langle\langle 1\rangle\rangle\langle\langle 1\rangle\rangle$.

Now let $n\geq 2$ and suppose that the cycle C=\underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n+1~{}times}} is generated by Algorithm 1 in step alg:connected-no-repetitions.3 from an input $A$. Then $\operatorname{merges}A=\varnothing$ (otherwise $C$ would be output in step alg:connected-no-repetitions.1), and thus $A$ cannot be a cycle, i.e., it has a nontrivial tree. Hence, Algorithm 1 does not immediately skip step alg:connected-no-repetitions.2. Then it must be the case that $A=\max(\operatorname{merges}(\operatorname{c-unmerge}A))$, since $C$ is not output in this step.

If step alg:connected-no-repetitions.2 is only executed once, then $\operatorname{c-unmerge}A$ only has trivial trees, that is, $\operatorname{c-unmerge}A$ is the cycle \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}}, and then A=\langle\langle n,\underbrace{1,\ldots,1}_{\text{n-1~{}times}}\rangle\rangle by Lemma 2.

If step alg:connected-no-repetitions.2 were executed exactly twice, that would imply that $\operatorname{c-unmerge}A$ has nontrivial trees, that $\operatorname{c-unmerge}A=\max(\operatorname{merges}(\operatorname{c-unmerge}(\operatorname{c-unmerge}A)))$, otherwise the algorithm would halt in step alg:connected-no-repetitions.2, and that $\operatorname{c-unmerge}(\operatorname{c-unmerge}A)$ only has trivial trees, that is, it is the cycle \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}}. Since \operatorname{c-unmerge}A=\max(\operatorname{merges}(\underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n~{}times}})), then by Lemma 2 \operatorname{c-unmerge}A=\langle\langle n,\underbrace{1,\ldots,1}_{\text{n-1~{}times}}\rangle\rangle. But then $\operatorname{merges}(\operatorname{c-unmerge}A)=\varnothing$, which is impossible because at least $A\in\operatorname{merges}(\operatorname{c-unmerge}A)$.

Step alg:connected-no-repetitions.2 is never executed more than twice by Lemma 5, which implies that there is only one input $A$ for Algorithm 1 giving output $C$. ∎

Lemma 7.

Let $C$ be a component with at least one nontrivial tree. Then, it is impossible for Algorithm 1 to generate $C$ twice, once in step alg:connected-no-repetitions.1 and once in step alg:connected-no-repetitions.2.

Proof.

By contradiction, suppose that $C$ is generated on input $A$ in step alg:connected-no-repetitions.1. Then we have $C=\min(\operatorname{merges}A)$, and thus in particular $C\in\operatorname{merges}A$.

Suppose that $C$ is also generated on input $B$ in step alg:connected-no-repetitions.2. Then $C\in\operatorname{merges}(\operatorname{c-unmerge}D)$ for some $D$, but $C>D$ in lexicographic order. Since $D\in\operatorname{merges}(\operatorname{c-unmerge}D)$, we have $C\neq\min(\operatorname{merges}(\operatorname{c-unmerge}D))$.

Since the sets of merges of distinct components are disjoint, necessarily $A=\operatorname{c-unmerge}D$. But then $C$ is simultaneously the minimum and not the minimum of $\operatorname{merges}A$, which is a contradiction. ∎

Lemma 8.

Let $C$ be a component with at least one nontrivial tree. Then, it is impossible for Algorithm 1 to generate $C$ twice in step alg:connected-no-repetitions.1.

Proof.

Suppose that $C$ is generated from both inputs $A$ and $B$ in step alg:connected-no-repetitions.1. Then $C=\min(\operatorname{merges}A)$ and $C=\min(\operatorname{merges}B)$. But then $C\in\operatorname{merges}A\cap\operatorname{merges}B$, which implies $A=B$. ∎

Lemma 9.

Let $C$ be a component with at least one nontrivial tree. Then, it is impossible for Algorithm 1 to generate $C$ twice in step alg:connected-no-repetitions.2.

Proof.

By Lemma 5, the output $C$ is generated either after one iteration of step alg:connected-no-repetitions.2, or after two.

If $C$ is generated from an input $A$ after only one iteration, then

[TABLE]

with $U=\operatorname{c-unmerge}A$. Since $C\in\operatorname{merges}U$, we also have $U=\operatorname{c-unmerge}C$, thus

[TABLE]

which implies

[TABLE]

which proves that $A$ only depends on $C$ and is thus unique.

On the other hand, if $C$ is generated from $A$ after two iterations, then

[TABLE]

with $U=\operatorname{c-unmerge}(\operatorname{c-unmerge}A)$. Since $C\in\operatorname{merges}U$, we also have $U=\operatorname{c-unmerge}C$, thus

[TABLE]

which implies

[TABLE]

Furthermore, we have $A=\max(\operatorname{merges}(\operatorname{c-unmerge}A))$, otherwise there would exist a component $M\in\operatorname{merges}(\operatorname{c-unmerge}A)$ with $M>A$, and Algorithm 1 would halt after only one iteration of step alg:connected-no-repetitions.2, a contradiction.

As a consequence, we have

[TABLE]

which only depends on $C$ and is thus unique. ∎

From Lemmas 6, 7, 8, and 9 we can finally prove that no duplicates whatsoever are generated.

Theorem 3.2.

Algorithm 1 never generates the same component multiple times (i.e., it computes an injective function). ∎

3.3 Complexity analysis

We can now prove that the proposed generation procedure has an $O(n^{3})$ delay between outputs.

Lemma 10.

Given a sequence of trees $\langle T_{1},\ldots,T_{k}\rangle$ with $n=|T_{1}|+\cdots+|T_{k}|$ total vertices, it is possible to check in $O(n)$ time if the sequence is its own minimal rotation, and thus the valid code of a component.

Proof.

Let $P=\langle 0\rangle{}^{\frown}T_{1}{}^{\frown}\langle 0\rangle{}^{\frown}T_{2}{}^{\frown}\cdots{}^{\frown}\langle 0\rangle{}^{\frown}T_{k}$ be the concatenation of the codes of the given trees, each prefixed with an extra $\langle 0\rangle$; remark that [math] is strictly less than any integer appearing in the code of a tree. Let $P^{\prime}$ be the minimal rotation of $P$; then $P^{\prime}$ must begin with 0, since it is the minimum element of the sequence, and thus $P^{\prime}=\langle 0\rangle{}^{\frown}U_{1}{}^{\frown}\langle 0\rangle{}^{\frown}U_{2}{}^{\frown}\cdots{}^{\frown}\langle 0\rangle{}^{\frown}U_{k}$, where each $U_{i}$ is one of the original trees $T_{j}$ and $\langle U_{1},\ldots,U_{k}\rangle$ is a rotation of $\langle T_{1},\ldots,T_{k}\rangle$.

We claim that $\langle U_{1},\ldots,U_{k}\rangle$ is, more specifically, the minimal rotation of $\langle T_{1},\ldots,T_{k}\rangle$. Otherwise, by contradiction, there would exist another rotation $\langle V_{1},\ldots,V_{k}\rangle<\langle U_{1},\ldots,U_{k}\rangle$. Let $V_{i}$ and $U_{i}$ be the leftmost trees such that $V_{i}\neq U_{i}$. Then

[TABLE]

since the two prefixes $U$ and $V$ are identical and $V_{i}<U_{i}$. But this contradicts the assumption that $P^{\prime}$ is the minimal rotation of $P$.

Then $P$ is its own minimal rotation if and only if $\langle T_{1},\ldots,T_{k}\rangle$ is a minimal rotation. Since $P$ is a sequence of integers, the former property can be checked in linear time by using a lexicographically minimal rotation algorithm, such as Booth’s [2, 3]. ∎

Theorem 3.3.

Algorithm 1 takes $O(n^{3})$ time, which is thus the delay for the generation of the successor of any components over $n$ vertices.

Proof.

Let $C=\langle T_{1},\ldots,T_{k}\rangle$ the input component.

• •

If the successor of $C$ generated by Algorithm 1 is obtained in step alg:connected-no-repetitions.1, then:

• –

Generation of $\operatorname{merges}{C}$ takes $O(n^{3})$ operations, since we go through all $\ell$ and $r$ such that $1\leq\ell<r\leq k$, where $k=n$ in the worst case, which takes $O(n^{2})$ operations. For each $\ell$ and $r$ we check if $T_{\ell}$ is trivial ($O(1)$ operations), if $\langle T_{\ell},\ldots,T_{r}\rangle$ is lexicographically nondecreasing ($O(n)$ operations), if $C_{\ell,r}$ is in canonical form, which takes $O(n)$ operations by Lemma 10, and if $\operatorname{c-unmerge}C_{\ell,r}=C$, which takes $O(n)$ operations. Therefore, overall this generation takes $O(n\cdot n^{2})=O(n^{3})$ operations, since $\operatorname{merges}{C}$ has $O(n^{2})$ elements ($k\leq n$ in Definition 5).

• –

In the end, we choose $\min(\operatorname{merges}C)$, which takes $O(n^{3})$ operations.

Therefore, the successor of $C$ obtained in step alg:connected-no-repetitions.1 is obtained with a $O(n^{3})$ delay.

• •

If the successor of $C$ generated by Algorithm 1 is obtained in step alg:connected-no-repetitions.2, then:

• –

Computing $U=\operatorname{c-unmerge}C$ takes $O(n)$ operations.

• –

Then, the generation of $\operatorname{merges}{U}$ takes $O(n^{3})$ operations, as previously discussed.

• –

Then, for each element $M$ of $\operatorname{merges}{U}$ we have to check if $M>C$, which takes $O(n)$ operations. Therefore, overall this verification takes $O(n\cdot n^{2})=O(n^{3})$ operations, since $\operatorname{merges}{U}$ has $O(n^{2})$ elements.

• –

In the end, we choose the minimum $M$ among the components remaining from the previous steps, if any exist, which takes $O(n^{3})$ operations.

• –

If such $M$ does not exist, we set $C:=U$ and repeat step alg:connected-no-repetitions.2.

By Lemma 5 step alg:connected-no-repetitions.2 is executed at most twice. Therefore, the successor of $C$ obtained in step alg:connected-no-repetitions.1 is obtained with a $O(n^{3})$ delay, which includes the operations of step alg:connected-no-repetitions.1.

• •

If the successor of $C$ generated by Algorithm 1 is obtained in step alg:connected-no-repetitions.3, then the delay is $O(n^{3})$ due to the execution of steps alg:connected-no-repetitions.1 and alg:connected-no-repetitions.2, since we simply need to create \underbrace{\langle\langle 1\rangle,\ldots,\langle 1\rangle\rangle}_{\text{n+1~{}times}}, the first component over $n+1$ vertices, which takes $O(n)$ extra time. ∎

4 Generation of arbitrary functional digraphs

We can now exploit Algorithm 1 as a subroutine in order to devise an efficient algorithm for the generation of arbitrary (non necessarily connected) functional digraphs. More precisely, like Algorithm 1, we will be able to compute the successor of a given functional digraph under some ordering. As a subroutine, we exploit an algorithm for generating partitions of an integer $n$ [9].

An arbitrary functional digraph can be represented by a sequence of its connected components. Since there is no intrinsic order among components, any permutation of the sequence would represent the same functional digraph; as a consequence, once again we choose a canonical permutation.

Definition 6 (code of a functional digraph).

Let $G=(V,E)$ be an arbitrary functional digraph having $m$ connected components $C_{1},\ldots,C_{m}$. Then, the isomorphism code of $G$ is the sequence

[TABLE]

where the connected components $C_{1},\ldots,C_{m}$ are in nondecreasing order of generation by means of Algorithm 1.

As usual, we identify a functional digraph $G$ with its own code and refer to it as a canonical form for $G$, and we denote its number of vertices by $|G|$.

Notice how the isomorphism code for a functional digraph resembles a PQ-tree, a data structure representing permutations of a given set of elements which, incidentally, is used to efficiently check isomorphic graphs of certain classes [4]. However, for our application we need to represent the equivalence of all permutations of the components $C_{1},\ldots,C_{m}$, as well as the equivalence of all rotations of the trees $T_{1},\ldots,T_{k}$ of a component $C_{i}$, and this latter condition is not represented directly in a PQ-tree.

For the generation of arbitrary functional digraphs, we modify the partition generation algorithm by Kelleher and O’Sullivan [9] in such a way that, if no further partition of $n$ exists, then the lexicographically minimum partition of $n+1$ is output.

Proposition 2 (Kelleher, O’Sullivan [9]).

There exists an algorithm that takes as input a partition of an integer $n$, represented by a sequence of nondecreasing integers, and returns the next partition of $n$ in lexicographic order (if there exists a next partition). ∎

Algorithm 2** (successor of an integer partition).**

On input a partition $P$ of the integer $n$, return the next partition of $n$ in lexicographic order, if any; if $P$ was the last partition of $n$, then return the first partition of $n+1$ in lexicographic order, i.e., $\underbrace{(1,1,\ldots,1)}_{n+1\text{ times}}$.

This allows us to formalise the generation of arbitrary functional digraphs.

Algorithm 3** (successor of an arbitrary functional digraph).**

On input $G=\langle C_{1},\ldots,C_{m}\rangle$, a functional digraph over $n$ vertices having components $C_{1},\ldots,C_{m}$:

1. LABEL:enumialg:successor-arbitrary.1

If there exists a component such that its successor given by Algorithm 1 has the same size, then let $C_{h}$ be the rightmost such component, and return

[TABLE]

where $C_{h}^{\prime}$ is the aforementioned successor of $C_{h}$ and, for all $i>h$, the component $C_{i}^{\prime}$ is a copy of $C_{h}^{\prime}$ if $|C_{i}|=|C_{h}^{\prime}|$; otherwise $|C_{i}|>|C_{h}^{\prime}|$, and then we let $C_{i}$ be the first component over $|C_{i}|$ vertices, i.e., the cycle of length $|C_{i}|$. 2. LABEL:enumialg:successor-arbitrary.2

If no such component exists, let $P=(|C_{1}|,\ldots,|C_{m}|)$ the partition of the integer $n$ corresponding to the sizes of the components of $G$, and let $Q=(q_{1},\ldots,q_{m^{\prime}})$ be the next partition according to Algorithm 2, then return $\langle C_{1}^{\prime},\ldots,C_{m^{\prime}}^{\prime}\rangle$, where each $C_{i}^{\prime}$ is the first component over $q_{i}$ vertices, i.e., the cycle of length $q_{i}$.

As an example, let us compute all $19$ functional digraphs over $4$ vertices.

Example 4.

We begin with $n=4$ self loops:

[TABLE]

In order to compute the next functional digraph, we try finding a component such that its successor given by Algorithm 1 has the same size. $G_{1}$ does not have such a component, since all the components are self loops, thus its successor $G_{2}$ is obtained by computing the successor of its partition via Algorithm 2. Let $P_{1}=(1,1,1,1)$ be the partition of $G_{1}$, then the partition of $G_{2}$ is $P_{2}=(p_{1},p_{2},p_{3})=(1,1,2)$. Each component $C_{i}$ of $G_{2}$ is the first component over $p_{i}$ vertices, i.e., the cycle of length $p_{i}$, thus

[TABLE]

Since $\langle\langle 1\rangle,\langle 1\rangle\rangle$ has a successor of the same size according to the Algorithm 1, the next generated digraph is

[TABLE]

There is no component of $G_{3}$ such that its successor given by Algorithm 1 has the same size, thus its successor $G_{4}$ must be obtained with the next partition $P_{3}=(1,3)$ where each component is the first generated component over corresponding number of vertices:

[TABLE]

Since $\langle\langle 1\rangle,\langle 1\rangle,\langle 1\rangle\rangle$ has a successor of the same size according to the Algorithm 1, the next generated digraph is

[TABLE]

As before, by taking a component with the successor of the same size twice we obtain two following digraphs:

[TABLE]

There is no component of $G_{7}$ such that its successor given by Algorithm 1 has the same size, thus its successor $G_{8}$ must be obtained with the next partition $P_{4}=(2,2)$ where each component is the first generated component over corresponding number of vertices:

[TABLE]

We take the rightmost component of $G_{8}$ that has a successor of the same size and we obtain the next generated digraph:

[TABLE]

By repeating the same step but putting a copy of the first component so that the obtained digraph is in canonical form, we generate

[TABLE]

There exists no component of $G_{10}$ such that its successor has the same size, therefore we move to the next partition $P_{5}=(4)$ and we return the digraph with the first component over $4$ vertices, i.e., the cycle of length $4$.

[TABLE]

By repeatedly taking the successor of the only component $\langle\langle 1\rangle,\langle 1\rangle,\langle 1\rangle,\langle 1\rangle\rangle$ we obtain all remaining functional digraphs over $4$ vertices, namely:

[TABLE]

Here the generation for $n=4$ vertices halts, since the successor of $\langle\langle 4,1,1,1\rangle\rangle$ has more than $4$ vertices, and there is no further partition of size $4$.

4.1 Proof of correctness

In order to prove the correctness of Algorithm 3, it is useful to first formalise the enumeration ordering it provides.

Definition 7.

Given two functional digraphs $G_{1}=\langle C_{1},\ldots,C_{m}\rangle$ and $G_{2}=\langle C_{1}^{\prime},\ldots,C_{m^{\prime}}^{\prime}\rangle$, their order is defined as follows. Let $P_{1}=(|C_{1}|,\ldots,|C_{m}|)$ and $P_{2}=(|C_{1}^{\prime}|,\ldots,|C_{m}^{\prime}|)$ be the partitions of $|G_{1}|$ and $|G_{2}|$ corresponding to the two digraphs.

• •

If $P_{1}$ precedes $P_{2}$ (resp., $P_{2}$ precedes $P_{1}$) by order of generation by Algorithm 2, then $G_{1}$ precedes $G_{2}$ (resp., $G_{2}$ precedes $G_{1}$).

• •

If $P_{1}=P_{2}$, then $G_{1}$ precedes $G_{2}$ (resp., $G_{2}$ precedes $G_{1}$) if it precedes it in the lexicographic order induced by the ordering of components given by Algorithm 1.

Lemma 11.

The order given by Definition 7 is a well-order on the set of functional digraphs.

Proof.

The order is total since, given functional digraphs $G_{1}$ and $G_{2}$, either they have different partitions, and thus are comparable according to the order of generation by Algorithm 2, or they have the same partition, and then they are comparable by the lexicographic order induced by Algorithm 1, which is total by Theorems 3.1 and 3.2.

This is a well-order since, given a set $S$ of functional digraphs, we can take the subset containing all digraphs having the minimal partition according to Algorithm 2 (this is also a well-order) and compare them by the lexicographic order induced by Algorithm 1 (another well-order) in order to find the minimum of $S$. ∎

Lemma 12.

On input a functional digraph $G=\langle C_{1},\ldots,C_{m}\rangle$ in canonical form, the output of Algorithm 3 is also in canonical form.

Proof.

Let $G^{\prime}$ be the output of Algorithm 3 on input $G$.

• •

If $G^{\prime}$ is obtained in step alg:successor-arbitrary.1, then it has the form

[TABLE]

The prefix $\langle C_{1},\ldots,C_{h-1}\rangle$ shared with $G$ is nondecreasing since $G$ is in canonical form. Since $C_{h}^{\prime}$ is the successor of $C_{h}$, this holds also for the prefix $\langle C_{1},\ldots,C_{h-1},C_{h}^{\prime}\rangle$. Immediately after we have zero or more copies of $C_{h}^{\prime}$, followed by a suffix consisting of larger minimal components (i.e., cycles) of nondecreasing sizes (since the partitions are nondecreasing sequences of integers), and this keeps the sequence in nondecreasing order of generation by Algorithm 1.

• •

If $G^{\prime}$ is generated in step alg:successor-arbitrary.2, then it consists of cycles of nondecreasing length, which is a canonical form. ∎

Lemma 13.

On input a functional digraph, Algorithm 3 outputs its immediate successor in the order of Definition 7.

Proof.

Let $G=\langle C_{1},\ldots,C_{m}\rangle$ be a functional digraph.

• •

If by applying Algorithm 3 on $G$ we obtain its successor $G^{\prime}$ in step alg:successor-arbitrary.1, then it has the form

[TABLE]

and it follows $G$ in the order of Definition 7 because the two digraphs share the same partition and $G^{\prime}$ is larger by lexicographic order, since the two digraphs share the same prefix $\langle C_{1},\ldots,C_{h-1}\rangle$ and $C_{h}^{\prime}$ is the successor of $C_{h}$ in the order given by Algorithm 1. Suppose that the functional digraph $H$ follows $G$ and precedes $G^{\prime}$ according to the order of Definition 7; then it also shares the same prefix $\langle C_{1},\ldots,C_{h-1}\rangle$; since no component is strictly between $C_{h}$ and $C_{h}^{\prime}$, the next component of $H$ is one of the two. If it is $C_{h}$, then $G$ and $H$ share the prefix $\langle C_{1},\ldots,C_{h}\rangle$, and since each component of the suffix $\langle C_{h+1},\ldots,C_{m}\rangle$ of $G$ is maximal among the components of the same size (otherwise $C_{h}$ would not be the rightmost component with a successor of the same size), then $H$ must share the same suffix, and thus $H=G$. If, on the other hand, the $h$-th component of $H$ is $C_{h}^{\prime}$, then it shares a prefix $\langle C_{1},\ldots,C_{h-1},C_{h}^{\prime}\rangle$ with $G^{\prime}$. Since each component $\langle C_{h+1}^{\prime},\ldots,C_{m}^{\prime}\rangle$ of the suffix of $G^{\prime}$ is minimal among the components of the same size, then $H$ must share the same suffix, and thus be identical to $G^{\prime}$. This shows that there exists no functional digraph $H$ strictly between $G$ and $G^{\prime}$, i.e., $G^{\prime}$ is the immediate successor of $G$ in the order of Definition 7.

• •

If $G^{\prime}$ is obtained in step alg:successor-arbitrary.2, then its partition $P^{\prime}$ immediately follows the partition $P$ of $G$ in the order given by Algorithm 2, thus $G^{\prime}$ follows $G$ in the order of Definition 7. There is no digraph $H$ strictly between $G$ and $G^{\prime}$ since $G$ is the last digraph having partition $P$, and $G^{\prime}$ is the first having partition $P^{\prime}$. ∎

Theorem 4.1.

All functional digraphs are obtained, in nondecreasing order by number of vertices, by applying Algorithm 3 zero or more times to the empty digraph. Algorithm 3 never generates two isomorphic functional digraphs (i.e., it computes an injective function).

Proof.

Since the order of Definition 7 is a well-order, and thus in particular a total order, by Lemma 11, and since Algorithm 3 outputs immediate successors by Lemma 13 according to that order, each functional digraph is reachable by consecutive applications of Algorithm 3. Once again by totality of the order and by Lemma 13, distinct inputs will produce distinct outputs, and since every output is in canonical form by Lemma 12, there will be no isomorphic duplicates. ∎

4.2 Complexity analysis

It is straightforward to prove the efficiency of Algorithm 3.

Theorem 4.2.

Algorithm 3 takes $O(n^{3})$ time, which is thus the delay for the generation of the successor of arbitrary functional digraphs over $n$ vertices.

Proof.

Let $G=\langle C_{1},\cdots,C_{m}\rangle$ be a functional digraph over $n$ vertices.

• •

If the successor of $G$ generated by Algorithm 3 in step alg:successor-arbitrary.1, then let $n_{1}=|C_{1}|,\ldots,n_{m}=|C_{m}|$ be the number of vertices of each component. We have $n=n_{1}+\cdots+n_{m}$. In the worst case we have to try to obtain a successor generated by Algorithm 1 for each component, but we always obtain a component of larger size except for $C_{1}$. This sequence of operations takes $O(n_{1}^{3})+\cdots+O(n_{m}^{3})$ time. Since $n_{1}^{3}+\cdots+n_{m}^{3}\leq(n_{1}+\cdots+n_{m})^{3}=n^{3}$, the output is generated in $O(n^{3})$ time.

• •

If the successor of $G$ generated by Algorithm 3 is obtained in step alg:successor-arbitrary.2, then the computation of the partition of $G$ takes linear time. The generation of the next partition according to Algorithm 2 and the construction of the cycles of the corresponding lengths also take linear time. Therefore, the output is generated in $O(n)$ time, plus the $O(n^{3})$ time spent in step alg:successor-arbitrary.1. ∎

5 Implementation

We provide a proof-of-concept implementation of the algorithms by means of the funkdigen command-line tool [14]. In its current version, it not yet meant to be an example of optimised software, but rather a straightforward and readable translation in Python 3 of the algorithms described in this paper, hopefully useful as a basis upon which a more efficient version may be developed. The funkdigen tools outputs connected or arbitrary functional digraph codes as described in Definitions 2 and 6.

6 Conclusions

We have described the first $O(n^{3})$-delay generation algorithm for the class of functional digraphs, both connected and arbitrary, which proves that these classes of graphs can be generated with a polynomial delay for each size $n$.

It is, of course, an open problem to establish if functional digraphs can be generated with a smaller delay. That would require us to somehow avoid testing $O(n^{2})$ possible merges in order to construct the next candidate digraph, and to avoid checking if it is its own minimal rotation at each iteration. Is an amortised constant time delay even possible?

Another line of research would be to describe a variation of this algorithm (based on merging adjacent trees) suitable for more general classes of graphs, without the uniform outdegree $1$ constraint. More generally, we hope that the techniques described in this paper can find application to other combinatorial problems.

Acknowledgements

Antonio E. Porreca was funded by his salary as a French State agent, and Ekaterina Timofeeva by the undergraduate internship program “Incubateurs de jeunes scientifiques” of Aix-Marseille Université and by the Agence National de la Recherche (ANR) project ANR-18-CE40-0002 FANs. Both authors are affiliated to Aix-Marseille Université, CNRS, LIS, Marseille, France.

We would like to thank Kellogg S. Booth, Jerome Kelleher, Brendan D. McKay, and Kévin Perrot for their useful suggestions and for providing some bibliographic references.