Next Article in Journal
Distributed Batch Learning of Growing Neural Gas for Quick and Efficient Clustering
Previous Article in Journal
Correction: Li et al. Attitude Control of UAVs with Search Optimization and Disturbance Rejection Strategies. Mathematics 2023, 11, 3794
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

New Upper Bounds for Covering Arrays of Order Seven

by
Jose Torres-Jimenez
*,† and
Idelfonso Izquierdo-Marquez
CINVESTAV-Tamaulipas, Cd. Victoria 87130, Tamaulipas, Mexico
*
Author to whom correspondence should be addressed.
These authors contributed equally to this work.
Mathematics 2024, 12(12), 1908; https://doi.org/10.3390/math12121908
Submission received: 6 May 2024 / Revised: 14 June 2024 / Accepted: 19 June 2024 / Published: 20 June 2024

Abstract

:
A covering array is a combinatorial object that is used to test hardware and software components. The covering array number is the minimum number of rows needed to construct a specific covering array. The search for better upper bounds for covering array numbers is a very active area of research. Although there are many methods for defining new upper bounds for covering array numbers, recently the use of covering perfect hash families has significantly improved a large number of covering array numbers for alphabets that are prime powers. Currently, excellent upper bounds have been reported for alphabets 2, 3, 4, and 5; therefore, the focus of this article is on defining new upper bounds on the size of covering arrays for the alphabet seven using perfect hash families. For this purpose, a greedy column extension algorithm was constructed to increase the number of columns in a covering perfect hash family while keeping the number of rows constant. Our greedy algorithm begins with a random covering perfect hash family containing only eight columns and alternates between adding and removing columns. Adding columns increases the size of the covering perfect hash family while removing columns reduces the number of missing combinations in covering perfect hash families with different column counts. The construction process continues with the covering perfect hash family with the smallest number of columns being refined (i.e., missing combinations reduced). Thus, columns are dynamically added and removed to refine the covering perfect hash families being built. To illustrate the advantages of our greedy approach, 152 new covering perfect hash families of order seven with strengths 3, 4, 5, and 6 were constructed, enabling us to improve 12,556 upper bounds of covering array numbers; 903 of these improvements are for strength three, 8910 for strength four, 1957 for strength five, and 786 for strength six.

1. Introduction

An orthogonal array OA ( N ; t , k , v ) is a mathematical structure consisting of a N × k over the set Z v = { 0 , 1 , , v 1 } such that every t-subset of columns contains exactly once every t-tuple over Z v . Value v is called the order or the alphabet of the orthogonal array, and value t is called the strength of the orthogonal array. One closely related design is a covering array CA ( N ; t , k , v ) , where every t-subset of columns contains at least once every t-tuple over Z v . The covering array number CAN ( t , k , v ) is the minimum number of rows N for which there exists a CA with k columns, strength t, and order v:
CAN ( t , k , v ) = min { N : CA ( N ; t , k , v ) } .
When v is a prime power and v > t , there exists a CA ( v t ; t , v + 1 , v ) [1]; that is, with v t rows it is possible to construct a CA where the number of columns is one unit more than the order. In this work, the focus is on CAs with v = 7 and t = 3 , 4 , 5 , 6 ; then, the construction of CPHFs starts with a random CPHF with 8 columns (one unit more than v = 7 ).
The motivation to do this research is twofold: theoretical and practical. On the theoretical side, the improvement of CANs helps to understand the asymptotic behavior of the number of rows needed to construct a predefined number of columns given an alphabet (v) and a strength (t). On the practical side, constructing improved CAs enhances their application in areas such as software and hardware testing [2,3]. In these contexts, the fewer rows a specific CA has, the less computing time–human resources are required to ensure a certain level of quality in software and hardware components. In addition to this motivation, the fact that the computational effort to construct CAs using the domain of CPHFs is less than the computational effort needed to construct CAs directly in the CA domain (this fact will become clearer later).
It is well known that it is a significant combinatorial challenge to find the exact value of CAN ( t , k , v ) for general values of t, k, and v; many results have been published on computing upper bounds of CAN values for v { 2 , 3 , 4 , 5 } ; see [4,5,6,7]. These studies remain relevant because, compared to the best-published results reported in [8], the mentioned papers still present many current upper bounds. Naturally, it is to be expected that the current upper bounds for v > 5 can be further improved. The definition of new upper bounds on the size of CAs has been addressed in several ways (see [9] and references therein). One active area of research is the construction of CAs with a maximum number of factors and a smaller number of rows (i.e., to improve the currently known upper bounds for CAN).
A CPHF, denoted by CPHF ( n ; k , v , t ) , has four parameters (n, t, k, and v), where n is the cardinality of the row set, k is the number of columns, v is the order or alphabet that must be a prime power, and t indicates the coverage strength of the CPHF; the covering properties of CPHFs will be explained later in this section.
CPHFs are very convenient representations of CAs for two main reasons: (1) a CPHF with n rows accounts for n · v t rows in its associated covering array; and (2) the coverage verification for a CPHF has a computational complexity proportional to n · k t · t 3 , while the computational complexity of the coverage verification in a covering array has a computational complexity proportional to n · v t · k t . To appreciate this advantage, assume a CPHF (3; 25, 7, 6), the corresponding CA will have 3 · 7 6 = 352,947 rows, i.e., a CA ( 352 , 947 ; 6 , 25 , 7 ) is obtained. Then, the computational effort to verify the CPHF will be on the order of 114,760,800, and conversely, the effort to verify the CA will be on the order of 62,506,913,700.
It was decided to construct improved upper bounds on the size of covering arrays for v = 7 using a CPHF representation (since the next prime power greater than 5 is 7). To achieve this goal, a greedy column-extension algorithm that starts with a random CPHF with 8 columns was used.
CPHFs were first described by Sherwood et al. [10]; and extensions of that work were given in [6,11,12,13,14] and references therein. The elements of CPHFs are t-tuples over F v , denoting the finite field with v elements. Let ( α 0 ( i ) , α 1 ( i ) , , α t 1 ( i ) ) be the base v representation of i { 0 , 1 , , v t 1 } , that is, i = α 0 ( i ) + v 1 α 1 ( i ) + + v t 1 α t 1 ( i ) ; and let ( h 0 , h 1 , , h t 1 ) be an element of a CPHF ( n ; k , v , t ) . This element generates a vector of size v t , where for 0 i v t 1 the symbol in position i is ( h 0 × α 0 ( i ) ) + ( h 1 × α 1 ( i ) ) + + ( h t 1 × α t 1 ( i ) ) . In other words, the vector of size v t is generated by computing the inner product of ( h 0 , h 1 , , h t 1 ) with the base v representation of each i { 0 , 1 , , v t 1 } .
A t-tuple of CPHF elements generates an array of size v t × t by placing as column vectors the vectors of length v t that are generated by the t CPHF elements. If this array is an OA ( v t ; t , t , v ) , then the t-tuple of CPHF elements is deemed covering; otherwise, the t-tuple is deemed non-covering [10]. In a CPHF ( n ; k , v , t ) , every t-subset of columns contains at least one covering tuple of CPHF elements.
A CPHF ( n ; k , v , t ) produces a CA ( n · v t ; t , k , v ) when the CPHF elements are replaced by their corresponding column vectors of length v t . However, the resulting covering array has a certain number of repeated rows, which can be eliminated to reduce the size of the covering array. The number of repeated rows in the corresponding CA depends on the repetition of values in the columns of the CPHF. See, for example, the CPHF( 3 ; 23 , 3 , 3 ) shown in Table 1 (matching elements in each column are colored in cyan), the corresponding CA with n · v t = 3 · 3 3 = 81 rows, CA ( 81 ; 3 , 23 , 3 ) , is shown in Table 2; repeated rows are colored in cyan (this means that after the removal of the repeated rows, the CA will be CA ( 75 ; 3 , 23 , 3 ) .
The advantage of the CPHF representation is that it allows for efficient verification of the covering conditions. The covering test is as follows: a t-tuple of CPHF elements is a covering tuple if and only if the t × t matrix (whose rows are the t CPHF elements) is nonsingular [11]. Then, to verify whether a given array over F v t is a CPHF ( n ; k , v , t ) , it is necessary to validate that each k t subarray of t columns contains at least one covering tuple. At most, it is necessary to solve k t · n linear systems of size t × t , each of which takes O ( t 3 ) time using Gaussian elimination.
The structure of the document is as follows: Section 2 reviews the randomized extension algorithm of [11] to add new columns to an initial CPHF; Section 3 describes our greedy method of adding new columns to a given CPHF; Section 4 presents the most important results that were obtained using the new greedy column-extension method; and Section 5 presents the conclusions.

2. Related Works

Colbourn et al. [11] introduced a random extension algorithm to increase the number of columns of an initial CPHF with k 0 columns. The initial CPHF ( n ; k 0 , v , t ) is created by a randomized algorithm. At the beginning of the algorithm, an array of size n × k 0 (remember that n is the number of rows of the CPHF and k 0 is the initial number of columns) is filled uniformly, at random, with elements from the set F v t ; this array might not be a CPHF because it is possible that some subarrays of t columns do not have a covering tuple (remember that t defines the strength of the CPHF). From these subarrays, one column is selected at random and its n entries are again assigned with random elements from F v t ; this process of resampling columns is repeated until the array becomes a CPHF ( n ; k 0 , v , t ) .
Now that the initial CPHF ( n ; k 0 , v , t ) has been generated, the task is to add as many columns as possible to form a CPHF ( n ; k , v , t ) with k k 0 columns (i.e., try to increase the number of columns). The extension algorithm generates random columns until it finds one that makes a CPHF with the ongoing solution, which at first is CPHF ( n ; k 0 , v , t ) . Thus, the first new solution is CPHF ( n ; k 0 + 1 , v , t ) , and becomes the new ongoing solution. The process is repeated in an attempt to construct a CPHF ( n ; k 0 + 2 , v , t ) . The number of columns to add to the initial CPHF is not predefined, but the algorithm performs a predefined number of iterations, where an iteration consists of generating a random column and checking if it can be appended to the current solution.
However, the algorithm has an interesting strategy for cases in which the random column does not form a CPHF with the ongoing solution, A = CPHF ( n ; k , v , t ) . Let [ X Y ] be the horizontal concatenation of arrays X and Y, and let C be a random column. For each ( t 1 ) -set B of columns from A, the extension algorithm determines whether the array [ B C ] contains at least one covering tuple; if not, the algorithm performs the following two actions:
  • Increment by one unit the value of a variable numuncov that is used to store the number of uncovered subarrays, that is, the number of subarrays that have no covering tuple as a row.
  • Increment the value of uncov[i] by one unit for each column i B . This array uncov stores the number of times that column i of the ongoing solution participates in an uncovered subarray.
If max(uncov[i]: 0 i k 1 ) = numuncov, then the random column C replaces one of the columns i such that uncov[i] = numuncov. Thus, the ongoing solution, A = CPHF ( n ; k , v , t ) , is not extended, but is modified because one of its columns was replaced by a randomly generated column.
This strategy attempts to eliminate from the current solution the columns that do not allow the addition of new columns. A large number of CAs were refined by this random extension algorithm.
Colbourn and Lanus [15] used the random extension algorithm from [11] to construct restricted CPHFs. Let A = CPHF ( n ; k , v , t ) , and denote by A i , j , l the l-th entry of the element at column j and row i of A. A restriction S of the replication r and dimension m is given by an r-tuple ( x 0 , x 1 , , x r 1 ) of distinct elements from { 0 , 1 , , n 1 } and by an r-tuple ( U 0 , U 1 , , U r 1 ) , where each U i is a m-tuple of distinct elements from { 0 , 1 , , t 1 } . Denote by U i j the j-th element of U i . A satisfies S if when 0 c , d r 1 is A x c , j , U c l = A x d , j , U d l for all 0 j k 1 and 0 l m 1 . A CPHF can satisfy one or more restrictions.
Wagner et al. [16] recently proposed an extension of the IPO algorithm called CPHIPO, which works directly in the CPHF domain and not in the CA domain, and many new CANs were reported.
Other related algorithms are those that expand a given covering array by adding more columns and possibly more rows. However, in the case of CAs, the columns to be added are not generated randomly, they are generated through a process that tries to minimize the number of t-tuples over Z v that are not covered in the new subarrays of t columns created by adding the new column. Examples of these algorithms are the IPO algorithm [17], the coverage inheritance algorithm [18], and the two-stage algorithm of [5].

3. Greedy Column Extension Algorithm

The greedy algorithm of this work adds s > 0 columns to a given CPHF ( n ; k 0 , v , t ) with k 0 columns. For each new column added, a new array is obtained. Then, the results of the algorithm are s arrays over F v t with the respective number of columns k 0 + 1 , k 0 + 2 , …, k 0 + s ; each of these arrays may or may not be a complete CPHF ( n ; k , v , t ) , where k { k 0 + 1 , , k 0 + s } .
During the execution of the algorithm, the number of columns of the ongoing solution increases and decreases so that several solutions can be generated with the same k { k 0 + 1 , , k 0 + s } . At any time, bestGlobalSolutions[j] contains the best solution found with k 0 + j columns, where j { 0 , 1 , , s } ; in particular, bestGlobalSolutions[0] contains the initial CPHF ( n ; k 0 , v , t ) with k 0 columns. The best solution found for a certain number of columns k is the array of size n × k over F v t , which has the smallest number of uncovered subarrays among all arrays with k columns that have been constructed by the algorithm.
To add a new column to the ongoing solution B with k columns, the algorithm generates numCandidates random columns, and the one that produces the smallest number of uncovered subarrays is added to B, which now has k + 1 columns. Each time a solution with k + 1 columns is constructed from a solution with k columns, the algorithm checks whether the new ongoing solution with k + 1 columns improves the best global solution with k + 1 columns, and in the positive case, the algorithm stores the new solution in bestGlobalSolutions[ k + 1 k 0 ].
After the addition of a new column, the algorithm deletes from the new ongoing solution B up to δ columns ( δ is the maximum number of columns that are deleted when trying to improve results), where δ > 1 . At each step, the algorithm deletes from the current solution the column involved in more uncovered subarrays. Suppose that the ongoing solution B has k > k 0 columns, where k 0 is the number of columns of the initial CPHF; then, the number of columns to be removed from B is p = min( δ , k k 0 ). The p columns are removed from B one at a time, producing p arrays with the respective numbers of columns k 1 , k 2 , , k p . The objective of producing these p arrays is to refine the best global solution with k 1 , k 2 , , k p columns. Each array with k i columns that improves its corresponding best global solution becomes the new best global solution with k i columns, and so it is stored in bestGlobalSolutions[ k i k 0 ].
After deleting the p columns from the ongoing solution with k columns, there are two possible cases:
  • None of the best global solutions with k 1 , k 2 , , k p were refined.
  • At least one of the best global solutions with k 1 , k 2 , , k p was refined.
In the first case, the algorithm continues its normal work, and it generates numCandidates random columns again to select the one that will be added to the ongoing solution.
The second case is more interesting. Suppose that the smallest refined best global solution was the one with k l columns ( 1 l p ) . Then, this array becomes the new ongoing solution B, and the process of adding one more column to the ongoing solution is restarted from this new ongoing solution.
Column removal is what makes this new algorithm special. It seems that removing columns takes us away from our desired result, but in reality, it is what allows us to build high-quality CPHFs. It is relevant to highlight that the algorithm does not remove just one column from the ongoing solution, it can remove several columns in a single iteration of the outer while loop.
The algorithm ends when the maximum number of columns to add is reached and none of the p arrays with the number of columns k 0 + s 1 , k 0 + s 2 , , k 0 + s p improves the corresponding global solution.
Algorithm 1 presents the pseudocode of the greedy algorithm to add columns to a given CPHF ( n ; k 0 , v , t ) . In the algorithm, k is not the number of columns of the ongoing solution, but the number of new columns that have been added to the initial CPHF with k 0 columns; so the ongoing solution has k 0 + k columns in the algorithm.
Algorithm 1: greedyExtension( A = CPHF ( n ; k 0 , v , t ) , s, numCandidates, δ )
 1 bestGlobalSolutions ← vector( s + 1 );
 2 bestGlobalSolutions[0] A ;
 3 for  i 1 to s do
Mathematics 12 01908 i001
28 writeResults(bestGlobalSolutions);
At the beginning of the while loop, the ongoing solution B is initialized with the best global solution with k 0 + k columns; so each iteration of the loop always takes the best solution found so far for its number of columns, regardless of what happened in the previous iteration. This is the greedy part of the algorithm because the algorithm does not take as the ongoing solution the one generated in the previous iteration. In some cases, the best ongoing solution with k columns may be the solution generated in the previous iteration, but it may also be a solution generated several iterations ago.
There are two places in the algorithm where a solution with k { k 0 , k 0 + 1 , , k 0 + s 1 } columns can be refined. The first place is at line 17 when a solution with k columns is obtained by adding a new column to the previous solution with k 1 columns. The second place is at line 24 when a solution with k columns is obtained by deleting columns from a solution with more than k columns. For the solution with k 0 + s columns, the only place where it can be refined is at line 17.
Note that the algorithm is designed in such a way that the initial array A = CPHF ( n ; k 0 , v , t ) may or may not be a complete CPHF, i.e., the input array can have some uncovered subarrays, and the algorithm may construct a complete CPHF. That is the reason why the input array A is placed in position 0 of bestGlobalSolutions. In particular, a random CPHF with 8 columns as the initial solution was used to see the real power of the greedy extension algorithm. However, it is worth mentioning that it is possible to start with a previously constructed CPHF with any number of columns (even if the CPHF has some uncovered combinations).
Algorithm 1 uses the following helper functions:
  • vector( s + 1 ): creates a vector of size s + 1 .
  • randomColumn( n , t , v ) : generates a column vector of size n, where each element is from the set F v t .
  • concatenateArrays( B , C ): creates and returns an array that contains the columns of B followed by the columns of C; the input arrays are not modified.
  • uncoveredSubarrays(X): returns the number of uncovered subarrays in the input array X.
  • removeWorstColumn(E): removes from the array E the column that appears more times in the uncovered subarray. The input array has one column less after the function call. If there is more than one column with the highest number of occurrences in uncovered subarrays, then one of those columns is selected randomly.
  • writeResults(bestGlobalSolutions): writes the best global solution for each array with k 0 k k 0 + s columns.
The functions uncoveredSubarrays() and removeWorstColumn() are the more complex and require the most execution time. Suppose that the input array for uncoveredSubarrays() has k columns; then, the function needs to check all k t subarrays of t columns to determine how many are uncovered. In the removeWorstColumn() function, the situation is similar because the function needs to find which of the k t subarrays are uncovered in order to determine the column involved in more uncovered subarrays.
If k and/or t are large, then the number of subarrays to be processed can be huge, and so the functions uncoveredSubarrays() and removeWorstColumn() could take a long time to run. This is an important factor to consider because uncoveredSubarrays() is invoked several times, and removeWorstColumn() is invoked p times in every iteration of the main while loop.
For these reasons, a small implementation refinement in the above algorithm was made. Together with each best global solution, the list of the subarrays that are uncovered in the solution was stored. On line 12, verification of the new subarrays of t columns that are created by the addition of the new column C to the ongoing solution B is performed. Let L be the list of the new subarrays that do not have a covering tuple as a row. Then, the list of uncovered subarrays for D is obtained by concatenating the list of uncovered subarrays for B with the list L. On line 23, the advantage of the list of uncovered subarrays to efficiently find the worst column in an array, was used.

4. Computational Results

Before presenting the main computational results, one of the cases where the greedy extension algorithm was able to achieve a new best result will be described. The initial CPHF is the non-restricted CPHF( 3 ; 32 , 7 , 4 ), which was built with the algorithm in [19]. The Algorithm 1 was executed with the following parameters: A = CPHF( 3 ; 32 , 7 , 4 ), s = 13 , numCandidates= 15,000, and δ = 6 . Table 3 shows the evolution of the number of uncovered subarrays for each number of columns from 33 to 45. The first column indicates the current number of columns; it can be seen how this value increases and decreases as the algorithm executes. In each row, the new best global result achieved for a column is enclosed in a box. It can be seen that the algorithm does not always obtain a new best global result for the column immediately before or after the last refined one. In this example, our algorithm can construct a CPHF( 3 ; 37 , 7 , 4 ), which is one of the results reported in Table 5. After this CPHF was built, the algorithm continued its execution, but it was not able to make zero the number of uncovered subarrays for a CPHF with k > 37 columns. For this reason, the rest of the iterations are not shown.
In the following, a description of the main computational results obtained with Algorithm 1 is presented. In most cases, the initial solution is a random CPHF with eight columns. The algorithm can construct both normal and constrained CPHFs.
Since the candidate columns are randomly generated, the algorithm is not deterministic. Moreover, it is possible to make several runs with an initial randomly generated CPHF, but with different values for the other three parameters. In the computational experimentation performed to obtain the results in this paper, the values for the parameters are as follows: numCandidates = 15,000, δ = s / 2 , and value of s varies between 10 and 2000 depending on the cardinality of the row set of the initial CPHF; the higher the cardinality of the row set, the higher the value of s (since our algorithm accepts any input CPHF, the result of one run can be used to make another run to add more columns).
As mentioned above, the focus was only on constructing CPHFs of order v = 7 and strengths from 3 to 6 (since excellent upper bounds have previously been reported for v 2 , 3 , 4 , 5 , the next prime power is 7; but it is possible to run the algorithm with any alphabet that is a prime power). As shown in Table 4, Table 5, Table 6 and Table 7, a large number of new results were achieved; it seems that this is good proof of the effectiveness of the proposed algorithm. The results are compared against the ones reported in [8].
Table 4 shows the important results for CPHFs of strength 3. The constructed CPHF is shown in the first column of the table, and the coverage array that is generated from the CPHF is given in the second column of the table. The CPHFs in the first column can be restricted or non-restricted. When there is more than one CPHF for the same cardinality of the set of rows, the ones with fewer columns are the restricted ones. As mentioned above, a CPHF can satisfy one or more restrictions, so that CPHFs with the same row-set cardinalities produce CAs with different row-set cardinalities. The third column of the table indicates the row-set cardinality of the previously known CA with the same number of columns, order, and strength as the covering array in the second column; thus, for example, the value in the third column of the first row indicates that the previously known covering array with k = 64 columns, order v = 7 , and strength t = 3 had N = 1014 rows, but the CA generated from our CPHF has 973 rows.
The last column of the table shows how many CA numbers (CAN) were refined by the new result in the second column. The covering array number for given values of t, k, and v, denoted by CAN ( t , k , v ) , is the minimum cardinality of the set of rows N for which there exists a covering array with precisely N rows, strength t, k columns, and order v. The minimum N for given values of t, k, and v is unknown in general. In the covering array number notation, the information in the first row of Table 4 indicates that the previously known result was CAN ( 3 , 64 , 7 ) 1014 , and that the new result is CAN ( 3 , 64 , 7 ) 973 . Our result improves the upper bound of CAN ( 3 , 64 , 7 ) from 1014 to 973. Value 7 in the last column of the first row indicates that N = 973 improves the known upper bound of the seven covering array numbers CAN ( 3 , 58 k 64 , 7 ) . In general, in any row of the table, let a and b, respectively, be the cardinality of the set of rows and columns of the covering array in the second column of the table, and let c be the value in the fourth column; then a is the new bound for the c covering array numbers CAN ( 3 , b c + 1 k b , 7 ) . The previous best bounds of the coverage array numbers were obtained from the covering array tables [8]. Table 4 reports 19 new CPHFs whose derived covering arrays refined 903 covering array numbers.
Similar to Table 4, Table 5 displays the most important results for t = 4 . In this case, the table contains 59 CPHFs, and their derived CAs refined 8910 best sizes of CANs. This is remarkable since the covering array tables contain results of CAs up to 10,000 columns, and our algorithm improved 8910 CANs. That is, our algorithm improved most of the known results for v = 7 and t = 4 .
Table 6 shows the computational results for strength five. The number of new CPHFs is 39, and the number of new upper bounds of CANs is 1957. The latter number is considerably smaller than the respective numbers for strength t = 4 ; the reason is the time constraints for processing CPHFs with k 2000 columns. However, it was a good achievement to construct a CPHF with 1999 columns, considering that it has 1999 5 = 264,672,325,837,899 submatrices with t = 5 columns. The obtained results suggest that our algorithm can refine the best-known sizes of CANs with k 2000 , but it was not possible to extend the computational experimentation beyond 2000 columns for t = 5 .
The main results for the strength t = 6 are shown in Table 7. The table contains 35 new CPHFs that are responsible for the improvement of 786 best CAN upper bounds. In this case, it was possible to process CPHFs with a maximum of k = 800 columns. As for strength t = 5 , the results indicate that our algorithm could improve the current best-covering arrays with k > 800 columns, but more computer resources will be needed.
In total, Table 4, Table 5, Table 6 and Table 7 contain 152 new CPHFs, which allow the improvement of 12,556 best sizes of covering array numbers. All the needed algorithms to obtain the results were coded in C language, ran under a UNIX environment, and compiled using GCC 11.4.0.

5. Conclusions

The main research question to be answered in this investigation concerns the improvement of upper bounds on the size of covering arrays of alphabet 7. This question was answered positively, given the definition of 12,556 new upper bounds of covering array numbers. The two reasons for focusing on order 7 were as follows: (a) the representation used is a covering perfect hash family that is defined only for prime power alphabets; (b) excellent upper bounds have been reported for alphabets 2, 3, 4, and 5, ergo, the next prime power alphabet is 7. The algorithm used to improve the upper bounds for covering arrays was a greedy column-extension algorithm that uses a column addition/removal process and starts with a random CPHF with eight columns. Our proposal allowed the construction of 152 new CPHFs of strengths 3, 4, 5, and 6. For strength three, 19 new CPHFs were built, and the derived CAs improved the upper bound of 903 CANs; for strength four, 59 new CPHFs were constructed and a total of 8910 new CANs were obtained; for strength five, the number of new CPHFs was 39 and the number of improved bounds of CANs was 1957; and finally, for strength six, the number of new CPHFs was 35 and the number of improved bounds of CANs was 786. In total, 152 new CPHFs were built, allowing the improvement of 12,556 upper bounds of CANs.

Author Contributions

Conceptualization, J.T.-J.; Methodology, J.T.-J.; Software, J.T.-J. and I.I.-M.; Validation, J.T.-J. and I.I.-M.; Formal analysis, J.T.-J. and I.I.-M.; Investigation, J.T.-J. and I.I.-M.; Resources, J.T.-J. and I.I.-M.; Data curation, J.T.-J. and I.I.-M.; Writing—original draft, J.T.-J. and I.I.-M.; Writing—review & editing, J.T.-J. and I.I.-M.; Visualization, J.T.-J. and I.I.-M.; Supervision, J.T.-J.; Project administration, J.T.-J.; Funding acquisition, J.T.-J. All authors have read and agreed to the published version of the manuscript.

Funding

CONAHCyT for the support of the project CF-2023-I-1014 “Construcción de un repositorio de Cluster Covering Arrays usando una metodología de tres etapas”.

Data Availability Statement

The CPHFs reported in this paper can be available upon request by email to the corresponding author.

Acknowledgments

The authors acknowledge: CONAHCyT for the support of the project CF-2023-I-1014 “Construcción de un repositorio de Cluster Covering Arrays usando una metodología de tres etapas”.

Conflicts of Interest

The authors declare no conflicts of interest.

Abbreviations

The following abbreviations are used in this manuscript:
CAcovering array
CANcovering array number
CPHFcovering perfect hash family

References

  1. Bush, K. Orthogonal arrays of index unity. Ann. Math. Stat. 1952, 23, 426–434. [Google Scholar] [CrossRef]
  2. Kuhn, R.; Lei, Y.; Kacker, R. Practical Combinatorial Testing: Beyond Pairwise. IT Prof. 2008, 10, 19–23. [Google Scholar] [CrossRef]
  3. Yuan, X.; Cohen, M.B.; Memon, A.M. GUI Interaction Testing: Incorporating Event Context. IEEE Trans. Softw. Eng. 2011, 37, 559–574. [Google Scholar] [CrossRef]
  4. Torres-Jimenez, J.; Rodriguez-Tello, E. New bounds for binary covering arrays using simulated annealing. Inf. Sci. 2012, 185, 137–152. [Google Scholar] [CrossRef]
  5. Torres-Jimenez, J.; Avila-George, H.; Izquierdo-Marquez, I. A two-stage algorithm for combinatorial testing. Optim. Lett. 2017, 11, 457–469. [Google Scholar] [CrossRef]
  6. Torres-Jimenez, J.; Izquierdo-Marquez, I. Covering arrays of strength three from extended permutation vectors. Des. Codes Cryptogr. 2018, 86, 2629–2643. [Google Scholar] [CrossRef]
  7. Torres-Jimenez, J.; Izquierdo-Marquez, I. A Simulated Annealing Algorithm to Construct Covering Perfect Hash Families. Math. Probl. Eng. 2018, 2018, 1860673. [Google Scholar] [CrossRef]
  8. Colbourn, C.J. Covering Array Tables for t = 2, 3, 4, 5, 6. 2020. Available online: https://www.public.asu.edu/~ccolbou/src/tabby/catable.html (accessed on 14 June 2024).
  9. Torres-Jimenez, J.; Izquierdo-Marquez, I.; Avila-George, H. Methods to Construct Uniform Covering Arrays. IEEE Access 2019, 7, 42774–42797. [Google Scholar] [CrossRef]
  10. Sherwood, G.B.; Martirosyan, S.S.; Colbourn, C.J. Covering arrays of higher strength from permutation vectors. J. Comb. Des. 2006, 14, 202–213. [Google Scholar] [CrossRef]
  11. Colbourn, C.J.; Lanus, E.; Sarkar, K. Asymptotic and constructive methods for covering perfect hash families and covering arrays. Des. Codes Cryptogr. 2018, 86, 907–937. [Google Scholar] [CrossRef]
  12. Colbourn, C.J.; Dougherty, R.E. Fractal Perfect Hash Families (Extended Abstract). Electron. Notes Discret. Math. 2018, 65, 37–42. [Google Scholar] [CrossRef]
  13. Colbourn, C.J.; Dougherty, R.E.; Horsley, D. Distributing hash families with few rows. Theor. Comput. Sci. 2019, 800, 31–41. [Google Scholar] [CrossRef]
  14. Walker, R.A.; Colbourn, C.J. Tabu search for covering arrays using permutation vectors. J. Stat. Plan. Inference 2009, 139, 69–80. [Google Scholar] [CrossRef]
  15. Colbourn, C.J.; Lanus, E. Subspace restrictions and affine composition for covering perfect hash families. Art Discret. Appl. Math. 2018, 1, P2-03. [Google Scholar] [CrossRef]
  16. Wagner, M.; Colbourn, C.J.; Simos, D.E. In-Parameter-Order strategies for covering perfect hash families. Appl. Math. Comput. 2022, 421, 126952. [Google Scholar] [CrossRef]
  17. Lei, Y.; Tai, K.C. In-Parameter-Order: A Test Generation Strategy for Pairwise Testing. In Proceedings of the 3rd IEEE International High-Assurance Systems Engineering Symposium, Washington, DC, USA, 13–14 November 1998; pp. 254–261. [Google Scholar]
  18. Calvagna, A.; Gargantini, A. T-wise combinatorial interaction test suites construction based on coverage inheritance. Softw. Test. Verif. Reliab. 2012, 22, 507–526. [Google Scholar] [CrossRef]
  19. Torres-Jimenez, J.; Izquierdo-Marquez, I. Improved covering arrays using covering perfect hash families with groups of restricted entries. Appl. Math. Comput. 2020, 369, 124826. [Google Scholar] [CrossRef]
Table 1. Explicit CPHF( 3 ; 3 , 23 , 3 ).
Table 1. Explicit CPHF( 3 ; 3 , 23 , 3 ).
200210221220222221120120121122112122100202102222201220200212202001122
212211201222202211120100110120112121101220111221200212220222210022102
202211200200221221111110120121110102111200102211210210212221202022122
Table 2. CA corresponding to the restricted CPHF( 3 ; 3 , 23 , 3 ) in which the first element in each column is the same. Each column of the table corresponds to one of the rows of the CPHF( 3 ; 3 , 23 , 3 ), the repeated rows are shown colored.
Table 2. CA corresponding to the restricted CPHF( 3 ; 3 , 23 , 3 ) in which the first element in each column is the same. Each column of the table corresponds to one of the rows of the CPHF( 3 ; 3 , 23 , 3 ), the repeated rows are shown colored.
First RowSecond RowThird Row
000000000000000000000000000000000000000000000000000000000000000000000
001021001222022210022120012100210102212102201200111110120111102211010
002012002111011120011210021200120201121201102100222220210222201122020
010210220101022112002110101211201101022100120001002211221010011112022
011201221020011022021200110011111200201202021201110021011121110020002
012222222212000202010020122111021002110001222101221101101202212201012
020120110202011221001220202122102202011200210002001122112020022221011
021111111121000101020010211222012001220002111202112202202101121102021
022102112010022011012100220022222100102101012102220012022212220010001
100210001202201122120121001101111022220212122010001101211100101121100
101201002121220002112211010201021121102011020210112211001211200002110
102222000010212212101001022001201220011110221110220021121022002210120
110120221000220201122201102012012120212012212011000012102110112200122
111111222222212111111021111112222222121111110211111122222221211111102
112102220111201021100111120212102021000210011111222202012002010022112
120000111101212010121011200220210221201112002012002220020120120012111
121021112020201220110101212020120020110211200212110000110201222220121
122012110212220100102221221120000122022010101112221110200012021101101
200120002101102211210212002202222011110121211020002202122200202212200
201111000020121121202002011002102110022220112220110012212011001120210
202102001212110001221122020102012212201022010120221122002122100001220
210000222202121020212022100110120112102221001021001110010210210021222
211021220121110200201112112210000211011020202221112220100021012202202
212012221010102110220202121010210010220122100121220000220102111110212
220210112000110102211102201021021210121021121022000021201220221100211
221201110222102012200222210121201012000120022222111101021001020011221
222222111111121222222012222221111111212222220122222211111112122222201
Table 3. Execution of Algorithm 1 with parameters A = CPHF ( 3 ; 32 , 7 , 4 ) , s = 13 , numCandidates = 15,000, δ = 6 .
Table 3. Execution of Algorithm 1 with parameters A = CPHF ( 3 ; 32 , 7 , 4 ) , s = 13 , numCandidates = 15,000, δ = 6 .
Current # Cols33343536373839404142434445
33 2
342 5
3525 9
36259 13
342 4 913
3524 6 13
342 3 613
33 1 3613
36136 9
3513 5 9
36135 6
3513 4 6
341 2 46
33 0 246
370246 10
3502 3 610
340 1 3610
38013610 14
3901361014 18
38013610 13 18
370136 9 1318
390136913 17
370136 8 1317
36013 5 81317
3501 2 581317
36012 4 81317
3501 1 481317
340 0 1481317
370014 7 1317
3800147 12 17
36001 3 71217
3500 0 371217
40000371217 21
4100037121721 25
390003712 15 2125
3800037 10 152125
370003 6 10152125
390003610 14 2125
36000 2 610142125
40000261014 19 25
3800026 9 141925
370002 5 9141925
3800025 8 141925
370002 4 8141925
36000 1 48141925
39000148 12 1925
3800014 7 121925
4000014712 15 25
410001471215 19
3800013 6 121519
39000136 9 1519
400001369 13 19
41000136913 17
4200013691317 22
41000136913 16 22
430001369131622 26
400001369 11 162226
39000136 8 11162226
3800013 5 811162226
41000135811 14 2226
370001 2 5811142226
4200012581114 17 26
400001258 10 141726
39000125 7 10141726
3800012 4 710141726
39000124 6 10141726
41000124610 13 1726
400001246 9 131726
4100012469 12 1726
400001246 8 121726
39000124 5 8121726
3800012 3 58121726
4100012358 10 1726
400001235 7 101726
39000123 4 7101726
370001 1 347101726
36000 0 1347101726
420000134710 13 26
43000013471013 17
4400001347101317 21
400000134 6 10131721
4100001346 9 131721
3800001 2 469131721
4100001246 8 131721
42000012468 11 1721
4100001246 7 111721
400000124 5 7111721
39000012 3 57111721
42000012357 10 1721
4300001235710 13 21
440000123571013 16
45000012357101316 20
42000012357 9 131620
430000123579 12 1620
400000123 4 79121620
4100001234 6 9121620
430000123469 11 1620
42000012346 8 111620
4100001234 5 9111620
42000012345 7 111620
4100001234 4 7111620
400000123 3 47111620
39000012 2 347111620
3800001 1 2347111620
370000 0 12347111620
Table 4. Results for CPHFs and CAs for v = 7 and t = 3 . The number of refined CAs is 973; the results are compared against the ones reported in [8].
Table 4. Results for CPHFs and CAs for v = 7 and t = 3 . The number of refined CAs is 973; the results are compared against the ones reported in [8].
CPHF ( n ; k , v , t ) CA ( N ; t , k , v ) Old NRefined CANs
CPHF( 3 ; 64 , 7 , 3 ) CA ( 973 ; 3 , 64 , 7 ) 10147
CPHF( 3 ; 80 , 7 , 3 ) CA ( 1009 ; 3 , 80 , 7 ) 101516
CPHF( 4 ; 200 , 7 , 3 ) CA ( 1309 ; 3 , 200 , 7 ) 135117
CPHF( 4 ; 209 , 7 , 3 ) CA ( 1321 ; 3 , 209 , 7 ) 13519
CPHF( 4 ; 241 , 7 , 3 ) CA ( 1351 ; 3 , 241 , 7 ) 151914
CPHF( 4 ; 264 , 7 , 3 ) CA ( 1369 ; 3 , 264 , 7 ) 151923
CPHF( 5 ; 461 , 7 , 3 ) CA ( 1615 ; 3 , 461 , 7 ) 168761
CPHF( 5 ; 471 , 7 , 3 ) CA ( 1645 ; 3 , 471 , 7 ) 168710
CPHF( 5 ; 502 , 7 , 3 ) CA ( 1663 ; 3 , 502 , 7 ) 168731
CPHF( 5 ; 650 , 7 , 3 ) CA ( 1687 ; 3 , 650 , 7 ) 185590
CPHF( 5 ; 713 , 7 , 3 ) CA ( 1711 ; 3 , 713 , 7 ) 189763
CPHF( 6 ; 753 , 7 , 3 ) CA ( 1855 ; 3 , 753 , 7 ) 189740
CPHF( 6 ; 798 , 7 , 3 ) CA ( 1861 ; 3 , 798 , 7 ) 189745
CPHF( 6 ; 810 , 7 , 3 ) CA ( 1891 ; 3 , 810 , 7 ) 189712
CPHF( 6 ; 838 , 7 , 3 ) CA ( 1897 ; 3 , 838 , 7 ) 19099
CPHF( 6 ; 952 , 7 , 3 ) CA ( 1909 ; 3 , 952 , 7 ) 1939101
CPHF( 6 ; 1200 , 7 , 3 ) CA ( 1957 ; 3 , 1200 , 7 ) 1999163
CPHF( 6 ; 1300 , 7 , 3 ) CA ( 2005 ; 3 , 1300 , 7 ) 202386
CPHF( 6 ; 1700 , 7 , 3 ) CA ( 2053 ; 3 , 1700 , 7 ) 2191106
Table 5. Results for CPHFs and CAs for v = 7 and t = 4 . The number of refined CAs is 8910; the results are compared against the ones reported in [8].
Table 5. Results for CPHFs and CAs for v = 7 and t = 4 . The number of refined CAs is 8910; the results are compared against the ones reported in [8].
CPHF ( n ; k , v , t ) CA ( N ; t , k , v ) Old NRefined CANs
CPHF( 2 ; 15 , 7 , 4 ) CA ( 4459 ; 4 , 15 , 7 ) 47531
CPHF( 2 ; 18 , 7 , 4 ) CA ( 4753 ; 4 , 18 , 7 ) 47951
CPHF( 2 ; 19 , 7 , 4 ) CA ( 4795 ; 4 , 19 , 7 ) 68531
CPHF( 3 ; 24 , 7 , 4 ) CA ( 6517 ; 4 , 24 , 7 ) 68535
CPHF( 3 ; 29 , 7 , 4 ) CA ( 6811 ; 4 , 29 , 7 ) 68535
CPHF( 3 ; 31 , 7 , 4 ) CA ( 6853 ; 4 , 31 , 7 ) 71471
CPHF( 3 ; 34 , 7 , 4 ) CA ( 7147 ; 4 , 34 , 7 ) 71891
CPHF( 3 ; 36 , 7 , 4 ) CA ( 7189 ; 4 , 36 , 7 ) 89112
CPHF( 3 ; 37 , 7 , 4 ) CA ( 7201 ; 4 , 37 , 7 ) 89111
CPHF( 4 ; 40 , 7 , 4 ) CA ( 8575 ; 4 , 40 , 7 ) 89113
CPHF( 4 ; 46 , 7 , 4 ) CA ( 8911 ; 4 , 46 , 7 ) 92051
CPHF( 4 ; 50 , 7 , 4 ) CA ( 8917 ; 4 , 50 , 7 ) 92474
CPHF( 4 ; 52 , 7 , 4 ) CA ( 9205 ; 4 , 52 , 7 ) 92472
CPHF( 4 ; 54 , 7 , 4 ) CA ( 9211 ; 4 , 54 , 7 ) 94992
CPHF( 4 ; 55 , 7 , 4 ) CA ( 9253 ; 4 , 55 , 7 ) 94991
CPHF( 4 ; 58 , 7 , 4 ) CA ( 9259 ; 4 , 58 , 7 ) 96013
CPHF( 4 ; 59 , 7 , 4 ) CA ( 9505 ; 4 , 59 , 7 ) 96011
CPHF( 4 ; 69 , 7 , 4 ) CA ( 9583 ; 4 , 69 , 7 ) 11,30510
CPHF( 4 ; 70 , 7 , 4 ) CA ( 9601 ; 4 , 70 , 7 ) 11,3051
CPHF( 5 ; 89 , 7 , 4 ) CA ( 11 , 305 ; 4 , 89 , 7 ) 11,64110
CPHF( 5 ; 100 , 7 , 4 ) CA ( 11 , 599 ; 4 , 100 , 7 ) 12,00111
CPHF( 5 ; 104 , 7 , 4 ) CA ( 11 , 641 ; 4 , 104 , 7 ) 12,0014
CPHF( 5 ; 114 , 7 , 4 ) CA ( 11 , 893 ; 4 , 114 , 7 ) 12,00110
CPHF( 5 ; 119 , 7 , 4 ) CA ( 11 , 935 ; 4 , 119 , 7 ) 13,3635
CPHF( 5 ; 120 , 7 , 4 ) CA ( 11 , 977 ; 4 , 120 , 7 ) 13,6991
CPHF( 5 ; 126 , 7 , 4 ) CA ( 12 , 001 ; 4 , 126 , 7 ) 13,6996
CPHF( 6 ; 128 , 7 , 4 ) CA ( 13 , 363 ; 4 , 128 , 7 ) 13,6992
CPHF( 6 ; 144 , 7 , 4 ) CA ( 13 , 657 ; 4 , 144 , 7 ) 13,99316
CPHF( 6 ; 161 , 7 , 4 ) CA ( 13 , 699 ; 4 , 161 , 7 ) 14,28717
CPHF( 6 ; 170 , 7 , 4 ) CA ( 13 , 717 ; 4 , 170 , 7 ) 14,3719
CPHF( 6 ; 180 , 7 , 4 ) CA ( 13 , 993 ; 4 , 180 , 7 ) 14,40110
CPHF( 6 ; 185 , 7 , 4 ) CA ( 14 , 035 ; 4 , 185 , 7 ) 14,4015
CPHF( 6 ; 189 , 7 , 4 ) CA ( 14 , 287 ; 4 , 189 , 7 ) 14,4014
CPHF( 6 ; 222 , 7 , 4 ) CA ( 14 , 371 ; 4 , 222 , 7 ) 14,40133
CPHF( 7 ; 247 , 7 , 4 ) CA ( 15 , 757 ; 4 , 247 , 7 ) 16,68122
CPHF( 7 ; 250 , 7 , 4 ) CA ( 15 , 775 ; 4 , 250 , 7 ) 16,6813
CPHF( 7 ; 267 , 7 , 4 ) CA ( 16 , 093 ; 4 , 267 , 7 ) 16,68117
CPHF( 7 ; 290 , 7 , 4 ) CA ( 16 , 117 ; 4 , 290 , 7 ) 16,76523
CPHF( 7 ; 312 , 7 , 4 ) CA ( 16 , 429 ; 4 , 312 , 7 ) 16,80122
CPHF( 7 ; 324 , 7 , 4 ) CA ( 16 , 681 ; 4 , 324 , 7 ) 16,80112
CPHF( 7 ; 379 , 7 , 4 ) CA ( 16 , 723 ; 4 , 379 , 7 ) 16,80155
CPHF( 7 ; 409 , 7 , 4 ) CA ( 16 , 801 ; 4 , 409 , 7 ) 19,07520
CPHF( 8 ; 427 , 7 , 4 ) CA ( 18 , 175 ; 4 , 427 , 7 ) 19,07518
CPHF( 8 ; 500 , 7 , 4 ) CA ( 18 , 517 ; 4 , 500 , 7 ) 19,20173
CPHF( 8 ; 543 , 7 , 4 ) CA ( 19 , 033 ; 4 , 543 , 7 ) 19,20143
CPHF( 8 ; 593 , 7 , 4 ) CA ( 19 , 075 ; 4 , 593 , 7 ) 19,20150
CPHF( 8 ; 640 , 7 , 4 ) CA ( 19 , 117 ; 4 , 640 , 7 ) 19,20147
CPHF( 8 ; 678 , 7 , 4 ) CA ( 19 , 201 ; 4 , 678 , 7 ) 21,46925
CPHF( 9 ; 800 , 7 , 4 ) CA ( 20 , 575 ; 4 , 800 , 7 ) 21,511122
CPHF( 9 ; 840 , 7 , 4 ) CA ( 20 , 917 ; 4 , 840 , 7 ) 21,60140
CPHF( 9 ; 986 , 7 , 4 ) CA ( 21 , 385 ; 4 , 986 , 7 ) 21,601146
CPHF( 9 ; 1218 , 7 , 4 ) CA ( 21 , 601 ; 4 , 1218 , 7 ) 23,90582
CPHF( 10 ; 1399 , 7 , 4 ) CA ( 22 , 975 ; 4 , 1399 , 7 ) 24,001181
CPHF( 10 ; 1500 , 7 , 4 ) CA ( 23 , 317 ; 4 , 1500 , 7 ) 24,001101
CPHF( 10 ; 1778 , 7 , 4 ) CA ( 23 , 779 ; 4 , 1778 , 7 ) 24,001278
CPHF( 11 ; 2387 , 7 , 4 ) CA ( 25 , 375 ; 4 , 2387 , 7 ) 26,401322
CPHF( 11 ; 2899 , 7 , 4 ) CA ( 26 , 173 ; 4 , 2899 , 7 ) 26,401512
CPHF( 12 ; 5758 , 7 , 4 ) CA ( 28 , 801 ; 4 , 5758 , 7 ) 44,4012265
CPHF( 13 ; 10,000 , 7 , 4 ) CA ( 31 , 201 ; 4 , 10 , 000 , 7 ) 50,2514242
Table 6. Results for CPHFs and CAs for v = 7 and t = 5 . The number of refined CAs is 1957; the results are compared against the ones reported in [8].
Table 6. Results for CPHFs and CAs for v = 7 and t = 5 . The number of refined CAs is 1957; the results are compared against the ones reported in [8].
CPHF ( n ; k , v , t ) CA ( N ; t , k , v ) Old NRefined CANs
CPHF( 2 ; 15 , 7 , 5 ) CA ( 33 , 613 ; 5 , 15 , 7 ) 48,0131
CPHF( 3 ; 18 , 7 , 5 ) CA ( 45 , 619 ; 5 , 18 , 7 ) 48,0133
CPHF( 3 ; 19 , 7 , 5 ) CA ( 47 , 677 ; 5 , 19 , 7 ) 48,0131
CPHF( 3 ; 21 , 7 , 5 ) CA ( 48 , 013 ; 5 , 21 , 7 ) 50,0712
CPHF( 3 ; 22 , 7 , 5 ) CA ( 50 , 071 ; 5 , 22 , 7 ) 50,4191
CPHF( 3 ; 24 , 7 , 5 ) CA ( 50 , 371 ; 5 , 24 , 7 ) 62,4192
CPHF( 4 ; 28 , 7 , 5 ) CA ( 62 , 419 ; 5 , 28 , 7 ) 64,4771
CPHF( 4 ; 30 , 7 , 5 ) CA ( 64 , 477 ; 5 , 30 , 7 ) 66,8292
CPHF( 4 ; 34 , 7 , 5 ) CA ( 64 , 813 ; 5 , 34 , 7 ) 67,2254
CPHF( 4 ; 36 , 7 , 5 ) CA ( 67 , 207 ; 5 , 36 , 7 ) 79,2192
CPHF( 4 ; 37 , 7 , 5 ) CA ( 67 , 225 ; 5 , 37 , 7 ) 79,2191
CPHF( 5 ; 47 , 7 , 5 ) CA ( 79 , 219 ; 5 , 47 , 7 ) 83,6298
CPHF( 5 ; 52 , 7 , 5 ) CA ( 81 , 613 ; 5 , 52 , 7 ) 95,6835
CPHF( 5 ; 57 , 7 , 5 ) CA ( 84 , 007 ; 5 , 57 , 7 ) 96,0195
CPHF( 6 ; 71 , 7 , 5 ) CA ( 96 , 019 ; 5 , 71 , 7 ) 100,83712
CPHF( 6 ; 79 , 7 , 5 ) CA ( 98 , 413 ; 5 , 79 , 7 ) 112,8198
CPHF( 6 ; 85 , 7 , 5 ) CA ( 10 , 0807 ; 5 , 85 , 7 ) 115,2136
CPHF( 6 ; 86 , 7 , 5 ) CA ( 10 , 0837 ; 5 , 86 , 7 ) 115,2131
CPHF( 7 ; 93 , 7 , 5 ) CA ( 110 , 425 ; 5 , 93 , 7 ) 115,2137
CPHF( 7 ; 103 , 7 , 5 ) CA ( 112 , 819 ; 5 , 103 , 7 ) 117,64310
CPHF( 7 ; 117 , 7 , 5 ) CA ( 115 , 213 ; 5 , 117 , 7 ) 117,64314
CPHF( 7 ; 130 , 7 , 5 ) CA ( 117 , 607 ; 5 , 130 , 7 ) 132,01313
CPHF( 7 ; 131 , 7 , 5 ) CA ( 117 , 613 ; 5 , 131 , 7 ) 132,0131
CPHF( 8 ; 143 , 7 , 5 ) CA ( 127 , 225 ; 5 , 143 , 7 ) 134,36512
CPHF( 8 ; 160 , 7 , 5 ) CA ( 129 , 619 ; 5 , 160 , 7 ) 134,44917
CPHF( 8 ; 168 , 7 , 5 ) CA ( 132 , 013 ; 5 , 168 , 7 ) 134,4498
CPHF( 8 ; 205 , 7 , 5 ) CA ( 134 , 407 ; 5 , 205 , 7 ) 151,16537
CPHF( 9 ; 207 , 7 , 5 ) CA ( 144 , 025 ; 5 , 207 , 7 ) 151,2072
CPHF( 9 ; 220 , 7 , 5 ) CA ( 146 , 419 ; 5 , 220 , 7 ) 151,25513
CPHF( 9 ; 240 , 7 , 5 ) CA ( 148 , 813 ; 5 , 240 , 7 ) 151,25520
CPHF( 9 ; 294 , 7 , 5 ) CA ( 151 , 207 ; 5 , 294 , 7 ) 167,67154
CPHF( 10 ; 340 , 7 , 5 ) CA ( 167 , 671 ; 5 , 340 , 7 ) 177,62525
CPHF( 10 ; 450 , 7 , 5 ) CA ( 168 , 007 ; 5 , 450 , 7 ) 184,765110
CPHF( 11 ; 500 , 7 , 5 ) CA ( 182 , 413 ; 5 , 500 , 7 ) 196,81950
CPHF( 11 ; 658 , 7 , 5 ) CA ( 184 , 867 ; 5 , 658 , 7 ) 201,565158
CPHF( 12 ; 694 , 7 , 5 ) CA ( 199 , 273 ; 5 , 694 , 7 ) 213,61936
CPHF( 12 ; 1000 , 7 , 5 ) CA ( 201 , 673 ; 5 , 1000 , 7 ) 547,322306
CPHF( 13 ; 1600 , 7 , 5 ) CA ( 218 , 479 ; 5 , 1600 , 7 ) 731,442600
CPHF( 14 ; 1999 , 7 , 5 ) CA ( 235 , 285 ; 5 , 1999 , 7 ) 743,922399
Table 7. Results for CPHFs and CAs for v = 7 and t = 6 . The number of refined CAs is 786; the results are compared against the ones reported in [8].
Table 7. Results for CPHFs and CAs for v = 7 and t = 6 . The number of refined CAs is 786; the results are compared against the ones reported in [8].
CPHF ( n ; k , v , t ) CA ( N ; t , k , v ) Old NRefined CANs
CPHF( 3 ; 15 , 7 , 6 ) CA ( 319 , 333 ; 6 , 15 , 7 ) 336,1332
CPHF( 3 ; 18 , 7 , 6 ) CA ( 336 , 133 ; 6 , 18 , 7 ) 352,9453
CPHF( 3 ; 19 , 7 , 6 ) CA ( 350 , 539 ; 6 , 19 , 7 ) 436,9751
CPHF( 4 ; 21 , 7 , 6 ) CA ( 436 , 975 ; 6 , 21 , 7 ) 453,7751
CPHF( 4 ; 25 , 7 , 6 ) CA ( 453 , 775 ; 6 , 25 , 7 ) 470,5934
CPHF( 4 ; 26 , 7 , 6 ) CA ( 468 , 181 ; 6 , 26 , 7 ) 554,6171
CPHF( 4 ; 27 , 7 , 6 ) CA ( 470 , 575 ; 6 , 27 , 7 ) 554,6171
CPHF( 5 ; 28 , 7 , 6 ) CA ( 537 , 823 ; 6 , 28 , 7 ) 585,8231
CPHF( 5 ; 32 , 7 , 6 ) CA ( 554 , 617 ; 6 , 32 , 7 ) 588,2414
CPHF( 5 ; 34 , 7 , 6 ) CA ( 571 , 417 ; 6 , 34 , 7 ) 588,2412
CPHF( 5 ; 36 , 7 , 6 ) CA ( 587 , 881 ; 6 , 36 , 7 ) 672,2592
CPHF( 5 ; 37 , 7 , 6 ) CA ( 588 , 217 ; 6 , 37 , 7 ) 689,0591
CPHF( 6 ; 38 , 7 , 6 ) CA ( 655 , 471 ; 6 , 38 , 7 ) 689,0591
CPHF( 6 ; 44 , 7 , 6 ) CA ( 672 , 259 ; 6 , 44 , 7 ) 705,8896
CPHF( 6 ; 47 , 7 , 6 ) CA ( 689 , 059 ; 6 , 47 , 7 ) 705,8893
CPHF( 6 ; 51 , 7 , 6 ) CA ( 705 , 523 ; 6 , 51 , 7 ) 821,1074
CPHF( 7 ; 54 , 7 , 6 ) CA ( 773 , 101 ; 6 , 54 , 7 ) 823,4593
CPHF( 7 ; 60 , 7 , 6 ) CA ( 789 , 901 ; 6 , 60 , 7 ) 823,5376
CPHF( 7 ; 66 , 7 , 6 ) CA ( 806 , 701 ; 6 , 66 , 7 ) 823,5376
CPHF( 7 ; 70 , 7 , 6 ) CA ( 823 , 459 ; 6 , 70 , 7 ) 938,7494
CPHF( 7 ; 71 , 7 , 6 ) CA ( 823 , 501 ; 6 , 71 , 7 ) 940,8071
CPHF( 8 ; 77 , 7 , 6 ) CA ( 890 , 743 ; 6 , 77 , 7 ) 941,1856
CPHF( 8 ; 86 , 7 , 6 ) CA ( 907 , 543 ; 6 , 86 , 7 ) 941,1859
CPHF( 8 ; 92 , 7 , 6 ) CA ( 924 , 343 ; 6 , 92 , 7 ) 941,1856
CPHF( 8 ; 100 , 7 , 6 ) CA ( 941 , 101 ; 6 , 100 , 7 ) 1,058,4498
CPHF( 9 ; 109 , 7 , 6 ) CA ( 1 , 008 , 385 ; 6 , 109 , 7 ) 1,142,8279
CPHF( 9 ; 130 , 7 , 6 ) CA ( 1 , 041 , 985 ; 6 , 130 , 7 ) 1,174,03321
CPHF( 9 ; 139 , 7 , 6 ) CA ( 1 , 058 , 833 ; 6 , 139 , 7 ) 1,176,4279
CPHF( 10 ; 150 , 7 , 6 ) CA ( 1 , 159 , 627 ; 6 , 150 , 7 ) 1,294,06911
CPHF( 10 ; 196 , 7 , 6 ) CA ( 1 , 176 , 481 ; 6 , 196 , 7 ) 1,411,71146
CPHF( 11 ; 250 , 7 , 6 ) CA ( 1 , 294 , 129 ; 6 , 250 , 7 ) 3,023,71354
CPHF( 12 ; 350 , 7 , 6 ) CA ( 1 , 411 , 777 ; 6 , 350 , 7 ) 5,646,840100
CPHF( 13 ; 500 , 7 , 6 ) CA ( 1 , 529 , 425 ; 6 , 500 , 7 ) 7,058,550150
CPHF( 14 ; 700 , 7 , 6 ) CA ( 1 , 647 , 073 ; 6 , 700 , 7 ) 8,470,260200
CPHF( 15 ; 800 , 7 , 6 ) CA ( 1 , 764 , 721 ; 6 , 800 , 7 ) 8,784,936100
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Torres-Jimenez, J.; Izquierdo-Marquez, I. New Upper Bounds for Covering Arrays of Order Seven. Mathematics 2024, 12, 1908. https://doi.org/10.3390/math12121908

AMA Style

Torres-Jimenez J, Izquierdo-Marquez I. New Upper Bounds for Covering Arrays of Order Seven. Mathematics. 2024; 12(12):1908. https://doi.org/10.3390/math12121908

Chicago/Turabian Style

Torres-Jimenez, Jose, and Idelfonso Izquierdo-Marquez. 2024. "New Upper Bounds for Covering Arrays of Order Seven" Mathematics 12, no. 12: 1908. https://doi.org/10.3390/math12121908

APA Style

Torres-Jimenez, J., & Izquierdo-Marquez, I. (2024). New Upper Bounds for Covering Arrays of Order Seven. Mathematics, 12(12), 1908. https://doi.org/10.3390/math12121908

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop