1 Introduction
Let be a finite set of elements. A set system on a set of elements is defined to be a pair of of elements and a family , where a set in is called a component. For a subset in a system , a component with is called maximal if no other component satisfies , and let denote the family of all maximal components. For two subsets , let denote the family of components such that . We call a set function from to the set of reals a volume function if for any subsets . A subset is called positive if . To discuss the computational complexities for solving a problem in a system, we assume that a system is implicitly given as two oracles and such that

given nonempty subsets , returns a component (or if no such exists) in time and space; and

given a nonempty subset , returns in time and space.
Given a volume function , we assume that whether holds or not can be tested in time and space. We also denote by an upper bound on , where we assume that is a nondecreasing function in the sense that holds for any subsets .
We define an instance to be a tuple of a set of elements, a family , a set of items and a function . Let be an instance. The common item set over a subset is defined to be . A solution to instance is defined to be a component such that
every component with satisfies . 
Let denote the family of all solutions to instance . Our aim is to design an efficient algorithm for enumerating all solutions in .
We call an enumeration algorithm
Ā  outputpolynomial
if the overall computation time is polynomial with respect to
āthe input and output size;
Ā  incrementalpolynomial
if the computation time between the th output and
āthe st output is bounded by a polynomial with respect to
āthe input size and ; and
Ā  polynomialdelay if the delay (i.e., the time between any two consecutive outputs),
āpreprocessing time and postprocessing time are all bounded by a polynomial
āwith respect to the input size.
In this paper, we design an algorithm
that enumerates all solutions in
by traversing a family tree over the solutions in ,
where the family tree is a tree structure that represents
a parentchild relationship among solutions.
The following theorem summarizes our main result.
Theorem 1
Let be an instance on a set system with a volume function , where and . All positive solutions in to the instance can be enumerated in delay and in space.
The problem is motivated by enumeration of solutions in an instance such that is transitive. We call a system transitive if any tuple of components with implies . For such an instance, we proposed an algorithm in [9] that enumerates all solutions such that the delay is bounded by a polynomial with respect to the input size and the running times of oracles. The proposed algorithm yields the first polynomialdelay algorithms for enumerating connectors in an attributed graphĀ [1, 6, 7, 8, 9, 12, 13, 14, 15, 16] and for enumerating all subgraphs with various types of connectivities such as all edge/vertexconnected induced subgraphs and all edge/vertexconnected spanning subgraphs in a given undirected/directed graph for a fixed .
It is natural to ask whether the result in [9] is extensible to an instance with a general set system. This paper gives an affirmative answer to the question; even when we have no assumption on the system of a given instance , there is an algorithm that enumerates all solutions in polynomialdelay with respect to the input size and the running times of oracles.
The paper is organized as follows. We prepare notations and terminologies in SectionĀ 2. In SectionĀ 3, we present a polynomialdelay algorithm that enumerates all solutions in an instance such that is an arbitrary set system. We also show that all components are enumerable in polynomialdelay, using the algorithm. Finally we conclude the paper in SectionĀ 4.
2 Preliminaries
Let (resp., ) denote the set of reals (resp., nonnegative reals). For a function for a finite subset and a subset , we let denote .
For two integers and , let denote the set of integers with . For a set with a total order over the elements in , we define a total order over the subsets of as follows. For two subsets , we denote by if the minimum element in belongs to . We denote if or . Note that holds whenever . Let denote the maximum element in . Then holds for , and , , if and only if the sequence of length with is lexicographically smaller than the sequence of length with . Hence we see that is a total order on .
Suppose that an instance is given. To facilitate our aim, we introduce a total order over the items in by representing as a set of integers. We define subsets and for each item . For each nonempty subset , define subset . For , define . For each subset , let denote the minimum item in , where for . For each , define a family of solutions in ,
Note that is a disjoint union of , . In SectionĀ 3.5, we will design an algorithm that enumerates all solutions in for any specified integer .
3 Enumerating Solutions
For a notational convenience, let for each item denote the family of components and let for each subset denote the family of components.
We can test whether a given component is a solution or not as follows.
Lemma 1
Let be an instance, be a component in and .

if and only if ; and

Whether is a solution or not can be tested in delay and in space.
Proof: (i) Note that . By definition, if and only if there is a component such that and , where a maximal one of such components belongs to . Hence if no such component exists then . Conversely, if then no such component exists.
(ii) Let be a subset such that . We claim that holds if and only if L returns the component . The necessity is obvious. For the sufficiency, if there is such that , would be a superset of , contradicting the maximality of . By (i), to identify whether or not, it suffices to see whether L returns . We can compute in time and in space, and can decide whether the oracle returns in time and in space. ā
3.1 Defining Family Tree
To generate all solutions in efficiently, we use the idea of family tree, where we first introduce a parentchild relationship among solutions, which defines a rooted tree (or a set of rooted trees), and we traverse each tree starting from the root and generating the children of a solution recursively. Our tasks to establish such an enumeration algorithm are as follows:

Select some solutions from the set of solutions as the roots, called ābases;ā

Define the āparentā of each nonbase solution , where the solution is called a āchildā of the solution ;

Design an algorithmĀ A that, given a solution , returns its parent ; and

Design an algorithmĀ B that, given a solution , generates a set of components such that contains all children of . We can test whether each component is a child of by constructing by algorithmĀ A and checking if is equal to .
Starting from each base, we recursively generate the children of a solution. The complexity of delaytime of the entire algorithm depends on the time complexity of algorithms A and B, where is bounded from above by the time complexity of algorithmĀ B.
3.2 Defining Base
For each integer , define a set of components
, 
and . We call each component in a base.
Lemma 2
Let be an instance.

For each nonempty set or , it holds that ;

For each , any solution is contained in a base in ; and

and .
Proof: (i) Let be a component in . Note that holds. When (i.e., ), no proper superset of is a component, and is a solution. Consider the case of . To derive a contradiction, assume that is not a solution; i.e., there is a proper superset of such that . Since , we see that . This, however, contradicts the maximality of . This proves that is a solution.
(ii) We prove that each solution is contained in a base in . Note that holds. By definition, it holds that . Let be a solution. Note that holds. Since for (resp., for ), we see that . This proves that is a base in . Therefore is contained in a base .
(iii) Let . We see from (i) that , which implies that . We prove that any solution is a base in . By (ii), there is a base such that , which implies that and . We see that , since for , and for . Hence would contradict that is a solution. Therefore , as required. ā
LemmaĀ 2(iii) tells that all solutions in can be found by calling oracle for and . In the following, we consider how to generate all solutions in for each item .
3.3 Defining Parent
This subsection defines the āparentā of a nonbase solution.
For two subsets , we denote if āā or ā and ā and let mean or .
Let be a subset such that . We call a solution a superset solution of if and . A superset solution of is called minimal if no proper subset is a superset solution of . We call a minimal superset solution of the lexmin solution of if for all minimal superset solutions of . For each item , we define the parent of a nonbase solution to be the lexmin solution of , and define a child of a solution to be a nonbase solution such that .
The next lemma tells us how to find the item set of the parent of a given solution .
Lemma 3
Let be an instance, be a nonbase solution for some item , and denote the lexmin solution of . Denote by so that . For each integer , holds if and only if holds for the item set .
Proof:
By LemmaĀ 2(i) and ,
we see that
for any integer .
CaseĀ 1. :
For any subset ,
the family is equal to and cannot
contain any minimal superset solution of .
This implies that .
CaseĀ 2. :
Let be an arbitrary component in .
Then is a solution by LemmaĀ 2(i).
Observe that and
, implying that is a superset solution of .
Then contains
a minimal superset solution of , where
and .
If or ,
then would hold, contradicting that is
the lexmin solution of .
Hence
and .
ā
The next lemma tells us how to construct the parent of a given solution .
Lemma 4
Let be an instance, be a nonbase solution for some item , and denote the lexmin solution of . Let . Let be a set such that , where is denoted by such that . Then:

for any vertex ;

Every component with satisfies ;

There is an integer such that for each and all components satisfy ;

For the integer in (iii), holds; and

For the integer in (iii), if then holds.
Proof: (i) Since , there exists a vertex . For such a vertex , is a component such that . If is not a maximal component, then there would exist a component with and , contradicting that is a solution. Hence for any vertex .
(ii) Let be a component with . Note that and . Since is a component, there is a solution such that and . Since , and are distinct solutions and there must be a minimal superset solution of such that , where we see that and . If , then implies that , contradicting that is the lexmin solution of .
(iii) By (i), for some integer , holds and some component satisfies . Let denote the smallest index such that no component satisfies for each . By (ii), for such , the statement of (iii) holds.
(iv) Since no component satisfies for all integers , no component such that can be the lexmin solution . Since some component satisfies , there is a component such that and . The lexmin solution satisfies for all minimal superset solutions of with . Therefore must contain .
(v) By (iv), . If then is a unique minimal superset solution of such that , implying that . ā
Lemma 5
Let be an instance, be a nonbase solution for some item . Then Parent in AlgorithmĀ 1 correctly delivers the lexmin solution of in time and in space.
Proof: Let denote the lexmin solution of . The item set constructed in the first forloop (lines 5 to 9) satisfies by LemmaĀ 3. The second forloop (lines 12 to 19) picks up by LemmaĀ 4(iv), and the termination condition (lineĀ 13) is from LemmaĀ 4(v).
The first forloop is repeated times, where we can decide whether the condition in lineĀ 6 holds in time and in space. The time and space complexities of the first forloop are and .
We can decide the set in time and in space.
The second forloop is repeated times. We can decide whether the condition of lineĀ 13 is satisfied by calling the oracle L, which takes time and space. When the condition of lineĀ 13 is satisfied, we can decide whether or not (lineĀ 15) in time and in space by LemmaĀ 1(ii). The time and space complexities of the second forloop are and .
The overall time and space complexities are and . ā
3.4 Generating Children
This subsection shows how to construct a family of components for a given solution so that contains all children of .
Lemma 6
Let be an instance and be a solution for some item . Then:

Every child of satisfies and is a component in for any item ;

The family of children of is equal to the disjoint collection of families Parent over all items ; and

The set of all children of can be constructed in time and space.
Proof: (i) Note that since . Since are both solutions, . Hence . Let be an arbitrary item in . We see since and . To show that is a component in , suppose that there is a component such that . Since and , we see that . Then should not be a solution since otherwise it would be a superset solution of such that , contradicting that is a minimal superset solution of . Since is not a solution but a component, there is a solution such that and . Hence . Such a solution contains a minimal superset solution of such that and . Then we have , and thus holds, which contradicts that is the lexmin solution of . Therefore, such does not exist, implying that .
(ii) By (i), the family of children of is contained in the family of maximal components over all items . Hence
Comments
There are no comments yet.