Given a set Σ of labels, a valence function val : Σ → ℤ₊ and a feature vector g of level K, find all (Σ, val)-labeled multitrees T such that f_K(T) = g and deg(v;T) = val(ℓ(v)) for all vertices v ∈ V(T).

Observe that a large number of chemical compounds contain a high proportion of hydrogens. Based on this fact, another model can be considered in the problem ETPF by removing all hydrogen atoms. These two different models were proposed by Fujiwara et al. 19 and Ishida 23.

In this paper, we consider the problem of enumerating all tree-like chemical graphs based on given upper and lower feature vectors because we want to relax the feature vector constraint in the problem ETPF. For feature vectors g₁ and g₂ of level K, we define g₁ ≤ g₂ to be g₁[t] ≤ g₂[t] for any label sequence t (|t| ≤ K). The problem of enumerating tree-like compounds from given two feature vectors can be formulated based on the problem ETPF as follows (see Fig. 2 for an illustration).

Given a set Σ of labels, a valence function val : Σ → ℤ₊ and feature vectors g_U and g_L of level K (g_L ≤ g_U), find all (Σ, val)-labeled multitrees T such that g_L ≤ f_K(T) ≤ g_U and deg(v;T) = val(ℓ(v)) for all vertices v ∈ V(T).

For the problem ETULF, we assume that g_L(ℓ) = g_U(ℓ) for an atom type ℓ ∈ Σ, where g(L) denotes the entry in g that corresponds to a label sequence L (thus g(ℓ) specifies the number of vertices of label ℓ) and that g_L(L) ≤ g_U(L) for any label sequence L (|L| ≥ 2).

Note that the number n of vertices is given by Σ_ℓ∈Σg(ℓ). To solve the problem ETULF, we start with an empty graph, and repeatedly extend the current tree T by appending a new vertex with each label ℓ ∈ Σ to obtain a valid tree (a tree that does not violate any constraints on output trees) one by one until we get n vertices. In order to avoid duplicate outputs, we follow the branch-and-bound framework of Fujiwara et al. 19, which first defines a canonical representation for isomorphic trees, and then lists them using the algorithm of Nakano and Uno 2021 (the branching operation) discarding invalid trees with some bounding operations. Since we cannot directly use the bounding operation proposed by Ishida et al. 22 due to upper and lower constraints, we introduce some new bounding operations.

In the problem ETULF, we cannot use the bounding operation proposed by Fujiwara et al. 19 directly due to upper and lower feature vectors, but we can introduce a bounding operation based on upper and lower feature vectors by modifying Fujiwara et al.’s work slightly.

Let T denote a current tree, f_K(T) denote the feature vector of T, g_u denote a given upper feature vector, and g_L denote a given lower feature vector. By the feature vector constraints in the problem ETULF, we check the following condition.

If T violates (1), then we discard T.

In addition, if |T| = n, then we check the following condition based on the constraint of upper and lower feature vectors.

If T violates (2), then we discard T.

This subsection describes the definition of detachment 18 and a new bounding operation based on it for the problem ETULF. Let G be a multigraph that may have self-loops, which represents the graph obtained from a chemical graph H by contracting the vertices with the same label into a single vertex, where each vertex in G corresponds a label in H (note that we do not eliminate any edges in H in contracting vertices to obtain G). A process of regaining H from G is described as follows. Given a function r : V(G) → ℤ₊, an r-detachment H of G is a multigraph obtained from G by splitting each vertex v ∈ V(G) into a set of r(v) copies of v, denoted by W_v = {v¹, v² …, v^r(v)}, so that each edge {u, v} ∈ E(G) joins some vertices uⁱ ∈ W_u and v^j ∈ W_v. Hence an r-detachment H of G is not unique in general. A self-loop {u, u} in G may be mapped to a self-loop {uⁱ,uⁱ} or a non-loop edge {uⁱ,u^j} in a detachment H of G. Note that, for all vertex pairs {u, v} ∈ V(G), the number of edges between subsets W_u and W_v in H is equal to that of edges between vertices u and v in G.

To obtain a chemical graph H as an r-detachment H of G, we need to specify the degree of vertices (with the same label) in H. For a function r : V(G) → ℤ₊, an r-degree specification is a set ρ of vectors for v ∈ V(G) such that

which is necessary for all the edges incident to vertex v in G to be assigned to split vertices vⁱ ∈ W_v completely. An r-detachment H of G is called a ρ-detachment if each v ∈ V satisfies

which is a requirement that each vertex v_i in H must have the prescribed degree . Figure 3 illustrates a ρ-detachment H for a graph G = (V, E) with V = {a, b, c}, a function r with r(a) = 4, r(b) = 3, r(c) = 1, and a degree specification ρ with ρ(a) = (2, 2, 3, 2), ρ(b) = (2, 3, 1), ρ(c) = (3). The next theorem gives a characterization of a multigraph G that admits a connected and loopless ρ-detachment.

Theorem 2 (Nagamochi 18) Let G = (V, E) be a multigraph, r : V → ℤ₊ and . Then G has a connected and loopless ρ-detachment H if and only if the following hold:

where r(X) = Σ _{v∈ X}r(v), c(G′) denotes the number of connected components of a graph G′, G – X denotes the graph obtained from a graph G by removing the vertices in X together with all edges incident to vertices in X, and d(A, B; G) denotes the number of edges (u, v) ∈ E with u ∈ A and v ∈ B.

Ishida et al. 22 proposed a bounding operation for the problem ETPF based on Theorem 2. However, we cannot use the bounding operation proposed by Ishida et al. for the problem ETULF due to upper and lower constraints. We now describe our new bounding operation based on detachments for the problem ETULF. The new bounding operation, called detachment-cut tests whether the current multitree T has a multitree that is consistent with given path frequencies among its descendants in the family tree, based on the difference between the feature vector f_K(T) and the input feature vectors g_U and g_L.

Let ℓ₁, ℓ₂, …, ℓ_s be input labels and g_U, g_L : Σ^{≤ K + 1} → ℤ₊ be feature vectors. Let r₀, …, r_h be the vertices in the rightmost path to which a new leaf can be appended and denote the number of vertices r_j (0 ≤ j ≤ h) with ℓ(r_j) = ℓ_i. For each label sequence t, #t denotes the number of paths P in T with ℓ(P) = t. From g_U, g_L, and T, we define new feature vectors and of level K = 1 to be

We next introduce a vertex with a new label ℓ_s+1 of valence h + 1 (for example, label A in Fig. 4), a graph G_U = (V_U, E_U) with a vertex set V_U = {v₁, …, v_s, v_s+1 | ℓ(v_i) = ℓ_i, 1 ≤ i ≤ s + 1} and edge set , and a graph G_L = (V_L,E_L) with a vertex set V_L = {v₁, …, v_s, v_s+1 | ℓ(v_i) = ℓ_i, 1 ≤ i ≤ s + 1} and edge set . Note that d({v_i}, {v_j}; G) means a multiplicity of the edge {v_i,v_j} in a graph G. The function r and degree specification ρ are defined to be

Using G_U, G_L, r, and ρ, we can check if a current multitree T violates (C4). We need to check whether none of the following two conditions is violated.

(a) .

(b) r(X) + c(G_U – X) – d(X, V_U; G_U) ≤ 1 (∀X ⊆ V_U, X ≠ ∅).

In the first condition, we check whether the number of the rest of bonds is large enough to satisfy the lower feature vector constraint. In the second condition, we check whether T has a connected and loopless descendant based on G_U and Theorem 2.

This subsection describes a new bounding operation based on multiplicity for the problem ETULF. Let g(ℓ) be the number of vertices with label ℓ ∈ Σ that are obtained from given the feature vector. Now we assume that g(ℓ) for all ℓ ∈ Σ are fixed in the problem ETULF. Then we can calculate the number of edges in output trees in the problem ETULF. Let n be the number of vertices in output trees. If we treat a multiple edge as a set of single edges, the number of edges e_m in an output tree is given by:

On the other hand, if we treat a multiple edge as a simple one, the number of edges e_s in an output tree is equal to n – 1 due to the tree-like constraint. Now we consider

which means that only M edges are used to construct multiple bonds in an output tree. Note that M ≥ 0. We calculate M from an input of the problem ETULF before the enumeration algorithm starts.

Let T = (V, E) be a multitree, and m_e denote the multiplicity of e ∈ E. The multiplicity M(T) of T is defined to be

Now we describe the multiplicity-cut based on M(T) and M.

Let T be the current rooted multitree in the branching operation, M(T) be the multiplicity of T, RP(T) = (r₀, r₁, …, r_k) be the rightmost path of T, T_i be the new rooted multitree obtained by appending a new leaf p to a vertex r_i (0 ≤ i ≤ k), and RP(T_i) be the rightmost path of T_i . The rightmost path RP(T_i) of T_i is updated by appending p to the end of RP(T) when a new leaf p is appended to r_i, that is, RP(T_i) = (r₀, r₁,…, r_i, p). Then we can determine the multiplicities of the edges {(r_j, r_{j – 1}), j = k, k – 1, …, i + 1} due to the valence constraint, at the same time, we update M(T_i). We denote the multiplicity of an edge (r_j, r_{j – 1}) in T_i by Mul(r_j, r_{j – 1} | T_i). When we update the multiplicity of the edge (r_j,r_{j – 1}), M(T_i) is updated as follows:

By the definition of M, a valid multitree T_i satisfies

If T_i violates (3), then we discard T_i . See Fig. 5 for an illustration of this.