1. Introduction

Within a graph, a vertex pair is connectable if there is a path going from a point at the pair to the complementary point. A collection of connectable vertex pair poses the simple problem to find explicitly connecting paths for each vertex pair. Evidently, some supplementary conditions may be imposed, e.g., the located connecting paths should have the shortest possible lengths, or the paths should not cross among themselves, or the collection of connecting paths should allow the extension to a *k*-factor of the graph, for a fixed *skein* is a set of connecting paths for a collection of connectable vertex pairs.

Let us consider the following problems:

**Skein extension** Given a collection of equally length paths in a graph which are
pairwise non-crossing (no pair has a common vertex which is internal in at least one
of the paths) and disjoint (no edge is shared), it is required to add one path with
prescribed endpoints in the graph such that the resulting set of paths remains
pairwise disjoint and non-crossing.

**Skein search** Given a collection of vertex pairs, it is required to decide whether
there are connecting paths, all of the same length such that they are pairwise
non-crossing and disjoint.

2. Preliminaries

For ease of exposition, let us recall some basic notions. A *graph* is a pair *G = (V, E)* where *V(G)* is a finite and non-empty set of *vertices*, and the set *E(G)* of *edges* is an unordered subset of *V x V*. The cardinalities of *V(G)* and *E(G)* are, respectively, the *order* and the *size* of *G*. A *subgraph H* of *G* is a graph such that *induced* subgraph of *G* by *V´* is the graph having *V´* as set of vertices, and two vertices *u*, *v* in *V´* are joined by an edge in *V´* if and only if *v*
_{1} is *adjacent* to *v*
_{2} and the vertices *v*
_{1} and *v*
_{2} are *incident* to the edge *e*. The *complete graph K*
_{n} of order *n* is a graph having *n* vertices, where each one is adjacent to any other. A *clique* in *G* is a complete induced subgraph of *G*. A *path* in *G* with *initial* vertex *v*
_{0} and *ending* vertex *v*
_{m} is a sequence of vertices *i = 0,…,m - 1* *v*
_{0},…, *v*
_{m-1} are pairwise different, and *m* is a positive integer. The vertices *v*
_{0} and *v*
_{m} are the *end-vertices* or *endpoints* of *length**m*, hence *m-path*. The *internal vertices* of π are *v*
_{1},…,*v*
_{m-1}. If *v*
_{0} = *v*
_{m}, then *cycle*.

The *distance d*
_{G}
*(u,v)* between two vertices *u*, *v* in *G* is the length of a shortest path connecting *u* and *v*. Two paths which are not cycles *non-crossing* if there is no common vertex in *disjoint* if no edge appears in both paths.

A *two-factor* in a graph *G* is a family *C*
_{1},…, *C*
_{k} of cycles of *G* such that any vertex in *G* belongs to one and only one cycle *C*
_{i}. A two-factor of *G* consisting of only one cycle is a *Hamiltonian* cycle of *G*. Let *G*. If *G* is called *Hamiltonian*.

An *independent* set of *G* is a subset *I* of
*V(G)* such that no edge in *E(G)* contains both
end-points in *I*. A *maximal independent set* of
*G* is an independent set of *G* that is not a
proper subset of another independent set of *G*. A *maximum
independent set* of *G* is a maximal independent set with
the largest cardinality, the so-called *independence number*
α(*G*) of *G*.

The *Independent Set Problem* consists in finding a maximum independent set in a given instance graph *G*. This is an NP-hard problem, difficult even to be approximated^{6}.

A graph *G* is a *Berge* graph, if neither *G* nor its complement has an odd-length induced cycle of length 5 or more. It is well-known that if *G* is a Berge graph, then the independence problem on *G* can be solved in polynomial time^{5}.

Any Hamiltonian cycle *H* in a graph *G = (V, E)* determines, for each pair of distinct vertices *u* to *v* and the supplementary path from *v* to *u*. Let *u* to *v* following the order in which the vertices of *H* are listed. Since *H* is Hamiltonian, for any two pairs (*u*
_{0}, *v*
_{0}), (*u*
_{1}, *v*
_{1}) such that *u*
_{0}, *v*
_{0}, *u*
_{1}, *v*
_{1} appear in the cyclic order of the Hamiltonian cycle, the paths

Given a positive integer *n*, the *n*-dimensional
*hypercube*, denoted *Q*
_{n}, is the graph containing the *n*-dimensional vectors
with entries in *Hamming distance* between two
vertices *u*, *v* in *Q*
_{n}, denoted Hamming(*u*, *v*) is the number
of entries in which they differ. It is easy to see that the graph distance and the
Hamming distance coincide, that is, *u*, *v*
in *V*(*Q*
_{n}) .

3. Particular Problems

Let us consider the following problem:

NonCrossingPaths

**Instance**: A graph *G* = (*V, E*). A positive number
*k*, a set of pairs *k* pairwise different vertex pairs in
*G*, and a positive integer *m* satisfying

**Solution**: A pairwise non-crossing and disjoint collection of
*m*-length paths *i*
_{l} and *j*
_{l}, for *l = 1*,…, *k*.

Given a Hamiltonian cycle *H* of *G* it is very simple to complete instances of the problem NonCrossingPaths having as solutions non-crossing and disjoint paths taken from *H*. For instance, if

the collection of paths

is a solution.

Conversely, given the collection

Let us consider the following problem:

HamiltonianExtension

**Instance**: a Hamiltonian graph *G = (V, E)*. A collection *m*-paths.

**Solution**: a Hamiltonian cycle *u* and *v* are the initial and the
ending points of

For instance, for the *n*-dimensional hypercube *Q*
_{n} and *Q*
_{n} (the paths at ^{2}^{,}^{3}.

Thus, HamiltonianExtension would allow to recover a Hamiltonian cycle from a solution of the problem NonCrossingPaths. However, a solution of NonCrossingPaths may be obtained without building a whole Hamiltonian cycle containing that solution.

But solving NonCrossingPaths can be reduced to finding a maximum independent set in a huge graph as we see now.

**Definition 3.1(Path Graphs)** Given the instance (*G*,
*k*, *path graph
P*
_{m,k,K,G} be the graph whose vertices are the *m*-paths in
*G* connecting pairs at *K*:

and the edges are of two types: for any

-if

-if

An independent set *I* of *K*, with no pair of extreme points connected by two paths.

For any pair *R*(*u, v*) be the subgraph of *u* and *v*. Then *R*(*u, v*) is a clique.

Those cliques produce a partition of the vertices in *k* subsets, and any solution of the problem NonCrossingPaths should contain exactly one member at each clique, hence it has at most *k* paths. Thus, whenever there exists an independent set *I** reaching the upper bound *k*, such *I** is maximum. Hence:

**Proposition 3.1** With the above notation, the parameter *k* equals
the independence number of

4. Hamiltonian Cycles in the Hypercube

Let us examine some criteria to select instances of NonCrossingPaths making it difficult to solve the problem.

The main interest in the stated problem is to find maximum independent sets in the graph

of NonCrossingPaths.

As we have agreed before, let us consider, in particular, the hypercube *G* = *Q*
_{n} for some positive integer *n*. The edges in the hypercube *Q*
_{n} are pairs of the form *vu* where *v* + *u* = *e*
_{i} is a vector in the canonical basis of *Q*
_{n}: all its entries are zero, except for the *i*-th entry. A Hamiltonian cycle in *Q*
_{n} is a sequence *V*(*Q*
_{n}) and each pair of contiguous terms ^{n}). A *square*, or *4-cycle*, in *Q*
_{n} is a sequence *v*
_{0}
*v*
_{1}
*v*
_{2}
*v*
_{3} of pairwise different vertices forming a cycle in the hypercube. Necessarily, any square has the form

The typical Hamiltonian cycle at the hypercube is the *binary Gray code*. As a sequence, this code is determined recursively by the following recurrence:

(join and rev are, respectively, list concatenation and list reversing, ∗ is a *prepend* map: b∗list prepends the bit b to each entry at the list). For instance:

In order to have an idea about the cardinality of *m*-length paths connecting two different vertices at the *n*-dimensional hypercube.

**Remark 4.1** Let *u*
_{0} and *u*
_{m} depends exclusively upon the distance \it Hamming (*u*
_{0},*u*
_{m}).

In fact, if *Q*
_{n} with

then *h*-subsets in *h* elements. For any permutation

we have that any *m*-path *m*-path *m*-paths connecting *u*
_{0} with *u*
_{m} can be put in a bijective correspondence with the *m*-paths connecting *v*
_{0} with *v*
_{m}.

Therefore, without losing any generality, we may assume *N*(*n, h, m*) denote the number of *m*-paths connecting *u*
_{0} and *u*
_{m}. The following remarks are evident:

-If either *N*(*n, h, m*) = 0.

-If *m* = *h*, then *N*(*n, h, m*) =m!.

-If

The experimental calculations allow to expect that the growth of *N*(*n, h, m*) exceeds the growth of m!:

From the simulations explained in the following section, we have checked that no Berge graph appeared in the trajectory graphs. However, this result is sufficient to claim that a general result holds:

**Proposition 4.1** Let *K*
_{0} of *k* pairwise disjoint vertex pairs in the
*n*
_{0}-dimensional hypercube *K* of *k* pairwise disjoint
vertex pairs in the *n*-dimensional hypercube *Q*
_{n} the graph

**Proof**. Let *n*
_{0} and *k* be as in the proposition statement. Let
*n* be an integer such that *K* be a collection of *k*
pairwise disjoint vertex pairs in the *n*-dimensional hypercube
*Q*
_{n}. Let *n*
_{0}-index subset and let

and let *K*
_{0} be a maximal subset of *K*
_{1} consisting of pairwise disjoint vertex pairs, then

Let *N*
_{0}.

Then *n*
_{0}-dimensional hypercube *n*-dimensional hypercube *Q*
_{n}. Via

Since

On the other hand, it can be observed that neither sparse graphs nor their complements do appear. Evidently, neither claw-free graphs are produced.

Thus the currently known polynomial-time methods^{4}^{,}^{7} to find maximal independent sets do not apply to the
introduced graphs

5. Computational Results

In Table 1 we give an exact calculation obtained experimentally for some particular values of *n*, *m* and *h*.

In our experiments, we have been restricted to *n* = 6,7,8. And thus, we implemented the vertex counting at *k* = 8,16,32 and m with fixed value 8, where *k* is the number of the given connectable pairs, and *m* is the length of the required paths. We have performed one hundred simulations for each value of *n* in

**Input** :

**Output**: A path graph

5.1. Programs

We propose algorithm 5.1 to compute path graphs and algorithm 5.2 to search odd-holes within a given path graph.

**Input**: A path graph

k < 5 an odd integer

**Output**: An odd-hole π_{k} if exists

Our programs implement a series of basic modules (BM):

1. BM 0: Given a positive integer *n* this module generates a Hamiltonian cycle *h* in the hypercube *Q*
_{n}.

2. BM 1: Given a Hamiltonian cycle *h* and a positive integer *m* this module generates *k* non-crossing and disjoint *m*-paths, splitting *h* into *k* segments.

3. BM 2: Given a collection *m*-paths this module computes a set *K* of cardinality *k* with *m*-paths in

4. BM 3: Given a set *K* of endpoints pairs, *m*, and n this module computes

5. BM 4: Given a set

6. BM 5: Given a path graph

Generating *n*-dimensional hypercube path graphs yielded huge amounts of data requiring careful management and storage. Our programs were written in Ruby, are open-source, and are available at^{1}.

6. Contributions and Applications

We introduced a family of problems, globally named *“skein problems”*. They were posed on general graphs and in particular, on the hypercube. These problems are reduced into the problem of finding independence subsets in graphs, which poses by itself an NP-hard problem and hard even to be approximated (in other words, it is PTAS-hard), and we provide evidence that the obtained reduced graphs are not Berge graphs, thus they are not suitable to be treated by the currently known polynomial-time approaches to solve the independence problem.

In general, from a Hamiltonian cycle in a graph, it is easy to show a family of non-crossing and pairwise disjoint paths connecting, obviously, the extreme vertex pairs. However, the converse of this problem is extremely difficult. This could be used in cryptographic protocols where the public-key corresponds to the path end vertices, and the private key is just the skein, namely, the set of non-crossing paths connecting them pairwisely.

This work opens the possibility to carry out many applications, particularly, in cryptography. The stated Skein Problem can be used to design authentication challenge-response protocols or to implement key exchange protocols.

In the same way, based on the Skein Problem, appropriate protocols arise for such different environments as conventional computing, mobile computing, and several communication platforms.

7. Conclusions

Finding maximum independent sets in graphs is a classical NP-hard problem. So, it is possible to profit of it for authentication purposes. In a naïve approach, one may use a huge graph as a private key and a maximum independent set as the public one, but several difficulties arise: the first is the manipulation of the graph which may require hundreds of megabytes to offer an acceptable security level, and the second difficulty is to find maximum independent sets to act as the public key.

Skein problems override these difficulties. The path graphs in the hypercube play the role of hard instances, and the corresponding maximum independent sets to be used as public keys can be easily found from Hamiltonian cycles in the hypercube. On the other hand, finding maximum independent sets in path graphs is a very difficult problem due to their size, even for hypercubes of relatively small dimensions.

This is a first intended paper in a series planned to publish the cryptographic protocols and their robustness. Now, we have introduced the skein problems and we discussed their most basic mathematical properties in a purely Graph Theory approach.