A Randomized Greedy Algorithm for Piecewise Linear Motion Planning

Abstract

We describe and implement a randomized algorithm that inputs a polyhedron, thought of as the space of states of some automated guided vehicle $\mathcal{R}$, and outputs an explicit system of piecewise linear motion planners for $\mathcal{R}$. The algorithm is designed in such a way that the cardinality of the output is probabilistically close (with parameters chosen by the user) to the minimal possible cardinality.This yields the first automated solution for robust-to-noise robot motion planning in terms of simplicial complexity (SC) techniques, a discretization of Farber’s topological complexity $\mathrm{TC}$. Besides its relevance toward technological applications, our work reveals that, unlike other discrete approaches to TC, the SC model can recast Farber’s invariant without having to introduce costly subdivisions. We develop and implement our algorithm by actually discretizing Macías-Virgós and Mosquera-Lois’ notion of homotopic distance, thus encompassing computer estimations of other sectional category invariants as well, such as the Lusternik-Schnirelmann category of polyhedra.

1. Introduction

In its more simplified form, a motion planning algorithm $\mathcal{A}$ for a given mechanical system $\mathcal{S}$ is a function which assigns, to any pair of initial-final states of $\mathcal{S}$, a motion of $\mathcal{S}$ starting and ending at the given states. The ultimate goal for $\mathcal{A}$ is to allow $\mathcal{S}$ to function in an autonomous regime. Such a task is fundamental in modern technological problems. See [1,2,3] for a survey on algorithmic motion planning, the former one with an emphasis on the randomized viewpoint.

The notion of topological complexity (TC), introduced by Michael Farber in [4], is a mathematical model measuring the continuity instabilities in the motion planning problem of robots. The theoretical aspects of Farber’s idea have been extensively studied by algebraic topologists through nearly twenty years. As a result, the concept has found deep and fruitful connections in homotopy theory. Nonetheless, the more computational aspects of the TC-ideas have seen limited developments, while actual engineering-minded TC-applications seem to be nonexistent. The purpose of this paper is to help mend such a situation by focusing on the more applied features of Farber’s TC. We take advantage of computational topology techniques and, more importantly, by using randomized algorithms, we settle a computer-based solution to the motion planning problem for autonomous systems under Farber’s model. We implement our algorithms with successful and, as explained below, unexpected results.

We use the discretization of Farber’s TC developed in [5]. Here is the basic idea (details are reviewed and generalized in the next section). Assume that the space of states of a given autonomous system is given by (the topological realization of) an abstract simplicial complex K where, for practical reasons, we assume K to be finite. Taking a linear order on the vertices of K, we consider the ordered simplicial product $K\times K$. In such a context, a piecewise linear motion planner defined on a subcomplex J of $K\times K$ is a chain of simplicial maps ${\phi }_0,{\phi }_1,\dots ,{\phi }_c: J\to K$ ($c\ge 1$) satisfying that (i) each ${\phi }_i$ is contiguous to the subsequent map ${\phi }_{i+1}$ ($0\le i<c$), and that (ii) ${\phi }_0$ (${\phi }_c$) is the restriction to J of the projection $K\times K\to K$ onto the first (second) factor. The rationale behind such a definition is that, for any given pair $(a,b)$ of initial-final points in the topological realization $\parallel J\parallel$ of J, the sequence of points

$$a,\parallel {\phi }_0\parallel (a,b),\parallel {\phi }_1\parallel (a,b),\dots ,\parallel {\phi }_c\parallel (a,b),b$$

flags a piecewise linear path in $\parallel K\parallel$ from a to b depending continuously on a and b. A motion planner defined on the full complex $K\times K$ exists only in the (topologically trivial) case that $\parallel K\parallel$ is contractible. It is then natural to define ${\mathrm{SC}}_{\mathrm{strict}}\left(K\right)$ as one less than the minimal cardinality of systems of piecewise linear motion planners whose domains cover $K\times K$. This yields a discretized approximation of Farber’s TC in the sense that $\mathrm{TC}(\parallel K\parallel )\le {\mathrm{SC}}_{\mathrm{strict}}\left(K\right)$.

A central result in [5] (coming from the Simplicial Approximation Theorem) is that, if we want to have a discretized invariant of K that actually recovers (rather than just approximates) Farber’s topological complexity of the realization $\parallel K\parallel$, then the above construction has to be done within a limiting process where $K\times K$ is allowed to be “sufficiently” subdivided, for instance, by taking b-iterated barycentric subdivisions ${\mathrm{Sd}}^b(K\times K)$. This yields the simplicial complexity (SC) of K,

$$\mathrm{SC}\left(K\right)=\underset{b\to \infty }{lim}{\mathrm{SC}}_{\mathrm{strict}}^b\left(K\right),$$

where ${\mathrm{SC}}_{\mathrm{strict}}^b\left(K\right)$ is defined in terms of ${\mathrm{Sd}}^b(K\times K)$ in the same way as ${\mathrm{SC}}_{\mathrm{strict}}\left(K\right)$ is defined in terms of $K\times K$ (so ${\mathrm{SC}}_{\mathrm{strict}}^0\left(K\right)={\mathrm{SC}}_{\mathrm{strict}}\left(K\right)$). Then, as shown in (Theorem 3.5 [5]),

$${\mathrm{SC}}_{\mathrm{strict}}^0(K\times K)\ge {\mathrm{SC}}_{\mathrm{strict}}^1(K\times K)\ge {\mathrm{SC}}_{\mathrm{strict}}^2(K\times K)\ge \cdots \ge \mathrm{SC}\left(K\right)=\mathrm{TC}(\parallel K\parallel ),$$

(1)

recovering Farber’s topological complexity of $\parallel K\parallel$. Our main theoretical result, Theorem 2 below, is a generalization of (1). This is achieved by introducing the notion of contiguity distance between simplicial maps (Definition 4), a discretization of the concept of homotopic distance studied recently in [6].

Remark 1.

The point above is that, by taking iterated barycentric subdivisions, we can recast Farber’s invariant by means of a finite model. However, any person familiar with the computational aspects involving subdivisions will immediately realize that the proposal based on b-iterated barycentric subdivisions becomes computationally prohibitive as b grows. Thus, in principle, the use of SC to evaluate TC carries a compromise between how close we want to approximate TC versus how long we are willing to wait for a computer to perform a calculation involving a large number of subdivisions. The following considerations explain that, in some cases, such compromises can be minimized without diminishing the effectiveness of the approach.

An initial way to soften the compromise above is to allow for coarser/partial subdivisions. The option is however still not satisfactory, as there is no indication a priori of what portions of $K\times K$ (and how much) should be subdivided. With the aid of human geometric intuition, the coarser subdivision alternative was used Section 4 in [5] to recast, after a single subdivision, the fact that the topological complexity of the circle (the natural benchmark in [5]) is 1, namely,

$${\mathrm{SC}}_{\mathrm{strict}}^b(\partial {\mathsf{\Delta }}^2)=1,\mathrm{for} b\ge 1.$$

(2)

With these preliminaries, we are ready to describe the main application-minded achievements of this paper. Firstly, we lay the grounds for a randomized algorithm that is able to perform, without human aid, evaluation tasks such as (2). Secondly, and more relevant for actual applications, we set a corresponding computer implementation which, besides of performing automated TC estimations, produces probabilistically close-to-optimal systems of piecewise linear motion planners. Optimality here means that, in each inputed case, the cardinality of the outputed system is close to being the minimal possible (i.e., close to the TC value of the complex under consideration), where closeness is controlled by means of user-given parameters in the probabilistic algorithm. In brief, our implementation outputs robust-to-noise system of piecewise linear motion planners, with a reliability that depends on the given parameters.

As a byproduct, we find somehow surprisingly that the subdivision ingredient implicit in (1) can be unnecessary in a SC-recasting of Farber’s TC, thus nullifying the critical compromise noted in Remark 1. This is a crucial feature for eventual technological TC-applications. For instance, running on a laptop computer, our algorithm finds in a bit less than a minute a system of piecewise linear motion planners giving

$${\mathrm{SC}}_{\mathrm{strict}}^0(\partial {\mathsf{\Delta }}^2)=1.$$

(3)

This should be compared to the fact that, starting with the barycentric subdivision ${\mathrm{Sd}}^1(\partial {\mathsf{\Delta }}^2\times \partial {\mathsf{\Delta }}^2)$, our computer implementation finds in about 10 h running time a system of piecewise linear motion planners recovering the weaker fact (2). The reported running times (obtained on the same laptop computer) are given for comparison purposes: the computation is about 600 times (unnecessarily) more complex by allowing a single subdivision. Naturally, the use of powerful computational clusters results in significant time reductions, thus allowing to replace the circle $\partial {\mathsf{\Delta }}^2$ by complexes arising from actual applications. The moral is that, in general, an SC-approach to motion planning applications tends to perform satisfactorily well by ignoring the subdivision component. Actual applications of the SC-ideas to concrete problems by using powerful computer clusters will be addressed in a future publication.

Remark 2.

The ability to recast Farber’s TC in discrete terms without the need of subdivisions is definitively a convenient advantage of our SC-model over other discrete approaches. Specifically, the discrete topological complexity introduced in [7] of a simplicial complex whose geometric realization is a circle turns out to be one unit larger than $\mathrm{TC}\left(S^1\right)$ (Theorem 5.6 [7]). Likewise, (if no subdivisions are allowed) the value of Tanaka’s combinatorial complexity on the minimal finite space model of a circle is two units higher than $\mathrm{TC}\left(S^1\right)$ (Example 3.7 [8]).

The first part of the paper is devoted to reviewing the basic tools (Section 2) and developing the theoretical basis (Section 3) that shows that our model recasts homotopy notions such as Farber’s topological complexity and Lusternik-Schnirelmann’s category. This is done via Macías-Virgós and Mosquera-Lois’ homotopic distance, a concept whose discretization is achieved by means of Theorem 2. The second part of the paper has an applied focus: Section 4 describes the main processes in our algorithm, while Section 5 illustrates, via experimentation, the power that the technique has even when the subdivision ingredient is omitted.

2. Background

2.1. Topological Complexity via Homotopic Distance

Let $P\left(X\right)$ stand for the free path space on a topological space X. Farber’s topological complexity of X, $\mathrm{TC}\left(X\right)$, is the sectional category of the end-point evaluation map $e: P\left(X\right)\to X\times X$, i.e., the fibration taking a free path $\gamma \in P\left(X\right)$ to the pair $\left(\gamma \right(0),\gamma (1\left)\right)$. In other words, $\mathrm{TC}\left(X\right)+1$ is the smallest cardinality of open covers ${\left\{U_i\right\}}_i$ of $X\times X$ so that e admits a continuous section ${\sigma }_i$ on each $U_i$. Note that we use reduced terms, so that a contractible space has zero topological complexity. The open sets $U_i$ in such an open cover are called local domains, the corresponding sections ${\sigma }_i$ are called local motion planners, and the family of pairs $\left\{(U_i,{\sigma }_i)\right\}$ is called a system of local motion planners for X. A system of local motion planners is said to be optimal if it has $\mathrm{TC}\left(X\right)+1$ local domains. In view of the continuity requirement on local rules, an optimal motion planner minimizes the possibility of accidents in the performance of a robot moving in a noisy environment.

When X is the realization of an abstract simplicial complex, the openness requirement on local domains can be replaced, without altering the numerical value of $\mathrm{TC}\left(X\right)$, by requiring that local domains are subdivided subcomplexes (see [5], or the adaptation to the simplicial analogue of homotopic distance in the proof of Theorem 2 below). Furthermore, a local motion planner is really a (local) homotopy in disguise:

Lemma 1

([9] Lemma 4.21). The evaluation map $e: P\left(X\right)\to X\times X$ admits a section on a subset A of $X\times X$ if and only if the restrictions to A of the two projections to the axes ${\pi }_i: X\times X\to X$, $i=1,2$, are homotopic.

Consequently, $\mathrm{TC}\left(X\right)=\mathrm{D}({\pi }_1,{\pi }_2)$, where:

Definition 1

([6]). The homotopic distance $\mathrm{D}(f,g)$ between two continuous maps $f,g: X\to Y$ is one less than the minimal cardinality of covers of X by open sets U on each of which the restricted maps $f_{|U}$ and $g_{|U}$ are homotopic.

2.2. Contiguity vs. Homotopy

For details on the facts reviewed in this subsection, the reader can consult standard references, such as (Chapter 3) [10].

Definition 2.

For a positive integer c, and a pair of simplicial maps $\phi ,{\phi }^{\prime }:J\to K$,

1. 

φ and ${\phi }^{\prime }$ are said to be 1-contiguous provided $\phi \left(\sigma \right) \cup {\phi }^{\prime }\left(\sigma \right)$ is a simplex of K for any facet (i.e., maximal simplex) σ of J.

2. 

φ and ${\phi }^{\prime }$ are said to be c-contiguous if there is a sequence of maps ${\phi }_0,{\phi }_1,\cdots ,{\phi }_c:J\to K$, with ${\phi }_0=\phi$ and ${\phi }_c={\phi }^{\prime }$, such that ${\phi }_{i-1}$ and ${\phi }_i$ are 1-contiguous for each $i\in \{1,2,\dots ,c\}$.

The sequence of maps ${\phi }_j$ in Definition 2 Item 2 is called a contiguity chain of length c between $\phi$ and ${\phi }^{\prime }$. We write $\phi {\sim }_c{\phi }^{\prime }$ to mean that there is such a sequence, and write $\phi \sim {\phi }^{\prime }$ to mean $\phi {\sim }_c{\phi }^{\prime }$ for some c. The latter is an equivalence relation in the set of simplicial maps $J\to K$. The corresponding equivalence classes are called contiguity classes. Note that contiguity classes are preserved under composition.

Remark 3.

Contiguity classes refine homotopy classes in the sense that the topological realizations of a pair of contiguous simplicial maps are homotopic through a piecewise affine homotopy. More importantly, as soon as highly subdivided complexes are allowed, this leads to a one-to-one correspondence between contiguity and homotopy classes. To make the latter statement precise (in Theorem 1 below), we need:

Definition 3. (a) For a simplex σ of K, the open realized simplex $\langle \sigma \rangle \subseteq \parallel K\parallel$ consists of the barycentric combinations ${\sum }_{v\in \sigma }{t}_{v}v$ with each $t_v$ positive. Note that the realization of σ, $\parallel \sigma \parallel \subseteq \parallel K\parallel$, is the closure of $\langle \sigma \rangle$. (b) A simplicial approximation of a continuous map $f: \parallel J\parallel \to \parallel K\parallel$ is a simplicial map $\phi : J\to K$ such that $\parallel \phi \parallel \left(x\right)\in \parallel \sigma \parallel$ provided $f\left(x\right)\in \langle \sigma \rangle$.

For instance, a simplicial map is the only approximation of its geometric realization. On the other hand, for a subdivision $K^{\prime }$ of K, the standard homeomorphism $\parallel K^{\prime }\parallel \stackrel{=}{\to }\parallel K\parallel$ is approximated by any simplicial map $\phi : K^{\prime }\to K$ with the property that, for every vertex $v^{\prime }$ of $K^{\prime }$, the barycentric coordinate of $v^{\prime }\in \parallel K\parallel$ at $\phi \left(v^{\prime }\right)$ is positive. Further, simplicial composition of approximations approximates the corresponding topological composition.

Theorem 1.

Uniqueness of approximations: Any two approximations of a continuous map are 1-contiguous. Further, for finite J:

(i) 

Existence of approximations: Any continuous map $f: \parallel J\parallel \to \parallel K\parallel$ admits an approximation ${\phi }_b: {\mathrm{Sd}}^b\left(J\right)\to K$ for any b large enough. In particular, if $\iota : {\mathrm{Sd}}^{b+1}\left(J\right)\to {\mathrm{Sd}}^b\left(J\right)$ is any approximation of the identity on $\parallel J\parallel$, then ${\phi }_b\iota$ and ${\phi }_{b+1}$ are 1-contiguous.

(ii) 

Contiguity vs. homotopy: Recall that simplicial maps in the same contiguity class have homotopic topological realizations (Remark 3). Conversely, given homotopic maps $f_0,f_1: \parallel J\parallel \to \parallel K\parallel$, there is a non-negative integer $b_0$ such that, for each $b\ge b_0$, any pair of approximations ${\phi }_0, {\phi }_1: {\mathrm{Sd}}^b\left(J\right)\to K$ of $f_0,f_1$, respectively, satisfy ${\phi }_0\sim {\phi }_1$.

All complexes we deal with will be assumed to be finite. Additionally whenever we need to talk about products, they will be taken in the category of ordered complexes (fixing some linear order on the corresponding sets of vertices). The key point is that the topological realization of an ordered product of complexes is homeomorphic to the product of the topological realizations of the factors (see [11]). We do not require, though, that maps of ordered complexes preserve the given orderings.

3. Contiguity Distance

We now adapt the viewpoint in [5] in order to recast, in simplicial terms, the homotopic distance between continuous functions. Throughout this section $\phi ,{\phi }^{\prime }: L\to K$ denote a fixed pair of simplicial maps. A subcomplex J of L is said to be a c-contiguity subcomplex for $\phi$ and ${\phi }^{\prime }$ if the restrictions ${\phi }_{|J}$ and ${\phi }_{|J}^{\prime }$ are c-contiguous. We say that J is a contiguity subcomplex for $\phi$ and ${\phi }^{\prime }$ if it is a c-contiguity subcomplex for some c. The strict c-contiguity distance of $\phi$ and ${\phi }^{\prime }$, denoted by ${\mathrm{SD}}_c(\phi ,{\phi }^{\prime })$, is defined as one less than the smallest cardinality of finite covers of L by c-contiguity subcomplexes for $\phi$ and ${\phi }^{\prime }$. The strict contiguity distance of $\phi$ and ${\phi }^{\prime }$ is $\mathrm{SD}(\phi ,{\phi }^{\prime }):={lim}_c{\mathrm{SD}}_c(\phi ,{\phi }^{\prime })$, the eventual constant value of the monotonic sequence

$${\mathrm{SD}}_1(\phi ,{\phi }^{\prime })\ge {\mathrm{SD}}_2(\phi ,{\phi }^{\prime })\ge {\mathrm{SD}}_3(\phi ,{\phi }^{\prime })\ge \cdots .$$

The concept of strict contiguity distance was introduced in (Definition 8.1) [6] (see also [12]) under the name of contiguity distance. We use the shorter name for the actual notion recovering homotopic distance (see Definition 4 and Theorem 2 below).

Examples 1.

Note that the subcomplex generated by any simplex of L is a contiguity subcomplex for φ and ${\phi }^{\prime }$ provided (the topological realization of) K is connected. Connectedness of complexes is an assumption that will be in force from this point on. The relation $\phi {\sim }_c{\phi }^{\prime }$ can be expressed through the equality ${\mathrm{SD}}_c(\phi ,{\phi }^{\prime })=0$, while the equality ${\mathrm{SC}}_{\mathrm{strict}}\left(K\right)=\mathrm{SD}({\pi }_1,{\pi }_2)$ holds by definition, where ${\pi }_1,{\pi }_2: K\times K\to K$ are the two simplicial projections.

Remark 3 readily gives

$$\mathrm{D}(\parallel \phi \parallel ,\parallel {\phi }^{\prime }\parallel )\le \mathrm{SD}(\phi ,{\phi }^{\prime })$$

(4)

We next use the full power of Theorem 1 in order to adjust the definition of SD and replace the inequality in (4) by an equality. For each positive integer b, fix a simplicial approximation $\iota ={\iota }_b: {\mathrm{Sd}}^b\left(L\right)\to {\mathrm{Sd}}^{b-1}\left(L\right)$ of the identity on $\parallel L\parallel$. We abuse notation and write $\iota : {\mathrm{Sd}}^b\left(L\right)\to {\mathrm{Sd}}^{b^{\prime }}\left(L\right)$ for the obvious iterated composition of $\iota$ maps ($b\ge b^{\prime }$). Set ${\mathrm{SD}}_c^b(\phi ,{\phi }^{\prime }):={\mathrm{SD}}_c({\phi }_b,{\phi }_b^{\prime })$ and ${\mathrm{SD}}^b(\phi ,{\phi }^{\prime }):=\mathrm{SD}({\phi }_b,{\phi }_b^{\prime })$, the corresponding c-stabilized value, where the maps ${\phi }_b,{\phi }_b^{\prime }: {\mathrm{Sd}}^b\left(L\right)\to K$ stand for $\phi \circ \iota$ and ${\phi }^{\prime }\circ \iota$, respectively. Note that the contiguity class of ${\phi }_b$ (respectively ${\phi }_b^{\prime }$) depends only on that of $\phi$ (respectively ${\phi }^{\prime }$). Although the numbers ${\mathrm{SD}}_c^b(\phi ,{\phi }^{\prime })$ depend in principle on the chosen set of approximations $\iota$, the proof of (Lemma 3.3) [5] applies word for word to show that the c-stabilized value ${\mathrm{SD}}^b(\phi ,{\phi }^{\prime })$ is independent of the chosen approximations. Furthermore, if J is a subcomplex of ${\mathrm{Sd}}^b\left(L\right)$ and $\lambda : \mathrm{Sd}\left(J\right)\to J$ is an approximation of the identity on $\parallel J\parallel$, then the two compositions in the diagram

are 1-contiguous, as they are approximations of the inclusion $\parallel J\parallel \subseteq \parallel L\parallel$. This shows ${\mathrm{SD}}_c^b(\phi ,{\phi }^{\prime })\ge {\mathrm{SD}}_{c+2}^{b+1}(\phi ,{\phi }^{\prime })$, which yields the monotonic sequence

$${\mathrm{SD}}^0(\phi ,{\phi }^{\prime })\ge {\mathrm{SD}}^1(\phi ,{\phi }^{\prime })\ge {\mathrm{SD}}^2(\phi ,{\phi }^{\prime }).\ge \cdots \ge 0.$$

(5)

Definition 4.

The contiguity distance between φ and ${\phi }^{\prime }$ is

$$\mathrm{D}(\phi ,{\phi }^{\prime }):=\underset{b}{lim}{\mathrm{SD}}^b(\phi ,{\phi }^{\prime }),$$

the b-stabilized value of the monotonic sequence (5).

Since $\mathrm{D}(\phi ,{\phi }^{\prime })={\mathrm{SD}}^b(\phi ,{\phi }^{\prime })$ holds for any large enough index b, (4) becomes

$$\mathrm{D}(\parallel \phi \parallel ,\parallel {\phi }^{\prime }\parallel )\le \mathrm{D}(\phi ,{\phi }^{\prime }).$$

(6)

We now adapt the argument in the proof of Theorem 3.5 [5] to prove:

Theorem 2.

Equality holds in (6).

Proof. 

Let $\mathrm{D}(\parallel \phi \parallel ,\parallel {\phi }^{\prime }\parallel )=k$ and choose an open covering $\{U_0,\dots ,U_k\}$ of $\parallel L\parallel$ as in Definition 1. Since L is finite, there is an integer $b\ge 0$ such that the realization of each simplex of ${\mathrm{Sd}}^b\left(L\right)$ is contained in some $U_j$ ($0\le j\le k$). For each $j\in \{0,1,\dots ,k\}$, let $L_j$ be the subcomplex of ${\mathrm{Sd}}^b\left(L\right)$ generated by those simplices whose realization is contained in $U_j$. Then $L_0,L_1,\dots ,L_k$ cover L, and ${\parallel \phi \parallel }_{|L_j}$ and $\parallel {\phi }^{\prime }{\parallel }_{|L_j}$ are homotopic for $0\le j\le k$. By Theorem 1, we can pick large enough integers $b^{\prime }$ and c such that, for each $j\in \{0,1,\dots ,k\}$, the two composites

$${\mathrm{Sd}}^{b+b^{\prime }}\left(L_i\right)\hookrightarrow {\mathrm{Sd}}^{b+b^{\prime }}\left(L\right)\underset{{\phi }_{b+b^{\prime }}^{\prime }}{\overset{{\phi }_{b+b^{\prime }}}{\rightrightarrows }}K$$

are c-contiguous. This yields $\mathrm{D}(\parallel \phi \parallel ,\parallel {\phi }^{\prime }\parallel )=k\ge {\mathrm{SD}}_c^{b+b^{\prime }}(\phi ,{\phi }^{\prime })\ge \mathrm{D}(\phi ,{\phi }^{\prime })$.    □

Since a continuous map $f: \parallel L\parallel \to \parallel K\parallel$ is homotopic to the geometric realization of any of its simplicial approximations, Theorem 2 and (Proposition 2.2 [6]) immediately yield:

Corollary 1.

For a pair of continuous maps $f,f^{\prime }: \parallel L\parallel \to \parallel K\parallel$, we have

$$\mathrm{D}(f,f^{\prime })=\mathrm{D}(\phi ,{\phi }^{\prime }),$$

where $\phi ,{\phi }^{\prime }: {\mathrm{Sd}}^b\left(L\right)\to K$ are any corresponding simplicial approximations (for some large enough b).

Actually, Theorem 2 allows us to import to the simplicial realm properties of homotopic distance proved in [6]. For instance:

Corollary 2.

$\mathrm{D}(\phi ,{\phi }^{\prime })$ is a contiguity invariant of the pair of maps $(\phi ,{\phi }^{\prime })$. Explicitly, if the simplicial maps in the diagram

satisfy $\beta \circ \phi \circ \alpha \sim \psi$ and $\beta \circ {\phi }^{\prime }\circ \alpha \sim {\psi }^{\prime }$, with α and β contiguity equivalences (i.e., they have inverses up to contiguity), then $\mathrm{D}(\phi ,{\phi }^{\prime })=\mathrm{D}(\psi ,{\psi }^{\prime })$.

Corollary 3.

The inequality $\mathrm{D}(\phi ,{\phi }^{\prime })\le \mathrm{TC}(\parallel K\parallel )$ holds, as well as the triangular inequality $\mathrm{D}(\phi ,{\phi }^{″})\le \mathrm{D}(\phi ,{\phi }^{\prime })+\mathrm{D}({\phi }^{\prime },{\phi }^{″})$ and the “sublogarithmic” inequalities

$$\begin{array}{cc}\hfill \mathrm{D}(\phi \circ \psi ,{\phi }^{\prime }\circ {\psi }^{\prime })& \le \mathrm{D}(\phi ,{\phi }^{\prime })+\mathrm{D}(\psi ,{\psi }^{\prime })\hfill \\ \hfill \mathrm{D}(\phi \times \varphi ,{\phi }^{\prime }\times {\varphi }^{\prime })& \le \mathrm{D}(\phi ,{\phi }^{\prime })+\mathrm{D}(\varphi ,{\varphi }^{\prime })\hfill \end{array}$$

for $\psi ,{\psi }^{\prime }: M\to L$, $\varphi ,{\varphi }^{\prime }: L^{\prime }\to K^{\prime }$ and $\phi ,{\phi }^{\prime },{\phi }^{″}: L\to K$.

Corollary 4.

$\mathrm{cat}(\parallel K\parallel )=\mathrm{D}(\ast ,1_K)=\mathrm{D}({\iota }_1,{\iota }_2)$ and $\mathrm{TC}(\parallel K\parallel )=\mathrm{D}({\pi }_1,{\pi }_2)$. Here $1_K$ is the identity map on K, ${\pi }_i$ are the simplicial projections in Examples 1, and ${\iota }_i: K\to K\times K$ are the axial inclusions ${\iota }_1\left(v\right)=(v,v_0)$ and ${\iota }_2\left(v\right)=(v_0,v)$.

4. Algorithms

We now describe a randomized algorithm whose implementation yields reasonable estimations of the contiguity distance between simplicial maps. As described in the introductory section, in the case of simplicial complexity, our implementation constructs reasonably close-to-optimal systems of piecewise linear local motion planners.

We represent an (abstract simplicial) complex K by a pair $(V_K,F_K)$, where $V_K$ is the list of the vertices of K, and $F_K$ is the list of the facets (i.e. maximal simplices) of K. This encoding is convenient because of Definition 2 Item 1 and, more importantly for our purposes, since a covering of a given complex is completely determined by a covering of its facets (see the discussion at the beginning of Section 4.3).

In what follows we assume given an algorithm, Contiguous, that checks whether two simplicial maps are contiguous. Note that if a simplicial map $\phi$ is contiguous (in the sense of Definition 2 Item 1) to a vertex map ${\phi }^{\prime }$, then ${\phi }^{\prime }$ must be simplicial. In this paper we assume that Contiguous has been implemented solely on the basis of Definition 2 Item 1, so to admit any two vertex maps as input, necessarily reporting false whenever one of the input parameters is not simplicial. In fact, under these assumption, Contiguous$(\phi ,\phi )$ can be used to check if a vertex map $\phi$ is simplicial. Such a function is available in standard mathematical software systems such as SageMath (http://mirrors.mit.edu/sage/win/index.html, accessed on 15 January 2019). For testing, the implementation of our algorithms is on Python 3 with the tools of a complete SageMath installation (Approximately a 1 Gb download). It is worth noticing that the latter is a system with particular convenient features for our purposes—such as a function for spelling out (as a list of facets) the ordered simplicial product of ordered complexes. Also, some libraries for standard management of graphs and random numbers are already included. Therefore, it is not necessary to perform any additional imports or additional installations of frameworks.

4.1. Randomized Local Search of Contiguity Chains

Recall that, for finite abstract simplicial complexes J and K, Theorem 1 characterizes homotopy classes of continuous maps $\parallel J\parallel \to \parallel K\parallel$ in terms of contiguity classes of maps $J\to K$ through a limiting process that takes finer and finer subdivisions of J. This classical fact is generalized in [13] by introducing a certain “contiguity complex” $\mathrm{Contig}(J,K)$ that approximates, as J becomes sufficiently subdivided, the homotopy type of the function space of continuous maps $\parallel J\parallel \to \parallel K\parallel$. What is relevant for us is to remark that Blumberg and Mandell propose a certain randomized algorithm in order to study the rate of growth (under subdivision of the domain) of the components of $\mathrm{Contig}(J,K)$. We adapt Blumberg-Mandell’s algorithm (without the subdivision component) for our computer implemented search of piecewise linear local motion planners.

The randomized algorithm LocalSearch (Algorithm 1) in this section inputs a pair of simplicial maps $\phi ,{\phi }^{\prime }: J\to K$, a positive integer M, and a probability parameter r ($r\in [0,1]$), and outputs a list $\mathsf{\Psi }$ that either contains a chain of maps

$${\phi }_0,{\phi }_1,\cdots ,{\phi }_c:J\to K,c\le M,$$

(7)

satisfying the conditions in Definition 2 Item 2 or, else, is empty, in case the randomized search for (7) is not successful. Starting at $\phi$, the search is done through a random walk with local steps in the space of simplicial maps $J\to K$. Actual steps in the walk are tried (and recorded in $\mathsf{\Psi }$), at most M times on a “greedy” basis, with the probability parameter r used to break a situation where no greedy step has been taken after a number of consecutive tries. A greedy step is actually taken whenever the distance from the goal map ${\phi }^{\prime }$ to the current position of the walk is larger than the distance from ${\phi }^{\prime }$ to the potentially new position of the walk. Here, the distance between simplicial maps $f,g: J\to K$ is defined as

$$d(f,g)=\sum d_K(f\left(v\right),g\left(v\right)),$$

where the summation runs over the vertices v of J, and $d_K$ stands for the graph distance on the 1-skeleton of K.

Algorithm 1: LocalSearch. Current element in Ψ is recorded by ϕ.

We use the following variant of LocalSearch (Algorithm 1) in our actual implementation. Start by noticing that, at each step of the iterative process (line 5), the potential new position f in the walk—a random single-vertex variant of $\varphi$—may fail to be contiguous to the current position $\varphi$, thus preventing us from taking the greedy step (line 10). The construction of f (lines 6 and 7) can then be replaced by a process that, first constructs a list $L_{\varphi ,w}$ of all the simplicial maps that differ from $\varphi$ on a single randomly chosen vertex $w\in V_J$, and then chooses f randomly from $L_{\varphi ,w}$ (provided $L_{\varphi ,w}\ne ⌀$). Of course, with this modification, the first test condition in line 9 can safely be removed.

4.2. Reduction of Contiguity Chains

The random walk performed by LocalSearch (Algorithm 1) has a local-step basis: any two consecutive maps ${\phi }_i$ and ${\phi }_{i+1}$ in a sequence (7) produced by LocalSearch (Algorithm 1) differ only by their values at a single vertex of J. In particular, it is usual that LocalSearch (Algorithm 1) outputs a long sequence of (hundreds and even thousands of) consecutive contiguous maps in between $\phi$ and ${\phi }^{\prime }$. This could be remedied by running a shortest path algorithm/heuristic on the contiguity graph generated by the maps ${\phi }_i$ in the sequence. However, the construction of the graph is costly for large sequences. The simpler alternative described in this subsection works well given the random nature of LocalSearch (Algorithm 1).

The algorithm Reduce (Algorithm 2) attempts to reduce the size of a contiguity sequence $\varphi =({\phi }_0,\dots ,{\phi }_c)$ by reporting the sequence ${\varphi }^{\prime }$ obtained from $\varphi$ by discarding the terms ${\phi }_{\ell +1},{\phi }_{\ell +2},\dots ,{\phi }_{\ell +m-1}$ in chunks ${\phi }_{\ell },{\phi }_{\ell +1},\dots ,{\phi }_{\ell +m}$ whenever $m>1$ is maximal with ${\phi }_{\ell }$ and ${\phi }_{\ell +m}$ contiguous.

Algorithm 2: Reduce.

4.3. Randomized Contiguity Subcomplexes

For simplicial maps $\psi ,{\psi }^{\prime }: L\to K$, the task of finding coverings of L by c-contiguity subcomplexes can be focused on facets of L. Indeed, by restricting to facets, a covering $\mathcal{C}$ of L by c-contiguity subcomplexes yields (in a non-unique way) a partition $\mathcal{P}$ of the facets of L. In such a situation, if $J_P$ stands for the subcomplex of L generated by the facets in a given $P\in \mathcal{P}$, then ${\mathcal{C}}_{\mathcal{P}}:=\{J_P:P\in \mathcal{P}\}$ is a covering of L by c-contiguity subcomplexes with $\mathrm{Card}\left({\mathcal{C}}_{\mathcal{P}}\right)\le \mathrm{Card}\left(\mathcal{C}\right)$. The definition of ${\mathrm{SD}}_c(\psi ,{\psi }^{\prime })$ can therefore be reformulated by limiting attention to coverings ${\mathcal{C}}_{\mathcal{P}}$ coming from a partition $\mathcal{P}$ of the facets of L as above. This is the viewpoint in the algorithms described next.

A random subset of the facets of L will most likely fail to generate a contiguity subcomplex. Likewise, a random partition $\mathcal{P}$ of the facets of L will most likely fail to produce a covering ${\mathcal{C}}_{\mathcal{P}}$ by contiguity complexes. A more careful randomized search is needed. As a first step, the randomized algorithm RCC (RandomContiguitysubComplex) in this subsection aims at constructing a maximal contiguity subcomplex for a given pair of simplicial maps. Then, in Section 4.4 we describe a randomized algorithm that searches for partitions $\mathcal{P}$ of the set of facets of L that yield a covering ${\mathcal{C}}_{\mathcal{P}}$ by contiguity subcomplexes. Lastly, the size of such a covering ${\mathcal{C}}_{\mathcal{P}}$ is optimized by the algorithm in Section 4.5. The latter algorithm is crucial for our purposes, as it gives us a real chance to get at systems of piecewise linear local motion planners that are (nearly) optimal in the sense of Section 2.2.

We start with the algorithm AddFacet (Algorithm 3), whose input is a pair of simplicial maps $\psi ,{\psi }^{\prime }: L\to K$, and a contiguity subcomplex J for $\psi$ and ${\psi }^{\prime }$. It is implicitly assumed that J is generated by a set of facets of L. With this information, the algorithm looks randomly for the first facet $\sigma$ of L not in J that, together with J, generates a contiguity subcomplex $J^{\prime }$. If such a facet $\sigma$ is found, AddFacet (Algorithm 3) outputs $J^{\prime }$, otherwise J is reported. Each testing is done by the algorithm LocalSearch (Algorithm 1) with the restricted simplicial maps ${\psi |}_{J^{\prime }}$ and ${\psi }^{\prime }{|}_{J^{\prime }}$ as parameters. Note that AddFacet (Algorithm 3) requires in addition the two parameters, M and r, needed by LocalSearch (Algorithm 1).

Algorithm 3: AddFacet. A random $\sigma$ ensures variety of results from multiple runs.

The main algorithm in this subsection, RCC, is an iteration of AddFacet (Algorithm 3). Starting with two simplicial maps $\psi ,{\psi }^{\prime }: L\to K$ as input, RCC applies AddFacet (Algorithm 3) recursively, using the output of the previous application as (part of) the input for the next application ($\psi$ and ${\psi }^{\prime }$ are kept as the rest of the input for all iterations of Algorithm 3, AddFacet). The iteration starts by using the contiguity subcomplex generated by a randomly chosen facet of L, which is a contiguity subcomplex in view of Examples 1. The iteration is applied at most $\mathrm{Card}\left(F_L\right)$ times, and is set to stop whenever the current application of AddFacet (Algorithm 3) is unable to add an additional facet (this will hold, for instance, if the total complex L has been identified as a contiguity complex for $\psi$ and ${\psi }^{\prime }$).

A slight generalization of RCC will also be needed in what follows. The algorithm AddFacets is an iteration of AddFacet (Algorithm 3) on the same grounds as RCC, except that the starting contiguity subcomplex is a prescribed parameter.

For latter use in the global algorithm, an actual implementation of both AddFacets and RCC should keep track of the (reduced version of the) last non-empty contiguity sequence $\varphi$ constructed by AddFacet (Algorithm 3), for this provides us with an explicit contiguity chain for the restrictions of $\psi$ and ${\psi }^{\prime }$ to the output of AddFacets (Algorithm 3) or RCC.

4.4. Randomized Coverings by Contiguity Subcomplexes

For simplicial maps $\psi ,{\psi }^{\prime }: L\to K$, the algorithm Covering (Algorithm 4) in this subsection constructs a partition $\mathcal{P}$ of $F_L$ as the one described in the initial paragraph of Section 4.3. The process is an iteration of RCC. Assume we have constructed a family $\mathcal{P}$ of pairwise disjoint subsets of $F_L$ such that each $P\in \mathcal{P}$ generates a contiguity subcomplex $J_P$ for $\psi$ and ${\psi }^{\prime }$ ($\mathcal{P}$ is empty at the start of the process). Then we execute RCC with the restricted maps ${\psi }_{|I},{\psi }_{|I}^{\prime }: I\to K$ as parameters, where I is the subcomplex of L generated by the facets of L that do not lie in any $P\in \mathcal{P}$. The set of relevant facets of the resulting contiguity complex is appended to $\mathcal{P}$. The process is iterated until the resulting $\mathcal{P}$ partitions $F_L$.

4.5. Optimization of Coverings

When applied to the two simplicial projections ${\pi }_1,{\pi }_2: K\times K\to K$, the algorithm Covering (Algorithm 4) in the previous subsection constructs systems of piecewise linear local motion planners in rather short time. In addition, in cases where we know the topological optimal $\mathrm{TC}(\parallel K\parallel )+1$, some sporadic runs of Covering (Algorithm 4) report systems with cardinality reasonably close to optimal. In this subsection we describe the randomized algorithm OptimizedCovering (Algorithm 5) that addresses all other situations, i.e., those where the systems reported by Covering (Algorithm 4) appear to have too many domains. This is achieved by using a greedy strategy that attempts to reduce the number of piecewise linear local domains by increasing the size of large domains. OptimizedCovering (Algorithm 5) is the key process giving the convenient performance of our implementation without the need of expensive subdivisions, as advertised in the introductory section.

Algorithm 4: Covering.

Algorithm 5: OptimizedCovering.

OptimizedCovering (Algorithm 5) starts with a partition $\mathcal{P}$ of $F_L$ produced by Covering (Algorithm 4), and goes into an iterative process that aims at shortening the length of $\mathcal{P}$. Explicitly, assume that, after the i-th stage of the iteration, the original partition has evolved to become the partition $\{P_0,P_1,\dots ,P_p\}$. Then, using a control variable j (inductively assumed to lie in between 0 and p), the $(i+1)$-st recursive stage of OptimizedCovering (Algorithm 5) performs the following actions:

• Order the partition so that $\mathrm{Card}\left(P_0\right)\ge \mathrm{Card}\left(P_1\right)\ge \cdots \ge \mathrm{Card}\left(P_p\right)$.
• Use the algorithm RCC to generate a random contiguity subcomplex $J_P$ of $J_{P_j\cup P_{j+1}\cup \cdots \cup P_p}$. Keep in P the largest set of P and $P_j$.
• Use the algorithm AddFacets to add as many facets of

  $$P_{j-1}\cup P_j\cup \cdots \cup P_p$$

  (8)

  as possible to P, so to produce a contiguity subcomplex $J_Q$ containing $J_P$. If $j=0$, part $P_{j-1}$ is inexistent in (8). If $j>0$, keep in Q the largest set between Q and $P_{j-1}$.

The $(i+1)$-st iteration of the process then finishes by constructing the new (optimized) partition

$$\{P_0,P_1,\dots ,P_{j-2},Q,P_{j-1}-Q,P_j-Q,\dots ,P_p-Q\},$$

(9)

where empty parts are eliminated. If $j=0$, parts $P_0$, $P_1,\dots ,P_{j-2}$, and $P_{j-1}-Q$ are nonexistent in (9). Lastly, in preparation for the next iteration, the control variable j is incremented by one, unless its value has to be reset to zero so to meet the inductive hypothesis on j. The rationale behind this process is to use the best possible contiguity subcomplex that can be built from the facets in ${\cup }_{i\ge j}{P}_i$ (step (2)) to greedily improve on the cardinality of $P_{j-1}$ (step (3)). The net effect of such a recursive process is that new longer portions start “bubbling up” in the most recently produced partitions, while shorter portions tend to disappear from previously constructed partitions, as their elements get added to the longer emerging parts. As a consequence, the new partitions tend to have fewer domains than the old partitions.

For better results, the main recursive loop in the process above is meant to be repeated a large number of times (indicated by a parameter N prescribed by the user). The pseudocode we describe uses in addition a parameter t (also determined by the user) that breaks the recursion as soon as a partition with t elements or less is achieved. The value of t is to be provided on the basis of getting a “short enough” partition, either because the user would be happy with the prescribed bound, or simply because it does not make sense to insist on getting a partition of length smaller that the optimal $\mathrm{TC}(\parallel K\parallel )+1$ (if the latter number is known in advance, say by theoretical but non-constructive means).

5. Computational Results

5.1. The Circle

Let $K:=\partial {\mathsf{\Delta }}^2$, i.e., the most efficient triangulation of the circle, with vertices labeled $0,1,2$. The (realization of the ordered) product structure on $K\times K$ is depicted in Figure 1, where opposite sides of the external square are identified as indicated. Using parameters $M=1000$ and $r=0.1$ for LocalSearch (Algorithm 1), OptimizedCovering (Algorithm 5) yields, in about 57 s, the contiguity covering $\{J_0,J_1\}$ of $K\times K$ for the two projections, where $J_i$ is generated by the i-labeled triangles in Figure 1. We remark that the technical features of the equipment used for testing all the examples are as follows: Processor AMD ryzen 2400 G with a processor of 3.8 Ghz speed, 12 Gb RAM, and Windows 10 Pro OS. We anticipate that better performance could be obtained in practice when using a compiled programming language.

Relevant stages in the actual process performed by OptimizedCovering (Algorithm 5) that lead to the cover $\{J_0,J_1\}$ are illustrated in Figure 2. At each of the stages shown, the largest (smallest) subcomplex is highlighted in light (dark) gray. OptimizedCover finishes when the dark gray subcomplex has been incorporated into two large subcomplexes. The corresponding contiguity chains (simplified by Algorithm 2, Reduce) for the restricted projections ${\pi }_1{{|}_{J_i},{\pi }_2|}_{J_i}: J_i\to K$ are described in

Table 1. Contiguity chain between ${\pi }_1{|}_{J_0}$ and ${\pi }_2{|}_{J_0}$ for $J_0$ in Figure 1. A row tabulates the values of the indicated simplicial map on the vertices $(i,j)$.

	$\left(0,0\right)$	$\left(0,1\right)$	$\left(0,2\right)$	$\left(1,0\right)$	$\left(1,1\right)$	$\left(1,2\right)$	$\left(2,0\right)$	$\left(2,1\right)$	$\left(2,2\right)$
${\phi }_0={\pi }_1{|}_{J_0}$	0	0	0	1	1	1	2	2	2
${\phi }_1$	0	0	0	2	1	1	2	2	2
${\phi }_2$	0	0	0	2	1	1	0	0	2
${\phi }_3$	0	1	1	2	1	1	0	0	2
${\phi }_4$	0	1	2	2	1	2	0	0	2
${\phi }_5$	0	1	2	0	1	2	0	0	2
${\phi }_6={\pi }_2{|}_{J_0}$	0	1	2	0	1	2	0	1	2

(for $i=0$) and

Table 2. Contiguity chain between ${\pi }_1{|}_{J_1}$ and ${\pi }_2{|}_{J_1}$ for $J_1$ in Figure 1.

	$\left(0,0\right)$	$\left(0,1\right)$	$\left(0,2\right)$	$\left(1,0\right)$	$\left(1,1\right)$	$\left(1,2\right)$	$\left(2,1\right)$	$\left(2,2\right)$
${\phi }_0={\pi }_1{|}_{J_1}$	0	0	0	1	1	1	2	2
${\phi }_1$	0	2	0	1	1	1	2	2
${\phi }_2$	0	2	0	1	1	1	1	2
${\phi }_3$	0	2	0	0	1	1	1	2
${\phi }_4$	0	2	0	0	1	0	1	2
${\phi }_5$	0	2	2	0	1	0	1	2
${\phi }_6$	0	1	2	0	1	0	1	2
${\phi }_7$	0	2	2	0	1	0	1	2
${\phi }_8$	0	1	2	0	1	0	1	2
${\phi }_9={\pi }_2{|}_{J_1}$	0	1	2	0	1	2	1	2

(for $i=1$). In particular, the optimal ${\mathrm{SC}}_{\mathrm{strict}}(\partial {\mathsf{\Delta }}^2)=1$ is attained though contiguity chains of length at most 9.

Remark 4.

Working instead with $\mathrm{Sd}(K\times K)$, OptimizedCovering (Algorithm 5) generates a system of piecewise linear motion planners using parameters M = 20,000 and $r=0.1$ for LocalSearch (Algorithm 1). A detailed report of the resulting pair of piecewise linear domains and corresponding contiguity chains can be found in the Master’s thesis of the first author. Here we remark that, the use of the barycentric subdivision $\mathrm{Sd}(K\times K)$ affects time performance dramatically, as the optimal covering is achieved in the subdivided case after 10 h of computer computations. Yet, despite the computer effort needed for such calculations, the output only gives that the optimal (2) can be attained though contiguity chains of length at most 26.

5.2. A Wedge of Two Circles

Consider the 1-dimensional complex K depicted in the following figure:

The geometric realization $\parallel K\parallel$ is homotopic to a wedge of two circles. As in the case of a single circle, OptimizedCovering (Algorithm 5) recovers the well known equality $\mathrm{TC}(\parallel K\parallel )=2$ without requiring subdivisions. The 25-minutes calculation was accomplished using parameters $r=0.1$ and $M=5000$ for LocalSearch (Algorithm 1). The three resulting optimal piecewise linear local domains $J_0,J_1,J_2$ are generated by the following list of facets where, for simplicity, a vertex $(i,j)$ of the ordered product $K\times K$ is labeled as $4i+j$:

$J_0$:

$\{5,9,10\},\{0,3,15\},\{0,4,7\},\{4,8,11\},\{0,4,6\},\{5,13,15\},\{0,3,7\},$

$\{0,2,10\},\{0,2,6\},\{0,4,5\},\{0,12,14\},\{1,13,15\},\{0,12,15\},\{4,5,9\},$

$\{4,8,9\},\{4,5,13\},\{4,7,11\},\{1,3,15\},\{0,2,14\},\{1,3,7\}.$

$J_1$:

$\{4,7,15\},\{0,1,9\},\{1,2,6\},\{0,1,13\},\{4,12,13\},\{5,7,15\},\{1,9,10\},$

$\{1,13,14\},\{0,1,5\},\{1,5,7\},\{4,12,15\},\{0,8,9\},\{1,5,6\},\{0,3,11\},$

$\{0,12,13\},\{0,8,11\},\{1,2,10\},\{1,2,14\}$.

$J_2$:

$\{4,12,14\},\{0,8,10\},\{1,9,11\},\{1,3,11\},\{5,13,14\},\{4,6,10\},\{4,6,14\},$

$\{5,6,10\},\{5,6,14\},\{4,8,10\},\{5,7,11\},\{5,9,11\}$.

The corresponding contiguity chains are described in

Table 3. Contiguity chain on $J_0$.

	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
${\phi }_0={\pi }_1{|}_{J_0}$	0	0	0	0	1	1	1	1	2	2	2	2	3	3	3	3
${\phi }_1$	0	0	0	0	1	1	1	1	1	1	2	2	0	3	0	3
${\phi }_2$	0	0	0	0	1	1	0	1	1	1	2	1	0	3	2	3
${\phi }_3$	0	0	2	0	1	1	0	0	0	1	2	1	0	3	0	3
${\phi }_4$	0	3	2	3	1	1	0	0	0	1	2	0	0	3	2	3
${\phi }_5$	0	3	2	3	1	1	0	0	0	1	2	0	0	1	2	3
${\phi }_6$	0	3	2	3	0	1	0	0	0	1	2	0	0	1	2	3
${\phi }_7$	0	3	2	3	0	1	0	3	0	1	2	0	0	1	2	3
${\phi }_8={\pi }_2{|}_{J_0}$	0	1	2	3	0	1	2	3	0	1	2	3	0	1	2	3

,

Table 4. Contiguity chain on $J_1$.

	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
${\phi }_0={\pi }_1{|}_{J_1}$	0	0	0	0	1	1	1	1	2	2	2	2	3	3	3	3
${\phi }_1$	0	0	0	0	1	1	1	1	0	2	2	0	3	3	3	3
${\phi }_2$	0	0	0	1	3	1	0	1	0	2	2	1	3	3	3	3
${\phi }_3$	0	0	0	0	3	1	0	1	0	2	2	1	0	0	0	3
${\phi }_4$	0	0	2	0	3	1	0	1	0	0	0	0	0	0	2	3
${\phi }_5$	0	0	0	3	3	1	0	1	0	0	0	3	0	0	0	3
${\phi }_6$	0	1	0	3	3	1	0	1	0	1	0	3	0	0	0	3
${\phi }_7$	0	1	0	3	3	1	0	3	0	1	0	3	0	0	0	3
${\phi }_8$	0	1	0	3	0	1	0	3	0	1	1	3	0	0	0	3
${\phi }_9$	0	1	1	3	0	1	0	3	0	1	1	3	0	1	1	3
${\phi }_{10}$	0	1	1	3	0	1	1	3	0	1	2	3	0	1	2	3
${\phi }_{11}={\pi }_2{|}_{J_1}$	0	1	2	3	0	1	2	3	0	1	2	3	0	1	2	3

and

Table 5. Contiguity chain on $J_2$.

	0	1	3	4	5	6	7	8	9	10	11	12	13	14
${\phi }_0={\pi }_1{|}_{J_2}$	0	0	0	1	1	1	1	2	2	2	2	3	3	3
${\phi }_1$	0	0	0	1	1	1	1	2	2	2	2	3	1	1
${\phi }_2$	2	0	0	1	1	2	1	2	2	2	2	3	1	1
${\phi }_3$	1	2	0	1	1	2	1	2	2	2	2	1	1	1
${\phi }_4$	1	2	2	1	1	2	2	2	1	2	2	2	1	2
${\phi }_5$	1	2	1	1	1	2	1	1	1	2	1	2	1	2
${\phi }_6$	1	1	1	1	1	2	3	1	1	2	1	2	1	1
${\phi }_7$	2	3	3	2	1	2	3	2	1	2	3	1	1	2
${\phi }_8$	0	1	3	2	1	1	3	0	1	2	3	2	1	2
${\phi }_9$	0	1	3	2	1	2	3	0	1	2	3	0	1	2
${\phi }_{10}={\pi }_2{|}_{J_2}$	0	1	3	0	1	2	3	0	1	2	3	0	1	2

.

Remark 5.

A detailed analysis of the computational complexity in our algorithms will be the basis of a future publication. For now, it should be remarked that, as reported above, while the case of a circle is solved in roughly a minute (obtaining an optimal system of piecewise linear motion planners), the case of a wedge of two circles took 25 min in order to produce the corresponding optimal result. Such an increment of time reflects the fact that we have not been able to get an optimal system of piecewise linear motion planners in the case of (a simplicial model of) the sphere of dimension 2, but only systems whose cardinality is above the known optimal $\mathrm{TC}\left(S^2\right)=2$.

6. Conclusions

We describe and implement a randomized algorithm based on Farber’s topological complexity model for robust-to-noise motion planning of an automated guided vehicle (AGV). The algorithm rests on a classical computational-topology foundation based on simplicial complexes, with iterated barycentric subdivisions playing a central role, thus allowing a full characterization of Farber’s invariant in discrete terms. This gives the first advantage of our model, as other discretization proposals in the literature lead only to approximations to the topological complexity of an AGV (See Remark 2). Additionally, the simplicial approach in this paper is more convenient than Tanaka’s finite-space approach in [8] as libraries and packages (relevant in eventual extensions of our implementation) are much better developed in the simplicial context. Also, our implementation in terms of ordered products of simplicial complexes has a natural advantage over the unordered product used in [7]. Indeed, on the one hand, the simplicial model for cartesian products resulting from using unordered products is larger in size than the one using ordered products. On the other hand, ordered products capture the homeomorphism type rather than just the homotopy type—as is the case for the unordered product. Furthermore, as reported in the paper, our implementation performs extremely well in the case of a circle and a wedge of circles, where the output reported recovers the theoretical answer without the need of iterated barycentric subdivisions. A future development of this research will include, on the one hand, discrete Morse theory techniques and, on the other, parallelization methods in powerful supercomputer clusters. This should make the TC approach fully usable in actual engineering applications.