1 Introduction

Counting problems, although intrinsically interesting, have applications in a wide range of different areas. For instance, when estimating the probability that a given graph remains connected (graph connectivity is fundamental in network reliability theory) or when a propositional formula needs to be probabilistically tested to be true. The estimation of such probabilities can be seen as a counting problem. Counting problems also arise naturally in Artificial Intelligence Research, when some methods are used in reasoning areas, such as computing the ‘degree of belief’ when ‘Bayesian belief networks’ are used [^{6}, ^{5}, ^{17}, ^{18}].

Counting has become an important area in theoretical computer science, even though it has received less attention than decision problems. There is a handful of counting problems in graph theory that can be solved exactly in polynomial time, and indeed an important line of research is to determine low-exponential upper bounds for the time complexity of hard counting problems.

An *edge cover* of a graph G is a subset of edges covering all nodes of G. The
problem of counting the number of edge cover sets of a graph, denoted as
#Edge_Covers, is a #P complete problem proven via the reduction from #Twice-SAT to
#Edge_Covers [^{4}]. Most of the research on the
subject has focused on approximate algorithms. In [^{2}], an approximation algorithm for counting edge covers on 3 regular
randomized graphs was presented.

More recently, in [^{13}] a fully polynomial time approximation scheme (FPTAS) for counting edge covers of simple graphs was proposed; same authors have extended the technique to tackle the weighted edge cover problem in [^{14}]. Additionally, the edge covering property was found interesting and relevant in various domains [^{7}, ^{15}, ^{16}]. The edge cover polynomial of a graph G is presented in [^{1}].

The edge cover problem is related to (perfect) matching, k-factor problems among others. The previous problems involve a set of edges satisfying local vertex constraints. For matching, it is at most one incident edge should be chosen compared to the edge cover problem in which at least one edge is chosen. For generic constraints, it is the Holant setting [^{10}, ^{11}], which has been studied for exact counting [^{9}, ^{11}, ^{8}].

In this paper, we present an exact algorithm for counting edge covers taking into account that there exists a polynomial time algorithm for non-intersecting cyclic graphs [^{15}]. Having said that, the technique is basically to reduce a simple graph into a sequence of non-intersecting cyclic graphs. The time complexity of the algorithm is also studied. Although, the complexity of our proposal remains exponential its complexity is smaller than the trivial 2^{(m−n)}, where m and n are the number of edges and vertices respectively of the input graph.

2 Preliminaries

A graph is a pair *G* = (*V*, *E*), where *V* is a set of *vertices* and *E* is a set of *edges* that associates pairs of vertices. The number of vertices and edges is denoted by *v*(*G*) and *e*(*G*), respectively. A *simple graph* is an unweighted, undirected graph containing no graph *loops* or multiple edges. Through the paper only *simple finite graphs* will be considered, where *G* is a *finite graph* if *n* = |*v*(*G*)| < ∞ and *m* = |*e*(*G*)| < ∞. A *simple cycle* in a simple graph is a set of vertices that can be arranged in a cyclic sequence in such a way that two vertices are adjacent if they are consecutive in the sequence, and are nonadjacent otherwise [^{3}]. A *cycle basis* is a minimal set of simple cycles such that any cycle can be written as the sum of the cycles in the basis. A graph is said to be *non-intersecting cyclic* if any pair of simple cycles are edge disjoints.

An *edge cover* of a graph *G* is a set of edges *C* ⊆ *E _{G}*, such that meets all vertices of

*G*. That is for any

*v*∈

*V*, it holds that

*E*∩

_{v}*C*≠ ∅ where

*E*is the set of edges incident to

_{v}*v*. The family of

*edge covers*for the graph

*G*will be denoted by 𝓔

*. The problem of computing the cardinality of 𝓔*

_{G}*is well known to be ♯P-complete problem.*

_{G}A *subgraph* of a graph *G* is a graph *G*′ = (*V*′, *E*′) such that *V*′ ⊆ *V* and *E*′ ⊆ *E*. If *e* ∊ *E*, *e* can simply be removed from graph *G*, yielding a subgraph denoted by *G*\*e*; this is obviously the graph (*V*, *E* − *e*). Analogously, if *v* ∈ *V*, *G*\*v* is the graph (*V* − *v*, *E*′) where *E*′ ⊆ *E* consists of the edges in *E* except those incident at *v*. A *spanning subgraph* is a subgraph computed by deleting a number of edges while keeping all its vertices covered, that is if *S* ⊂ *E* is a subset of *E*, then a spanning subgraph of *G* = (*V*, *E*) is a graph (*V*, *S* ⊆ *E*) such that for every *v* ∈ *V* it holds *E _{v}* ∩

*S*≠ ∅.

A *path* in a graph is a linear sequence of adjacent vertices, whereas a *cycle* in a graph *G* is a simple graph whose vertices can be arranged in a cyclic sequence in such a way that two vertices are adjacent if they are consecutive in the sequence, and are nonadjacent otherwise [^{3}]. The length of a path or a cycle is the number of its edges.

An *acyclic* graph is a graph that does not contain cycles. The connected acyclic graphs are called *trees*, and a connected graph is a graph that for any two pair of vertices there exists a path connecting them. The number of connected components of a graph *G* is denoted by *c*(*G*). It is not difficult to infer that in a tree there is a unique path connecting any two pair of vertices. Let *T*(*v*) be a tree *T* with root vertex *v*. The vertices in a tree with degree equal to one are called *leaves*.

2.1 The Cycle Space

A *cycle basis* is a minimal set of basic cycles such that any cycle can be written as the sum of the cycles in the basis [^{12}]. The sum of cycles *C _{i}* is defined as the subgraph

*C*

_{1}⊕ ⋯ ⊕

*C*, where the edges are those contained in an odd number of

_{k}*C*’s,

_{i}*i*∈ {1, …,

*k*} with

*k*∈ ℕ arbitrary. The aforementioned sum gives to the set of cycle or cycle space the structure of a vector space under a given field k. The dimension of the cycle space 𝒞 is dim

_{k}𝒞 = |𝓑| where 𝓑 is a basis for 𝒞. In particular, if

*G*is a simple graph the field is taken to be k = 𝔽

_{2}, which is the case concerning this paper. Thus the field 𝔽

_{2}will be used through the entire paper to describe cycle space of graphs.

3 Splitting Simple Graphs

The technique proposed in this paper, assumes that if the graph has cycles, it is always possible to calculate a cycle basis for the cycle space of the graph. The cycle basis to be considered in this paper can easily be constructed by using the well known depth first search algorithm (DFS) [^{3}]. The process of getting a spanning tree for *G* by DFS algorithm will be denoted by ⟨*G*⟩. By using depth first search a spanning tree or forest *T* = ⟨*G*⟩ can be constructed for any graph *G*. The cycle basis is the set of all cycles such that each of them consists of an edge in and the simple path in *T* connecting its two end vertices. The dimension of 𝒞* _{G}* is therefore .

3.1 Non-intersecting Cycle Graph or Basic Graphs

In this paper we define *basic graphs* or *non-intersecting cycle graphs* as those simple graphs *G* with dim 𝒞* _{G}* ≠ 0 in such a way that any pair of basic cycles are edge disjoints. Let 𝓑 = {

*C*

_{1}, …,

*C*} a basis for the cycle space 𝒞

_{k}*; if*

_{G}*C*= (

_{k}*V*,

_{k}*E*) let us define the sequence of intersections of the edge sets {

_{k}*E*} as

_{i}

for any *I _{p}* = {

*i*

_{1}, …,

*i*} {1, …,

_{p}*k*}, it is clear that for any permutation

*σ*∈

*S*; where

_{p}*S*is the symmetric group of permutations. The number of different terms to consider in Equation (3.1) is given by

_{p}*k*!/(

*k*−

*p*)!

*p*! which is the number of different combinations of the index set

*I*. Thus, we can establish the conditions of whether a graph

_{p}*G*has not an intersecting cycle basis. If the graph

*G*is not acyclic and

*B*

_{2}= ∅ then dim

*G*≥ 1 so

*G*is called a basic graph. Let

*e*∈

*E*be an edge and define

*n*as the maximum integer such that

_{e}*e*belongs to as many as

*n*edge sets

_{e}*E*. In other words,

_{i}*n*= max{

_{e}*p*|

*B*≠ ∅}.

_{p}3.2 Splitting a Graph into Basic Graphs

Computing edge covers for simple graphs lies on the idea of splitting a given graph *G* into acyclic graphs or basic graphs. It will be shown, that calculating edge covers for simple graphs can be reduced to the computation of edge covers for acyclic graphs or basic graphs thus being able to fully compute |𝓔* _{G}*|. The definition below describes in detail the process of splitting a graph into smaller graphs, which eventually leads to a decomposition of simple graphs into acyclic graphs or basic graphs.

**Definition 1** *For a given graph* *G* = (*V*, *E*),

*1. the split at vertex v*∈*V is defined as the graph G*⊣*v*= (*V*′,*E*′)*where**and**with w*′ ∉*V,**2. the subdivision operation at edge**e*=*uv*∈*E**is defined as the graph**G*⊥*e*= (*V*∪ {*z*}, (*E*−*e*) ∪ {*uz*,*zv*})*with**z*∉*V, and**z**can be written either as**u*_{v}*or**v*_{u}.*3. If**e*=*uv*∈*E**is an edge*,*G*/*e**will denote the resulting graph after performing the following operation*

*where* *S* = *E _{u}* ∪

*E*− {

_{v}*e*}

*. The subdivide operation*(

*G*\

*e*) ⊥

*S*

*means tacitly*(⋯((

*G*\

*e*) ⊥

*f*) ⊥

*g*⋯))

*where*

*f*,

*g*, … ∈

*S.*

Above definition can be easily extended to subsets *V′* = {*v*_{1}, …, *v _{r}*} ⊆

*V*,

*E*′ = {

*e*

_{1}, …,

*e*} ⊂

_{s}*E*, that is

*G*⊣

*V*′ = (⋯((

*G*⊣

*v*

_{1}) ⊣

*v*

_{2})⋯) ⊣

*v*; analogously,

_{r}*G*⊥

*E*′ = (⋯((

*G*⊥

*e*

_{1}) ⊥

*e*

_{2})⋯) ⊥

*e*. It must be noted, that the order on which the operations to obtain

_{s}*G*/

*e*are performed is unimportant as long as one keeps track of the labels used during the process.

**Example 1** *Consider the star graph* *W*_{4} *as presented in Figure 1.*

If *H*, *Q* are graphs not necessarily edge or vertex disjoint we define a formal union of *H* and *Q* as the graph *H* ⊔ *Q* by properly relabelling *V _{H}* and

*V*; this can be accomplished by defining

_{Q}*V*

_{H}_{⊔}

*= {(*

_{Q}*u*, 1) |

*u*∈

*H*} ∪ {(

*u*, 2) |

*u*∈

*Q*}. The edge set

*E*

_{H}_{⊔}

*could be defined as follows: if*

_{Q}*a*,

*b*∈

*V*

_{H}_{⊔}

*such that*

_{Q}*a*= (

*u*,

*i*),

*b*= (

*v*,

*j*) for some

*i*,

*j*∈ {1, 2} and

*u*,

*v*∈

*V*∪

_{H}*V*then

_{Q}*ab*∈

*E*

_{H}_{⊔}

*if and only if*

_{Q}*uv*∈

*E*∪

_{H}*E*and

_{Q}*i*=

*j*.

Others labeling systems might work out just fine, as long as they respect the integrity of graphs *H* and *Q*. To recover the original graphs, we define the projections *π _{X}*, as

*π*(

_{H}*H*⊔

*Q*) =

*H*and

*π*(

_{Q}*H*⊔

*Q*) =

*Q*; that is the projections

*π*revert the relabeling process to the original for both graphs

_{X}*H*and

*Q*.

**Definition 2** *Let* *G* = (*V*, *E*) *be a simple graph. Let us define the split operator* ⊔_{e}*as*

*(i) the graph*⊔=_{e}G*G*\*e*⊔*G*/*e, that is the graph**G**splits into the graph**G*\*e**and the graph**G*/*e**if**e*∈*E. If**e*∉*E**then*⊔=_{e}G*π*(_{G}*G*\*e*⊔*G*/*e*) =*π*(_{G}*G*⊔*G*) =*G.**(ii) if**H*,*Q**are arbitrary graphs then*⊔(_{e}*H*⊔*Q*) = ⊔⊔ ⊔_{e}H_{e}Q*with**e*∈*E*∪_{H}*E*_{Q}.

**Example 2** *Figure 2 shows an example of how a simple graph can be decomposed into acyclic or basic graphs.*

3.3 Edge Covering Sets for Simple Graphs

The following results summarize the main properties of the split operator ⊔* _{e}*, necessary for the calculation of the edge covering sets for simple graphs. The first result is regarding the dimension of the cycle spaces 𝒞

_{G}_{/}

*and 𝒞*

_{e}*for an edge*

_{G}*e*in the cotree of

*G*. The proposition is rather simple in the sense that the resulting graph after applying

*G*/

*e*its dimension must diminishes certain amount which allow us to conclude that the operator ⊔ will split the graph

*G*into non-intersecting cyclic graph.

**Proposition 3.1** *Let* *G* *be a simple graph*, *a cycle base*, *e* = *uv* ∈ *an edge in the cotree of* *G. If* *b _{e}* = |𝓑

*∪*

_{u}*|*

_{v}*where*

*= {*

_{u}*C*∈ 𝓑|

*u*∈

*C*}

*and*𝓑

*= {*

_{v}*C*∈ 𝓑|

*v*∈

*C*}

*then*

*b*+ dim 𝒞

_{e}

_{G}_{/}

*= dim*

_{e}

_{G}**Proof 1** *Every fundamental cycle containing either* *u* *or* *v* *must disappear under the operation* *G*/*e* *then those edges in* *that do not contain* *u* *or* *v* *are the only ones that contribute to the dimension of the graph* *G*/*e, therefore* dim 𝒞_{G}_{/}* _{e}* = dim 𝒞

*−*

_{G}*b*

_{e}.The proposition above allow us to explicitly calculate the number of connected components into which the graph *G*/*e* is being decomposed, on the other hand is providing a rather efficient way of testing whether or not *G*/*e* is a non-intersecting cyclic graph. The lemma below assumes that the graph in consideration is not connected, that is *G* has multiple connected components, thus we must consider a spanning forest for *G* instead of its spanning tree.

**Lemma 1** *Let* *G* = (*V*, *E*) *be a simple graph*, *F*, are *a spanning forest and its corresponding coforest for* *G, respectively; let us choose an edge* *e* = *uv* ∈ *E _{G}*

*and consider the split*⊔

_{e}G*of*

*G. If*

*a*= |(

_{e}*E*∪

_{u}*E*) ∩ |

_{v}*then*

*(i) If**e*∈*then**c*(*G*\*e*) =*c*(*G*)*and**c*(*G*/*e*) =*c*(*G*) +*d*(_{F}*u*) +*d*(_{F}*v*) +*a*−_{e}*b*− 3._{e}*(ii) It holds that*dim 𝒞_{G}_{\}= dim 𝒞_{e}− 1_{G}*and*dim 𝒞_{G}_{/}< dim 𝒞_{e}_{G}.*(iii) There exists a bijective map**ε*: 𝓔_{⊔}→ 𝓔_{eG},_{G}. That is*if**S**is an edge covering set for**G*\*e**or**G*/*e**then**ε*(*S*)*is an edge covering set for**G, which is equivalent to*𝓔= 𝓔_{G}_{G}_{\}∪_{e}*ε*(𝓔_{G}_{/})_{e}*. Thus*, |𝓔| = |𝓔_{G}_{G}_{\}| + |𝓔_{e}_{G}_{/}|._{e}

**Proof 2** *(i) For any forest* *F*, |*E _{F}*| = |

*V*| −

_{F}*c*(

*F*)

*. If*

*G*= ⊕

_{s}G_{s}, where*G*

_{s}*are the connected components of*

*G, a spanning forest*

*F*

*for*

*G*

*is a disjoint union*⊕

*T*

_{s}*such that*

*T*

_{s}*is an spanning tree for every component*

*G*

_{s}. If*e*∈ = ∪

_{s}_{ }

_{s}, where*=*

_{s}*E*−

_{Gs}*E*

_{Ts}, there exist*q*

*such that*

*e*∈

*,*

_{q}*e*∉

*E*

_{Gs}*and*

*G*\

_{s}*e*=

*G*

_{s}*with*

*s*≠

*q*

*and therefore*

*c*(

*G*\

_{q}*e*) =

*c*(

*G*)

_{q}*which immediately implies that*

*c*(

*G*\

*e*) =

*c*(

*G*).

*The operation* *G*/*e* *on* *G* *is clearly adding vertices and edges as follows:* |*V _{G}*

_{/}

*| = |*

_{e}*V*| + 2(

_{G}*d*(

_{G}*u*) +

*d*(

_{G}*v*)) − 6

*for vertices and*|

*E*

_{G}_{/}

*| = |*

_{e}*E*| +

_{G}*d*(

_{G}*u*) +

*d*(

_{G}*v*) − 3

*for edges. It is not difficult to check that for any graph*

*G*,

*c*(

*G*) = dim 𝒞

*− |*

_{G}*E*| + |

_{G}*V*|

_{G}*, as a consequence we also have*

*c*(

*G*/

*e*) = dim 𝒞

_{G}_{/}

*− |*

_{e}*E*

_{G}_{/}

*| + |*

_{e}*V*

_{G}_{/}

*|*

_{e}*. Since*

*T*

_{q}*is a spanning tree of G*dim 𝒞

_{q}, by Proposition (3.1)

_{Gq}_{/e}= dim 𝒞

*−*

_{Gq}*b*

_{e}*where*𝓑

*, the basis that defines*

*b*𝒞

_{e}, is the basis for the cycle space

_{Gq}; clearly we also have that*d*(

_{G}*u*) +

*d*(

_{G}*v*) =

*d*(

_{F}*u*) +

*d*(

_{F}*v*) +

*a*

_{e}*then*

*(ii) By definition of the cycle space*𝒞,_{Gs}_{s}*forms a vector basis for every**s, thus*dim 𝒞= ||_{Gs}*and since*|*E*| = |_{Ts}*V*| − 1_{Gs}*we have that*dim 𝒞= |_{Gs}*E*| − |_{Gs}*V*| + 1_{Gs}*. Now, if**e*∈*then**e*∈_{q}*for some**q; thus*dim 𝒞_{Gq}_{\}= |_{e}*E*_{Gq}_{\}| − |_{e}*V*_{Gq}_{\}| + 1,_{e}*but*|*E*_{Gq}_{\}| = |_{e}*E*| − 1_{Gq}*and*|*V*_{Gq}_{\}| = |_{e}*V*|_{Gq}*so we have that*dim 𝒞_{Gq}_{\}= dim 𝒞_{e}− 1_{Gq}*. On the other hand, since**G*= ⊕_{s}G_{s}*we have that**G*\*e*= [*G*\_{q}*e*] ⊕ ⊕_{s}_{≠}_{q}*Gs**and so a sum of cycle spaces*𝒞_{G}_{\}= 𝒞_{e}_{Gq}_{\}⊕ ⊕_{e}_{s}_{≠}𝒞_{q}_{Gs}*such that*

*It readily follows from Proposition (3.1) that* dim 𝒞_{Gq}_{/}* _{e}* = dim 𝒞

*−*

_{Gq}*b*

_{e}*where*

*b*

_{e}*as in Proposition (3.1) with*𝓑

*replaced by*𝓑

^{q}, the fundamental basis for graph*G*, b

_{q}. Now_{e}

*is always different form zero since*𝓑

^{q}

_{u}≠ ∅

*and*𝓑

^{q}

_{v}≠ ∅

*because they always contain the fundamental cycle formed by the edge*

*e. Thus*,

*If* *e* ∈ *T* *for some* *T* *in the forest then there must exists* *C* ∈ *B* *such that* *e* ∈ *C. The cycle* *C* *is destroyed under the operation* ⊔_{e}G*therefore* dim 𝒞_{⊔}* _{eG}* < dim 𝒞

_{G}.

*(iii) The family*𝓔_{G}*can be partitioned into two disjoint subfamilies of edge covering sets, that is*𝓡 = {*S*∈ 𝓔|_{G}*e*∈*S*}*then*𝓔= 𝓡 ∪ 𝓡_{G}^{c}. To build up the map*ε**we proceed as follows:**S*∈ 𝓡^{c}*if and only if**S*∈ 𝓔_{G}_{\}_{e}; this is because*G*\*e*⊆*G**thus any**S*∈ 𝓡^{c}*must be a subset of**E*_{G}_{\}_{e}*and vice versa. Therefore, we define**ε*|𝓡*c*=*id, where**id**is the identity map. Let**N*= {_{z}*z*}_{i}_{i}_{∈}_{Iz}*be the set of adjacent vertices to**z*,*I*_{z}*a set of indices of cardinality**d*_{G}_{\}(_{e}*z*)*where**z**is either**u**or**v. Let us define**Q*= {_{z}*z*′_{i}z}_{i}*and Q*′= {_{z}*z*′″_{i}z}_{i}*, thus any**S*∈ 𝓔_{G}_{/}_{e}*must necessarily contain the set**Q*′_{z}; if any*f*∈*Q*′_{z}*is not in**S**then**S**would not be an edge covering set because**z*″_{i}*will be an isolated vertex for some**i*∈*I*,_{z}. So*S*=*Q*′∪_{u}*Q*′∪_{v}*S*′*for some**S*′ ⊆*E*_{G}_{/}_{e}*such that**S*′ ∩*Q*′= ∅_{z}*for**z*=*u*,*v. Now if**R*∈ 𝓡*then**R*= {*e*} ∪*R*′*such that**e*∉*R*′*. Since*|*E*_{G}_{/}| = |_{e}*E*_{G}_{\}| +_{e}*d*_{G}_{\}(_{e}*u*) +*d*_{G}_{\}(_{e}*v*)*, and*|*E*_{G}_{/}−_{e}*Q*′∪_{u}*Q*′| = |_{v}*E*_{G}_{/}| − |_{e}*Q*′| − |_{u}*Q*′|_{v}*which implies that*|*E*_{G}_{/}−_{e}*Q*′∪_{u}*Q*′| = |_{v}*E*_{G}_{\}|_{e}*and therefore there exist a bijection**φ**between sets*𝒫(*E*_{G}_{/}−_{e}*Q*′∪_{u}*Q*′)_{v}*and*𝒫(*E*_{G}_{\})_{e}*since they are both finite. In fact*,*φ**can be chosen in such a way that if**Q*′∪_{u}*Q*′∪_{v}*S*′ ∈ 𝓔_{G}_{/}_{e}*then*{*e*} ∪*φ*(*S*′) ∈ 𝓡*and vice versa. Therefore*,*ε*(*Q*′∪_{u}*Q*′∪_{v}*S*′) = {*e*} ∪*φ*(*S*′)*and ε*^{−1}({*e*} ∪*R*′) =*Q*′∪_{u}*Q*′∪_{v}*φ*^{−1}(*R*′).

The family 𝓔_{G}_{\}* _{e}* accounts for those edge covering sets

*S*for

*G*on which

*e*∉

*S*whereas 𝓔

_{G}_{/}

*stands for those edge covering sets where*

_{e}*e*is always a member.

Let *S* ⊆ *E* be a subset of edges, from Definiton (2)(i) the split of *G* along *S*, denoted by ⊔* _{S}G*, is recursively defined in terms of the sequence of splits

*G*= ⊔

_{ij}

_{ei}G_{(}

_{i}_{−1)j}=

*G*

_{(}

_{i}_{−1)}

*\*

_{j}*e*⊔

_{i}*G*

_{(}

_{i}_{−1)}

*/*

_{j}*e*,

_{i}*i*∈ {1, ..., |

*S*|} in particular for

*i*= 1 we define

*G*

_{11}=

*G*

_{00}\

*e*

_{1}⊔

*G*

_{00}/

*e*

_{1 }where

*G*

_{00}=

*G*. By setting

*φ*(

*i*) = 2

^{i}^{−1}− 1 and for 0 ≤

*j*≤

*φ*(i) we have therefore,

To short up the notation, we make G** _{tj}* =

*G*

_{(}

_{t}_{−1)}

***

_{j}*e*, 𝓔

_{t}*= 𝓔*

_{tj}*and 𝓔**

_{Gtj}*= 𝓔*

_{tj}

_{G}_{(}

_{t}_{−1)}

_{j}_{*}

*= 𝓔*

_{et}

_{G}_{*}

*with * ∈ {\, /}; under this notation we have that*

_{tj}*G*=

_{tj}*G*

^{\}

*⊔*

_{tj}*G*

^{/}

*. In general, the graph*

_{tj}*G*is disconnected, if we denote by

_{tj}*G*its connected components then 𝓔

_{tjs}*will denote the family of edge covering sets for each graph*

_{tjs}*G*. For any given spanning tree

_{tj}*T*for a simple graph

*G*, let us make

*t*= || = dim 𝒞

*, 𝓗*

_{G}_{j}= 𝓔

*for some set*

_{tjs}*S*⊆ ℕ, where denotes the cartesian product and the projections will be denoted by

_{tj}*π*, for every

_{sj}*s*,

*j*. Every edge covering set of a graph

*G*induces a subgraph; if

*S*⊆

*E*by definition

_{Q}*S*meets all vertices of

*G*then the induce graph of

*S*becomes (

*V*,

_{G}*S*). For the rest of the paper the family of edge covering sets, like 𝓔

*will also denote the family of induced graphs by this sets. Therefore, the calculation of edge cover for a graph*

_{ijs}*G*is equivalent to calculate the induced graphs by edge covering sets, since most of the operations to be performed are graph operation like vertex splitting and edge subdivision.

**Theorem 1** *Let* *G* *be a finite, connected simple graph*, *T* *a spanning tree for* *G* *and * *denotes its cotree and t* = |*| **then*

*(i) the family*{*G*^{\},_{tj}*G*^{/}}_{tj}*, appearing in the expansion*⊔*G, are all acyclic graphs or non-intersecting cycle graphs for all**j**satisfying*0 ≤*j*≤*φ*(*t*).*(ii) If**G**_{tjs}*denotes the connected components of**G**_{tj}*, then**G**_{tjs}*are edge and vertex disjoint for every**j, and**G**=_{tj}*G**_{tjs}*for some set of indices**S*∈ ℕ._{tj}*(iii) For every**j*, 0 ≤*j*≤*φ*(*t*)*there exist bijections**ε*: 𝓔_{t}→ 𝓔_{tj},_{t}*ε*: 𝓔_{tj}→ 𝓔_{tj}_{(}_{t}_{−1)}_{j}*such that*𝓔_{(}_{t}_{−1)}= 𝓔_{j}^{\}_{(}_{t}_{−1)}∪_{j}*ε*[𝓔_{tj}^{/}_{(t−1)j}]*and therefore*.*(iv) Let**H*= (*H*^{1}, ...,*H*||^{St}) ∈ 𝓗^{j}_{j}*be a vector of graphs of the cartesian product of family*𝓔_{tjs}*of induced graphs by edge covering sets, then*𝓔=_{tj}*and*

*For every* *q*, 1 ≤ *q* ≤ *t, there exist bijections* *ε _{q}*

*in such a way that if* *ε* = *ε*_{1} ◦ · · · ◦ *ε _{q}*

*then*𝓔

*=*

_{G}*ε*(𝓔

*)*

_{t}*and*

**Proof 3** *(i) Let* *T* *be a spanning tree of* *G*, = *E*\*T* *its cotree and let* *I* *be an index set of integers. Let us consider* *e _{i}* ∈ ,

*u*,

_{i}*v*∈

_{i}*V*

_{G}*such that*

*e*=

_{i}*u*

_{i}v_{i}; it is well known that*e*

_{i}*and the path of*

*T*

*joining*

*u*

_{i}*to*

*v*

_{i}*forms a basic cycle. Let*𝓑 = {

*C*}

_{i}

_{i}_{∈}

_{I}*be that set of basic cycles then*𝓑

*is a basis for the cycle space*𝒞

_{G}*where*

*C*

_{i}*is the basic cycle corresponding to edge*

*e*

_{i}*[*{

^{12}]. Let us define the family*G*}

_{tj}*as in Equation (3.2) of*

*G*

_{t}*of subgraphs such that*

*G*

_{00}=

*G*,

*G**

*=*

_{tj}*G*

_{(}

_{t}_{−1)}

_{j}_{*}

*,*

_{et}*j*∈

*J*

_{i}*and*

*i*∈

*I*

*where*

*J*= {

_{i}*j*|0 ≤

*j*≤

*φ*(

*i*),

*i*∈

*I*}

*. By making*𝒞*

*= 𝒞**

_{ij}

_{Gij}*, it follows from Lemma (1)*, dim 𝒞

^{\}

_{(}

_{i}_{)(}

_{Ji}_{)}= dim 𝒞

^{\}(

_{i}_{−1)(}

_{Ji}_{)}− 1

*and*dim 𝒞

^{/}(

_{i}_{)(}

_{Ji}_{)}< dim 𝒞

^{/}

_{(}

_{i}_{−1)(}

_{Ji}_{)}

*for all*

*i*∈

*I. Therefore at some point in the decomposition process of graph*

*G*

*we must have*dim 𝒞*

*= 0*

_{tj}*or*dim 𝒞*

*> 0*

_{tj}*and*

*B*

_{2}(

*G**

*) ≠ ∅*

_{tj}*, which means that graphs*

*G**

_{tj}*are acyclic or non-intersecting cycle graphs for all*

*j*∈

*J*

_{t}.

*(ii) It is clear from the definition of operator*⊔*that all graphs**G**_{tj}*are vertex and edge disjoint. The connected components**G**_{ijs}*are all subgraphs of**G**_{tj}*thus**G**= ⊕_{ij}*_{s}G_{ijs}*make sense.**(iii) It follows from Lemma (1)(iii).**(iv) It follows from Lemma (1)(iii) and (i)-(iii) of this theorem.*

Algorithm 1 decomposes the input graph into basic or acyclic graphs as Definition 1 establishes.

4 Time Complexity of the SPLIT Algorithm

Let *G* = (*V*, *E*) be a simple graph, *m* = |*E*|, *n* = |*V*|. The time complexity of Algorithm 1 is given by the recursive calls over *G* (steps 9 and 12) which can be established by the following theorem.

**Theorem 2** *Let* *G* = (*V*, *E*) *be a simple connected graph with* *m* = |*E*|, *n* = |*V*| *and* *nc* = *m* − *n* + 1 *the basic cycles of* *G. The recurrence which represent the complexity of Algorithm 1 is given by:*

*whose solution is* ≈ 1.46557

**Proof 4** *Since* *e* *is part of at least one pair of intersecting cycles, then* *G* \ *e* = (*V*_{1}, *E*_{1}) *is still a connected graph.* |*V*_{1}⊨*n*_{1}*=n*, |*E*_{1}| = *m*_{1} = *m* − 1*. The number of base cycles in* *H*_{1} *is* *nc*_{1} = *m*_{1} − *n*_{1} = *m* − *n* − 1 = *nc* − 1*. Then*, *G* \ *e* *contains at least one pair less of intersecting cycles than* *G.*

*Let* *G*/*e* = (*V*_{2}, *E*_{2}), *n*_{2} = |*V*_{2}| *and* *m*_{2} = |*E*_{2}|*. By lemma 1-(i)* *nc*−3*. This recurrence has the characteristic polynomial* *p*(*r*) = *r*^{3} − *r*^{2} − 1 *which has the maximum real root* *r* ≈ 1.46557.

**Remark 1** *Finding* *e* *such that* *e* = *uv* ∈ *E*, *e* ∈ *B _{p}*(

*G*) ≠ ∅

*for some*

*p*

*has complexity*

*O*(

*m*+

*n*).

**Corollary 1** *The time complexity for splitting a simple graph* *G* *is given by:*

A polynomial procedure for computing edge covers for basic graphs (acyclic or non-intersecting graphs) can be consulted at [^{15}], so the complexity of counting edge covers is given by the splitting process.

5 Conclusions

A sound procedure has been presented to decompose a graph in order to compute the number of edge covers for the resulting subgraphs.

Regarding the cyclic graphs with intersecting cycles, a branch and bound procedure has been presented, it reduces the number of intersecting cycles until basic graphs are produced (subgraphs without intersecting cycles). Since polynomial time procedures are known for basic graphs, the computational complexity of the edge cover problem resides on intersecting cycle graphs.

Additionally, a recurrence relation has been deter-mined that establish an upper bound on the time to compute the number of edge covers on intersecting cycle graphs. It was also designed a “low-exponential” algorithm for the #Edge Covers problem whose upper bound is *O*(1.465571^{(}^{m}^{−}^{n}^{)} * (*m* + *n*)), *m* and *n* being the number of edges and nodes of the input graph, respectively.