CAPÍTULO SEIS .1K APOLO 1.2K

The computational complexity analysis of the trajectory assignment problem is based on two main concepts: NP-hard problem and self-reducibility. The informal definitions of these two concepts can be stated as follows [100]:

Definition 2.1 (Deterministic Turing machine). A deterministic Turing machine is a mathematical model that defines an abstract machine, designed to manipulate symbols on a strip of tape, according to a table of rules.

Definition 2.2 (Non-deterministic Turing machine). A non-deterministic Turing machine is a Turing machine, which set of rules prescribes more than one action for a given situation.

Definition 2.3 (P complexity class). A decision problem is part of the P class if it can be solved by a deterministic Turin machine in a polynomial time

Definition 2.4 (NP complexity class). A decision problem is said to be NP if it can be solved by a non-deterministic Turin machine in a polynomial time

Definition 2.5 (NP-hard problem). A search problem Π is said to be NP-hard if it some NP-complete decision problem Π^′exists, such that it Turing-reduces to Π. It is indicated with Π^′∝_T Π.

Definition 2.6 (Self-reducibility). A search problem Π is self-reducible if the corre-sponding decision problem Π^′∈ NP Turing-reduces to Π. That is, Π is self-reducible if there is a polynomial-time Turing machine to solve Π that calls an oracle subrou-tine S that solves Π^′.

The trajectory assignment problem can be proved to be NP-hard, thereby in-tractable, which mathematically means that it cannot be solved in polynomial time unless P = NP. The self-reducibility technique is used to prove the NP hardness of the optimization problem (search problem) [100, 101]. The corresponding decision problem will be proved to be NP-complete; subsequently, a polynomial-time Turing

reduction (Cook reduction) will be outlined to prove that TAP is self-reducible. The notation used in [100] will be adopted in the following discussion. The trajectory assignment decision problem can be stated as follows:

Instance: The inputs of the trajectory assignment decision problem are:

• a flight schedule and a set of taxiway segments E;

• for each arrival and departure 1 ≤ j ≤ NF:

– a set of three paths Ps = {p₁( j) , p₂( j) , p₃( j)} ⊂ E;

– the corresponding set of taxiing speeds V s = {V₁( j) ,V₂( j) ,V₃( j)} ∈ V;

– a set of three buffer times Buffers = {buff₁( j) , buff₂( j) , PB_buff( j)} ∈ buff;

• for each path k:

– a path length d_k( j) ∈ R⁺₀;

– a corresponding time period l_k( j,V_k( j)) ∈ R⁺; – an earliest starting time et_k( j) ∈ R⁺;

– a deadline time dt_k( j) ∈ R⁺; a cost c_k( j,V_k(i)) ∈ R;

• a constant K ∈ R⁺.

Question: Is there a set of paths, speeds and buffer time that generates schedules for the taxi operations without conflicts between the trajectories, respecting the runway separation minima, and with total cost ∑^NF_j=1 ∑³_k=1c_k( j) + k_t· (buff₁( j) + buff₂( j) +

PB_buff( j)

≤ K? 

Before showing the proof of the NP-completeness of the trajectory assignment decision problem, we need to recall a problem that is known to be NP-complete: the no-wait job-shopscheduling, to which the trajectory assignment decision problem will be restricted.

Instance: The inputs of the trajectory assignment decision problem are:

• the number m ∈ Z⁺ of processors;

• a set of jobs J, each j ∈ J consisting of an ordered collection of tasks t_k∈ j 1 ≤ k ≤ n_j;

• for each task t ∈ j:

– a length l_t∈ Z⁺₀;

2.4 Trajectory assignment problem formulation | 37

– a processor p_t∈ {1, 2, . . . , m}, where p_tk̸= p_tk+1, with t_kand t_k+1∈ j, for all j ∈ J and 1 ≤ k ≤ n_j

– a deadline D ∈ Z⁺.

Question: Is there a job-shop schedule for J that meets the overall deadline, namely a collection of one-processor schedules σ_iwith 1 ≤ i ≤ m, such that:

• for two tasks of different jobs t and t^′, σi,t> σ_i,t^′ implies σi,t≥ σ_i,t^′+ l_t^′;

• for two tasks of the same job tk+1 and t_k, σt_k+1 = σt_k+ l_tk, with t_kand tk+1∈ j;

• σt_{n j}+ l_{tn j} ≤ D;

for all j ∈ J and 1 ≤ k ≤ n_j? 

The no-wait job-shop scheduling can be easily proved to be NP-complete, show-ing that for m = 1 it restricts to the travelshow-ing salesman problem, also known to be NP-complete [100]. It is possible now to state Theorem 2.1.

Theorem 2.1 (TAP decision NP-completeness). The trajectory assignment decision problem is NP-complete.

Proof. The decision problem can be restricted to no-wait job-shop scheduling, with the paths representing the jobs j ∈ J, the path segments as the tasks t_k ∈ j and the taxiways E being the processors. It is done by allowing only instances with Pscontaining one path for each phase of each mission, buffer time equal to zero, constant taxiing speeds V^′, thereby implying a fixed task length l_k^′ ∈ R⁺, earliest starting times et_k= 0, deadlines dt_k= D, cost c_k= l_kand having K = 3 · NF · D.  The second step of the proposed proof of intractability for the trajectory assign-ment problem consists in proving the self-reducibility of the problem, to demonstrate Theorem 2.2.

Theorem 2.2 (TAP NP-hardness). The trajectory assignment problem is NP-hard.

Proof. Suppose that S [x, K] is a subroutine to solve the TAP decision problem for a generic instance x, and that the optimal cost is denoted by K^∗. Each instance x has n = 9 · NF variables that can be ordered in a solution vector φ = (φ1, . . . φn) that contains, for all 1 ≤ j ≤ NF, respectively the paths p_k, the speeds V_k, with 1 ≤ k ≤ 3, and the buffer times buff₁, buff₂and PB_buff.

We know that the optimal cost lies between the values K_min = K(Ps_min,V s_min, Buffers_min) and K_max = K (Ps_max,V s_max, Buffers_max), with the pa-rameters standing for Ps_min= {p_1,shortest, p_2,shortest, p_3,shortest}_j, V s_min= {V_min}^NF, Buffers_min = {0}^NF, Ps_max = {p_1,longest, p_2,longest, p_3,longest}_j, V s_max = {V_max}^NF, Buffers_max= {MaxBuffer}^NF, for 1 ≤ j ≤ NF. Therefore, it is possible to deter-mine the value K^∗using a binary search procedure that calls the subroutine S [x, K]

with different values of K. It can be considered, without loss of generality, that the number of paths available for each phase of each mission is equal and defined as N p. Therefore, the binary search runs at most in ⌈log₂ NF⁹· N p³· NV³· Nb³
⌉

iterations.

Once the optimal cost K^∗has been computed, the following procedure can be applied to find the solution vector φ^∗that gives a conflict-free schedule with total cost K^∗. It must be noticed that, if more than one set of variable values solve the optimization problem, they are considered equivalent; therefore, it is sufficient that the algorithm outputs any of these sets.

• For j = 1 to n do:

– Substitute φj with one of its possible values φ^′_j and run the subroutine S[x^′, K^∗].

– If the modified φ is not satisfiable, substitute φj with its subsequent possible value.

– Repeat the two steps above until a satisfiable φ is found, thereby fixing φ_j= φ^∗_j.

• Output φ₁^∗, . . . , φ_n^∗.

The above algorithm, when used to solve the search problem, given a sub-routine S for the correspondent decision problem, runs in maximum 3 · NF · (NP + NV + Nb) = n/3 · (NP + NV + Nb) iterations, beyond the iterations required to find K^∗. Therefore, the algorithm runs in polynomial time, thereby constituting a polynomial-time Turing reduction and proving that TAP is self-reducible. As the TAP decision problem is NP-complete, it descends that the corresponding optimization

problem is NP-hard.