Aircraft routing and crew pairing: updated algorithms at Air France

TL;DR

This paper presents updated, efficient algorithms for aircraft routing and crew pairing at Air France, enabling quick solutions for large industrial instances and integrating both problems effectively.

Contribution

It introduces a compact MIP formulation for aircraft routing and a resource constrained shortest path framework for crew pairing, improving solution speed and scalability.

Findings

Routing can be solved in minutes for large instances.

Crew pairing optimal solutions are achievable for large instances.

Integrated problem solutions are near optimal using combined algorithms.

Abstract

Aircraft routing and crew pairing problems aims at building the sequences of flight legs operated respectively by airplanes and by crews of an airline. Given their impact on airlines operating costs, both have been extensively studied for decades. Our goal is to provide reliable and easy to maintain frameworks for both problems at Air France. We propose simple approaches to deal with Air France current setting. For routing, we introduce a compact MIP formulation that can be solved by current MIP solvers in at most a few minutes even on Air France largest instances. Regarding crew pairing, we provide a standard methodology to model the column generation pricing subproblem within a new resource constrained shortest path framework recently introduced by the first author. This new framework, which can be used as a black-box, leverages on bounds on paths' resource to discard partial solutions and speed-up the resolution. The resulting approach enables to solve to optimality Air France largest instances. Recent literature has focused on integrating aircraft routing and crew pairing problems. As a side result, we have been able to solve to near optimality large industrial instances of the integrated problem by combining the aforementioned algorithms within a simple cut generating method.

Tables

Table 1. Table 1. Air France industrial instances

Instance	Legs	Airplane	Airplanes	Crew	Crew	Short
		connect.		connect.	pairings ($\simeq$)	connect.
A318	669	39,564	18	3,742	130	1,230
A319	957	45,901	41	3,738	240	996
A320	918	49,647	45	3,813	280	1,103
A321	778	29,841	25	3,918	165	1,006
A318-9	1,766	–	(59)	8,070	350	2,226
A320-fam	3,398	–	(129)	21,563	690	4,398

Table 2. Table 2. Aircraft routing results

	(1) alone		(1) within (Int)
Instance	Uncons. CPU time (mm:ss)	Optim. CPU time (mm:ss)	Infeas. CPU time (mm:ss)	Feas. CPU time (mm:ss)
A318	00:17	00:58	00:14	01:35
A319	00:16	01:05	00:22	00:19
A320	01:02	03:55	00:35	13:28
A321	00:16	01:03	00:23	00:19

Table 3. Table 3. Crew pairing results – Instances are solved to optimality

Instance	$\kappa$	Col. Gen. Iter	Pricing time	LP time	MIP time	Total time (hh:mm:ss)
A318	150	394	86.60%	13.34%	0.05%	01:21:22
A319	150	264	60.66%	39.14%	0.15%	00:10:47
A320	150	226	74.54%	25.20%	0.20%	00:08:35
A321	150	382	65.82%	32.60%	1.25%	00:33:51
A318-9	150	867	69.71%	30.21%	0.07%	05:43:00
A320fam	250	2,166	43.28%	56.62%	0.10%	104:05:59

Table 4. Table 4. Numerical results on integrated problem

Instance	Integ. steps	CG it. total	(CP) CG time	(CP) MIP time	(1) time	Sho. Con.	Gap	Total time (hh:mm:ss)
A318	6	460	95.53%	2.56%	1.91%	323	0.0002%	01:53:47
A319	4	343	76.99%	13.27%	9.74%	448	0.0013%	00:20:18
A320	2	240	24.24%	39.38%	36.38%	436	0.0017%	00:38:36
A321	2	380	96.60%	2.53%	0.88%	413	0.0074%	00:29:18
A318-9	2	915	97.66%	1.71%	0.63%	790	0.0008%	06:34:31
A320-fam	Stopped after one week

Table 5. Table 5. Sequential versus integrated resolution of aircraft routing and crew pairing

Instance	318	319	320	321	318-9
Cost reduction	0.08%	0.16%	0.33%	0.31%	0.31%
CPU time ratio	10.6$\times$	3.0$\times$	5.6$\times$	2.0$\times$	5.1$\times$

Table 6. Table 6. Medium size artificial crew pairing instances

Instance	Legs	Connections	Pairings ($\simeq$)
CP50	290	1,006	50
CP70	408	1,705	70
CP90	516	2,490	90

Table 7. Table 7. Relative performance of pricing subproblems algorithms

Instance	Algorithm	$\kappa$	RCSP iter av. nb.	Cut Dom.	RCSP time av (mm:ss.ff)	Pricing time	Total time (hh:mm:ss)
CP50	Label setting	–	1.020e+04	–	00:00.56	97.55%	00:04:38
CP50	Label correcting	–	1.308e+04	–	00:01.28	97.38%	00:11:37
CP50	Algorithm 2	1	2.326e+03	6.89%	00:00.03	75.28%	00:00:23
CP50	Algorithm 2	10	4.914e+02	4.01%	00:00.02	59.87%	00:00:17
CP50	Algorithm 2	100	2.033e+02	5.03%	00:00.04	77.06%	00:00:33
CP70	Label setting	–	5.644e+04	–	00:11.49	99.52%	05:07:05
CP70	Label correcting	–	7.730e+04	–	00:17.16	99.56%	07:28:22
CP70	Algorithm 2	1	9.208e+03	7.69%	00:00.24	90.61%	00:04:41
CP70	Algorithm 2	10	1.994e+03	4.28%	00:00.04	58.48%	00:01:12
CP70	Algorithm 2	100	8.007e+02	5.77%	00:00.07	77.43%	00:01:43
CP90	Label setting	–	9.779e+04	–	00:40.71	Stopped after 48h
CP90	Label correcting	–	2.007e+05	–	01:42.87	Stopped after 48h
CP90	Algorithm 2	1	5.000e+04	9.81%	00:05.98	98.86%	02:56:33
CP90	Algorithm 2	10	9.966e+03	5.88%	00:00.34	81.86%	00:12:36
CP90	Algorithm 2	100	4.377e+03	5.60%	00:00.25	77.98%	00:10:28
A318	Label setting	–	1.319e+05	–	00:53.01	Stopped after 48h
A318	Label correcting	–	3.802e+05	–	01:36.04	Stopped after 48h
A318	Algorithm 2	1	7.161e+04	8.99%	00:08.61	97.87%	05:35:42
A318	Algorithm 2	10	5.472e+04	6.62%	00:05.97	96.02%	05:06:47
A318	Algorithm 2	100	2.549e+04	3.72%	00:01.65	86.97%	01:32:50

Table 8. Table 8. Sets of bounds B v subscript 𝐵 𝑣 B_{v} used (here, singletons)

$v$	$B_v$
${\ell }_1$	{((0,0,0,0),-5.8)}
${\ell }_3$	{((2,6,0,0),0.4)}
${\ell }_4$	{((1,4,0,0),2.5)}
${\ell }_5$	{((0,0,0,0),1.2)}
${\ell }_6$	{((1,2,0,0),1.5)}

Table 9. Table 9. Algorithm execution with single bounds: iterations considering paths P 𝑃 P starting by an o 𝑜 o - ℓ 1 subscript ℓ 1 \ell_{1} path P 1 subscript 𝑃 1 P_{1}

$P$	key$\left(P\right)$	$q_P$	$a$	$q_a$	$q_Q$	$w$	$b$ $B_w=\left\{b\right\}$	$q_Q\oplus b$	$Q$ added to $𝖫$
$P_1$	$-4.8$	$(0,0,1,6)$	$({\ell }_1,{\ell }_3$)	$(0,0,2,2)$	$(0,0,2,2)$	${\ell }_3$	$(2,6,0,0)$	$(0,0,0,0)$	yes
			$({\ell }_1,{\ell }_5$)	$(0,0,1,6)$	$(0,0,1,6)$	${\ell }_5$	$(0,0,0,0)$	$(0,0,0,0)$	yes
			$({\ell }_1,{\ell }_6$)	$(0,0,1,2)$	$(0,0,1,2)$	${\ell }_6$	$(1,2,0,0)$	$(0,0,0,0)$	yes
$P_1,{\ell }_3$	$-4.8$	$(0,0,2,2)$	$({\ell }_3,{\ell }_4)$	$(1,2)$	$(0,0,3,4)$	${\ell }_4$	$(1,4,0,0)$	$(0,0,0,0)$	yes
$P_1,{\ell }_3,{\ell }_4$	$-4.8$	$(0,0,3,4)$	$({\ell }_4,{\ell }_5)$	$(1,6)$	$(0,0,4,10)$	${\ell }_5$	$(0,0,0,0)$	$\infty$	no
			$({\ell }_4,{\ell }_6)$	$(1,2)$	$(0,0,4,6)$	${\ell }_6$	$(1,2,0,0)$	$\infty$	no
$P_1,{\ell }_6$	$4.6$	$(0,0,1,2)$	$({\ell }_6,{\ell }_7)$	$(1,2)$	$(0,0,2,4)$	${\ell }_7$	etc.
$P_1,{\ell }_5$	$8.4$	$(0,0,1,6)$	$({\ell }_5,{\ell }_8)$	$(0,0,2,6)$	$(0,0,2,6)$	${\ell }_8$

Table 10. Table 10. Algorithm execution with B ℓ 3 = { ( ( 2 , 8 , 0 , 0 ) , 0.4 ) , ( ( 3 , 6 , 0 , 0 ) , 1.5 ) } subscript 𝐵 subscript ℓ 3 2 8 0 0 0.4 3 6 0 0 1.5 B_{\ell_{3}}=\big{\{}\big{(}(2,8,0,0),0.4\big{)},\big{(}(3,6,0,0),1.5\big{)}\big{\}}

$P$	key$\left(P\right)$	$q_P$	$a$	$q_a$	$q_Q$	$w$	$b$	$q_Q\oplus b$	$Q$ added to $𝖫$
$P_1$	$-4.8$	$(0,0,1,6)$	$({\ell }_1,{\ell }_3$)	$(0,0,2,2)$	$(0,0,2,2)$	${\ell }_3$	$(2,8,0,0)$	$\infty$
							$(3,6,0,0)$	$\infty$	no
			$({\ell }_1,{\ell }_5$)	$(0,0,1,6)$	$(0,0,1,6)$	${\ell }_5$	$(0,0,0,0)$	$(0,0,0,0)$	yes
			$({\ell }_1,{\ell }_6$)	$(0,0,1,2)$	$(0,0,1,2)$	${\ell }_6$	$(1,2,0,0)$	$(0,0,0,0)$	yes
$P_1,{\ell }_6$	$4.6$	$(0,0,1,2)$	$({\ell }_6,{\ell }_7)$	$(1,2)$	$(0,0,2,4)$	${\ell }_7$	etc.
$P_1,{\ell }_5$	$8.4$	$(0,0,1,6)$	$({\ell }_5,{\ell }_8)$	$(0,0,2,6)$	$(0,0,2,6)$	${\ell }_8$

Equations

$$\sum _{a\in {\delta }^{-}(v)}{x}_a=\sum _{a\in {\delta }^{+}(v)}{x}_a$$

$$\sum _{a\in {\delta }^{-}(V_{\ell })}{x}_a=1$$

$$\sum _{a\in A_0}{x}_a\le n^{\mathrm{a}}$$

$$x_a\in \{0,1\}$$

$$\begin{array}[]{rl@{\qquad}l}\min&\displaystyle\sum_{p\in\mathcal{P}}c_{p}y_{p}\\ \mathrm{s.t.}&\displaystyle\sum_{p\ni\ell}y_{p}=1&\forall\ell\in\mathcal{L}\\ &\displaystyle\sum_{p\in\mathcal{P}^{\mathrm{l}}}y_{p}\leq\alpha\sum_{p\in\mathcal{P}}y_{p}\\ &\displaystyle\sum_{p\in\mathcal{P}}\left((1-\beta)\Delta^{\mathrm{l}}(p)-\beta\Delta^{\mathrm{s}}(p)\right)y_{p}\leq 0\\ &y_{p}\in\{0,1\}&\forall p\in\mathcal{P},\end{array}$$

$$\underset{p\in \mathcal{P}}{\min }{\tilde{c}}_p.$$

$$o$$

$$v$$

$$\mathrm{key}(P)=\min \{c(q_P\oplus b):b\in B_v,\rho (q_P\oplus b)=0\}\text{where v is the last vertex of P.}$$

$$o$$

$$r\oplus \infty$$

$$(n,f)\oplus (\tilde{n},\tilde{f})$$

$$(n,f)\oplus ({\tilde{n}}^b,{\tilde{f}}^b,{\tilde{n}}^e,{\tilde{f}}^e)$$

$$(n^b,f^b,n^e,f^e)\oplus (\tilde{n},\tilde{f})$$

$$(n^b,f^b,n^e,f^e)\oplus ({\tilde{n}}^b,{\tilde{f}}^b,{\tilde{n}}^e,{\tilde{f}}^e)$$

$$(0,0)⪯q$$

$$(n,f)⪯(\tilde{n},\tilde{f})$$

$$(n^b,f^b,n^e,f^e)⪯({\tilde{n}}^b,{\tilde{f}}^b,{\tilde{n}}^e,{\tilde{f}}^e)$$

$$\rho \left((r,z)\right)={\rho }_{M^{\rho }}(r)\text{and}c((r,z))=z$$

$$\displaystyle\rho_{M^{\rho}}\big{(}(n,f)\big{)}$$

$${\rho }_{M^{\rho }}\left((n^b,f^b,n^e,f^e)\right)$$

$${\rho }_{M^{\rho }}(\infty )$$

$$\sum _{p\in {\mathcal{P}}_{\alpha }}{y}_p\le \sum _{a\in A_{\alpha }}{x}_a$$

$$\begin{array}[]{rll}\min&\displaystyle\sum_{p\in\mathcal{P}}c_{p}y_{p}\\ \mathrm{s.t.}&\mbox{$\boldsymbol{x}$ satisfies constraints of~{}\eqref{eq:ARprogram}}\\ &\mbox{$\boldsymbol{y}$ satisfies constraints of~{}\eqref{eq:MasterProblem}}\\ &\mbox{$\boldsymbol{x}$ and $\boldsymbol{y}$ satisfy constraints~{}\eqref{eq:shortConnectionConstraint} for all short connections $\alpha$.}\end{array}$$

$$\sum _{p\in \mathcal{P}}|p\cap S|y_p\le |S|-1,$$

$$\begin{array}[]{rl}\min&\boldsymbol{c}^{T}\boldsymbol{z}\\ \mathrm{s.t.}&A\boldsymbol{z}=\boldsymbol{b}\\ &\boldsymbol{z}\in\mathbb{Z}_{+}.\end{array}$$

$$\begin{array}[]{rl}\min&\displaystyle{\bar{v}+\sum_{i\in N}\tilde{c}_{i}z_{i}}\\ \mathrm{s.t.}&A\boldsymbol{z}=\boldsymbol{b}\\ &\boldsymbol{z}\in\mathbb{Z}_{+},\end{array}$$

$$\bar{v}+\sum _{i\in N}{\tilde{c}}_i{z}_i^{\ast }=\mathbf{c}\cdot {\mathbf{z}}^{\ast }\le \mathrm{UB}.$$

$$z_i^{\ast }\le \frac{\mathrm{UB}-\bar{v}}{{\tilde{c}}_i}.$$

$$q\wedge \infty$$

$$(n,f)\wedge (\tilde{n},\tilde{f})$$

$$(n^b,f^b,n^e,f^e)\wedge ({\tilde{n}}^b,{\tilde{f}}^b,{\tilde{n}}^e,{\tilde{f}}^e)$$

$$\min$$

$$s.t.$$

$$\sum _{a\in {\delta }^{-}(v)}{x}_a=\sum _{a\in {\delta }^{+}(v)}{x}_a$$

$$\sum _{j\in [n^{\mathrm{a}}]}\sum _{a\in {\delta }^{-}(V_{\ell }^j)}{x}_a=1$$

$$x_a\in \{0,1\}$$

$$\underset{(\overline{\mathbf{x}},\overline{\mathbf{y}},\overline{\mathbf{z}})}{\min }$$

$$s.t.$$

Full text

1. Introduction

1.1. Context

Interactions between Operations Research and Air Transport Industry have been successful for at least five decades [5, 18]. These interactions have taken various forms: yield management, airplane timetabling, ground operations scheduling, air traffic management, etc. Key applications are notably the construction of sequences of flight legs operated by airplanes and crews. As airplane sequences of legs are routes and crew sequences pairings, this construction is called aircraft routing for airplanes, and crew pairing for crews.

The present paper focuses on these two applications and is the fruit of a research partnership with Air France, the main French airline. We aim at providing a reliable and easy to maintain framework that can cope with the specific and challenging industrial context of the company. Air France working rules are more complex than the IATA standards: Collective agreements reach hundreds of pages, and two of the most cited references on crew pairing [12, 29] develop ad-hoc approaches to build pairings satisfying the company’s rules. While the aircraft routing remains easy, this turns the exact resolution of Air France crew pairing into a challenge.

As crews need time to cross airports if they change airplane, the two problems are linked and the sequential resolution currently in use in the industry is suboptimal. Solving the integrated problem has been identified by academics as a difficult problem. Air France also requested an easy to maintain solution scheme for the integrated problem.

1.2. Literature review

All the versions of the problems considered in this paper are NP-hard. We focus here on mathematical programming approaches.

Aircraft routing is considered at Air France as a pure feasibility problem, which contrasts with the recent literature which considers optimization versions. Authors either maximize profit when the fleet is heterogeneous [13, 4], or minimize delay propagation along sequences of flights [28]. A recent paper introduces tools to deal with richer maintenance constraints [37]. State-of-the-art solution approaches rely on column generation [4, 13, 28, 20], where columns are sequences of flight legs between airports where maintenance checks can be performed. They can solve to optimality large instances of the optimization versions in a few hours. (The solution proposed in [28] is actually for the so-called tail assignment problem, where the airplanes are distinguishable, but it can be adapted to aircraft routing.) Alternative approaches include heuristics [19] and Lagrangian relaxations [9].

Clarke et al. [9] propose a MIP with few variables. However, their MIP has two exponential-size families of constraints: The first one is formed by classical subtour elimination constraints; the second one is formed by “minimal violation path” constraints that enforce the maintenance requirements. While the first family can be discarded for the aircraft routing problem we consider, the second one must be kept, and thus cut generation cannot be avoided to solve their MIP. Practically efficient compact integer programming formulations, that is, formulations which require neither column generation, nor cut generation, have recently been proposed by Cacchiani and Salazar-González [7] and Khaled et al. [25]. Compact formulations have the advantage to be more handy and can often be directly implemented in standard MIP solvers. Cacchiani and Salazar-González [7] consider the integrated problem, and propose a compact integer programming formulation for aircraft routing. Since they assume that the airplanes spend alternatively one night in a base and one night outside, their approach does not generalize to the Air France case, where one maintenance must be performed at least every four days, while the maintenance day is not fixed. By the way, due to the different maintenance requirements, the aircraft routing problem considered by Cacchiani and Salazar-González [7] has a polynomial status [22], while Air France problem is NP-hard [41]. Khaled et al. [25] have also recently proposed a compact MIP approach to tail assignment, which can be adapted to aircraft routing. They are able to solve to optimality instances with up to 1,178 legs and 30 airplanes in 3 hours. Their approach could in principle be used to address the version of the aircraft routing problem met at Air France. We discuss later in the paper the advantage of the approach we propose for aircraft routing with respect to theirs.

Crew variable wages and hotel rooms are among airlines first sources of variable costs. As both depend on the sequences of flight legs crews operate, crew pairing is an intensively studied optimization problem; see Gopalakrishnan and Johnson [21] for an extensive review. Regulatory agencies and collective bargaining agreements list numerous working rules that make the crew pairing problem highly non-linear and hence difficult. There is a long tradition of MIP approaches to crew pairing [21, 2]. Since the seminal work of Minoux [33], state-of-the-art approaches solve the crew pairing by column generation [29, 1, 23, 8, 12, 27, 26, 3, 40, 44]. They consider set partitioning formulations where columns are possible pairings. These methods hide the non-linearity in the pricing subproblem, which can be efficiently solved using resource constrained shortest path approaches [24]. As a large part of the working rules apply to duties, i.e., subsequences of a pairing formed by the flight legs operated on a same day, the subproblem is often split into two parts [12, 44]. The first one builds the set of all non-dominated duties. The second one builds the pairings by solving a path problem in the graph whose vertices are the non-dominated duties, and whose arcs are the pair of duties that can be chained. However, as the number of non-dominated duties is huge, solving the pricing subproblem becomes costly on large instances. When working rules are simple, one can also use compact integer programming approaches [6] where variables indicate if a given connection is used, and set partitioning formulations, where columns are the duties [42]. However, this is generally not the case, and such models are generally turned into initialization heuristics [3].

During the last decade, much attention has been devoted to the integration of aircraft routing and crew pairing. Moving from a sequential to an integrated approach enables to reduce the cost by $5\%$ on average according to Cordeau et al. [11], and $1.6\%$ according to Papadakos [35]. Solution methods are column generation based heuristics [32, 31, 10, 35, 43, 38, 7, 39]. The heuristics of Weide et al. [43], Salazar-González [38], Cacchiani and Salazar-González [7] share many similarities with the ones we propose in this paper. Dunbar et al. consider robust [16] and stochastic [17] versions of the problem. To the best of our knowledge, the largest instances considered in the literature have 750 legs [43].

1.3. Contribution and methods

The present paper is the result of a project initiated by Air France to design efficient and easy to maintain solution schemes for aircraft routing, crew pairing, and the integrated problem.

The first author has recently proposed an abstract framework [36] for computing resource constrained shortest paths. The main contribution of the present paper is the proof that this framework can be used on a concrete problem and considerably improves the size of the instances that can be solved at optimality. Indeed, we apply this framework to the pricing subproblem of a standard column generation approach for the crew pairing problem and solve to optimality from a few minutes to a few hours instances with up to $1,000$ flight legs, which outperforms previous performances on that problem. One key element in the performances of this framework is the use of sets of bounds to discard paths, instead of single bounds: This is useful in a context where any two resources are not necessarily comparable (in Section 4, further details will be given). Even if this idea of sets of bounds is present in the aforementioned paper of the first author, the present paper is the first proof that such a technique is very efficient in practice. We finally emphasize that the framework for shortest path computation does not explain how to model concrete problems like the one met for crew pairing. The modeling we propose is thus also a contribution on its own: More than $70$ rules have to be satisfied, and most of them are non-linear. Finally, Desrosiers and Lübbecke [14, p. 16] underline that, in a column generation context, “accelerating the pricing algorithm itself usually leads most significant speeds-up”. As all the approaches to the integrated problem use a column generation approach for the crew pairing, we believe that these approaches can be significantly accelerated by using our improved crew pairing pricing subproblem algorithm.

Our second contribution is a simple and compact integer formulation for aircraft routing. Such formulations are desirable in an industrial context since, as mentioned in the literature review, they do not require tricky development and can often be directly implemented in off-the-shelf solvers. In addition, our formulation is very efficient: It enables to solve all Air France industrial instances in at most a few minutes. As mentioned in the literature review, other compact formulations have recently been proposed [7, 25]. Even though the formulation of Khaled et al. [25] could in theory be adapted to the Air France specific problem, such an adaptation is not straightforward due to the fact that routes are cyclic in the Air France aircraft routing problem. Furthermore, on the Air France problem, our formulation admits a stronger linear relaxation than theirs (we discuss it in Appendix B), which gives a clear competitive advantage to our approach. We do not claim that our formulation outperforms their one on other versions of the problem such as the ones they consider.

Finally, we design a simple cut generating method for solving the integrated problem, which relies on our contributions for aircraft routing and crew pairing. Like the one of Weide et al. [43], our method consists in solving alternatively crew pairing and aircraft routing problems. However, they do not consider the same problem: Their version includes a notion of robustness with respect to delay. Experiments show that the method is able to solve to near optimality instances with up to $1,766$ flight legs, which again outperforms previous results on that problem. Due to the specificity of the Air France problem, with no aircraft routing costs, our method cannot handle all the problems considered in the literature. However, it is the only one that proves optimality gaps smaller than 0.01% on instances with more than 600 legs.

We emphasize that for the three problems, our solution is easy to use and to maintain by the company. The algorithm for computing the shortest paths is already implemented and can be used as a black-box. The only non-trivial task is the modeling of the rules in the framework, but once a few techniques have been understood (like the ones we use later in the paper, in Section 4.2), even this step is straightforward.

1.4. Organization of the paper

Each of the three problems considered in the paper is addressed in a separate section: The aircraft routing problem is studied in Section 2, the crew pairing problem in Section 3, and the integrated problem in Section 5. Each of these sections gets exactly the same structure. It starts with a subsection describing the problem. A second subsection is then devoted to a modeling of the problem (e.g., the compact integer formulation for the aircraft routing problem). It ends with a subsection explaining the proposed method to solve the problem (e.g., column generation for the crew pairing problem and cut generation for the integrated problem).

Experiments showing the efficiency of the methods proposed in each of these three sections are provided and discussed in Section 6.

Section 4 is a section making a focus on an algorithmic subroutine required by our method for the crew pairing problem. This section is much more technical than the others and can be safely skipped at first reading (and the same holds for Section 6.7 that deals with specific experiments regarding this subroutine). This subroutine is the algorithm solving the pricing subproblem of the column generation. It relies on the shortest path framework of the first author and on bound sets, both described in that section.

The paper ends with a short conclusion (Section 7). All proofs are postponed to Appendix A.

2. Compact integer program for aircraft routing

2.1. Problem formulation

Building the sequences of flight legs required for aircraft routing corresponds to solving the following problem.

The input is formed by a set of airports, a collection $\mathcal{L}$ of flight legs, and a number $n^{\mathrm{a}}$ of airplanes. Some airports are bases in which maintenance checks can be performed. A flight leg is characterized by departure and arrival airports, as well as departure and arrival times (it is of course assumed that departure time is smaller than arrival time for any flight leg). We consider the flight legs on a weekly horizon: the departure and arrival times are given for a typical week.

The purpose of aircraft routing is to determine routes for airplanes so that each flight leg is operated by an airplane each week without using more than $n^{\mathrm{a}}$ airplanes. In addition, there are maintenance operations that have to be regularly performed: Each airplane has to spend a night in a base at least every $\Delta_{\text{maint}}$ days, where $\Delta_{\text{maint}}$ is a given parameter, which is equal to $4$ at Air France.

Formally, an airplane connection is a pair $(\ell,\ell^{\prime})$ of flight legs which satisfies

• •

the arrival airport of $\ell$ is the departure airport of $\ell^{\prime}$

• •

the duration between the departure time of $\ell^{\prime}$ and the arrival time of $\ell$ is bounded from below by a fixed quantity (which can depend on the airport, the time, and the fleet).

We underline that there are connections $(\ell,\ell^{\prime})$ with $\ell$ at the end of the week and $\ell^{\prime}$ at the beginning of the (next) week. A route is a cyclic sequence of distinct flight legs $\ell_{1},\ldots,\ell_{k}$ such that any two consecutive flight legs $(\ell,\ell^{\prime})=(\ell_{i-1},\ell_{i})$ or $(\ell_{k},\ell_{1})$ is an airplane connection. Routes can last several weeks, but each week, the sequences of flight legs operated by airplanes are the same. In other words, when we consider all airplanes as indiscernible, the solution must have a week periodicity. Figure 1 illustrates two routes, which last respectively one and two weeks. As each flight leg has to be operated each week, routes lasting $p$ weeks require $p$ airplanes. A route satisfies the maintenance requirement if an airplane following this route in a cyclic way (repeating the solution when it reaches the end of the cycle) spends a night in a base at least every $\Delta_{\text{maint}}$ days

The task consists in partitioning $\mathcal{L}$ into routes satisfying the maintenance requirement such that the number of airplanes needed to operate these routes is less than or equal to $n^{\mathrm{a}}$.

2.2. Modeling as an integer program

We first explain how the problem can be modeled as a disjoint cycle problem in a directed graph. This will make the description of the integer program a straightforward task.

Define the directed graph $D=(V,A)$ as follows. Its vertex set is $\mathcal{L}\times[\Delta_{\text{maint}}]$. In other words, each flight leg is duplicated $\Delta_{\text{maint}}$ times. Each vertex $(\ell,\delta)$ corresponds to a flight leg $\ell\in\mathcal{L}$ with the number of days $\delta\in[\Delta_{\text{maint}}]$ since the last night spent in a base. An ordered pair $\left((\ell,\delta),(\ell^{\prime},\delta^{\prime})\right)$ is in $A$ if $(\ell,\ell^{\prime})$ is an airplane connection and we are in one of the three following situations:

• •

$\ell$ and $\ell^{\prime}$ are performed during a same day and $\delta=\delta^{\prime}$, as illustrated between legs $\ell_{f}$ and $\ell_{h}$ on Figure 2,

• •

$\ell$ and $\ell^{\prime}$ are not performed on the same day, the airport is a base, and $\delta^{\prime}=1$, as illustrated between legs $\ell_{j}$ and $\ell_{l}$,

• •

$\ell$ and $\ell^{\prime}$ are not performed on the same day, the airport is not a base, and $\delta^{\prime}-\delta\geq 0$ is the number of days between the arrival of $\ell$ and the departure of $\ell^{\prime}$, as illustrated between $\ell_{m}$ and $\ell_{o}$.

In other words, an arc corresponds to two flight legs that can be consecutive in a route, with the suitable restrictions on the number of days since the last night spent in a base. A cyclic sequence of legs $\ell_{1},\ldots,\ell_{k}$ satisfies the maintenance requirement if and only if there exist $\delta_{i}$ for $i$ in $\{1,\ldots,k\}$ such that $(\ell_{1},\delta_{1}),\ldots,(\ell_{k},\delta_{k})$ is a cycle in $D$. Indeed, suppose that a route $\ell_{1},\ldots,\ell_{k}$ satisfies the maintenance requirement, and denote by $\delta_{i}$ the number of days since the last night spent in a base before $\ell_{i}$. Then the definition of $D$ ensures that $(\ell_{1},\delta_{1}),\ldots,(\ell_{k},\delta_{k})$ is a cycle in $D$. Conversely, suppose that a route does not satisfies the maintenance requirement. It contains a sequence of legs $\ell_{1},\ldots,\ell_{k}$ spending more than $\Delta_{\text{maint}}$ successive days out of a base. Let $\ell_{j}$ be the last leg in that sequence before the $\Delta_{\text{maint}}$th night. Then any path $(\ell_{1},\delta_{1}),\ldots,(\ell_{j},\delta_{j})$ in $D$ necessarily ends in vertex $(\ell_{j},\Delta_{\text{maint}})$, which has no outgoing arc, and there is no cycle in $D$ corresponding to the route.

Figure 2 illustrates such a directed graph $D$. The route $\ell_{a},\ell_{c},\ell_{e},\ell_{h},\ell_{i},\ell_{k},\ell_{n},\ell_{o},\ell_{q}$ satisfies the maintenance requirement and corresponds to the dashed cycle in $D$. The route $\ell_{b},\ell_{c},\ell_{e},\ell_{g},\ell_{i},\ell_{k},\ell_{n},\ell_{o},\ell_{q}$ does not satisfy the maintenance requirement. The dotted path is an attempt to make it a cycle in $D$, but since there is no arc outgoing from $(\ell_{k},\Delta_{\text{maint}})$, it is not possible.

We choose arbitrarily one instant in the week and we denote by $A_{0}$ the set of arcs $((\ell,\delta),(\ell^{\prime},\delta^{\prime}))$ “crossing this instant”, i.e., such that the time interval between the departure of $\ell$ (included) and the departure of $\ell^{\prime}$ (excluded) contains the instant. Define moreover $V_{\ell}$ to be the set \big{\{}(\ell,\delta)\in V\colon\delta\in[\Delta_{\text{maint}}]\big{\}}.

Proposition 1**.**

Feasible solutions of the aircraft routing problem are in one-to-one correspondence with collections $\mathcal{C}$ of vertex disjoint cycles in $D$ such that we have simultaneously

1. (i)

for each $\ell$, exactly one cycle in $\mathcal{C}$ has a nonempty intersection with $V_{\ell}$, and this intersection consists of a single vertex. 2. (ii)

$\mathcal{C}$* has at most $n^{\mathrm{a}}$ arcs in $A_{0}$.*

Therefore, the aircraft routing problem is equivalent to deciding whether the following integer program has a feasible solution:

[TABLE]

Equation (AR.1) is the flow equation. Together with (AR.2), it ensures that the solution is composed of vertex disjoint cycles. Equation (AR.2) ensures that (i) is satisfied and Equation (AR.3) ensures that (ii) is satisfied.

2.3. Solution method

The solution we propose is to implement directly the integer program (1) in any standard MIP solver. Its number of constraints is $|\mathcal{L}|\times\Delta_{\text{maint}}+|\mathcal{L}|+1$ and its number of variables is the number of airplane connections times $\Delta_{\text{maint}}$. Program (1) is therefore of tractable size, and current off-the-shelf solvers can solve industrial instances in a few minutes. See our experiments in Section 6.

3. Column generation approach to crew pairing

3.1. Problem formulation

Roughly speaking, the crew pairing problem is similar to the aircraft routing problem: instead of building sequences of flight legs for the airplanes (the routes), crew pairing requires to build pairings, which are sequence of flight legs operated by the crews. While routes are cyclic sequences, pairings are noncyclic sequences (and they are often quite short). The set of flight legs have to be partitioned into pairings, but the constraints are much more complicated. Before stating formally the crew pairing problem, we introduce some terminology.

A pair of flight legs $(\ell,\ell^{\prime})$ is a connection if it satisfies:

• •

The arrival airport of $\ell$ is the departure airport of $\ell^{\prime}$

• •

The departure time of $\ell^{\prime}$ minus the arrival time of $\ell$ is bounded from below by a fixed quantity (which can depend on the airport, the time, and the fleet). This quantity is in general different from the similar one for aircraft routing.

If the arrival of $\ell$ and the departure of $\ell^{\prime}$ are on the same day, then it is a day connection. Otherwise, it is a night connection. If the duration of a night connection is smaller than a threshold, then it is a reduced rest. (This term is due to the rest taken by crews performing a night connection.)

A pairing is a sequence of distinct flight legs such that any two consecutive flight legs form a connection. The subsequence of a pairing formed by all flight legs operated during a same day is a duty.

To be feasible, a pairing $\ell_{1},\ldots,\ell_{k}$ has to satisfy the following rules:

1. (a)

the period between the departure of $\ell_{1}$ and the arrival of $\ell_{k}$ spans at most $4$ days, 2. (b)

$\ell_{1}$ starts and $\ell_{k}$ ends in one of the Paris airports, 3. (c)

each duty contains at most $4$ flight legs. If a duty starts with a leg $\ell^{\prime}$, and the night connection $(\ell,\ell^{\prime})$ that leads to $\ell^{\prime}$ is a reduced rest, then the number of legs of the duty is at most $3$, 4. (d)

the total flying duration in a duty does not exceed $F(t)$, where $F$ is a given function and $t$ is the time at which the first leg of the duty departs,

as well as more than $70$ other rules which encode the IR-OPS regulation of the European Aviation Safety Agency and Air France working rules. A pairing is long if it spans $4$ days. A duty is long if it contains more than $3$ flight legs, and short otherwise. We denote by $\mathcal{P}$ the set of feasible pairings

Operating a pairing $p$ in $\mathcal{P}$ has a cost $c_{p}$ that corresponds to crew wages and hotel nights. Given a set $\mathcal{L}$ of flight legs, solving the crew pairing problem consists in selecting a collection of feasible pairings of minimum total cost so that each leg $\ell$ in $\mathcal{L}$ belongs to exactly one of them, and so that the following global constraints are satisfied: The proportion of long pairings in the solution is less than or equal to a quantity $\alpha$, and the proportion of long duties is at most a quantity $\beta$.

Our purpose here is to introduce the main modeling ideas and not to get into details of the intricacies of the IR-OPS and Air France regulations. In the rest of the paper, we therefore present these ideas on a simplified problem with only the four illustrating rules (a), (b), (c), and (d). All the other rules are also taken into account in the numerical results.

3.2. Modeling as an integer program

As pairings must satisfy many non-linear rules such as rule (c), it is difficult to model crew pairing using a compact integer program that has both a good linear relaxation and a tractable size. The literature therefore generally uses a column generation approach where rules complexity are hidden in the set of variables (and dealt with using ad-hoc algorithms in the pricing subproblem). We also use a column generation approach.

The binary variable $y_{p}$ indicates if a pairing $p$ in $\mathcal{P}$ belongs to the solution.

[TABLE]

where $p\ni\ell$ means that the flight leg $\ell$ is present in $p$, where $\mathcal{P}^{\mathrm{l}}$ is the set of long pairings, and where $\Delta^{\mathrm{s}}(p)$ (resp. $\Delta^{\mathrm{l}}(p)$) is the number of short (resp. long) duties in a pairing $p$. The first constraint ensures that each leg is covered, the second that the proportion of long pairings is less than or equal to $\alpha$, and the third that the proportion of long duties is less than or equal to $\beta$.

3.3. Column generation approach

We propose an exact method for solving the program (CP). It is based on column generation. We describe the method without assuming special knowledge in column generation. We will in particular be sketchy on the theoretical rationale; more details on that topic can be found for instance in a survey by Lübbecke [30].

Algorithm 1 describes our column generation approach, which maintains a subset of pairings $\mathcal{P}^{\prime}\subseteq\mathcal{P}$. The idea of column generation is to solve the master problem, which is the linear relaxation of (CP) on such a subset $\mathcal{P}^{\prime}$, and to check if by chance the optimal solution found on this restricted version is also an optimal solution of the master problem with the full set $\mathcal{P}$. This checking is done exactly as in the classical simplex algorithm: It is the optimal solution for the full problem if all reduced costs are nonnegative. Since the number of elements in $\mathcal{P}$ is huge, it is not possible to compute and check all these reduced costs one by one. However, given an element $p$ in $\mathcal{P}$, it is always possible to compute its reduced cost from the value of the dual variables by standard linear programming theory. To find the element $p$ with the smallest reduced cost, an auxiliary optimization problem instantiated by the values of the dual variables is solved: The pricing subproblem. In Algorithm 1, this is done in Step 5. The exact method to solve the pricing subproblem is described in Section 4. Right before Step 10, the linear relaxation of (CP) is fully solved.

Since the total number of possible pairings is finite, Step 3 – which consists in solving the master problem – is repeated only finitely many times, and thus the overall method terminates in finite time. After having performed Step 3 for the last time, $c^{\mathrm{low}}$ is a lower bound on the optimal value of (CP). Step 10 provides a first feasible solution of (CP). The value $c^{\mathrm{upp}}$ (Step 11) is thus an upper bound on the optimal value of (CP). At that time, we have thus a lower bound on the optimal value, and a feasible solution.

The purpose of the remaining steps is to “close the gap”. The idea consists in generating all pairings $p$ that might be in an optimal solution. These pairings are precisely those whose reduced cost is smaller than or equal to $c^{\mathrm{upp}}-c^{\mathrm{low}}$. This is completely formalized by Lemma 2 below. Finding all these pairings in Step 12 is a variant of the pricing subproblem, briefly discussed in Remark 2 of Section 4. At the end, the solution $\boldsymbol{y}^{*}$ is an optimal solution of (CP).

Lemma 2** (Nemhauser and Wolsey [34, Proposition 2.1, p. 389]).**

Consider an integer program in standard form with variables $(z_{i})$ for which the linear relaxation admits a finite optimal value $\bar{v}$. Suppose given an upper bound $\operatorname{UB}$ on the optimal value of the integer program. Then for every $i$ such that $\tilde{c}_{i}>\operatorname{UB}-\bar{v}$, the variable $z_{i}$ is equal to [math] in all optimal solutions of the integer program, where $\tilde{c}_{i}$ denotes the reduced cost of the variable $z_{i}$ when the linear relaxation has been solved to optimality.

Remark 1*.*

The last steps of Algorithm 1 works only if the gap $c^{\mathrm{upp}}-c^{\mathrm{low}}$ is small, as otherwise a huge number of pairings might be added at Step 12. We found out numerically that it is the case for all Air France instances, and we thus use this technique. Lemma 2 has been recently used by Cacchiani and Salazar-González [7] on the integrated problem. They underline that when $c^{\mathrm{upp}}-c^{\mathrm{low}}$ is large, a branch and bound approach is required.

4. Pricing subproblem

We now introduce a solution scheme for the pricing subproblem

[TABLE]

As pairings can be considered as paths satisfying constraints in the graph whose vertices are the legs and arcs the connections, the pricing subproblem is generally solved as a resource constrained shortest path problem, and we do not depart from this approach. We model it within the Monoid Resource Constrained Shortest Path Problem framework [36], which we now briefly describe. This framework is rather abstract, but practically, it only requires to implement a few operators on the resource set. This work is the first application of the Monoid Resource Constrained Shortest Path Problem framework to an industrial problem.

4.1. Framework and algorithm

A binary operation $\oplus$ on a set $M$ is associative if $q\oplus(q^{\prime}\oplus q^{\prime\prime})=(q\oplus q^{\prime})\oplus q^{\prime\prime}$ for $q,q^{\prime},$ and $q^{\prime\prime}$ in $M$. An element [math] is neutral if $0\oplus q=q\oplus 0=q$ for any $q$ in $M$. A set $(M,\oplus)$ is a monoid if $\oplus$ is associative and admits a neutral element. A partial order $\preceq$ is compatible with $\oplus$ if the mappings $q\mapsto q\oplus q^{\prime}$ and $q\mapsto q^{\prime}\oplus q$ are non-decreasing according to this order for all $q^{\prime}$ in $M$. A partially ordered set $(M,\preceq)$ is a lattice if any pair $(q,q^{\prime})$ of elements of $M$ admits a greatest lower bound or meet denoted by $q\wedge q^{\prime}$, and a least upper bound or join denoted by $q\vee q^{\prime}$. A set $(M,\oplus,\preceq)$ is a lattice ordered monoid if $(M,\oplus)$ is a monoid, $(M,\preceq)$ is a lattice, and $\preceq$ is compatible with $\oplus$.

Given a digraph $D=(V,A)$, a lattice ordered monoid $(M,\oplus,\preceq)$, elements $q_{a}\in M$ for each $a\in A$, origin and destination vertices $o$ and $d$, and two non-decreasing mappings $c:M\rightarrow\mathbb{R}$ and $\rho:M\rightarrow\{0,1\}$, the Monoid Resource Constrained Shortest Path Problem seeks

[TABLE]

where $\bigoplus_{a\in P}$ is always performed in the order of the arcs on the path $P$ (the operation $\oplus$ is not necessarily commutative). We call such a $q_{a}$ the resource of the arc $a$. The sum $\bigoplus_{a\in P}q_{a}$ is the resource of a path $P$, and we denote it by $q_{P}$. The real number $c\left(q_{P}\right)$ is its cost, and the path $P$ is feasible if $\rho\left(q_{P}\right)$ is equal to [math]. We therefore call $c$ and $\rho$ the cost and the infeasibility functions.

We now describe an enumeration algorithm for the Monoid Resource Constrained Shortest Path Problem. It follows the standard labeling scheme [24] for resource constrained shortest paths. The specificity of our algorithm is that it uses, for each $v$ in $V$, a set $B_{v}$ of bounds such that,

[TABLE]

The lattice ordered monoid framework enables to design procedures to build these sets of bounds; see Section 4.3 for more details. Having defined these bounds, we define $\operatorname{key}(P)$ as

[TABLE]

The empty path at a vertex $v$ is the path with no arcs starting and ending at vertex $v$. By definition of paths resources, its resource is the neutral element of the monoid. A path $P$ dominates a path $Q$ if $q_{P}\preceq q_{Q}$. During the algorithm, a list $\mathsf{L}$ of partial paths, an upper bound $c_{od}^{UB}$ on the cost of an optimal solution, and lists $(\mathsf{L}_{v}^{\mathrm{nd}})_{v\in V}$ of non-dominated $o$-$v$ paths are maintained. Algorithm 2 states our algorithm. We denote by $P+a$ the path composed of a path $P$ followed by an arc $a$.

Proposition 3**.**

Suppose that $D$ is acyclic. Then Algorithm 2 converges after a finite number of iterations, and, at the end of the algorithm, $c_{od}^{UB}$ is equal to the cost of an optimal solution of the Monoid Resource Constrained Shortest Path Problem if such a solution exists, and to $+\infty$ otherwise.

The specificity of our approach lies in the use of the bounds of Equation (3) in the algorithm. While it is well known that the use of lower bounds is a key element in the performance of the enumeration algorithms [15], our approach is the first to allow the use of bounds with non-linear constraints such as (c) and (d). Not only these bounds are used to discard more paths, but they are also used to improve the order in which the paths are considered by the algorithm. The two main resource constrained shortest path algorithms in the literature [24] differ by the order in which they consider paths. The label correcting algorithm is obtained from our one by using $c(q_{P})$ as $\operatorname{key}(P)$ and removing the test of Step 14. It is for instance described by Dunbar et al. [16, 17] in the context of crew pairing. The label setting algorithm considers vertices $v$ in a topological order, and then apply Steps 8 to 21 for each path $P$ in $\mathsf{L}_{v}^{\mathrm{nd}}$. Again, the test of Step 14 is not present.

Finally, as is has already been noted, we go further by using sets of bounds rather than singletons (we give additional explanations in Section 4.3).

Remark 2*.*

Step 12 of Algorithm 1 requires to solve the following variant of the Monoid Resource Constrained Shortest Path Problem:

[TABLE]

Algorithm 2 can be easily adapted to this variant. It suffices to maintain a set $\mathsf{S}$ of solutions (initially empty), to replace $c_{od}^{UB}$ by $c^{\mathrm{upp}}-c^{\mathrm{low}}$ in Steps 8 and 14, to replace Step 9 by $\mathsf{S}\leftarrow\mathsf{S}\cup\{P\}$, and to return $\mathsf{S}$. The set $\mathsf{S}$ returned contains all the $o$-$d$ paths $P$ satisfying $\rho(q_{P})=0$ and $c(q_{P})\leq c^{\mathrm{upp}}-c^{\mathrm{low}}$.

Remark 3*.*

The terminology “label setting” and “label correcting” varies in the literature. We stick here to Irnich and Desaulniers [24]. What Dunbar et al. [16, 17] call a “label setting” algorithm is a label correcting algorithm according to Irnich and Desaulniers [24].

4.2. Modeling the pricing subproblem

We now explain how to model our pricing subproblem (2) in the Monoid Resource Constrained Shortest Path Problem framework. As already mentioned, we only consider rules (a) to (d) (Section 3.1) to focus on ideas rather than on the full intricacies of the regulation. In other words, the set of feasible pairings is the set of pairings satisfying rules (a) to (d). For simplicity, we also omit in the master problem the long pairings and long duties constraints, and we assume that the cost $c_{p}$ is of the form $\sum_{(\ell,\ell^{\prime})\in p}c_{(\ell,\ell^{\prime})}$. We emphasize that all IROPS and Air France rules, as well as the real costs and the long pairings and long duties constraints, are taken into account in the numerical experiments. The reduced cost is then of the form $\tilde{c}_{p}=\sum_{(\ell,\ell^{\prime})\in p}c_{(\ell,\ell^{\prime})}+\sum_{\ell\in p}z_{\ell}$, where $z_{\ell}$ is the dual variable associated to the partitioning constraint.

We now model this toy subproblem as a Monoid Resource Constrained Shortest Path Problem. According to Section 4.1, we have to describe the digraph with its origin and destination vertices, the lattice ordered monoid, the resources on the arcs, and the cost and infeasibility functions. We actually solve a shortest path problem for each sequence of four consecutive days in a week, in order to satisfy rules (a) and (b) (Section 3.1). We thus solve seven Monoid Resource Constrained Shortest Path Problem instances per iteration of the pricing subproblem.

4.2.1. The digraph with its origin and destination vertices

Let $D=(V,A)$ be the acyclic digraph defined as follows. The vertex set is $V=\mathcal{L}\cup\{o,d\}$, where $\mathcal{L}$ is the set of legs of four consecutive days, $o$ is a dummy origin vertex, and $d$ is a dummy destination vertex. The arc set $A$ contains an arc $(o,\ell)$ for all legs $\ell$ starting in Paris on the first day of the period, an arc $(\ell,d)$ for all legs $\ell$ ending in Paris, and an arc $(\ell,\ell^{\prime})$ for each connection $(\ell,\ell^{\prime})$. With these definitions, pairings starting on the first day of the period and satisfying rules (a) and (b) are in one-to-one correspondence with $o$-$d$ paths in $D$.

4.2.2. The lattice ordered monoid

The monoid $M$ we use for the resources is of the form $M^{\rho}\times\mathbb{R}$, where $M^{\rho}=(\mathbb{Z}_{+}\times\mathbb{R}_{+})\cup(\mathbb{Z}_{+}\times\mathbb{R}_{+})^{2}\cup\{\infty\}$.

An element $(n,f)\in\mathbb{Z}_{+}\times\mathbb{R}_{+}$ models the resource used over a single day by a pairing: $n$ flight legs and a total flying duration $f$. An element $(n^{b},f^{b},n^{e},f^{e})\in(\mathbb{Z}_{+}\times\mathbb{R}_{+})^{2}$ models the resource used over the first and last days of a pairing lasting more than one day. Quantities $n^{b}$ and $f^{b}$ are the number of flight legs and flying duration on the first day of a pairing, and $n^{e}$ and $f^{e}$ are the number of flight legs and flying duration on the last day of a pairing. The element $\infty$ is used to capture infeasibility of certain pairings.

Let $F_{\mathrm{m}}=\displaystyle\max_{t}F(t)$. We define the operator $\oplus$ on $M^{\rho}$ as follows.

[TABLE]

We define $\preceq$ on $M^{\rho}$ by

[TABLE]

and a pair $(n,f)\neq(0,0)$ is not comparable with $(n^{b},f^{b},n^{e},f^{e})$.

Lemma 4**.**

$(M^{\rho},\oplus,\preceq)$* is a lattice ordered monoid.*

As $(\mathbb{R},+,\leq)$ is a lattice ordered monoid, the monoid $M=M^{\rho}\times\mathbb{R}$ is a lattice ordered monoid when endowed with the componentwise sum and order.

4.2.3. Resources on the arcs

Consider an arc $(\ell,\ell^{\prime})$ of $D$. If it is a day connection, then we define its resource to be $\left((1,f(\ell^{\prime})),c_{(\ell,\ell^{\prime})}+z_{\ell^{\prime}}\right)$, where $f(\ell^{\prime})$ is the flying duration of leg $\ell^{\prime}$, and $z_{\ell^{\prime}}$ is the dual variable of the cover constraint associated to $\ell^{\prime}$ in (CP). If it is a night connection, then we define its resource to be $\left((0,0,n^{e},f^{e}),c_{(\ell,\ell^{\prime})}+z_{\ell^{\prime}}\right)$, where $n^{e}=2$ if $(\ell,\ell^{\prime})$ is a reduced rest, and $1$ otherwise, and $f^{e}=f(\ell^{\prime})+F_{\mathrm{m}}-F(t)$, where $t$ is the departure time of $\ell^{\prime}$. Similarly, each arc $(o,\ell^{\prime})$ has resource \big{(}(0,0,1,f^{e}),z_{\ell^{\prime}}\big{)}, and each arc $(\ell,d)$ resource \big{(}(0,0,0,0),0\big{)}.

4.2.4. Cost and infeasibility functions

Given $q=(r,z)\in M$, we define

[TABLE]

where $\rho_{M^{\rho}}$ is defined on $M^{\rho}$ by

[TABLE]

where $\mathbf{1}_{I}$ denotes the indicator function of a set $I$. With this definition, the feasibility function $\rho$ encodes the satisfaction of rules (c) and (d).

4.2.5. Conclusion

The following proposition concludes the reduction of the pricing subproblem to a Monoid Resource Constrained Shortest Path Problem.

Proposition 5**.**

The sequence of flight legs $p$ corresponding to an $o$-$d$ path $P$ is in $\mathcal{P}$ (i.e., is a feasible pairing) if and only if $\rho(q_{P})=0$. In that case, $c(q_{P})=\tilde{c}_{p}$.

Appendix C details how this reduction works on a small pricing subproblem instance and shows a few typical iterations of Algorithm 2.

4.3. Bounds on resources

We give now a simple illustration of why sets of bounds enable to discard more paths than single bounds. Consider the example on Figure 4.a, where we have an $o$-$w$ path $Q$, and three $w$-$d$ paths $R$, $R^{\prime}$, and $R^{\prime\prime}$. Resources, which belong to $\mathbb{R}^{2}$ endowed with the componentwise sum and order, are indicated on Figure 4.a. The resources of $w$-$d$ paths are indicated by crosses on Figure 4.b. Consider a situation where \rho\big{(}(q^{1},q^{2})\big{)} is equal to $1$ if and only if $\max(q^{1},q^{2})>2$. There is no feasible $o$-$d$ path starting by $Q$.

Suppose first that we are using single bounds as in the usual approach, i.e., $B_{w}$ contains a unique element $b_{w}$. Recall that $b_{w}$ is then such that $b_{w}\preceq q_{S}$ for every $w$-$d$ path $S$. In such a case, $b_{w}\preceq q_{R}\wedge q_{R^{\prime}}\wedge q_{R^{\prime\prime}}=(1,1)$. Hence, $\rho(q_{Q}\oplus b_{w})=0$ and the path $P$ is not discarded at Step 14 of Algorithm 2. Suppose instead that we use the two bounds $b_{1}=q_{R}\wedge q_{R^{\prime}}$ and $b_{2}=q_{R^{\prime\prime}}$, which are indicated by circles on Figure 4.b. We have then $\rho(q_{Q}\oplus b_{1})=\rho(q_{Q}\oplus b_{2})=1$, and the path $Q$ is discarded at Step 14. This example is very simple, but it is the same mechanism that is in work in the general case.

The first author [36] introduced a procedure which, given a size $\kappa$ in input, builds lower bounds sets $B_{w}$ of size $\kappa$. Larger sets of bounds $B_{w}$ enable to get larger lower bounds, and hence to discard more paths. However, larger sets of bounds also mean a longer preprocessing is required to compute the bounds. Hence, the parameter $\kappa$ is chosen to obtain a tradeoff between the quality of the bounds and the time needed to compute them. Regarding the practical choice of $\kappa$ for the crew pairing pricing subproblem, the following rule of thumbs ensures good results in practice: Use $\kappa=1$ if there are fewer than $100$ vertices, $\kappa=50$ if there are fewer than $300$ vertices, $\kappa=150$ if there are fewer than $1,500$ vertices, and $\kappa=250$ if there are more.

When solving (CP), the preprocessing, which actually consists in building an “extended graph”, is done once and for all: The same extended graph is used each time we solve the pricing subproblem. We can thus work with larger sets of bounds than independent resolutions of the Monoid Resource Constrained Shortest Path Problem would have allowed.

5. Integrated problem

5.1. Problem formulation

If a crew changes airplane during a connection between two flight legs $\ell$ and $\ell^{\prime}$, its members need time to cross the airport between the arrival of $\ell$ and the departure of $\ell^{\prime}$. This is not possible if the time between the arrival of $\ell$ and the departure of $\ell^{\prime}$ is too short. A short connection is an ordered pair $(\ell,\ell^{\prime})$ of flight legs that can be operated by a crew only if $\ell$ and $\ell^{\prime}$ are operated by the same airplane. Due to short connections, aircraft routing and crew pairing are linked. Given the collection of all short connections, the integrated problem consists in finding a solution of the aircraft routing problem of Section 2 and a solution of the crew pairing problem of Section 3 such that whenever a short connection is used in a pairing, it is also used in a route of an airplane.

5.2. Modeling as an integer program

The solutions $\boldsymbol{x}$ of (1) and $\boldsymbol{y}$ of (CP) provide a solution of the integrated problem if and only if

[TABLE]

for every short connection $\alpha=(\ell,\ell^{\prime})$, where we denote by $A_{\alpha}$ (resp. $\mathcal{P}_{\alpha}$) the set of arcs (resp. pairings) using the short connection $\alpha$. For any feasible solution of the aircraft routing problem, there is a solution of the crew pairing problem compatible with it since there is no constraint on the number of crews, but solving the two problems simultaneously allows to spare these additional crews and to reduce the costs, as explained in Section 1.2. The integrated problem aims at performing this task and is thus modeled by the following integer program

[TABLE]

5.3. A cut generating approach

As we will see in the numerical results, the aircraft routing and crew pairing solution schemes introduced solve most of our industrial instances to optimality in a few hours. It is therefore natural to test the ability of a simple combination of these approaches to tackle with the integrated problem. Instead of solving directly Program (Int), we adopt a cut generating approach using the methods proposed in the previous sections in a rather independent way.

Let $S(\boldsymbol{y})$ denote the set of short connections used in a solution $\boldsymbol{y}$ of (CP). Given a feasible solution $\boldsymbol{y}$ of (CP), if there is no feasible solution $\boldsymbol{x}$ of (1) satisfying (5), then any solution $\boldsymbol{y}^{\prime}$ such that $S(\boldsymbol{y})\subseteq S(\boldsymbol{y}^{\prime})$ leads to a more constrained (1), and hence to a similar infeasibility. To avoid such solutions in (CP), we set $S=S(\boldsymbol{y})$ and add the constraint

[TABLE]

where $|p\cap S|$ denotes the cardinality of $\{\alpha\in S\colon p\in\mathcal{P}_{\alpha}\}$. It prevents a solution to use all short connections in $S$ but does not restrict otherwise the set of solutions.

We can now describe the algorithm for the integrated problem. The algorithm maintains a set $\mathsf{S}$ of short connection cuts. Initially, $\mathsf{S}$ is empty. The following steps are repeated.

1. (i)

Solve (CP) with additional constraints (6) for $S\in\mathsf{S}$. Let $\boldsymbol{y}^{*}$ be the optimal solution. 2. (ii)

Solve (1) with the additional constraints (5).

• •

If it is feasible, then stop (we have found the optimal solution of (Int)).

• •

Otherwise, add $S(\boldsymbol{y}^{*})$ to $\mathsf{S}$ and go back to (i).

Because of the cuts added along the algorithm, a solution $\boldsymbol{y}^{*}$ is considered at most once. The number of solutions to the crew pairing problem being finite, the cut generation algorithm terminates after a finite number of iterations. The solutions of the last call to (i) and (ii) form an optimal solution to (Int): at each iteration, the only solutions to (CP) that are forbidden by the additional constraints (6) are not feasible for (Int) and at the last iteration, $\boldsymbol{y}^{*}$ is the optimal solution of a relaxation of (Int).

In practice, the algorithm does not converge after thousands of iterations on industrial instances. We therefore replace $|S|-1$ by $\gamma|S|$ with $\gamma<1$ in the constraints (6), losing the optimality of the solution returned. During the first iteration, there is no additional constraint (6): the crew pairing problem (CP) is therefore not constrained by the aircraft routing. It is therefore a relaxation of the integrated problem, and its optimal solution provides a lower bound on the optimal solution of the integrated problem. We use this lower bound to evaluate the quality of the solution of the integrated problem returned by the algorithm. Numerical experiments in Section 6 show that $\gamma=0.9$ is a good compromise: We obtain near optimal solutions after a few dozens of iterations.

6. Experimental results

6.1. Instances

Table 1 describes six industrial instances of Air France. Each instance contains the legs of a fleet on a weekly horizon. The first two columns provide the name of the instance and the number of legs it contains. Columns “Airplane connect.” and “Airplanes” respectively give the number of connections that can be done by airplanes, i.e., the number of ordered pairs of legs $(\ell,\ell^{\prime})$ that can be operated consecutively in a route, and the number $n^{\mathrm{a}}$ of airplanes available. Columns “Crew connect.” and “Crew pairings” respectively provide the number of connections that can be taken by crews, and the order of magnitude of the number of pairings in a good solution. Finally, column “Short connect.” gives the number of short connections available. These instances are large: For instance, the largest instance considered by Mercier et al. [32] has 707 legs, and the largest instance for the integrated problem in the literature [43] has 750 legs.

The instance A318-9 (resp. A320-fam) contains the legs of the A318 and A319 (resp. A318, A319, A320, and A321) instances, as well as a few extra “fictitious” legs. As Air France’s crews can operate legs on planes of different subfleets on the same pairing, there is a common crew pairing problem for each of the instance A318-9 and A320-fam. On the contrary, the subfleet of an airplane is fixed: An A318 does not become an A319. Hence, solving aircraft routing for multiple subfleets together consists in solving one separate problem for each subfleet. This is what we do when we solve aircraft routing instances within the integrated problem solution scheme for instances A318-9 and A320-fam.

6.2. Experimental setting

All the numerical experiments are performed on a server with 128 GB of RAM and 12 cores at 2.4 GHz. CPLEX 12.1.0 is used to solve all linear and integer programs. The algorithms are not parallelized.

6.3. Aircraft Routing

Table 2 provides the results for aircraft routing. The first column gives the name of the instance. The next two ones give results for the aircraft routing problem on its own. Column “Uncons. CPU time (mm:ss)” gives the time needed to solve (1). Column “Optim. CPU time (mm:ss)” gives the time needed to find an optimal solution of the optimization problem that consists in finding the minimum number of airplanes needed to operate the instance: We use the left-hand side of (AR.3) as objective. Note that this problem has not been mentioned previously in the paper. The solution scheme for the integrated problem in Section 5 solves (1) with additional constraints (5). The last two columns provide numerical results for this constrained version. On all but the last iterations of the integrated problem scheme, aircraft routing is infeasible. Column “Infeas. CPU time” provides the time needed to solve the penultimate iteration, which is infeasible, and column “Feas. CPU time ” the last iteration, which is feasible. The typical computing time is a few dozens of seconds on industrial instances. The longest constrained feasible version requires a few minutes. The optimization version in the second column is typically one order of magnitude faster than the one obtained by Khaled et al. [25, Tables 10 and 11] on instances with similar numbers of legs. However, this last statement must be taken with care as the structure of the instances (number of airplanes, number of days of planning, etc.) is very different. This improved performance is likely due to the fact that our relaxation has a better relaxation than their one, as we prove in Proposition 7 in Appendix A and that our formulation has less symmetry.

6.4. Crew Pairing

Table 3 provides the results for crew pairing. All instances are solved to optimality. The first column of Table 3 gives the name of the instance. The next column provides the value of $\kappa$ determined using the rule of thumb of Section 4.3 and needed by the algorithm building the sets $B_{v}$. Column “Col. Gen. Iter” provides the number of iterations in the column generation, and column “Pricing time” the percentage of time spent in the pricing subproblem. This pricing time includes the time needed by the computation of the sets $B_{v}$ and by the enumeration algorithm (Algorithm 2). Columns “LP time” and “MIP time” indicate the percentage of the total CPU time spent in Algorithm 1 solving Step 3, and solving Steps 10 and 13. The last column gives the total time needed by the algorithm. On all these instances, the integrality gap does not exceed 0.01%. This explains the fast resolution of Step 13.

Remark 4*.*

One may be tempted to stop the column generation before convergence to exchange quality for speed. Unfortunately, and this is a limit of our method, if we stop the column generation before convergence, the solution found by the MIP solver at Step 10 is poor, and Step 12 is not tractable in practice.

6.5. Integrated problem

Table 4 provides the results for the integrated problem. The constraint strength parameter $\gamma$ of the end of Section 5 is equal to 0.9, and the bounds sets size $\kappa$ is equal to $150$. The first column provides the instance solved. Columns “Integ. steps” provides the number of steps of the integrated problem algorithm of Section 5 before convergence. Column “CG it. total” provides the total number of column generation iterations realized on the successive integrated problem algorithms steps. Column “(CP) CG time” provides the proportion of the total CPU time spent in the column generation, i.e., solving the pricing subproblem and the linear relaxation of the master problem, and column “(CP) MIP time” the proportion spent solving the integer version of the crew pairing master problem. The column “(1) time” provides the proportion spent solving aircraft routing integer program (1). The column “Sho. Con.” gives the number of short connections in the final solution. The linear relaxation of the crew pairing master problem (CP) with no short connection constraint is used as the lower bound on the cost of an optimal solution. The gap provided is between the cost of the solution returned and this lower bound. Finally, the last column provides the total CPU time needed by the algorithm. Only instance A320-fam could not be solved, as the algorithm had not converged after one week of computing time.

We emphasize the fact that the solution returned by the approximate algorithm is almost optimal. Practically speaking, the gap obtained is less than or equal to 0.01%. The computation time needed to obtain a near optimal solution of the integrated problem is of the same order of magnitude than the time needed to obtain a solution of the crew pairing problem in Table 3. Solving aircraft routing and crew pairing sequentially strongly constrains the solution: Indeed, when solved in an integrated fashion, around half of the connections in the solution are short connections.

Finally, Table 5 compares the sequential approach, where aircraft routing is solved first, and then crew pairing, to the integrated approach of Section 5. Line “Cost reduction” provides the percentage by which the cost is reduced when using the integrated approach, and line “CPU time ratio” the increase in computing time. On average, using the integrated approach enables to reduce the costs by 0.25%, and computing time is 5.1 times longer. This reduction of cost on our instances is smaller than what is mentioned in the literature: $5\%$ on average according to Cordeau et al. [11], and $1.6\%$ according to Papadakos [35]. We believe that this comes from the fact that our instances are larger: Adding new connections have a stronger impact when few connections are available. The increase in computing time is mainly due to the fact that the crew pairing is longer to solve in the integrated approach due to the addition of short connections.

6.6. Industrial relevance

To be usable in an industrial context, the computing time of the solvers must not exceed eight hours, which represent one night of computing time. Our algorithms enable to solve to near optimality instances of the integrated problem with up to $1,766$ legs within this time constraint. Our solution scheme therefore enables to deal practically with instances larger than those in the literature – the largest instances in the literature [43] have 750 legs. These performances have been made possible by our pricing subproblem algorithm. Further improvements to deal with larger instances cannot be done by only working on the pricing subproblem. Indeed, we can see in Table 3 that most of the CPU time on instance A320-fam is spent in the simplex algorithm.

6.7. Focus on the pricing subproblem

The key element in the performance of our approach is the performance of Algorithm 2. We compare it in this section to the algorithms previously used. As our industrial instances are too large to be solved using these algorithms, we introduce in Table 6 smaller instances, which we have built by considering only a subset of the legs of the instance A318. Columns “Legs” and “Connections” respectively provide the number of legs and connections in the instances, and column “Pairings” the approximate number of pairings in a solution. Table 7 provides results on the performance of the pricing subproblem scheme on these instances. Its first column gives the instance solved. The next one provides the algorithm used. Parameter $\kappa$, introduced in Section 4.3, gives the size of the lower bounds sets for algorithms using bounds. The next three columns provide statistics on the resource constrained shortest path (RCSP) algorithms. As mentioned in Section 4.2, seven RCSP instances are solved for each pricing subproblem, one for each period of four consecutive days. The statistics are averaged on all the instances solved along the column generation. Column “RCSP iter av. nb” provides the average number of iterations of the RCSP algorithm, “Cut Dom.” provides the proportion of paths cut at Step 15, the remaining being cut at Step 14. Column “RCSP time” provides the average time needed to solve one RCSP instance. Column “Pricing subproblem” provides the proportion of the total computing time spent solving the pricing subproblem, and the last column gives the total computing time of the crew pairing solution scheme.

We can see that the use of bounds enables a huge speed-up with respect to the usual algorithms. This speed-up is required to deal with instances with more than 500 legs. Two elements explain this speed-up. First, the condition at Step 14 enables to discard many paths: In Algorithm 2, more than 90% of the paths discarded are discarded at Step 14 and not at Step 15. Second, running Algorithm 2 with $c(q_{P})$ instead of $\min\{c(q_{P}\oplus b)\colon b\in B_{v},\rho(q_{P}\oplus b)=0\}$ makes it much slower. Hence, $\min\{c(q_{P}\oplus b)\colon b\in B_{v},\rho(q_{P}\oplus b)=0\}$ seems numerically to be a better evaluation of how $P$ is promising than $c(q_{P})$, and enables Algorithm 2 to find good solutions faster than the label correcting algorithm, and also faster than the label setting algorithm that does not use keys at all for choosing the next path to consider.

7. Conclusion

We have proposed a compact integer program for aircraft routing. Its main strength is its ease of implementation. Numerical results show that it can deal with large industrial instances in at most a few minutes, even when optimization versions are considered. We have used a resource constrained shortest path algorithm recently introduced by the first author for the crew pairing column generation pricing subproblem. This algorithm leverages on the lattice ordered monoid structure of the resource set to build efficient lower bounds. Practically, this enables to solve to optimality very large industrial crew pairing instances. As a side result, we have combined these aircraft routing and crew pairing solution schemes in a cutting plane approach to the integrated problem. The resulting algorithm solves to near optimality large industrial instances of the integrated problem.

Acknowledgments

We thank the reviewers for their thorough reading and all their useful comments and suggestions that helped us improve the paper. We are grateful to Air France which partially supported the project. We are especially thankful to Alexandre Boissy, who initiated the project, and to Mathieu Sanchez and Mohand Ait Alamara who helped us with the implementation in Air France softwares. We also thank Sourour Elloumi for pointing out the correct reference for Lemma 2.

Appendix A Proofs

Proof of Proposition 1.

The fact that a feasible solution of the aircraft routing problem induces a collection $\mathcal{C}$ as in the statement is obvious. Let us prove the other direction, which is almost as easy.

Consider a collection $\mathcal{C}$ as in the statement. Each cycle provides a route, possibly of several weeks. We show now that the solution consisting of these routes is feasible. By construction of the graph, the maintenance requirement is satisfied. Moreover, the number of times a cycle intersects $A_{0}$ is an upper bound on the number of airplanes required to operate the corresponding route: The number of times it intersects $A_{0}$ is equal to the number of weeks this cycle lasts, as illustrated on Figure 3. Thus the number of arcs selected in $A_{0}$ by the whole collection is an upper bound on the number of airplanes required to operate the solution. Since this number is at most $n^{\mathrm{a}}$, the solution is feasible. ∎

Proof of Lemma 2.

Consider the following integer program in the standard form:

[TABLE]

By the theory of the simplex algorithm, the program (7) can be written in the form

[TABLE]

where the $\tilde{c}_{i}$ – the reduced costs – are all non-negative, and where $N$ is the complement of the considered basis (all indices $i$ such that $\tilde{c}_{i}>0$ are in $N$). Consider now an optimal solution $\boldsymbol{z}^{*}$ of the program (7). We have

[TABLE]

The non-negativity of the $\tilde{c}_{i}$’s and the $z_{i}^{*}$’s implies the following inequality for every $i\in N$:

[TABLE]

In particular, if $\tilde{c}_{i}>\operatorname{UB}-\bar{v}$, we necessarily have $z_{i}^{*}<1$, i.e., $z_{i}^{*}=0$. ∎

Proof of 3.

We first prove that the algorithm terminates after a finite number of iterations. By induction on the iterations, we see that there is never two distinct elements in $\mathsf{L}$ such that one is a subpath of the other: There is no such two elements when the algorithm starts, and if there is no such two elements at a given iteration, there cannot be such two elements at the next iteration either. In particular, when a path $P$ leaves $\mathsf{L}$ at some iteration, it prevents the presence of a subpath of it in $\mathsf{L}$ at the current iteration. Thus, because of the update rule, $P$ cannot be added again to $\mathsf{L}$ in a subsequent iteration. It implies that a given path $P$ is considered at most once by the algorithm and, as there is a finite number of paths in an acyclic digraph, we get the sought conclusion regarding the termination of the algorithm.

We prove now the part of the statement regarding the cost of $c_{od}^{UB}$ at the end of the algorithm. At any step of the algorithm, $c_{od}^{UB}$ is either equal to $+\infty$ or to the cost of an $o$-$d$ path $P$ such that $\rho(q_{P})=0$. Therefore, if there is no feasible solution, then $c_{od}^{UB}$ is never updated, and equal to $+\infty$ at the end of the algorithm. Suppose now that there is a feasible solution, and let $P$ be a feasible $o$-$d$ path of minimum cost. By definition of $P$ and due to the update rule, we have $c(q_{P})\leq c_{od}^{UB}$ at the end of the algorithm. Suppose for a contradiction that this inequality is strict. Given the update rule of $c_{od}^{UB}$, this means that neither $P$ nor a feasible $o$-$d$ path $Q$ dominating $P$ has been considered present in $\mathsf{L}$. Let $P^{\prime}$ be the longest subpath of $P$, with origin $o$, such that $P^{\prime}$, or a path dominating $P^{\prime}$ with the same origin and destination as $P^{\prime}$, has been present in $\mathsf{L}$. Denote by $v$ the destination of $P$. Among all $o$-$v$ paths present in $\mathsf{L}$ at some time during the algorithm and that dominate $P^{\prime}$, pick a path $Q^{\prime}$ that is non-dominated by the others.

The test of Step 15 is necessarily satisfied by $Q^{\prime}$ because, by definition of $Q^{\prime}$, there is no $o$-$v$ path in $\mathsf{L}_{v}^{\mathrm{nd}}$ dominating $Q^{\prime}$ when $Q^{\prime}$ is considered by the algorithm. We now prove that the test of Step 14 is also necessarily satisfied. Indeed, let $P^{\prime\prime}$ be the $v$-$d$ subpath such that $P=P^{\prime}+P^{\prime\prime}$, and $b$ a bound in $B_{v}$ such that $b\preceq q_{P^{\prime\prime}}$. (Here, $P^{\prime}+P^{\prime\prime}$ means that we append $P^{\prime\prime}$ to $P^{\prime}$.) We have $q_{Q^{\prime}}\oplus b\preceq q_{P^{\prime}}\oplus b\preceq q_{P^{\prime}}\oplus q_{P^{\prime\prime}}=q_{P}$. We therefore have, when $Q^{\prime}$ is considered, $\rho(q_{Q^{\prime}}\oplus b)\leq\rho(q_{P})=0$, and $c(q_{Q^{\prime}}\oplus b)\leq c(q_{P})<c_{od}^{UB}$, where the last inequality relies on the fact that $c_{od}^{UB}$ is non-increasing along the algorithm. Hence, the test of Step 14 is satisfied. Therefore, $Q^{\prime}$ satisfies the tests of Steps 14 and 15, and is added to $\mathsf{L}$ whatever the combination of these two tests the algorithm uses. Since $Q^{\prime}$ is non-dominated by other $o$-$v$ paths considered by the algorithm, it is extended in a subsequent iteration. Denote by $a$ the arc in $P$ that follows $P^{\prime}$ and denote by $w$ the head of $a$. Since $q_{Q^{\prime}}\oplus q_{a}\preceq q_{P}^{\prime}\oplus q_{a}$, either $Q^{\prime}+a$, or another $o$-$w$ path that dominates $P^{\prime}+a$ is present once in $\mathsf{L}$, which contradicts the length maximality of $P^{\prime}$. ∎

Proof of Lemma 4.

Considering the different cases in the definitions enables to prove that $(0,0)$ is the neutral element of $\oplus$, that $\oplus$ is associative, that $\preceq$ is compatible with $\oplus$, and that $(M^{\rho},\preceq)$ is a lattice with meet operator

[TABLE]

and $q\wedge\tilde{q}=(0,0)$ for any other combinations. ∎

Proof of Proposition 5.

Let $p$ be a sequence of flight legs. The definition of $D$ ensures that there is an $o$-$d$ path $P$ whose vertices correspond to the legs in $p$ if and only if $P$ is a pairing that satisfies rules (a) and (b). In that case, this path $P$ is unique. Let $p$ be such a pairing and $P$ be the corresponding path. Let q_{P}=\big{(}q_{P}^{\rho},c_{P}\big{)} be the resource of $P$.

By definition of the arc resources, $c_{P}$ is the sum of $c_{(\ell,\ell^{\prime})}+z_{\ell^{\prime}}$ for $(\ell,\ell^{\prime})$ in $P$ and hence in $p$, and we therefore have $c_{P}=\tilde{c}_{p}$. Hence $c(q_{P})=\tilde{c}_{p}$.

Let $n^{b}$, $f^{b}$, $n^{e}$, and $f^{e}$ be respectively the number of legs and the flying time of the first duty of $p$, and the number of legs and the flying time of the last duty of $p$. Let $A_{P}$ be the set of duties of $P$ except the first and the last. We claim that $q_{P}^{\rho}$ is equal to $\infty$ if and only if there is a duty in $A_{P}$ that does not satisfy both rules (c) and (d), and to $(n^{b},f^{b},n^{e},f^{e})$ otherwise. This result is proved by induction on the number of arcs in $P$. Denoting $a$ the last arc of $P$, and $P^{\prime}$ the subpath of $P$ obtained by removing $a$, the induction hypothesis can be applied to $P^{\prime}$, and the result for $P$ follows by considering the different possible cases for the components in $M^{\rho}$ of $q_{P}$ and $q_{a}$. The definition of $M^{\rho}$ then ensures that $\rho(q_{P})=0$ if and only if rules (c) and (d) are satisfied. Hence, $\rho(q_{P})=0$ if and only if $p$ is a feasible pairing. ∎

Appendix B Aircraft routing MIP

Khaled et al. [25] propose a compact MIP for the tail assignment problem. Aircraft routing and tail assignment both consist in building the sequences of legs operated by the airplanes of an airline. The main difference between them is that in aircraft routing, airplanes are identical and routes do not need to be assigned to airplanes, while in tail assignment airplane specific costs are taken into account and routes are assigned to airplanes. Aircraft routing and tail assignment problems being fairly similar, MIP formulations for one problem can generally be applied to the other one.

However, the first reason why we do not use Khaled et al.’s formulation on Air France problem is that their formulation does not naturally adapt to this problem. Indeed, an important difference between Khaled et al.’s tail assignment and Air France aircraft routing is that, in Khaled et al.’s problem, routes are not cyclic, while in Air France problem, they are. By cyclic routes, we mean that sequences of legs are built for a typical week, and that airplanes operate the same sequences of legs week after week in a cyclic way. And as we have seen in Section 2.1, one cycle can potentially last several weeks. If Khaled et al.’s compact MIP for tail assignment can easily be adapted to solve a “non-cyclic” version of the aircraft routing problem, this is not the case for the “cyclic” aircraft routing problem considered at Air France that we introduce in Section 2. Indeed, adapting it would require introducing many new binary variables to encode how the end of a week cycles with the beginning of the next one.

The second reason is computational. As cyclic routes are difficult to take into account in their formulation, we compare the formulations on the Air France tail assignment problem. Both Khaled et al.’s formulation and an adapted version of our formulation (1) have been implemented at Air France, and the adapted version of our formulation is now used in practice by Air France to solve its tail assignment. Our formulation is able to solve the Air France medium haul instances (the tail assignment version of instances A318, A319, A320, and A321 of Table 1) to optimality in at most 3 minutes, while the version of Khaled et al. is unable to solve these instances in two hours. On long-haul instances of Air France, which are easier, their formulation had been previously used and was able to find optimal solutions, but each instance took at least 16 minutes, while our formulation solves each instance in at most 20 seconds.

Actually, the better performances of our formulation are easily explained by theoretical considerations on the linear relaxations. Solvers of MIP are based on branch-and-bound, which crucially relies on the quality of the linear relaxation to discard partial solutions. On the Air France tail assignment problem, the linear relaxation of our MIP provides bounds that are non smaller than those provided by the Khaled et al.’s MIP and can be strictly larger, even on very simple and natural examples. In the remaining of the appendix, we introduce the Air France tail assignment problem, adapt Khaled et al.’s formulation and (1) to that problem, and prove the result mentioned on linear relaxations.

We now introduce the Air France tail assignment problem. The input is formed of a given week, a set of airports, a collection $\mathcal{L}$ of flight legs operated between these airports that week, and a set of $n^{\mathrm{a}}$ available airplanes. Some airports are bases where maintenance can be performed, and each airplane must still spend a night in a maintenance base at least every $\Delta_{\text{maint}}$ days. Airplanes are indexed by $j$. For each airplane $j$ in $[n^{\mathrm{a}}]$, let $k_{0}^{j}$ be the airport where airplane $j$ is at the beginning of the week, and $\delta_{0}^{j}$ be the number of days since the last maintenance night of $j$ at the beginning of the week. For each airplane $j$ and leg $\ell$, we have a cost of operating a leg $\ell$ with airplane $j$. The aim of the tail assignment problem is to build the (non-cyclic) sequence of legs operated by each airplane at minimum cost.

A tail assignment connection is therefore a pair $(\ell,\ell^{\prime})$ of flight legs such that $\ell^{\prime}$ departs from the arrival airport of $\ell$, and such that the departure time of $\ell^{\prime}$ minus the departure time of $\ell$ is bounded from below by a given quantity. We underline that, if there were airplane connections between a leg $\ell$ at the end of the week and a leg $\ell^{\prime}$ at the beginning of the week in the aircraft routing problem, there is no such tail assignment connection. A tail assignment route $r$ for airplane $j$ is a (non-cyclic) sequence of legs $\ell_{1},\ldots,\ell_{k}$ such that $\ell_{i}$ departs from $k_{0}^{i}$ and any pair of two consecutive legs $(\ell_{i},\ell_{i+1})$ is a tail assignment connection. It satisfies the maintenance requirement if, first, supposing that airplane $j$ follows this route, it spends its first night in a maintenance base after at most $\Delta_{\text{maint}}-\delta_{0}^{j}$ days and then spends a night in a maintenance base at least every $\Delta_{\text{maint}}$ days, and second, if $\ell_{k}$ arrives in an airport that is not a base, then the last night of the week spent in a base is at most $\Delta_{\text{maint}}-1$ days before the end of the week. The cost of $r$ is the sum of the costs of operating the legs $\ell$ in $r$ with airplane $j$.

The task consists in building, for each airplane $j$, a route satisfying the maintenance requirement in such a way that each leg of $\ell$ is operated by one airplane $j$, and the sum of the costs of the routes is minimum.

We now generalize our MIP to Air France tail assignment. Let $D^{\prime}=(V,A^{\prime})$ be the digraph with vertex set $V=\mathcal{L}\times\Delta_{\text{maint}}$, and arc set $A^{\prime}$ composed of pairs \big{(}(\ell,\delta),(\ell^{\prime},\delta^{\prime})\big{)} such that $(\ell,\ell^{\prime})$ is a tail assignment connection and $\ell$, $\delta$, $\ell^{\prime}$, and $\delta^{\prime}$ satisfy one of the three conditions defining the arcs of digraph $D$ in Section 2.2. Digraph $D^{\prime}$ is the analogue of digraph $D$ of Section 2.2 where airplane connections are replaced by tail assignment connections. Contrary to digraph $D$, digraph $D^{\prime}$ is acyclic as there is no connection between the end of the week and the beginning of the week. For each airplane $j$, let $V^{j}$ and $\tilde{A}^{j}$ be copies of $V$ and $A^{\prime}$. We build a digraph $D^{j}$ as follows. Its vertex set is $V^{j}\cup\{s^{j},t^{j}\}$, where $s^{j}$ is a source vertex, and $t^{j}$ a sink vertex. Its arc set is denoted by $A^{j}$ and contains $\tilde{A}^{j}$ as well as arcs

• •

\big{(}s^{j},(\ell,\delta)\big{)} such that leg $\ell$ starts from airport $k_{0}^{j}$ on day $\delta-\delta_{0}^{j}$ if $k_{0}^{j}$ is not a base,

• •

\big{(}s^{j},(\ell,1)\big{)} such that leg $\ell$ starts from airport $k_{0}^{j}$ if $k_{0}^{j}$ is a base,

• •

\big{(}(\ell,\delta),t^{j}\big{)} such that leg $\ell$ ends on day $d_{\ell}$ in an airport that is not a base, and $\delta<\Delta_{\text{maint}}+d_{\ell}-8$,

• •

\big{(}(\ell,\delta),t^{j}\big{)} such that leg $\ell$ ends in a base.

The number $8$ in the third condition is just the number of days in a week plus $1$. The digraph $D^{j}$ is acyclic. For each leg $\ell$ and airplane $j$, we denote by $V_{\ell}^{j}$ the vertices of $V^{j}$ of the form $(\ell,\delta)$. Given an arc $a$ in $A^{j}$, we define the cost $c_{a}$ to be equal to [math] if the tail of $a$ is $s^{j}$ and to the cost of operating the leg of the tail vertex of $a$ with airplane $j$ otherwise. Given the definition of the digraph $D^{j}$, the following proposition is immediate.

Proposition 6**.**

A sequence of legs $\ell_{1},\ldots,\ell_{k}$ is a tail assignment route $r$ for airplane $j$ if and only if there exists $\delta_{1},\ldots,\delta_{k}$ such that $s^{j},(\ell_{1},\delta_{1}),\ldots,(\ell_{k},\delta_{k}),t^{j}$ is an $s^{j}$-$t^{j}$ path $P$ in $D^{j}$. In that case, the cost of operating $r$ with $j$ is $\sum_{a\in P}c_{a}$.

The following integer program therefore enables to model Air France tail assignment.

[TABLE]

The MIP proposed by Khaled et al. for tail assignment with maintenance constraints is given by Equations (3-15) of their paper. They use binary variables $\overline{\boldsymbol{x}},\overline{\boldsymbol{y}},\overline{\boldsymbol{z}}$. (We denote their variables with an overline to distinguish them from our variables.) The binary variables $\overline{x}_{ij}$ indicate if the leg $i$ is operated by the airplane $j$. The binary variables $\overline{y}_{jd}$ indicate if a maintenance of airplane $j$ takes place on day $d$. The binary variables $\overline{z}_{ijd}$ indicate if a night maintenance of airplane $j$ takes place in the arrival airport of the leg $i$ on day $d$. Air France tail assignment version is slightly different from the one considered by Khaled et al. For instance, they have a constraint limiting the cumulated flight time of an airplane between two maintenances (modeled by Equation (13) of their MIP). The following formulation adapts the MIP of Khaled et al. to Air France tail assignment problem.

[TABLE]

where $F$ and $P$ are the notations of [25] for the sets of flights legs and available airplanes respectively, and constraint (KTA.3) ensures that airplane $j$ spends its first night in a base after at most $\Delta_{\text{maint}}-\delta_{0}^{j}$ days.

The next proposition shows that the linear relaxation of Program (8) provides bounds that will discard more partial solutions than that of  (9) in a branch-and-bound.

Proposition 7**.**

The optimal value of the linear relaxation of (8) is not smaller than the one of the linear relaxation of (9) and there are instances for which it is strictly larger.

Proof.

We first prove that any feasible solution of the linear relaxation of Program (8) can be turned into a feasible solution of the linear relaxation of (9). Consider a feasible solution $\boldsymbol{x}=(\boldsymbol{x}^{1},\ldots,\boldsymbol{x}^{n^{\mathrm{a}}})$ of the linear relaxation of Program (8), where $\boldsymbol{x}^{j}$ is the vector of variables $x_{a}$ with $a$ in $A^{j}$. As Equation (TA.3) defines the $s^{j}$-$t^{j}$ flow polyhedron of the acyclic digraph $D^{j}$, $\boldsymbol{x}^{j}$ can be written as a conic combination $\sum_{P}\lambda_{P}\chi^{P}$ of indicator vectors of $s^{j}$-$t^{j}$ paths in $D^{j}$, where the sum is taken over all $s^{j}$-$t^{j}$ paths and the $\lambda_{P}$ are non-negative. Equation (TA.2) gives $\sum_{P}\lambda_{P}=1$.

Let $\mathcal{R}^{j}$ be the set of tail assignment routes $r$ for airplane $j$. Given $r$ in $\mathcal{R}^{j}$, we define $\lambda_{r}$ as the coefficient $\lambda_{P}$ of the $s^{j}$-$t^{j}$ path $P$ corresponding to $r$ according to Proposition 6. Denoting $c^{r}$ the cost of operating route $r$ with airplane $j$, Proposition 6 also implies that

[TABLE]

Besides, as $\boldsymbol{x}$ satisfies Equation (TA.4), we have

[TABLE]

where $\mathcal{R}^{j,\ell}$ denotes the subset of $\mathcal{R}^{j}$ of routes containing leg $\ell$.

For each airplane $j$, route $r$ in $\mathcal{R}^{j}$, leg $i$, and day $d$, we set $\overline{x}_{ij}^{r}=1$ if leg $i$ is in route $r$ and [math] otherwise, $\overline{y}_{jd}^{r}=1$ if airplane $j$ operating route $r$ undergoes a maintenance on the night after day $d$ and [math] otherwise, and $\overline{z}_{ijd}^{r}=1$ if $i$ is in route $r$ and airplane $j$ operating $r$ undergoes a maintenance on the night after day $d$ and [math] otherwise. As $r$ satisfies the maintenance requirement, $(\overline{x}_{ij}^{r},\overline{y}_{jd}^{r},\overline{z}_{ijd}^{r})_{id}$ satisfies the equations of the linear relaxation of (9) (restricted to airplane $j$) except cover constraint (3) of [25]. Furthermore, as $x_{ij}$ is the cost of operating leg $i$ with $j$, we have $\sum_{i\in F}c_{ij}\overline{x}_{ij}^{r}=c^{r}$, where $c^{r}$ is the cost of operating route $r$ with airplane $j$.

Let $(\overline{\boldsymbol{x}},\overline{\boldsymbol{y}},\overline{\boldsymbol{z}})$ be defined as follows. For each airplane $j$, leg $i$, and day $d$, let $\overline{x}_{ij}=\sum_{r\in\mathcal{R}^{j}}\lambda_{r}\overline{x}_{ij}^{r}$, let $\overline{y}_{jd}=\sum_{r\in\mathcal{R}^{j}}\lambda_{r}\overline{y}_{jd}^{r}$, and let $\overline{z}_{ijd}=\sum_{r\in\mathcal{R}^{j}}\lambda_{r}\overline{z}_{ijd}^{r}$. As $\lambda^{r}\geq 0$ and $\sum_{r\in\mathcal{R}^{j}}\lambda_{r}=1$, the components indexed by $j$ of $(\overline{\boldsymbol{x}},\overline{\boldsymbol{y}},\overline{\boldsymbol{z}})$ is a convex combination of the $(\overline{x}_{ij}^{r},\overline{y}_{jd}^{r},\overline{z}_{ijd}^{r})_{id}$. Hence, $(\overline{\boldsymbol{x}},\overline{\boldsymbol{y}},\overline{\boldsymbol{z}})$ satisfies the equations of the linear relaxation of (9) (restricted to airplane $j$) except cover constraint (3) of [25]. Equation (11) ensures that $(\overline{\boldsymbol{x}},\overline{\boldsymbol{y}},\overline{\boldsymbol{z}})$ also satisfies cover constraint (3) of [25], and is therefore a solution of the linear relaxation of (9). Finally, Equation (10) ensures that $\sum_{i\in F}\sum_{j\in P}c_{ij}\overline{x}_{ij}=\sum_{j}\sum_{a\in A^{j}}c_{a}x_{a}$, which concludes the proof that the optimal value of the linear relaxation of (8) is not smaller than the one of the linear relaxation of (9).

Consider now the example with $n^{\mathrm{a}}=3$ and $\Delta_{\text{maint}}=4$ on Figure 5. Dashed horizontal lines correspond to airports and arrows to legs between airports. The weekly schedule is composed of six round trips between airport $A$ and airport $B$, and six round trips between airport $A$ and airport $C$. There is an outward leg $\ell_{a}^{d}$ from $A$ to $B$ and an outward leg from $\ell_{c}^{d}$ from $A$ to $C$ every day $d$ in {1,…,6}, a return leg $\ell_{b}^{d}$ from $B$ to $A$ every day $d$ in {1,…,6}, and a return leg $\ell_{f}^{d}$ from $C$ to $A$ every day $d$ in {2,…,7}. The table provides, for each airplane $j$, the airport $k_{0}^{j}$ where the airplane starts, and the number of days $\delta_{0}^{j}$ since the last maintenance on day 1, and the costs of operating the different legs with the airplanes. In the remaining of the proof, we show that the optimal value of the linear relaxation of (8) on this instance is equal to 160, and exhibit a solution of the linear relaxation of $\eqref{eq:TAkhaled}$ with value 157.5.

Let $\boldsymbol{x}=(\boldsymbol{x}_{j})_{j}$ be a solution of (8) on that instance. Let $V_{\leq d}^{j}$ be the set vertices of $D^{j}$ composed of $s^{j}$ and vertices $(\ell_{\cdot}^{\tilde{d}},\delta)$ with $\tilde{d}\leq d$. As the flow on the cut $\delta^{+}(V_{\leq d}^{j})$ has value $1$, we have $\sum_{j=1}^{3}\sum_{a\in\delta^{+}(V_{\leq d}^{j})}x_{a}=3$. Besides, (TA.3) and (TA.4) give that

[TABLE]

Hence, any arc $a=(v,v^{\prime})$ with $x_{a}>0$ in $\delta^{+}(V_{\leq d}^{j})$ is such that $v$ is in $V_{\ell_{b}^{d}}^{j}\cup V_{\ell_{c}^{d}}^{j}\cup V_{\ell_{f}^{d}}^{j}$ and $v^{\prime}$ belongs to $V_{\ell_{a}^{d+1}}^{j}\cup V_{\ell_{c}^{d+1}}^{j}\cup V_{\ell_{f}^{d+1}}^{j}$. Any arc $a$ with $x_{a}>0$ is therefore of the form \big{(}(\ell,\delta)(\ell^{\prime},\delta^{\prime})\big{)} with $(\ell,\ell^{\prime})$ in

[TABLE]

Furthermore, as we discussed in the first part of the proof, $\boldsymbol{x}_{j}$ can be written as the conic combination $\sum_{r\in R^{j}}\lambda_{r}\chi^{P(r)}$, where $\chi^{P(r)}$ is the indicator vector of the $s^{j}$-$t^{j}$ path $P(r)$ corresponding to route $r$, and coefficients $\lambda_{r}$ are non-negative. Remark that there is no connection $(\ell_{f}^{d},\ell_{c}^{d+1})$ in a route that satisfies the maintenance requirement, as such a route would spend $\Delta_{\text{maint}}+1$ days out of a base. Constraint (TA.4) applied to leg $\ell_{c}^{d+1}$ then ensures the only arcs $a$ such that $x_{a}>0$ are of the form \big{(}(\ell,\delta),(\ell^{\prime},\delta^{\prime})\big{)} with $(\ell,\ell^{\prime})$ in

[TABLE]

Hence, for each airplane $j$ the only routes $r$ in $\mathcal{R}^{j}$ that can satisfy $\lambda_{r}>0$ are $r_{1}=\ell_{a}^{1},\ell_{b}^{1},\ell_{c}^{2},\ell_{f}^{3},\ell_{a}^{4},\ell_{b}^{4},\ell_{c}^{5},\ell_{f}^{6}$, $r_{2}=\ell_{c}^{1},\ell_{f}^{2},\ell_{a}^{3},\ell_{b}^{3},\ell_{c}^{4},\ell_{f}^{5},\ell_{a}^{6},\ell_{b}^{6}$, and $r_{3}=\ell_{a}^{2},\ell_{b}^{2},\ell_{c}^{3},\ell_{f}^{4},\ell_{a}^{5},\ell_{b}^{5},\ell_{c}^{6},\ell_{f}^{7}$. Operating any of these three routes has cost $32$ with airplane 1, $48$ with airplane $2$, and $80$ with airplane 3. Hence, $\boldsymbol{x}$ has cost $160$. Remark that this is the cost of the optimal integer solution obtained by assigning $r_{j}$ to airplane $j$.

On the contrary setting

[TABLE]

[TABLE]

[TABLE]

[TABLE]

[TABLE]

and $z_{ijd}=0$ for any $i,j,d$ such that $z_{ijd}$ has still not been defined, provides a feasible solution of the linear relaxation of (9) with cost 157.5, which concludes the proof. ∎

Appendix C Example of the Monoid resource constrained shortest path problem

This appendix details the execution of Algorithm 2 on a simple example. Figure 6 provides an example of instance of the crew pairing pricing subproblem and its Monoid Resource Constrained Shortest Path Problem modeling. Only a subpart of the instance is represented. On Figure 6.a, legs are represented as arrows between airports. On this instance, there are three airports $A_{1}$, $A_{2}$, and $A_{3}$, and legs only between $A_{1}$ and $A_{2}$, and $A_{2}$ and $A_{3}$. The flying durations between $A_{1}$ and $A_{2}$ and $A_{2}$ and $A_{3}$ are respectively 6 and 2 hours. There are two reduced rests: $(\ell_{1},\ell_{3})$ and $(\ell_{5},\ell_{8})$. The maximum duty flying duration $F(t)$ in a duty is taken equal to $F_{m}=9$ hours for all $t$.

Figure 6.b provides the corresponding digraph $D$, as well as the resource of each arc. Note that the component in $M^{\rho}$ of the resources of day connections is in $\mathbb{Z}_{+}\times\mathbb{R}_{+}$ and that of the resources of night connections is in $(\mathbb{Z}_{+}\times\mathbb{R}_{+})^{2}$. Furthermore, reduced rests are the only night connections whose resources have a component in $M^{\rho}$ of the form $(0,0,2,\cdot)$, the other night connections having a component of the form $(0,0,1,\cdot)$. The reduced costs have been chosen arbitrarily. For simplicity, we assume that \big{(}(0,0,0,0),0\big{)} is a lower bound on the resource of $\ell_{7}$-$d$ paths and on the resource of $\ell_{8}$-$d$ paths.

Algorithm 2 execution

We now provide an example of Algorithm 2 when the bounds in Table 8 are used. We remind the reader that these bounds are computed before the execution of Algorithm 2 in a preprocessing and taken by this latter in input. See Section 4.3 for more details on bounds. At the very end of the appendix, we illustrate the way bounds are computed by justifying the set of bounds $B_{\ell_{3}}$ in this table.

Let $P_{1}$ be an $o$-$\ell_{1}$ path with resource \big{(}(0,0,1,6),1.0\big{)}. Table 9 describes the iterations of Algorithm 2 where $P_{1}$ and the paths starting by $P_{1}$ are dealt with. Each iteration is separated by an horizontal line. Column $P$ provides the path $P$ considered at Step 5 of Algorithm 2. We assume that $\mathsf{L}_{\ell_{3}}^{\mathrm{nd}}$, $\mathsf{L}_{\ell_{5}}^{\mathrm{nd}}$, and $\mathsf{L}_{\ell_{6}}^{\mathrm{nd}}$ are empty when $P_{1}$ is considered as path $P$, and $\mathsf{L}_{\ell_{4}}^{\mathrm{nd}}$ is empty when $P_{1},\ell_{3}$ is considered. We also assume that $c_{od}^{UB}=+\infty$ and hence $c(q_{P}\oplus b)\leq c_{od}^{UB}$ during all the iterations detailed. Column key$(P)$ provides its key defined in Equation (4). As the treatment of reduced costs is standard, to enhance readability, we omit them in all resources in Table 9 and in the remaining of the discussion. Column $q_{P}$ gives the resource of $P$, column $a$ provides the arc of Step 11, column $q_{a}$ gives its resource. Path $Q$ of Step 12 is path $P$ followed by $a$. Then next column gives the resource $q_{Q}=q_{P}\oplus q_{a}$ of $Q$, and column $w$ provides the destination of $Q$ computed at Step 13. Column $b$ provides the single bound in $B_{w}$, and the next column provides $q_{Q}\oplus b$ computed at Step 14. Finally, the last column indicates if $Q$ is added to $\mathsf{L}$ at Step 17.

The key of $P_{1}$ is equal to $-4.8$ because, with $P=P_{1}$ and $B_{\ell_{1}}=\{b\}$, we have q_{P}\oplus b=\big{(}(0,0,1,6),1.0\big{)}\oplus\big{(}(0,0,0,0),-5.8\big{)})=\big{(}(0,0,0,0),-4.8\big{)}, and c\big{(}(0,0,0,0),-4.8\big{)}=-4.8. The sums $(0,0,2,2)\oplus(2,6,0,0)$ and $(0,0,3,4)\oplus(1,4,0,0)$ are equal to $(0,0,0,0)$ because $(2,2)+(2,6)=(3,4)+(1,4)=(4,8)\leq(4,F_{m})$, where $F_{m}=9$. Since $\rho((0,0,0,0))=0$, the path $Q$ cannot be discarded at the iterations where $P=P_{1}$ and $a=(\ell_{1},\ell_{3})$, and where $P=P_{1},\ell_{3}$ and $a=(\ell_{3},\ell_{4})$, and it is added to $\mathsf{L}$. On the contrary $(0,0,4,10)\oplus(0,0,0,0)=\infty$ because $(4,10)\nleq(4,F_{m})$. Since $\rho(\infty)=1$, the path $Q$ is not kept after Step 14 when $a=(\ell_{4},\ell_{5})$, and it is not added to $\mathsf{L}$. We have a similar outcome when $a=(\ell_{4},\ell_{6})$: In this case, $(0,0,4,6)\oplus(1,2,0,0)=\infty$ because $(5,8)\nleq(4,F_{m})$. The treatment of $Q=P_{1},\ell_{3},\ell_{4},\ell_{6}$ shows the interest of the bounds: Although path $Q$ itself satisfies rule (c), the algorithm identifies that any path starting by $Q$ violates rule (c).

Table 10 provides the same informations as Table 9 when we use a set of bounds B_{\ell_{3}}=\big{\{}\big{(}(2,8,0,0),0.4\big{)},\big{(}(3,6,0,0),1.5\big{)}\big{\}} instead of the singleton given in Table 8. Fewer iterations are then needed: the “if” condition at Step 14 is not satisfied when $P_{1},\ell_{3}$ is considered as path $Q$, and path $P_{1},\ell_{3}$ is never added to $\mathsf{L}$. Even though $P_{1},\ell_{3}$ itself satisfies rules (c) and (d), the algorithm identifies that any $o$-$d$ path starting by $P_{1},\ell_{3}$ does not satisfy at least one of these rules.

Rationale of $B_{\ell_{3}}$

We explain why $B_{\ell_{3}}$ is a correct bound set, both in the singleton and non-singleton cases. This explanation can be seen as a rough illustration of the procedure mentioned in Section 4.3 for the bound computation.

Any $\ell_{3}$-$d$ path must either start with $\ell_{3},\ell_{4},\ell_{5},\ell_{8}$, or with $\ell_{3},\ell_{4},\ell_{6},\ell_{7}$. Recall that we have assumed that \big{(}(0,0,0,0),0\big{)} is a lower bound on the resource of $\ell_{7}$-$d$ paths and on the resource of $\ell_{8}$-$d$ paths. Given that q_{(\ell_{3},\ell_{4})}\oplus q_{(\ell_{4},\ell_{5})}\oplus q_{(\ell_{4},\ell_{8})}\oplus\big{(}(0,0,0,0),0\big{)}=\big{(}(2,8,0,0),0.4\big{)} and q_{(\ell_{3},\ell_{4})}\oplus q_{(\ell_{4},\ell_{6})}\oplus q_{(\ell_{6},\ell_{7})}\oplus\big{(}(0,0,0,0),0\big{)}=\big{(}(3,6,0,0),1.5\big{)}, any $\ell_{3}$-$d$ path starting by $\ell_{3},\ell_{4},\ell_{5}$ has a resource lower bounded by \big{(}(2,8,0,0),0.4\big{)}, and any $\ell_{3}$-$d$ path starting by $\ell_{3},\ell_{4},\ell_{6},\ell_{7}$ has a resource lower bounded by \big{(}(3,6,0,0),1.5\big{)}. This explains why \big{\{}\big{(}(2,8,0,0),0.4\big{)},\big{(}(3,6,0,0),1.5\big{)}\big{\}} can be used as a set of bounds $B_{\ell_{3}}$, and why \big{(}(2,8,0,0),0.4\big{)}\wedge\big{(}(3,6,0,0),1.5\big{)}=\big{(}(2,6,0,0),0.4\big{)} is a lower bound on the resource of any $\ell_{3}$-$d$ path.