Lower Bounds for Restricted Schemes in the Two-Adaptive Bitprobe Model

04/07/2022
by   Sreshth Aggarwal, et al.
0

In the adaptive bitprobe model answering membership queries in two bitprobes, we consider the class of restricted schemes as introduced by Kesh and Sharma (Discrete Applied Mathematics 2021). In that paper, the authors showed that such restricted schemes storing subsets of size 2 require Ω(m^2/3) space. In this paper, we generalise the result to arbitrary subsets of size n, and prove that the space required for such restricted schemes will be Ω((m/n)^1 - 1/⌊ n / 4 ⌋ + 2).

READ FULL TEXT VIEW PDF

Authors

page 1

page 2

page 3

page 4

12/12/2018

An Improved Scheme in the Two Query Adaptive Bitprobe Model

In this paper, we look into the adaptive bitprobe model that stores subs...
10/07/2019

Improved Bounds for Two Query Adaptive Bitprobe Schemes Storing Five Elements

In this paper, we study two-bitprobe adaptive schemes storing five eleme...
11/20/2017

On estimating the alphabet size of a discrete random source

We are concerned with estimating alphabet size N from a stream of symbol...
10/31/2018

A Two Query Adaptive Bitprobe Scheme Storing Five Elements

We are studying the adaptive bitprobe model to store an arbitrary subset...
03/28/2019

Improved Lower Bounds for the Restricted Isometry Property of Subsampled Fourier Matrices

Let A be an N × N Fourier matrix over F_p^N/p for some prime p. We impro...
03/14/2020

Partial Queries for Constraint Acquisition

Learning constraint networks is known to require a number of membership ...
11/06/2019

Permutations With Restricted Movement

We study restricted permutations of sets which have a geometrical struct...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

In the bitprobe model, we store subsets of size from an universe of size in a data structure taking amount of space, and answer membership queries by reading bits of the data structure. The conventional notation to denote such schemes is as an -scheme. Each such scheme has two components – the storage scheme sets the bits of the data structure according to the given subset , and the query scheme probes at most bits of the data structure to answer membership queries. Schemes are categorised as adaptive if the location of each bitprobe in their query scheme depends on the answers obtained in the previous bitprobes. If the location of the bitprobes in the query scheme is independent of the answers obtained in the earlier bitprobes, the corresponding scheme is called non-adaptive. For further reading about bitprobe and other related models and their associated results, Nicholson et al. [2] has quite a detailed survey of the area.

In this paper, we restrict ourselves to those bitprobe schemes that answer membership queries using two adaptive bitprobes, i.e. . The data structure of such schemes can be thought of as having 3 tables, namely and . The first bitprobe is made in table , and if the bit probed in table has been set to 0 the next bitprobe is made in table . On the other hand, the second bitprobe is made in table if the bit queried in table has been set to 1. The answer to the membership query is “Yes” if the second bitprobe returns 1, “No” otherwise.

The best known scheme for storing subsets of size two and answering membership queries using two adaptive bitprobes is due to Radhakrishnan et al. [3] which takes amount of space; the best known lower bound for the problem is  [4]. Though the problem is yet to be settled for subsets of size two, it has recently been shown for subsets of size three that the space required is  [5, 6]. Garg and Radhakrishnan [7] proved that for arbitrary sized subsets, the space bounds for two adaptive bitprobe schemes are and , where .

2 Restricted Schemes

Kesh and Sharma [1] proved that is indeed the lower bound for two adaptive bitprobe schemes storing subsets of size two, albeit for a restricted class of schemes. We now introduce the restriction that characterises this class of schemes.

In the literature, elements of the universe that query, or equivalently map to, the same bit in table are said to form a block. We label the elements of a block uniquely as 1, 2, 3, , which we will refer to as the index of the element within a block. The element with index of a block will be denoted as . Elements of that query, or map to, the same bit in tables or form a set. This departure in labels is made to distinguish the collections of elements in tables and from those of table , which will prove useful henceforth. The set to which the element belongs to in table will be denoted as ; similarly for sets of table .

We impose the following restriction on the schemes designed to store subsets and answer membersip queries using two bitprobes.

Restriction 2.1

If two elements belong to the same set either in table or in table , then their indices are the same.

To take an example, in the schemes that we consider if , then it must be the case that . We further simplify our premise by imposing the following restrictions on the schemes we are addressing. They are being made for the sake of simplicity and do not affect the final result.

Restriction 2.2

Our class of schemes satisfy the following constraints.

  1. The three tables and do not share any bit.

  2. All the three tables are of the same size.

  3. All the blocks in table are of equal size. Let that size be .

  4. There are no singleton sets in tables and .

  5. All of the sets in the tables and are clean [6], i.e. no two elements of a block belong to the same set.

As discussed in [1], the motivation for these kind of restrictions is from the schemes presented in such works as by Radhakrishnan et al. [3], Lewenstein et al. [8], and Radhakrishnan et al. [4]. The final restriction is motivated from Section 3 of Kesh [6], where it is shown that any scheme can be converted to a scheme with only clean sets with no asymptotic increase in the size of the data structure.

The main result of the paper(Theorem 8.1) is as follows.

Theorem

Two adaptive bitprobe schemes for storing subsets of size at most and satisfying Restriction 2.1 requires space.

In this restricted setting, as one might expect, the lower bound of Theorem 8.1 improves upon the bound proposed by Garg and Jaikumar [7] for all schemes, which is for . To generalise the proof presented, Lemma 3, which shows that indices increase as the in -Universe (Definition 4) increases, and Lemma 5, which works because the subsets and (defined in Section 3) are disjoint, need to be proven for the generalised setting. Other lemmas, including those of Section 8, lend itself to generalisation without much effort.

3 Premise

As mentioned earlier, the subset of the universe that we want to store in our data structure will be referred to as . In the subsequent discussion, it will be necessary to build certain subsets that we would like to store in the data structure of the restricted schemes and, consequently, arrive at certain contradictions – such subsets will be denoted at various places as etc. As we build the subsets to store, it will also be required to keep track of certain elements that cannot be part of – such subsets will be denoted as etc.

As Restriction 2.1 forces sets in tables and to contain elements of only a certain index, it will prove helpful to refer to the various structures in the two tables by their indices. To start with, will denote those elements of which have index . will refer to the collection of all sets of table comprised of elements of ; similarly . Sometimes, we will also use and to refer to either of the tables or . Hence, if we have two distinct tables and , then one of them will be and the other , which is not important. On the other hand, table will always be referred to by its name.

In the literature the size of the data structure has always been denoted by . As the sizes of the three tables are equal (Restriction 2.2), we would instead use to denote the size of any particular table; this would alleviate the need of using the fraction whenever we refer to the table sizes. So, the schemes will henceforth be referred to as an -schemes.

In the following two results, we present some self-evident and one essential property of the notations as defined above. They will be referenced to later, as needed.

Observation 3.1

The size of a table and the elements of index are related as follows.

  1. .

Proof

The first of the two observations follows from the fact that each block of table has exactly one element of any particular index. The second observation follows from the definition of . ∎

Lemma 1

The correctness of a scheme remains unaffected under a permutation of the indices.

Proof

Consider an -scheme that satisfies Restrictions 2.1 and 2.2. Suppose is some permutation on the indices of the blocks of table . We observe that a permutation of the indices do not affect the membership of a block – two elements which belonged to block before, still belongs to but with their indices changed according to . The same is true for any set of table or – elements of a set all had the same index, say , to start with, and they will now have the index . So, the data structure of a scheme remains unaffected under the permutation, only the labels of the sets have changed. Thus, if a scheme was correct to begin with, it will remain so after a permutation of the indices. ∎

We end the section with a final notational convenience. We would, in the discussion to follow, require to perform some arithmetic on index , like or . As the range of indices lie between 1 and , inclusive, all such expressions should be considered . This would help us to keep the expressions simple and avoid repetition.

4 Nodes and Paths

In this section we define nodes, edges, and paths, structures that are defined on top of the elements belonging to a set.

Definition 1

A node of table , denoted as

, is an ordered pair of distinct elements

and such that they belong to the same set in .

Each of the components of a node are called its terms, the first being referred to as the antecedent and the second as the consequent.

We say that a block is stored in table if the bit corresponding to the block in table is set to 0. Then any query for any element of block will be made in table , and the sets corresponding to those elements in table should be set to 1 or 0 according as the elements are in or not. We can, hence, say that the elements of block are being stored in table . Storing a block or an element in table in can similarly be defined as when the the bit in table corresponding to the block is set to 1.

Observation 4.1

Suppose a node be such that one of its terms is in the subset and the other in . Then, if the antecedent of the node is stored in its own table, the consequent of the node cannot be stored in its table.

Proof

Consider the node . If we store the antecedent in its table, namely , then there is way to ensure that the consequent cannot be stored in its table. To that end, we put in and in . Then as we are storing in table , the set corresponding to in the table must be set to 1. The element belongs to the same set in yet it is not part of . So, , and consequently its block , cannot be stored in table , because if we do the query for element will incorrectly return “Yes”.

An equally good choice to force the antecedent and the consequent to separate tables is to have and . ∎

Definition 2

There is said to be an edge from the node to the node if the following holds.

  1. The nodes belong to distinct tables, i.e. .

  2. .

  3. The consequent of the first node and the antecedent of the second node belong to the same block, i.e. .

The second node above can be rewritten as . The nodes with the edge between them are connected via the common block , and hence will be will be shown as

Definition 3

A sequence of nodes is said to be a path if between every pair of adjacent nodes there is an edge from the former to the latter. The length of a path is the number of edges it contains.

A path will be denoted as

For our discussion, we will only consider paths of length at most ; we will see in Section 7 as to the reason why.

Observation 4.2

An element cannot occur in the path more than once.

Proof

It follows from the definition of a path which dictates that indices increase from the first node onwards, and from our upper bound on the length of a path. On the other hand, it should be noted that a block may occur multiple times along a path. ∎

Lemma 2

Suppose for every node in a path one of the terms of the node is in and the other is in . Then, if the antecedent of the first node is stored in its own table, antecedents of all the nodes will have to be stored in their respective tables and the consequents of the nodes cannot be stored in their respective tables.

Proof

The lemma is a direct consequence of Observation 4.1, and the proof can be found in the appendix as Lemma 10. ∎

5 Universe of Elements

In this section, we define the universe of an element of recursively, and establish its relation with nodes and paths.

Definition 4

The -Universe of an element w.r.t. table , denoted as , is defined as follows.

The table is defined as follows.

Similar to the upper bound on paths, we will consider -universes for , and, as stated before, we will see in Section 7 as to the reason why.

The -Universe of an element is the union of the 1-Universes of all the elements in its -Universe. So, as increases so does the size of the universe. We will show that the elements of the -Universe must necessarily belong to distinct sets in a table, so the larger the the larger has to be the size of the data structure to accomodate the -Universe. We start with a few properties of the elements belonging to the -Universe of an element.

Observation 5.1

.

Lemma 3

If an element belongs to the -Universe of , then .

Proof

The statement of the lemma can be established by induction on , and the proof is given in the appendix as Lemma 11. ∎

Lemma 4

If the element belongs to the -Universe of w.r.t. table , then there is a path such that

  1. The first node is in table with its antecedent being .

  2. The last node is in table with its antecedent being . The table is defined as follows.

  3. The length of the path is .

It is important to observe that the nature of the table in the lemma above is contrary to that in Definition 4 in that is the same as when is even in the lemma above, whereas they are equal when is odd in the definition of the -Universe.

Proof

We will prove the aforementioned statement by induction on in the appendix in Lemma 12. ∎

6 Bad Elements

In this section, we show that large universes of elements give rise to bad elements, which put constraints on how and what subsets can be stored.

Definition 5

An element is said to be -bad w.r.t. table if for any between 1 and , inclusive, there exist distinct elements and in s.t.

The table is defined as follows.

Elements which are not -bad are said to be -good.

The above definition suggests that if is some constant less than or equal to and the element is -bad, then it is also -bad.

Lemma 5

If an element is -bad w.r.t. table , then there exists a choice of the sets and , each of size at most , s.t. the block cannot be stored in table .

Proof

This lemma has been proved in the appendix as Lemma 13. ∎

7 Modified Schemes

Consider any restricted adaptive -scheme, the last component 2 denoting the number of bitprobes allowed. Let some element of its universe be -bad w.r.t. table . Lemma 5 states that there exist sets and , each of size at most , s.t. the block cannot be stored in table . Also, as an element becomes -bad due to the elements of its -Universe, the indices of the elements in the either of the sets and lie between 1 and . Consider the element . If this element is -bad w.r.t. table there will exist sets and , again of size at most each, s.t. the block cannot be stored in table . The range of the indices in the two sets in this case would be from to .

We already know that the sets and are disjoint, as are the sets and . Furthermore, as the range of indices in the two pairs of sets do not overlap, we can deduce that all the four sets are disjoint. Let us then consider the sets

each of their sizes being at most . As discussed above, this pair of sets imply that the block cannot be stored in either of the tables or , which is absurd as the scheme is deemed to be correct. So, we may conclude the following.

Lemma 6

For any block of table , say , if the element is -bad w.r.t. table , then the element cannot be -bad w.r.t. table .

Let us partition the universe based on good and bad elements w.r.t. table . One part will be the union of all those blocks whose index 1 elements are good. The other part will be union of the remaining blocks.

According to Lemma 6, we know that though the index elements of the blocks of are bad w.r.t. table , the index elements must necessarily be good w.r.t. table .

We now split our data structure in the following way. For any set in either of table or , we split it into two sets, one containing the elements of and the other containing the elements of . More formally,

It is important to note that the indices of the elements in the two sets and are the same as that of . Consequently, the table has been split into two parts, namely containing the sets with elements from , and containing sets with elements from . Thus, the collection of all sets in table containing elements with index , namely is now . The table have similarly been split into two parts - and .

Observation 7.1

The size of has at most doubled due to the above modification.

The table is also split into two tables, namely and , containing elements of and , respectively. As per our definition of and , either a block belongs entirely in or entirely in , and thus individual blocks are not split.

We now have two sets of data structures, one corresponding to the elements of and the other corresponding to

This also means that within the original scheme, we have two independent schemes, one for the elements of and the other for the elements of . Any subset that is to be stored can now be split into and stored in the data structure corresponding to , and which can be stored in the data structure corresponding to . The storage and query schemes remain as before for each of the parts of the data structure. So, to store a subset, if any block was earlier set to 0, in the new data structure it will still be set to 0. If any set was being set to 1, now both and will be set to 1; and so on.

We further modify the new data structure as follows. For the part , we interchange the parts and in the tables and so that will now be part of table and will now be part of table . With this modification, for any index the tables will be as follows.

As the part pertaining to , i.e. , is unaffected, the query scheme and storage scheme for it remains unchanged. For the part , if a block was earlier set to 0 and thus sent to table , it should now be set to 1 and sent to table . Similarly, a block which was earlier set to 1 will now have to be set to 0.

Let us consider the sizes of the tables. For lack of a better notation, we will use to refer to the original table, the table after the first modification, and after the second modification, respectively. Observation 7.1 tells us that

After the second modification, we note that

We make the third and final modification to our scheme. Before the second modification, all the elements of index 1 in were good w.r.t. table . After the second modification, all the elements of index in , which were earlier good w.r.t. table , are now good w.r.t. table because is now part of table . In Lemma 1, we have seen that the correctness of a scheme remains unaffected under a permutation of its indices. We now apply the following permutation over the indices of the data structure corresponding to – the labels and are interchanged, where , whereas the rest of the indices remain unchanged. With this further modification, all the indices labelled from to will now be labelled 1 to in that order, whereas the previously labelled indices 1 and will now be labelled to , in that order.

With this final modification, we now have a scheme where all the elements of index 1 are good w.r.t. table .

Lemma 7

Any given restricted -scheme can be modified into a -scheme such that in the modified scheme all the elements of index 1 are -good w.r.t. table .

As the third and final modification does not affect indices larger than , we can say that

for . As for the indices 1 to , the sets have been relabelled but not created, and as a result the total number of sets remain unchanged, i.e.

(1)

Finally, all of this can only be proven for subsets and whose sizes are at least , and for the range of indices 1 to . So, for the first condition we can set . As for the range of indices, the size of a block has to be larger than , which implies that universes and path lengths are bounded by .

8 Lower Bound

In this section, we will present our theorem on the space lower bound on restricted schemes. We start by presenting an estimate of the total sizes of all the

-universes of good elements.

Lemma 8

Suppose all the elements with index 1 are -good w.r.t. table . Then the sizes of their -Universes satisfy the following inequality.

for some constant .

Proof

In this lemma, for the sake of convenience, we introduce two new notations. If is a block then was meant to denote that element of which has index . We now abuse the notation and use to denote the element with index in the block . We also introduce to denote the set . These notations will help us keep the expressions to follow succint.

Let us assume that is odd. The sum of the sizes of the -universes of all index 1 elements can be expressed as follows.

The above derivation follows from the definition of -universe, the fact that all elements of index 1 are -good, and Observation 5.1 about the size of 1-universes. We have now arrived at a summation indexed by the elements of , and applying Lemma 14, we get –

The summation can be equivalently expressed as . As the elements and both belong to the set and are distinct from each other, we can now reorder the first three indices of the summation as . By pushing the summation indexed by inside, we can finally rewrite down the summation as –

(2)

Each term of this summation is determined by a tuple such as

where each block, except for the first, is dependent on the previous blocks. On the other hand, if any of the sets in the tuple is fixed, then the other blocks and the terms of the summation they index are fixed by the set. With this insight, we are going to put a lower bound on the sum of all -universes.

Suppose be the smallest set that occurs in the summation above (Equation 2), either as one of its terms or as one of its indices. We first consider the case when occurs as the index under the th summation. Let us also consider that is odd, which would imply that belongs to table . Thus the terms of the summation in which participates is determined as follows – the indices under the th summation and beyond is determined as

and the indices prior to that is determined as

It is important to note that in the latter of the two tuples, is the set .

The sum of all the terms in which the set participates is as follows.

As all of the sets involved have sizes , the above sum is at least , for some constant . From the remaining terms and index sets of the summation in Equation 2, we remove all the blocks that belong to set . So, if the initial sum in Equation 2 is denoted by , and the remaining sum after the above procedure is , we have

We next identify the smallest set, say , in the summation and repeat the above proceduce which ends up in an estimation of all the terms associated with , the estimation being , and removing the terms and blocks associated with from the remainder. We repeat this until all the blocks have thus been removed, upon which we will have a family of sets labelled s and they partition the blocks of table . The number of sets would, in the worst case, be the total number of sets in the tables and with index at most . Consequently, we have

where is some suitable constant. The final bound arises using the Cauchy-Schwarz inequality.

All the other scenarios including the case where is presumed to be even, can be similarly argued. ∎

Lemma 9

If all elements of are -good w.r.t. table , then

for some constant .

Proof

As before, we will establish the statement of the lemma assuming that is odd. The case when is even will follow similarly. According to the definition of bad elements (Definition 5), a necessary property for an element to be -good w.r.t. table is that the elements of its -Universe belong to distinct sets in , being odd. Consequently, we have

From Lemma 8, the inequalities follows.

and the lemma follows. ∎

Lemma 7 states that given a restricted -scheme, it can be modified into a -scheme such that in the modified scheme all the elements of are -good for some constant . Furthermore, in that case we require the subset size, , should be at least . So, from Equation 1 and Lemma 9, we can deduce the following.

(3)

where comes from the fact that the first modification splits the sets of tables and (Observation 7.1).

Let the indices in the original scheme be so chosen that the sum on the first indices in Equation 3 is the minimum among all choices. We can then derive the following.

which upon simplification gives us

for some suitable constant . Hence, the main result of the paper is as follows.

Theorem 8.1

Two adaptive bitprobe schemes for storing subsets of size at most and satisfying Restriction 2.1 requires space.

9 Conclusion

In this paper, we addressed a class of schemes, as devised by Kesh and Sharma [1], in the two adaptive bitprobe model and provided a space lower bound on such schemes for subsets of arbitrary sizes, thereby generalising the lower bound presented in that paper. As discussed earlier, one of the key lemmas that our lower bound proof hinges upon is Lemma 5, which demonstrates the generation of bad elements, and establishing this lemma is crucial in generalising the proof to arbitrary schemes. We hope that this issue can be resolved and the structure of our proof could serve as a template to provide bounds stronger that those presented by Garg and Jaikumar [7].

References

  • [1] Deepanjan Kesh, Vidya Sagar Sharma: On the bitprobe complexity of two probe adaptive schemes. Discrete Applied Mathematics, 2021 (in press).
  • [2] Patrick K. Nicholson, Venkatesh Raman, S. Srinivasa Rao: A Survey of Data Structures in the Bitprobe Model. Space-Efficient Data Structures, Streams, and Algorithms – Papers in Honor of J. Ian Munro on the Occasion of His 66th Birthday. pp. 303–318, 2013.
  • [3] Jaikumar Radhakrishnan, Venkatesh Raman, S. Srinivasa Rao: Explicit Deterministic Constructions for Membership in the Bitprobe Model. 9th Annual European Symposium on Algorithms (ESA) 2001, Aarhus, Denmark. Proceedings, pp. 290–299, 2001.
  • [4] Jaikumar Radhakrishnan, Smit Shah, Saswata Shannigrahi: Data Structures for Storing Small Sets in the Bitprobe Model. 18th Annual European Symposium on Algorithms (ESA) 2010, Liverpool, UK. Proceedings, Part II, pp. 159–170, 2010.
  • [5] Mirza Galib Anwarul Husain Baig, Deepanjan Kesh: Two New Schemes in the Bitprobe Model. 12th International Conference and Workshops on Algorithms and Computation (WALCOM) 2018, Dhaka, Bangladesh. Proceedings, pp. 68–79, 2018.
  • [6] Deepanjan Kesh: Space Complexity of Two Adaptive Bitprobe Schemes Storing Three Elements. 38th IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS) 2018, Ahmedabad, India. Proceedings, pp. 12:1–12:12, 2018.
  • [7] Mohit Garg, Jaikumar Radhakrishnan: Set membership with a few bit probes. Proceedings of the Twenty-Sixth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA) 2015, San Diego, CA, USA. pp. 776–784, 2015.
  • [8] Moshe Lewenstein, J. Ian Munro, Patrick K. Nicholson, Venkatesh Raman: Improved Explicit Data Structures in the Bitprobe Model. 22nd Annual European Symposium on Algorithms (ESA) 2014, Wroclaw, Poland. Proceedings, pp. 630–641, 2014.
  • [9]

    Mirza Galib Anwarul Husain Baig, Deepanjan Kesh: Improved Bounds for Two Query Adaptive Bitprobe Schemes Storing Five Elements. 13th International Conference on Combinatorial Optimization and Applications (COCOA) 2019, Xiamen, China. Vol. 11949 of Lecture Notes in Computer Science, Springer. pp. 13–25, 2019.

Appendix 0.A Appendix

Lemma 10

Suppose for every node in a path one of the terms of the node is in and the other in . Then, if the antecedent of the first node is stored in its own table, antecedents of all the nodes will have to be stored in their respective tables and the consequents of the nodes cannot be stored in their respective tables.

Proof

It is to be noted that it is actually possible to put one element of each node in the set and the other in such that the two sets remain disjoint. It is due to the simple fact, summarised in Observation 4.2, that no element occurs more than once in a path.

Let the path under consideration be

Furthermore, we are saving the element in its own table, namely .

Observation 4.1 tells us that as one of the terms of the first node is in and the other in , the consequent cannot be stored in . Thus the element and its block will have to be stored in table . For the second node the antecedent is being stored in its own table, and, as before, one of its terms is in and the other in . So, the consequent of the second node cannot be stored in its own table . This again implies that the element and its block will have to be stored in , and thus the antecedent of the third node is being stored in its own table.

Continuing thus, we see that for every node in the path the antecedent is being stored in its own table and the consequent is not, which establishes the statement of the lemma. ∎

Lemma 11

If an element belongs to the -Universe of , then .

Proof

We will prove the statement by using induction on . Definition 4 tells us that any element in has index , so the lemma is trivially true for the base case.

Suppose that the statement is true for all between 1 and , inclusive. Let us now consider an element in the -Universe of . Then, according to Definition 4 belongs to the 1-Universe of some element in . By induction hypothesis, the index of that element in the -Universe is . Let that element in be . As belongs to the 1-Universe of , we have shown earlier that must be equal to . This completes the induction. ∎

Lemma 12

If the element belongs to the -Universe of w.r.t. table , then there is a path such that

  1. The first node is in table with its antecedent being .

  2. The last node is in table with its antecedent being . The table is defined as follows.

  3. The length of the path is .

Proof

We will prove the aforementioned statement by induction on . Consider the 1-Universe of and . By the definition of 1-Universe (Definition 4), belongs to . Furthermore, consider an element in the set , where . The path to consider in such a scenario is

which satisfies all the requirements of the lemma. Thus the base case of the induction is proven.

Let us assume that the statement of the lemma holds for all values of between 1 and , inclusive. Let us further suppose that is odd. Consider an element in the -Universe of . The index of the element is set by Lemma 3. According to the definition of -Universe (Definition 4), there must exist an element in the -Universe of s.t.  The index of the 1-Universe is because of the definition of -Universe and the fact that has been assumed to be even. In this scenario, we have already established that there will exist an edge of the form

for some .

As , by induction hypothesis there exists a path of length of the form

By induction hypothesis, the path will end in as is odd.

Combining the two paths above by setting , we get the desired path of length .

The case for being even can be similarly argued with due consideration for the fact that in this scenario the desired path will end in . ∎

Lemma 13

If an element is -bad w.r.t. table , then there exists a choice of the sets and , each of size at most , s.t. the block cannot be stored in table .

Proof

As the element is -bad w.r.t. table , then, according to Definition 5, there exists some between and s.t. two elements of the -Universe of w.r.t. table belong to the same set in table . Let the two elements of be and . Then Lemma 4 suggests that there exist two paths, both of whom have as the antecedent of the first node and are of length , such that the antecedent of the last node of one of them is , as

and the antecedent of the last node of the other is , as

The notion of the table in Definition 5 and Lemma 4 are identical.

It is given to us that the elements and belong to the same set in table , and thus the last nodes of the two paths belong to the same set. In that case, we can set the consequents of the last two nodes of the paths as

Suppose we store the element in its own table, namely . According to Lemma 2, for the first path there exist a choice of sets and such that the antecedent must be stored in table and the consequent cannot be stored in . Furthermore, as the length of the path is , each of the subsets are of size . For the second path we have sets and , of size each, such that the antecedent will have to stored in table .

Let us consider the sets

each of their sizes being at most , as some elements might be common among the sets. Together, it will imply that storing in table with result in a contradiction w.r.t. the storage of the element . So, we may conclude that the element , and consequently its block , cannot be stored in table .

It may happen that an element in also is in , there by violating the requirement that the sets and must be disjoint. Let that common element be , and the nodes of the two paths be

where the table will depend on . Furthermore, we have in both and , in and in . In such a scenario, for the second node if we put in and in , the resulting sets and will become disjoint. As the index cannot occur anywhere else in the paths, this change will not affect the choices of other nodes in the two paths.

Any other conflicts similar to the one above can be similarly resolved, thereby establishing the statement of the lemma. ∎

In the next lemma, we will continue to use the notations