Problem and main theorem
We are given a directed acyclic graph G = ( V , E ) G = (V, E) G = ( V , E ) and m m m identical machines. Each vertex is a job of processing time one. A job can start only after all its predecessors have finished. Jobs cannot be interrupted. The objective is to minimize the time at which the last job finishes. This is the problem
P m ∣ p r e c , p j = 1 ∣ C max . P_m \mid\mathrm{prec}, p_j = 1 \mid C_{\max}. P m ∣ prec , p j = 1 ∣ C m a x .
Write n = ∣ V ∣ n = \lvert V\rvert n = ∣ V ∣ , and let L L L be the binary input length. Vertices 1 , … , n 1,\ldots,n 1 , … , n are individually listed, including isolated vertices; arcs are distinct and use standard binary vertex labels. A deadline, when supplied, is a nonnegative binary integer.
Theorem 1.1 (An exact algorithm for fixed machine capacity). For every integer m ≥ 3 m \ge3 m ≥ 3 and n ≥ 2 n \ge2 n ≥ 2 , there are algorithms to decide deadline feasibility and construct an optimum schedule using
O ( L ) + m O ( m 2 ) n 6 m 2 + 13 m + 1 log n (1) O(L) + m^{O(m^2)} n^{6m^2+13m+1} \log n \tag*{(1)} O ( L ) + m O ( m 2 ) n 6 m 2 + 13 m + 1 log n (1) elementary RAM operations in the model specified in Section 6. A single deadline test needs no logarithmic search factor. In particular, the simpler uniform bound
O ( L ) + m O ( m 2 ) n 11 m 2 O(L) + m^{O(m^2)} n^{11m^2} O ( L ) + m O ( m 2 ) n 11 m 2 holds for optimization as well. On a deterministic Turing machine with a fixed number of tapes, optimization and construction of an optimum schedule take
O ( L ) + m O ( m 2 ) n 12 m 2 + 26 m + 2 log 3 n O(L) + m^{O(m^2)} n^{12m^2+26m+2} \log^3 n O ( L ) + m O ( m 2 ) n 12 m 2 + 26 m + 2 log 3 n steps. A single deadline test uses log 2 n \log^2 n log 2 n instead of log 3 n \log^3 n log 3 n in this multitape bound, proved in Proposition 6.5. Thus the running time is polynomial for each fixed m m m . The algorithm is uniform: all constants, families, and loops are specified as functions of its input.
The cases m = 1 m = 1 m = 1 and m = 2 m = 2 m = 2 have the familiar direct and Coffman–Graham solutions, respectively [8 ] . Our explicit procedures focus on m ≥ 3 m \ge3 m ≥ 3 , which is the range of the generalization.
The central algorithmic idea. A subset dynamic program can have 2 N 2^N 2 N job-set entries. The full-slot algorithm retains only sets represented by prescribed short formulas. For a candidate W W W , a state ( L , Z , R ) (L, Z, R) ( L , Z , R ) separates an earlier prefix, a full marked slot and the remaining suffix. Previously stored schedules for the initial prefix, successive gaps and final suffix are concatenated through the marks. Exact ideal and antichain tests make every accepted certificate sound. The structural theorem supplies a complete certificate for the root, while increasing prefix cardinality permits a single acyclic state-path evaluation.
Previous results and status. The complexity of P m ∣ p r e c , p j = 1 ∣ C max P_m \mid\mathrm{prec}, p_j = 1 \mid C_{\max} P m ∣ prec , p j = 1 ∣ C m a x has been investigated for several decades; see the surveys by Lawler, Lenstra, Rinnooy Kan, and Shmoys [21 ] , Chen, Potts, and Woeginger [6 ] , and Mnich and van Bevern [27 ] . For m = 1 m = 1 m = 1 the problem is immediate, while for m = 2 m = 2 m = 2 polynomial-time algorithms were given by Fujii, Kasami, and Ninomiya [12 ] and Coffman and Graham [8 ] . Ullman [36 ] proved NP-hardness when the number m m m of machines is part of the input. This does not establish NP-hardness for any fixed m ≥ 3 m \ge3 m ≥ 3 . Indeed, the exact complexity for three machines remained a prominent open problem for many years; Lenstra and Rinnooy Kan [22 pp. 518–519] explicitly raised the fixed-machine question, also discussed in the later survey [27 ] .
Special precedence orders. For unit-time jobs, polynomial-time exact algorithms were already known for several restricted precedence classes. With an arbitrary number of machines, these include in-forests and out-forests [17 ] , interval orders [32 ] , quasi-interval orders [28 ] , and overinterval orders [5 ] . For opposing forests and level orders, the cited algorithms require a fixed number of machines [14 , 11 ] ; the bounded-height result requires both the height and the number of machines to be fixed [10 ] . All these statements concern unit-processing-time jobs.
Approximation algorithms. For arbitrary processing times and precedence constraints, Graham’s list scheduling achieves ratio 2 − 1 / m 2 - 1/m 2 − 1/ m [16 ] . For background on list scheduling and approximation algorithms, see Williamson and Shmoys [38 Section 2.3 and Exercise 2.3] . In the unit-job case, Coffman–Graham scheduling and the analyses of Lam and Sethi, and Braschi and Trystram, yield stronger bounds, including the approximation ratio 4 / 3 4/3 4/3 for three machines [8 , 20 , 3 ] . For m ≥ 4 m \ge4 m ≥ 4 , Gangal and Ranade [13 ] obtained ratio 2 − 7 / ( 3 m + 1 ) 2 - 7/(3m + 1) 2 − 7/ ( 3 m + 1 ) ; see also the open questions collected by Schuurman and Woeginger [34 ] . For unit-time jobs under arbitrary precedence constraints, Levey and Rothvoß [23 ] obtained a ( 1 + ε ) (1 + \varepsilon) ( 1 + ε ) -approximation through an LP hierarchy, with a super-quasipolynomial running-time bound. Garg [15 ] gave a quasipolynomial-time approximation scheme, and Li [24 ] improved the running time to n O ( ( m 4 / ε 3 ) ( log log n ) 3 ) n^{O((m^4/\varepsilon^3)(\log\log n)^3)} n O (( m 4 / ε 3 ) ( l o g l o g n ) 3 ) . Das and Wiese [9 ] subsequently gave a simpler combinatorial quasipolynomial-time approximation scheme. These are approximation algorithms; their displayed running-time bounds remain superpolynomial in n n n when m m m and ε \varepsilon ε are fixed. In particular, they do not give polynomial-time exact algorithms for general precedence orders.
Exact algorithms for general precedence orders. Nederlof, Swennenhuis, and Węgrzycki [29 ] obtained an exact algorithm with running time ( 1 + n / m ) O ( n m ) (1 + n/m)^{O(\sqrt{nm})} ( 1 + n / m ) O ( nm ) ; the result appeared at SODA 2025, and an accepted journal version was published online in ACM Transactions on Algorithms in January 2026. For every fixed m m m this is subexponential in n n n , but it is not a polynomial bound. A September 2026 OpenAI manuscript [30 ] established a polynomial-time exact algorithm for the three-machine problem P 3 ∣ p r e c , p j = 1 ∣ C max P_3 \mid\mathrm{prec}, p_j = 1 \mid C_{\max} P 3 ∣ prec , p j = 1 ∣ C m a x . The present paper gives a uniform algorithm for every fixed m ≥ 3 m \ge3 m ≥ 3 , with explicit description families, correctness proofs, and bounds for both RAM and deterministic fixed-tape computation.
Relation to the OpenAI construction and the new ideas. The OpenAI construction [30 ] for three machines uses normalized intervals, global priority lists, and changes of frame; its structural analysis involves lists of at most five entries, of which at most three are injections. Our extension to arbitrary fixed m ≥ 3 m \ge3 m ≥ 3 uses a boundary-exchange argument. At each strict promotion, a spare job in the ending slot cannot be the successor witness of a surviving high-priority birth group. Counting the remaining witnesses yields at most m − 1 m - 1 m − 1 surviving birth groups and at most m m m active entries at a node. When m = 3 m = 3 m = 3 , these bounds are two groups and three entries. Historical extensions prevent information from accumulating through successive frame reversals.
The proof distinguishes exact global descriptions of nodes from carry identities valid only after restriction to a node.
For the algorithm, separate formula budgets for node sets and prefix cuts, exact binary-trie lookup, and an acyclic evaluation of prefix states yield the RAM bound
O ( L ) + m O ( m 2 ) n 6 m 2 + 13 m + 1 log n . O(L) + m^{O(m^2)}n^{6m^2+13m+1}\log n. O ( L ) + m O ( m 2 ) n 6 m 2 + 13 m + 1 log n .
The polynomial degrees in n n n are 94, 149, and 216 for m = 3 , 4 , 5 m=3,4,5 m = 3 , 4 , 5 , respectively. Theorem 1.1 of the OpenAI manuscript [30 ] states a deterministic fixed-tape bound O ( ( L + 2 ) 150020 ) O((L+2)^{150020}) O (( L + 2 ) 150020 ) for three machines. For the same input-length measure, our fixed-tape bound from Proposition 6.5 implies O ( ( L + 2 ) 189 ) O((L+2)^{189}) O (( L + 2 ) 189 ) at m = 3 m=3 m = 3 . This compares upper bounds in the same formal computation model, not implementation running times. Unlike the cited three-machine theorem, our bound applies to every fixed m ≥ 3 m \ge3 m ≥ 3 .
Schedules and a finite description language
Road map: from explicit candidates to a structural certificate. We first specify the objects that the algorithm can compute, then prove that they suffice. § 2 introduces integral slots, padding by isolated jobs, and full schedules. It defines the boundary sets and their predecessor and successor cones P A , D A P_A,D_A P A , D A , the weak cones P ^ A , D ^ A \widehat{P}_A,\widehat{D}_A P A , D A , and a fixed topological rank function with rank suffixes R h R_h R h . These globally defined sets are the atoms of the Boolean language. The family F K \mathcal{F}_K F K contains all distinct subsets of the padded universe J J J represented with at most K K K atomic occurrences. Algorithm 1, GenerateFamily, constructs this family by set operations and exact duplicate detection, without knowing a feasible schedule.
§ 3 gives the scheduling algorithm. It processes candidate node sets in increasing cardinality and joins previously stored schedules through selected full slots. A separate cut family supplies candidate prefixes, and a directed state graph records which pieces can be combined while respecting precedence. Algorithm 6 turns this evaluation into an exact deadline test by padding and subsequently deleting the dummy jobs. Algorithm 7 uses binary search on the integer deadline to obtain an optimum makespan and an explicit schedule. § 4 illustrates the records, the stored schedule, and the longer certificate used to justify acceptance.
§ 5 proves correctness. After establishing padding, exact family generation, and soundness of the schedule combinations, it introduces a recursive hierarchy described by two families ( F , F c u t ) (\mathcal{F},\mathcal{F}_{\mathrm{cut}}) ( F , F cut ) . Marked full slots split a node into smaller open gaps, which become its children. Every node set must belong to F \mathcal{F} F , whereas a prefix before a marked slot is required to have the form W ∩ C W \cap C W ∩ C for a global cut C ∈ F c u t C \in\mathcal{F}_{\mathrm{cut}} C ∈ F cut . Induction on node size then shows that such a hierarchy forces acceptance of the root. The existence of the required hierarchy is stated here and proved in § 7 . § 6 counts the candidates and the work needed to generate, store, and evaluate them, including unsuccessful tests, schedule reconstruction, and binary search. It gives the RAM bound and a deterministic multitape implementation. This analysis uses only the specified family budgets; its operation counts can therefore be read before the structural proof.
§ 7 contains the structural heart of the polynomial-time result. Starting from a feasible witness schedule, it constructs the hierarchy using normalization, separators, priority lists, and changes of frame. The central task is to prevent inherited information from growing along the recursion and to turn it into short global Boolean descriptions. The resulting linear leaf budgets are 4 m + 5 4m+5 4 m + 5 for nodes and m + 3 m+3 m + 3 for cuts, giving F = F 4 m + 5 \mathcal{F}=\mathcal{F}_{4m+5} F = F 4 m + 5 and F c u t = F m + 3 \mathcal{F}_{\mathrm{cut}}=\mathcal{F}_{m+3} F cut = F m + 3 . These are bounds on formula size, not constant bounds on family cardinality: for fixed m m m , they make the enumerated search space polynomial in the number of jobs. The proof distinguishes exact global node descriptions from cut identities valid after intersection with the local node. It completes Theorem 5.8 , thereby discharging the structural premise of completeness and completing, together with § 6 , the proof of the main Theorem 1.1 .
Slots, induced precedence, and full schedules
The following representation is sufficient for the original scheduling model: integral slots lose no optimality, and isolated dummy jobs can fill unused positions of a deadline schedule. These statements are proved in Lemmas 5.1 and 5.2 , after the complete algorithm has been specified.
Compute the transitive closure of G G G . Write x ≺ y x \prec y x ≺ y when there is a directed path of positive length from x x x to y y y . Every subset below inherits this global order: a precedence remains even if a path establishing it uses jobs outside that subset.
A slot schedule of deadline T T T assigns each job a slot τ ( x ) ∈ { 1 , … , T } \tau(x) \in\{1,\ldots,T\} τ ( x ) ∈ { 1 , … , T } , with at most m m m jobs per slot and τ ( x ) < τ ( y ) \tau(x) < \tau(y) τ ( x ) < τ ( y ) whenever x ≺ y x \prec y x ≺ y . Slot t t t means execution during [ t − 1 , t ) [t-1,t) [ t − 1 , t ) . A job’s machine can be assigned arbitrarily within its slot, using distinct machines for the jobs of that slot.
For a relevant deadline ⌈ n / m ⌉ ≤ T < n \lceil n/m\rceil\le T < n ⌈ n / m ⌉ ≤ T < n , add m T − n mT-n m T − n isolated jobs and call the resulting set J J J . Its size is N = m T ≤ m n N=mT \le mn N = m T ≤ mn . The algorithm tests whether these jobs have a full schedule of T T T slots.
Definition 2.1 (Full schedule, ideal, and antichain). A full schedule of W ⊆ J W \subseteq J W ⊆ J is an ordered partition of W W W into antichains of exactly m m m jobs that respects the induced order on W W W . It has ∣ W ∣ / m |W|/m ∣ W ∣/ m slots. The empty set has the empty full schedule. A set U ⊆ W U \subseteq W U ⊆ W is an ideal of W W W if y ∈ U y \in U y ∈ U , x ∈ W x \in W x ∈ W , and x ≺ y x \prec y x ≺ y imply x ∈ U x \in U x ∈ U . A set is an antichain if no two of its jobs are comparable.
Both tests inspect entries of the precomputed transitive precedence matrix. To test whether U U U is an ideal of W W W , inspect every ordered pair ( x , y ) ∈ W × U (x,y) \in W \times U ( x , y ) ∈ W × U and reject if x ≺ y x \prec y x ≺ y but x ∉ U x \notin U x ∈ / U . To test whether Z Z Z is an antichain, inspect every ordered pair of distinct jobs in Z Z Z and reject if one precedes the other. Each matrix entry and membership entry can be accessed in constant time, so either test uses at most O ( N 2 ) O(N^2) O ( N 2 ) RAM operations.
A small padding example. Let m = 3 m=3 m = 3 and consider five jobs with only a 1 ≺ a 2 a_1 \prec a_2 a 1 ≺ a 2 and b 1 ≺ b 2 b_1 \prec b_2 b 1 ≺ b 2 , together with an independent job c c c . For deadline two, add one isolated job d d d . A full padded schedule is
{ a 1 , b 1 , c } , { a 2 , b 2 , d } . \{a_1,b_1,c\},\quad\{a_2,b_2,d\}. { a 1 , b 1 , c } , { a 2 , b 2 , d } .
Removing d d d gives the original five-job schedule. A table entry for three jobs asks for one full slot; an entry for six jobs asks for two. There is no separate time coordinate in a table entry.
Atoms are sets computed from the input order
All descriptions denote subsets of the entire padded set J J J . For an m m m -element set A ⊆ J A \subseteq J A ⊆ J , define
P A = { x ∈ J : ∃ a ∈ A , x ≺ a } , D A = { x ∈ J : ∃ a ∈ A , a ≺ x } , P_A=\{x\in J:\exists a\in A,\ x\prec a\},\qquad D_A=\{x\in J:\exists a\in A,\ a\prec x\}, P A = { x ∈ J : ∃ a ∈ A , x ≺ a } , D A = { x ∈ J : ∃ a ∈ A , a ≺ x } ,
P ^ A = P A ∪ A , D ^ A = D A ∪ A . \widehat{P}_A=P_A\cup A,\qquad\widehat{D}_A=D_A\cup A. P A = P A ∪ A , D A = D A ∪ A .
Choose one topological ordering by repeatedly removing the smallest identifier among available minimal jobs. Its rank function rank : J → { 1 , … , N } \operatorname{rank}:J\to\{1,\ldots,N\} rank : J → { 1 , … , N } satisfies x ≺ y ⇒ rank ( x ) < rank ( y ) x\prec y\Rightarrow\operatorname{rank}(x)<\operatorname{rank}(y) x ≺ y ⇒ rank ( x ) < rank ( y ) . For 1 ≤ h ≤ N + 1 1\le h\le N+1 1 ≤ h ≤ N + 1 , put
R h = { x ∈ J : rank ( x ) ≥ h } . R_h=\{x\in J:\operatorname{rank}(x)\ge h\}. R h = { x ∈ J : rank ( x ) ≥ h } .
In particular, R 1 = J R_1=J R 1 = J and R N + 1 = ∅ R_{N+1}=\varnothing R N + 1 = ∅ .
Definition 2.2 (Atoms and the family F K \mathcal{F}_K F K ). The atomic sets are
J , ∅ , R h , A , P A , D A , P ^ A , D ^ A ( ∣ A ∣ = m ) . J,\quad\varnothing,\quad R_h,\quad A,\quad P_A,\quad D_A,\quad\widehat{P}_A,\quad\widehat{D}_A\quad(|A|=m). J , ∅ , R h , A , P A , D A , P A , D A ( ∣ A ∣ = m ) . A Boolean formula uses these atoms, binary union and intersection, and unary complement relative to J J J . Its leaf count is the number of atomic occurrences, counted with multiplicity. Unary complement does not add a leaf. The family F K \mathcal{F}_K F K contains the distinct sets represented by formulas with at most K K K leaves.
The enumeration uses every m m m -set A A A , even if it is not an antichain. Only an actual full slot must pass the antichain test. Every atom is computed directly from the order and rank table. No schedule is used to generate this family.
Represent a set by its N N N -bit incidence vector. Equality, inclusion, union, intersection, complement, and cardinality are then explicit finite operations on vectors. When two formulas have the same vector, the algorithm stores the vector once. It need not store the formulas.
Generating the family directly by set operations
The following procedure avoids enumerating tree shapes. It groups sets by an upper bound on their leaf count. It is exact, not a heuristic selection of promising subsets.
Exact storage by incidence vectors. For duplicate detection, use a binary trie . Its root represents the empty bit prefix. At depth r = 0 , … , N − 1 r = 0, \ldots, N - 1 r = 0 , … , N − 1 , the next edge is labelled by the membership bit of job N − r N-r N − r ; a complete root-to-leaf path therefore reads the N N N bits in decreasing job-label order. Missing edges are created during insertion. A terminal node stores a pointer to the record for that vector. An existing terminal identifies an exact duplicate. Insertion and lookup inspect at most N N N edges and cost O ( N ) O(N) O ( N ) RAM operations; no hashing or probabilistic equality test is used. Each generated layer has its own trie and list of distinct vectors. A traversal taking edge 0 before edge 1 lists its vectors in lexicographic order.
Algorithm 1 (GenerateFamily(J J J , m m m , K K K )). Input: the padded global order on J J J , its fixed rank order, and integers m m m , K ≥ 1 K \ge1 K ≥ 1 . Output: all distinct members of F K \mathcal{F}_K F K as bit vectors, together with the intermediate layers F 1 , … , F K \mathcal{F}_1, \ldots, \mathcal{F}_K F 1 , … , F K and their tries.
Build the atomic list in the order J J J , ∅ \varnothing ∅ , R 1 , … , R N + 1 \mathcal{R}_1, \ldots, \mathcal{R}_{N+1} R 1 , … , R N + 1 , followed by A A A , P A P_A P A , D A D_A D A , P ^ A \widehat{P}_A P A , D ^ A \widehat{D}_A D A for each m m m -set A A A in lexicographic identifier order.
Create an empty list F 1 \mathcal{F}_1 F 1 and its binary trie. For each atom A A A in the atomic list, insert A A A and J ∖ A J \setminus A J ∖ A into the trie. Append the vector to F 1 \mathcal{F}_1 F 1 exactly when its terminal node is new. Each insertion, including exact duplicate detection, costs O ( N ) O(N) O ( N ) operations.
For k = 2 , 3 , … , K k = 2, 3, \ldots, K k = 2 , 3 , … , K , do the following:
(a) Create an empty list F k \mathcal{F}_k F k and a new trie. Insert every vector of F k − 1 \mathcal{F}_{k-1} F k − 1 into this trie and append it to F k \mathcal{F}_k F k .
(b) For i = 1 , 2 , … , k − 1 i = 1, 2, \ldots, k - 1 i = 1 , 2 , … , k − 1 , and then for each X ∈ F i X \in\mathcal{F}_i X ∈ F i and each Y ∈ F k − i Y \in\mathcal{F}_{k-i} Y ∈ F k − i in their stored order, insert X ∪ Y X \cup Y X ∪ Y and X ∩ Y X \cap Y X ∩ Y into F k \mathcal{F}_k F k , using its trie for the same exact duplicate test.
All source lists in step (b) have index smaller than k k k and remain fixed during the iteration.
Return F K \mathcal{F}_K F K , retaining the intermediate lists and tries for reuse.
Lemma 5.3 proves that the returned family is exactly F K \mathcal{F}_K F K . The size bound in Lemma 6.1 and the operation count in Lemma 6.2 explain its cost.
Why the loop has a specified final layer. The procedure runs through K = 4 m + 5 K = 4m + 5 K = 4 m + 5 layers and also retains layer m + 3 m + 3 m + 3 . A single unchanged layer does not prove that all later layers will be unchanged: formulas with two more expensive subexpressions can first appear later. An independent sufficient condition for early termination is that every one of the 2 N 2^N 2 N possible bit vectors has already been generated. This optimization is unnecessary for the proof or its upper bound.
Two budgets for two purposes. Use
K n o d e = 4 m + 5 , F = F n o d e = F 4 m + 5 , K_{\mathrm{node}} = 4m + 5,\quad\mathcal{F} = \mathcal{F}_{\mathrm{node}} = \mathcal{F}_{4m+5}, K node = 4 m + 5 , F = F node = F 4 m + 5 ,
K c u t = m + 3 , F c u t = F m + 3 . K_{\mathrm{cut}} = m + 3,\quad\mathcal{F}_{\mathrm{cut}} = \mathcal{F}_{m+3}. K cut = m + 3 , F cut = F m + 3 .
The first family supplies candidate job sets; the second supplies global cuts defining state prefixes. The structural theorem will prove these two description budgets separately.
Four different sets in one computation. The following distinctions are useful when reading the algorithm.
Table 1.
The structural theorem supplies family memberships for the gaps of one successful decomposition. It does not assert that every intersection or difference of candidate vectors is another candidate. For an internal candidate, a table value of zero means that this recurrence has not constructed a schedule; it need not certify that an arbitrary candidate set is infeasible. Completeness is proved for the full root instance by the structural hierarchy theorem.
The exact algorithm
For a deadline T T T , padding gives N = m T N = mT N = m T jobs. The algorithm generates F = F 4 m + 5 \mathcal{F} = \mathcal{F}_{4m+5} F = F 4 m + 5 and computes one Boolean value for each W ∈ F W \in\mathcal{F} W ∈ F :
a ( W ) = 1 ⟺ the algorithm has constructed a full schedule of W . a(W) = 1 \Longleftrightarrow\text{the algorithm has constructed a full schedule of } W. a ( W ) = 1 ⟺ the algorithm has constructed a full schedule of W .
Whenever it sets a value to one, it also stores that schedule explicitly. The empty set starts with value one and the empty schedule. Sets are processed by increasing cardinality. Thus the basic operation is to join already stored schedules of smaller sets, with a full slot inserted between successive pieces.
The smaller family F c u t = F m + 3 \mathcal{F}_{\mathrm{cut}} = \mathcal{F}_{m+3} F cut = F m + 3 supplies candidate cuts. Given a parent W W W and a cut C C C , the set L = W ∩ C L = W \cap C L = W ∩ C is a candidate prefix. The intersection is computed directly as a bit vector. It need not itself belong to either family.
Records, states, and elementary predicates
Fix job labels 1 , … , N 1,\ldots,N 1 , … , N . If b j b_j b j indicates membership of job j j j , order incidence vectors lexicographically as b N ⋯ b 1 b_N \cdots b_1 b N ⋯ b 1 , with 0 < 1 0 < 1 0 < 1 ; equivalently, order their integer values ∑ j b j 2 j − 1 \sum_j b_j2^{j-1} ∑ j b j 2 j − 1 . The cut family is traversed in this lexicographic vector order. Order m m m -subsets by their increasing lists of job labels. These orders fix every choice made below. A full schedule is stored as a list of m m m -element slots, with the labels within each slot increasing.
The family table has one row
( X , a ( X ) , σ ( X ) ) ( X ∈ F ) . (X, a(X), \sigma(X)) \qquad(X \in\mathcal{F}). ( X , a ( X ) , σ ( X )) ( X ∈ F ) .
For each candidate set X ∈ F X \in\mathcal{F} X ∈ F , the table stores a Boolean value a ( X ) ∈ { 0 , 1 } a(X) \in\{0,1\} a ( X ) ∈ { 0 , 1 } , together with a schedule field σ ( X ) \sigma(X) σ ( X ) . The value a ( X ) = 1 a(X) = 1 a ( X ) = 1 means that the algorithm has constructed and stored a feasible full schedule of X X X : every job of X X X occurs exactly once, each slot contains exactly m m m jobs, and all precedence relations induced on X X X are respected. Note that σ ( X ) \sigma(X) σ ( X ) is either an explicitly stored full schedule or the symbol ⊥ \bot ⊥ . Rows are sorted by the pair ( ∣ X ∣ , b N ⋯ b 1 ) (|X|,b_N\cdots b_1) ( ∣ X ∣ , b N ⋯ b 1 ) and retain that order throughout evaluation. Initially all values are zero and all schedules are ⊥ \bot ⊥ , except a ( ∅ ) = 1 a(\varnothing) = 1 a ( ∅ ) = 1 and σ ( ∅ ) = ( ) \sigma(\varnothing) = () σ ( ∅ ) = ( ) .
For X ⊆ W X \subseteq W X ⊆ W , define the two tests
Ideal ( X , W ) ⟺ ∀ x ∈ X ∀ y ∈ W : ( y ≺ x ⇒ y ∈ X ) , \operatorname{Ideal}(X,W) \Longleftrightarrow\forall x \in X\ \forall y \in W : (y \prec x \Rightarrow y \in X), Ideal ( X , W ) ⟺ ∀ x ∈ X ∀ y ∈ W : ( y ≺ x ⇒ y ∈ X ) ,
Antichain ( X ) ⟺ ∀ x , y ∈ X : ¬ ( x ≺ y ) . \operatorname{Antichain}(X) \Longleftrightarrow\forall x,y \in X : \neg(x \prec y). Antichain ( X ) ⟺ ∀ x , y ∈ X : ¬ ( x ≺ y ) .
These are finite tests against the precomputed global transitive order. In particular, an induced precedence is retained even if its path in the input DAG passes through jobs outside W W W .
Definition 3.1 (State of a candidate set). For a nonempty W ∈ F W \in\mathcal{F} W ∈ F with m ∣ ∣ W ∣ m \mid|W| m ∣ ∣ W ∣ , a state is a partition
W = L ∪ ˙ Z ∪ ˙ R W = L \mathbin{\dot\cup} Z \mathbin{\dot\cup} R W = L ∪ ˙ Z ∪ ˙ R such that L = W ∩ C L = W \cap C L = W ∩ C for some C ∈ F c u t C \in\mathcal{F}_{\mathrm{cut}} C ∈ F cut , ∣ Z ∣ = m |Z| = m ∣ Z ∣ = m , m ∣ ∣ L ∣ m \mid|L| m ∣ ∣ L ∣ , m ∣ ∣ R ∣ m \mid|R| m ∣ ∣ R ∣ , Z Z Z is an antichain, and L L L and L ∪ Z L \cup Z L ∪ Z are ideals of W W W .
The two ideal conditions state exactly that no job in a later part of ( L , Z , R ) (L,Z,R) ( L , Z , R ) precedes a job in an earlier part. A state record stores ( L , Z , R ) (L,Z,R) ( L , Z , R ) , the already computed prefix cardinality ∣ L ∣ |L| ∣ L ∣ , a reachability bit, and either a predecessor-state index, START, or UNREACHED. Different cuts can produce the same triple; retaining these duplicate records is harmless and simplifies the specification.
The following algorithm uses two operations. Lookup( X ) (X) ( X ) accepts any query set X ⊆ J X \subseteq J X ⊆ J , whether or not X X X belongs to the generated family. It follows the incidence vector of X X X through the family trie’s N N N levels to its table-row pointer, or detects a missing edge. Thus exact lookup costs O ( N ) O(N) O ( N ) operations. It returns
Lookup ( X ) = { a ( X ) , X ∈ F , 0 , X ∉ F . \operatorname{Lookup}(X) =
\begin{cases}
a(X), & X \in\mathcal{F},\\
0, & X \notin\mathcal{F}.
\end{cases} Lookup ( X ) = { a ( X ) , 0 , X ∈ F , X ∈ / F .
Fetch( X ) (X) ( X ) retrieves the schedule whose existence is certified by a successful lookup. It is defined only when Lookup ( X ) = 1 \operatorname{Lookup}(X) = 1 Lookup ( X ) = 1 , and it returns a copy of the explicitly stored slot list σ ( X ) \sigma(X) σ ( X ) .
Algorithm 2 (Exact lookup and schedule retrieval). Lookup( X ) (X) ( X ) and Fetch( X ) (X) ( X ) operate on the current family table.
Read the membership bits of X X X in decreasing job-label order, following the correspondingly labelled edges of the family trie. A missing edge means there is no matching row; a complete path gives the terminal node’s pointer to that row.
If the matching row is found, Lookup returns its stored bit a ( X ) a(X) a ( X ) . If that bit is one, Fetch returns a copy of its stored schedule σ ( X ) \sigma(X) σ ( X ) .
If there is no matching row, Lookup returns zero. Calling Fetch on a missing or zero-valued row is forbidden; the subsequent procedures only fetch sets whose lookup has returned one.
Thus a lookup never solves a new scheduling problem. It only reads the value stored in the matching row.
Algorithm 3 (Enumerate every state of one parent). BuildStates ( W , F c u t , m ) \operatorname{BuildStates}(W,\mathcal{F}_{\mathrm{cut}},m) BuildStates ( W , F cut , m ) returns an ordered list S W S_W S W .
Start with the empty list.
For each C ∈ F c u t C \in\mathcal{F}_{\mathrm{cut}} C ∈ F cut in lexicographic vector order, set L = W ∩ C L = W \cap C L = W ∩ C . If m ∤ ∣ L ∣ m \nmid|L| m ∤ ∣ L ∣ , proceed to the next cut.
For each m m m -subset Z Z Z of W ∖ L W \setminus L W ∖ L in the fixed subset order, set R = W ∖ ( L ∪ Z ) R = W \setminus(L \cup Z) R = W ∖ ( L ∪ Z ) . Append ( L , Z , R ) (L,Z,R) ( L , Z , R ) to the list exactly when
m ∣ ∣ R ∣ , Antichain ( Z ) , Ideal ( L , W ) , Ideal ( L ∪ Z , W ) . m \mid|R|,\qquad\operatorname{Antichain}(Z),\qquad\operatorname{Ideal}(L,W),\qquad\operatorname{Ideal}(L \cup Z,W). m ∣ ∣ R ∣ , Antichain ( Z ) , Ideal ( L , W ) , Ideal ( L ∪ Z , W ) .
The loops in this step are executed separately for each cut in Step 2.
Number the appended records 1 , … , s 1,\ldots,s 1 , … , s in their append order, initialize all reachability bits to zero and predecessor fields to UNREACHED, and return the list.
Write ( L i , Z i , R i ) (L_i,Z_i,R_i) ( L i , Z i , R i ) for record i i i . Conceptually, there is an edge i → j i \to j i → j when
L i ∪ Z i ⊆ L j and Lookup ( L j ∖ ( L i ∪ Z i ) ) = 1. (2) L_i \cup Z_i \subseteq L_j \quad\text{and}\quad\operatorname{Lookup}(L_j \setminus(L_i \cup Z_i)) = 1. \tag*{(2)} L i ∪ Z i ⊆ L j and Lookup ( L j ∖ ( L i ∪ Z i )) = 1. (2)
An initial record satisfies Lookup ( L i ) = 1 \operatorname{Lookup}(L_i) = 1 Lookup ( L i ) = 1 , and a final record satisfies Lookup ( R i ) = 1 \operatorname{Lookup}(R_i) = 1 Lookup ( R i ) = 1 . The next algorithm finds a path from an initial record to a final record. It computes the edge test when needed; storing a separate edge table is unnecessary. Every edge satisfies ∣ L j ∣ ≥ ∣ L i ∣ + m |L_j| \ge|L_i| + m ∣ L j ∣ ≥ ∣ L i ∣ + m . Thus increasing prefix cardinality gives an acyclic evaluation order.
Algorithm 4 (Evaluate the finite family). EvaluateFamily ( J , F , F c u t , m ) \operatorname{EvaluateFamily}(J,\mathcal{F},\mathcal{F}_{\mathrm{cut}},m) EvaluateFamily ( J , F , F cut , m ) returns the family table.
Sort the distinct members of F \mathcal{F} F by ( ∣ X ∣ , b N ⋯ b 1 ) (|X|,b_N\cdots b_1) ( ∣ X ∣ , b N ⋯ b 1 ) , using a lexicographic trie traversal followed by stable cardinality buckets. Bind each trie terminal to its table row. Initialize the table rows in this order as specified above, including the empty schedule in the row for ∅ \varnothing ∅ .
Process the nonempty rows in that order. Skip a row if its cardinality is not a multiple of m m m ; its value remains zero. For each remaining parent W W W , perform Steps 3–6.
Set S W = BuildStates ( W , F c u t , m ) S_W = \operatorname{BuildStates}(W,\mathcal{F}_{\mathrm{cut}},m) S W = BuildStates ( W , F cut , m ) and let s = ∣ S W ∣ s = |S_W| s = ∣ S W ∣ . For i = 1 , … , s i = 1,\ldots,s i = 1 , … , s , if Lookup ( L i ) = 1 \operatorname{Lookup}(L_i) = 1 Lookup ( L i ) = 1 , set reached [ i ] = 1 \operatorname{reached}[i] = 1 reached [ i ] = 1 and pred [ i ] = START \operatorname{pred}[i] = \operatorname{START} pred [ i ] = START .
Stably bucket the state indices by ∣ L i ∣ |L_i| ∣ L i ∣ , preserving their index order within a bucket. Process these buckets in increasing order. For each reached source i i i , inspect the target indices j = 1 , … , s j = 1,\ldots,s j = 1 , … , s once. If reached [ j ] = 0 \operatorname{reached}[j] = 0 reached [ j ] = 0 and (2) holds, set
reached [ j ] = 1 , pred [ j ] = i . \operatorname{reached}[j] = 1,\qquad\operatorname{pred}[j] = i. reached [ j ] = 1 , pred [ j ] = i .
Updates take effect immediately. Each possible edge goes to a later prefix-cardinality bucket, so no bucket needs to be processed again.
Inspect records i = 1 , … , s i = 1,\ldots,s i = 1 , … , s in order. If none satisfies reached [ i ] = 1 \operatorname{reached}[i] = 1 reached [ i ] = 1 and Lookup ( R i ) = 1 \operatorname{Lookup}(R_i) = 1 Lookup ( R i ) = 1 , leave the row of W W W at ( W , 0 , ⊥ ) (W,0,\perp) ( W , 0 , ⊥ ) . Otherwise choose the first such record t t t , set a ( W ) = 1 a(W) = 1 a ( W ) = 1 , and store
σ ( W ) = Reconstruct ( t , S W ) . \sigma(W) = \operatorname{Reconstruct}(t,S_W). σ ( W ) = Reconstruct ( t , S W ) .
Discard the temporary state list for this W W W and continue with the next parent in Step 2. After all parents have been processed, return the table.
The state list can be empty; in that case there are no sources to process and the parent is rejected. A path consisting of one initial and final state is allowed. Once a record is reached, its predecessor field is never changed.
Meaning of a zero entry. After a row has been processed, zero means that no schedule certificate was found using these two families. Some feasible candidate sets can have value zero when a family omits needed descriptions. Soundness will establish that every value one has a valid stored schedule. The structural theorem will establish completeness for the final root decision. Unprocessed rows also start at zero; the proper-query lemma below ensures that they are never consulted during an earlier parent’s evaluation.
Algorithm 5 (Recover and store one full schedule). Reconstruct( t , S W ) (t, S_W) ( t , S W ) is called only for a reached final state.
Follow predecessor fields backward from t t t until a record with predecessor START is reached. Reverse the recorded index list to obtain a path i 1 , … , i k i_1,\ldots,i_k i 1 , … , i k in forward order.
Start the output list with a copy of Fetch( L i 1 ) (L_{i_1}) ( L i 1 ) .
For r = 1 , … , k r=1,\ldots,k r = 1 , … , k , append the full slot Z i r Z_{i_r} Z i r . If r < k r<k r < k , append a copy of
Fetch ( L i r + 1 ∖ ( L i r ∪ Z i r ) ) . \operatorname{Fetch}\left(L_{i_{r+1}}\setminus\left(L_{i_r}\cup Z_{i_r}\right)\right). Fetch ( L i r + 1 ∖ ( L i r ∪ Z i r ) ) .
Append a copy of Fetch( R i k ) (R_{i_k}) ( R i k ) and return the resulting list of full slots.
Deadline feasibility and optimum makespan
The following two wrappers complete the algorithm for the original jobs. The graph is read and its global transitive order computed once. A deterministic topological order is obtained by repeatedly choosing the smallest-labelled available job. The padded order extends this order by isolated dummy jobs; choose the smallest-labelled available job again when computing the rank used by GenerateFamily.
In the next algorithm, Deadline( G , m , T ) (G,m,T) ( G , m , T ) , G = ( V , E ) G=(V,E) G = ( V , E ) denotes the original directed acyclic precedence graph, m m m is the number of machines, and T T T is the proposed nonnegative integer deadline. Thus, the algorithm asks whether the jobs represented by G G G admit a feasible schedule with makespan at most T T T .
Algorithm 6 (Exact deadline test). Deadline( G , m , T ) (G,m,T) ( G , m , T ) returns NO or a schedule of all original jobs with makespan at most the nonnegative integer T T T .
If n = 0 n=0 n = 0 , return the empty schedule. If T < ⌈ n / m ⌉ T<\lceil n/m\rceil T < ⌈ n / m ⌉ , return NO. If T ≥ n T\ge n T ≥ n , return the serial topological schedule.
Add m T − n mT-n m T − n isolated dummy jobs with fresh consecutive labels. Let J J J be the padded set, N = m T N=mT N = m T , and K = 4 m + 5 K=4m+5 K = 4 m + 5 .
Generate F = GenerateFamily ( J , m , K ) \mathcal{F}=\operatorname{GenerateFamily}(J,m,K) F = GenerateFamily ( J , m , K ) by the specified Boolean-family procedure, retain F c u t = F m + 3 \mathcal{F}_{\mathrm{cut}}=\mathcal{F}_{m+3} F cut = F m + 3 , and run EvaluateFamily ( J , F , F c u t , m ) \operatorname{EvaluateFamily}(J,\mathcal{F},\mathcal{F}_{\mathrm{cut}},m) EvaluateFamily ( J , F , F cut , m ) .
If a ( J ) = 0 a(J)=0 a ( J ) = 0 , return NO. Otherwise delete dummy jobs from the stored full schedule σ ( J ) \sigma(J) σ ( J ) , discard trailing empty slots, and return the remaining slot schedule. Within each slot, assign its original jobs in increasing label order to machines 1 , 2 , … 1,2,\ldots 1 , 2 , … .
Algorithm 7 (Exact optimization). Optimum ( G , m ) \operatorname{Optimum}(G,m) Optimum ( G , m ) returns an optimum schedule of the original jobs.
If n = 0 n=0 n = 0 , return the empty schedule of makespan zero. Otherwise set
ℓ = ⌈ n m ⌉ − 1 , u = n , \ell= \left\lceil\frac{n}{m} \right\rceil- 1,\qquad u=n, ℓ = ⌈ m n ⌉ − 1 , u = n ,
and let σ b e s t \sigma_{\mathrm{best}} σ best be the serial topological schedule.
While u − ℓ > 1 u-\ell>1 u − ℓ > 1 , set T = ⌊ ( ℓ + u ) / 2 ⌋ T=\left\lfloor(\ell+u)/2\right\rfloor T = ⌊ ( ℓ + u ) /2 ⌋ and call Deadline ( G , m , T ) \operatorname{Deadline}(G,m,T) Deadline ( G , m , T ) . If it returns NO, set ℓ = T \ell=T ℓ = T . If it returns a schedule σ \sigma σ , set u = T u=T u = T and σ b e s t = σ \sigma_{\mathrm{best}}=\sigma σ best = σ .
Return u u u and σ b e s t \sigma_{\mathrm{best}} σ best .
All inputs to the scheduling calls are obtained from explicit job sets, bit-vector operations, and previously computed table rows. In particular, the algorithm never calls a procedure to find a normalized schedule or to recognize a genuine structural history. Those objects will be used only in the completeness proof.
A small example: the stored schedule and a longer certificate
Consider m m m disjoint chains of length three,
j i , 1 ≺ j i , 2 ≺ j i , 3 ( 1 ≤ i ≤ m ) , j_{i,1} \prec j_{i,2} \prec j_{i,3}\qquad(1\le i\le m), j i , 1 ≺ j i , 2 ≺ j i , 3 ( 1 ≤ i ≤ m ) ,
with no relations between different chains. Put Z t = { j i , t : 1 ≤ i ≤ m } Z_t=\{j_{i,t}:1\le i\le m\} Z t = { j i , t : 1 ≤ i ≤ m } for t = 1 , 2 , 3 t=1,2,3 t = 1 , 2 , 3 and W = Z 1 ∪ ˙ Z 2 ∪ ˙ Z 3 W=Z_1\mathbin{\dot\cup}Z_2\mathbin{\dot\cup}Z_3 W = Z 1 ∪ ˙ Z 2 ∪ ˙ Z 3 . For deadline three no dummy jobs are needed. A feasible schedule is ( Z 1 , Z 2 , Z 3 ) (Z_1,Z_2,Z_3) ( Z 1 , Z 2 , Z 3 ) , and a chain of length three excludes every smaller deadline. We now trace how the algorithm obtains a schedule.
Step 1: the required vectors are generated. Each Z t Z_t Z t is an m m m -set and hence an atom. The global cut P Z 3 = Z 1 ∪ Z 2 P_{Z_3}=Z_1\cup Z_2 P Z 3 = Z 1 ∪ Z 2 is another atom, as is D Z 1 = Z 2 ∪ Z 3 D_{Z_1}=Z_2\cup Z_3 D Z 1 = Z 2 ∪ Z 3 . Both families also contain ∅ \varnothing ∅ and W = J W=J W = J . Thus all the vectors below occur in both generated families without knowing the displayed schedule.
Step 2: single-slot sets are accepted. When the algorithm processes Z 2 Z_2 Z 2 , it generates ( ∅ , Z 2 , ∅ ) (\varnothing,Z_2,\varnothing) ( ∅ , Z 2 , ∅ ) . Its initial and final queries both ask for the empty set, whose stored schedule is empty. It therefore stores σ ( Z 2 ) = ( Z 2 ) \sigma(Z_2)=(Z_2) σ ( Z 2 ) = ( Z 2 ) . The same holds for Z 1 Z_1 Z 1 and Z 3 Z_3 Z 3 . The two-slot set Z 2 ∪ Z 3 Z_2\cup Z_3 Z 2 ∪ Z 3 is then accepted with the state ( ∅ , Z 2 , Z 3 ) (\varnothing,Z_2,Z_3) ( ∅ , Z 2 , Z 3 ) , and stores the schedule ( Z 2 , Z 3 ) (Z_2,Z_3) ( Z 2 , Z 3 ) . Step 3: the parent has two useful states. Using the cuts ∅ \varnothing ∅ and P Z 3 P_{Z_3} P Z 3 gives
s = ( ∅ , Z 1 , Z 2 ∪ Z 3 ) , t = ( Z 1 ∪ Z 2 , Z 3 , ∅ ) . s = (\varnothing, Z_1, Z_2 \cup Z_3), \qquad t = (Z_1 \cup Z_2, Z_3, \varnothing). s = ( ∅ , Z 1 , Z 2 ∪ Z 3 ) , t = ( Z 1 ∪ Z 2 , Z 3 , ∅ ) .
Both are compatible. State s s s is initial and t t t is final. The transition test calculates the actual vector
G = L t ∖ ( L s ∪ Z s ) = ( Z 1 ∪ Z 2 ) ∖ Z 1 = Z 2 . G = L_t \setminus(L_s \cup Z_s) = (Z_1 \cup Z_2) \setminus Z_1 = Z_2. G = L t ∖ ( L s ∪ Z s ) = ( Z 1 ∪ Z 2 ) ∖ Z 1 = Z 2 .
Its lookup succeeds because step 2 stored a schedule of this exact set. Thus s → t s \to t s → t is a valid edge of the conceptual state graph. In this small example, t t t is also initial: its prefix Z 1 ∪ Z 2 Z_1 \cup Z_2 Z 1 ∪ Z 2 is itself an accepted candidate. An already initial state retains its START pointer.
Step 4: the deterministic execution uses its first final state. With the fixed orders, s s s is the first state: its cut is empty and Z 1 Z_1 Z 1 is the only full slot consisting of minimal jobs. Its suffix Z 2 ∪ Z 3 Z_2 \cup Z_3 Z 2 ∪ Z 3 was accepted in step 2. Therefore s s s is already both initial and final. The procedure reconstructs the one-state path, outputting the empty initial schedule, Z 1 Z_1 Z 1 , and the stored schedule ( Z 2 , Z 3 ) (Z_2, Z_3) ( Z 2 , Z 3 ) . Its result is ( Z 1 , Z 2 , Z 3 ) (Z_1, Z_2, Z_3) ( Z 1 , Z 2 , Z 3 ) .
How to read the nonempty-gap edge. The longer path s → t s \to t s → t is also a valid accepting certificate. Along that path, the pieces would be the empty initial schedule, Z 1 Z_1 Z 1 , the stored schedule σ ( Z 2 ) \sigma(Z_2) σ ( Z 2 ) , Z 3 Z_3 Z 3 , and the empty final schedule. This explains the nonempty gap in Figure 1 ; it does not assert that t t t receives predecessor s s s in the deterministic execution. The soundness theorem applies to both certificates. The structural theorem guarantees a suitable certificate for every feasible instance, extending the example beyond disjoint chains.
Figure 1. Three disjoint chains illustrate m = 3 m=3 m = 3 ; use m m m chains for general capacity. The longer certificate uses the middle full slot as an already accepted gap between two marked slots.
Figure 2 illustrates a general decomposition; its marked-slot labels are independent of the labels in the preceding example. To clarify the construction, consider a feasible full schedule ( S 1 , S 2 , S 3 , S 4 , S 5 , S 6 ) (S_1, S_2, S_3, S_4, S_5, S_6) ( S 1 , S 2 , S 3 , S 4 , S 5 , S 6 ) , where each S i S_i S i is a slot containing exactly m m m jobs, and mark slots S 2 S_2 S 2 and S 5 S_5 S 5 . In Figure 2 , these marks are denoted by Z 1 = S 2 Z_1 = S_2 Z 1 = S 2 and Z 2 = S 5 Z_2 = S_5 Z 2 = S 5 . The three gaps are then A 0 = S 1 A_0 = S_1 A 0 = S 1 , A 1 = S 3 ∪ S 4 A_1 = S_3 \cup S_4 A 1 = S 3 ∪ S 4 , and A 2 = S 6 A_2 = S_6 A 2 = S 6 . Thus, a gap may contain several consecutive slots. The prefixes strictly before the marks are L 1 = S 1 L_1 = S_1 L 1 = S 1 and L 2 = S 1 ∪ S 2 ∪ S 3 ∪ S 4 L_2 = S_1 \cup S_2 \cup S_3 \cup S_4 L 2 = S 1 ∪ S 2 ∪ S 3 ∪ S 4 , so the transition between the corresponding states queries precisely L 2 ∖ ( L 1 ∪ Z 1 ) = S 3 ∪ S 4 = A 1 L_2 \setminus(L_1 \cup Z_1) = S_3 \cup S_4 = A_1 L 2 ∖ ( L 1 ∪ Z 1 ) = S 3 ∪ S 4 = A 1 . The complete schedule is reconstructed by concatenating the stored schedule of A 0 A_0 A 0 , the marked slot S 2 S_2 S 2 , the stored schedule of A 1 A_1 A 1 , the marked slot S 5 S_5 S 5 , and the stored schedule of A 2 A_2 A 2 . The preceding three-slot example is the special case with empty initial and final gaps: its first and third slots are marked, and its middle slot is the intervening gap. Consequently, the set called Z 2 Z_2 Z 2 in that example plays the role of A 1 A_1 A 1 , while its Z 3 Z_3 Z 3 plays the role of the second mark labeled Z 2 Z_2 Z 2 in Figure 2 .
Figure 2. In general, the queried edge gap is A 1 = L 2 ∖ ( L 1 ∪ Z 1 ) A_1 = L_2 \setminus(L_1 \cup Z_1) A 1 = L 2 ∖ ( L 1 ∪ Z 1 ) . The current prefix can grow through several marks. A table entry is required for each gap, not for every intermediate prefix.
Correctness
There are two reasons the algorithm is correct. First, every accepted table row stores a valid schedule; this property holds for every finite choice of node and cut families. Second, the bounded-description theorem ensures that the generated families contain enough sets and cuts to accept a feasible instance.
Discrete schedules, padding, and exact family generation
Lemma 5.1 (Why integral slots suffice). Every feasible nonpreemptive unit-job schedule with nonnegative real start times can be replaced by a slot schedule of no larger makespan.
Proof. Add an arc from every job to the next job on its assigned machine. Along every original or added arc, the old start time increases by at least one, so the augmented graph is acyclic. Process it topologically, starting each job at the maximum of zero and the completion times of its augmented predecessors. Induction gives integer start times no later than their old values. The added arcs prevent overlap on a machine, and the original arcs preserve precedence. Number the slots by start time plus one.
Lemma 5.2 (Padding a deadline). For n > 0 n > 0 n > 0 , a deadline below ⌈ n / m ⌉ \lceil n/m \rceil ⌈ n / m ⌉ is infeasible, and a deadline at least n n n is feasible. For a remaining deadline T T T , add m T − n mT - n m T − n isolated jobs. If J J J is the resulting job set and N = ∣ J ∣ = m T N = |J| = mT N = ∣ J ∣ = m T , the original instance is feasible by T T T if and only if J J J can be scheduled in T T T slots containing exactly m m m jobs each. Moreover, N ≤ m n N \le mn N ≤ mn .
Proof. There are m T mT m T positions in T T T slots. Fill the m T − n mT - n m T − n unused positions of any original schedule with the isolated jobs. Conversely, deleting those jobs from a padded schedule preserves capacity and precedence. Capacity proves the lower bound on T T T , and a serial topological schedule proves the upper bound. The empty original instance has optimum zero and is handled directly.
Lemma 5.3 (Exactness of the generation procedure). After layer k k k , the stored list F k \mathcal{F}_k F k contains exactly F k \mathcal{F}_k F k . In particular, each F k \mathcal{F}_k F k is closed under complement relative to J J J , although it need not be closed under arbitrary union or intersection within the same layer.
Proof. De Morgan’s laws and cancellation of double complements turn every formula into one with complements only on atoms, without increasing its leaf count. Hence a one-leaf formula is a signed atom, giving the claim for k = 1 k = 1 k = 1 .
Assume the claim for smaller layers. Every copied set uses at most k − 1 k - 1 k − 1 leaves. Every newly inserted set combines a formula with at most i i i leaves and one with at most k − i k - i k − i leaves, so it uses at most k k k . This proves that no extra set is inserted.
Conversely, consider a normalized formula with at most k k k leaves. A signed atom is already in F 1 \mathcal{F}_1 F 1 . Otherwise its root is union or intersection. If its left subtree has i i i leaves, then 1 ≤ i < k 1 \le i < k 1 ≤ i < k and its right subtree has at most k − i k - i k − i leaves. By induction their sets occur in F i \mathcal{F}_i F i and F k − i \mathcal{F}_{k-i} F k − i ; the appropriate operation inserts the resulting set. Every formula is therefore covered. Complementing a formula preserves its leaf count, so exactness also proves complement closure of F k \mathcal{F}_k F k . The trie suppresses only repeated copies of exactly the same incidence vector, so duplicate detection changes none of these set memberships.
Progress, reachability, and soundness
Purpose of the progress bound. The evaluator processes candidate sets in increasing order of their cardinality. To justify this order, we must show that every call to Lookup or Fetch made while processing a nonempty set W W W concerns a strictly smaller set. We must also show that state transitions make strict progress, so that a path cannot return to a state with the same or a smaller prefix. Both facts follow from the presence of a marked slot containing exactly m m m jobs.
Lemma 5.4 (All queries are proper and all state edges progress). While processing a nonempty candidate W W W , every set passed to Lookup or Fetch has cardinality at most ∣ W ∣ − m |W|-m ∣ W ∣ − m . Moreover, every state edge i ⟶ j i\longrightarrow j i ⟶ j satisfies
∣ L j ∣ ≥ ∣ L i ∣ + m . |L_j| \ge|L_i|+m. ∣ L j ∣ ≥ ∣ L i ∣ + m .
Proof. Rows whose cardinalities are not divisible by m m m are skipped and make no such calls. Consider a row W W W for which the evaluator constructs the state list. Every state record i i i is a disjoint partition
W = L i ∪ ˙ Z i ∪ ˙ R i , ∣ Z i ∣ = m . W=L_i\mathbin{\dot\cup} Z_i\mathbin{\dot\cup} R_i,\qquad|Z_i|=m. W = L i ∪ ˙ Z i ∪ ˙ R i , ∣ Z i ∣ = m .
We examine all types of queries.
The initial-state test queries L i L_i L i , and the final-state test queries R i R_i R i . Both sets are contained in W ∖ Z i W\setminus Z_i W ∖ Z i . Consequently,
∣ L i ∣ ≤ ∣ W ∣ − m , ∣ R i ∣ ≤ ∣ W ∣ − m . |L_i|\le|W|-m,\qquad|R_i|\le|W|-m. ∣ L i ∣ ≤ ∣ W ∣ − m , ∣ R i ∣ ≤ ∣ W ∣ − m .
For a proposed transition from i i i to j j j , the queried gap is G i j : = L j ∖ ( L i ∪ Z i ) G_{ij}:=L_j\setminus(L_i\cup Z_i) G ij := L j ∖ ( L i ∪ Z i ) . Since L j ⊆ W L_j\subseteq W L j ⊆ W and this difference excludes every job of Z i Z_i Z i , we have G i j ⊆ W ∖ Z i G_{ij}\subseteq W\setminus Z_i G ij ⊆ W ∖ Z i . Thus ∣ G i j ∣ ≤ ∣ W ∣ − m |G_{ij}|\le|W|-m ∣ G ij ∣ ≤ ∣ W ∣ − m . This bound holds whenever the gap is queried, irrespective of the answer returned by Lookup.
Reconstruction fetches only an initial prefix, the gaps on the selected path, and a final suffix. These are precisely the types of sets just considered, so the same bound applies to every call to Fetch.
Finally, an actual state edge i ⟶ j i\longrightarrow j i ⟶ j satisfies L i ∪ Z i ⊆ L j L_i\cup Z_i\subseteq L_j L i ∪ Z i ⊆ L j . As L i L_i L i and Z i Z_i Z i are disjoint,
∣ L j ∣ ≥ ∣ L i ∪ Z i ∣ = ∣ L i ∣ + ∣ Z i ∣ = ∣ L i ∣ + m . |L_j|\ge|L_i\cup Z_i|=|L_i|+|Z_i|=|L_i|+m. ∣ L j ∣ ≥ ∣ L i ∪ Z i ∣ = ∣ L i ∣ + ∣ Z i ∣ = ∣ L i ∣ + m .
This proves both assertions.
Consequences for evaluation and reconstruction. Every queried set that belongs to the family has an earlier table row, since its cardinality is strictly smaller than ∣ W ∣ |W| ∣ W ∣ ; the empty row is already accepted at initialization. A lookup for a missing row returns zero. Hence all lookup answers used to define the state graph remain fixed while W W W is processed.
The prefix-size inequality also makes the state graph acyclic. Following a predecessor pointer backward decreases prefix size by at least m m m . More generally, a path with r r r state records satisfies
( r − 1 ) m ≤ ∣ L l a s t ∣ − ∣ L f i r s t ∣ ≤ ∣ W ∣ − m , (r-1)m\le|L_{\mathrm{last}}|-|L_{\mathrm{first}}|\le|W|-m, ( r − 1 ) m ≤ ∣ L last ∣ − ∣ L first ∣ ≤ ∣ W ∣ − m ,
and therefore r ≤ ∣ W ∣ / m r\le|W|/m r ≤ ∣ W ∣/ m .
The cuts enumerated by Algorithm 3 are not the queried subproblems in this lemma. A cut C ∈ F c u t C\in\mathcal{F}_{\mathrm{cut}} C ∈ F cut is used through its incidence vector to form L = W ∩ C L=W\cap C L = W ∩ C . Its own cardinality may be as large as ∣ J ∣ |J| ∣ J ∣ . No acceptance value for the cut is consulted. The proper-query bound applies to the arguments of Lookup and Fetch.
Why one pass is sufficient. The family trie identifies an exact candidate row, and Lookup returns its stored bit a ( X ) a(X) a ( X ) , which may be zero. Step 4 processes sources in increasing order of ∣ L i ∣ |L_i| ∣ L i ∣ and reads a source’s current reachability bit when its bucket is visited. Every edge satisfies ∣ L j ∣ ≥ ∣ L i ∣ + m |L_j|\ge|L_i|+m ∣ L j ∣ ≥ ∣ L i ∣ + m , so every newly reached target belongs to a later bucket. Consequently, a source cannot become reachable after its bucket has been passed, and one pass suffices.
Lemma 5.5 (The pass computes exactly the reachable states). At the end of Step 4 of Algorithm 4, a record is marked exactly when it is reachable from an initial record by edges (2) . Its predecessor fields describe such a path.
Proof. All queried table rows are smaller than W W W and stay fixed while W W W is processed, so the edge relation is fixed during Step 4. Initially only initial records are marked. Every later marking uses a marked source and a valid edge, so induction on marking events proves the forward implication and validates the stored predecessor.
For the converse, induct on the prefix-cardinality buckets processed in Step 4. Every initial record is marked before any bucket is processed. If a reachable record j j j is not initial, choose a path to it and let i i i be its predecessor on that path. By Lemma 5.4 , ∣ L i ∣ < ∣ L j ∣ |L_i| < |L_j| ∣ L i ∣ < ∣ L j ∣ , so the bucket of i i i was processed earlier. The induction hypothesis says that i i i was already marked when it was processed. Its scan of all target indices therefore marked j j j , unless j j j had already been marked. Thus every reachable record is marked before its own bucket is processed.
There are no edges within one bucket. Equal prefix sizes and duplicate state triples therefore cause no difficulty. Predecessor pointers cannot cycle, since their edges strictly increase prefix size by Lemma 5.4 .
Theorem 5.6 (Soundness for every explicit family). Every row assigned value one by Algorithm 4 stores a feasible full schedule of its set. This holds for every family F \mathcal{F} F containing ∅ \varnothing ∅ and J J J , and every finite cut family F c u t ⊆ 2 J \mathcal{F}_{\mathrm{cut}} \subseteq2^J F cut ⊆ 2 J .
Proof. Induct on the cardinality of processed sets. The empty row is correct. By Lemma 5.4 , every successful nonempty query while processing W W W is to an earlier row, whose stored schedule is feasible by the induction hypothesis.
An initial record has a stored schedule of L i L_i L i . Suppose a reached record i i i certifies a full schedule of L i L_i L i and leads to record j j j . Let G = L j ∖ ( L i ∪ Z i ) G = L_j \setminus(L_i \cup Z_i) G = L j ∖ ( L i ∪ Z i ) . The edge test supplies a full schedule of G G G . Since L i L_i L i is an ideal of W W W , no job of Z i Z_i Z i precedes a job of L i L_i L i . Since L i ∪ Z i L_i \cup Z_i L i ∪ Z i is an ideal, no job of G G G precedes a job of L i ∪ Z i L_i \cup Z_i L i ∪ Z i . Thus the prefix schedule, the single antichain slot Z i Z_i Z i , and the schedule of G G G concatenate to a feasible full schedule of L j L_j L j .
At a reached final record t t t , the same ideal conditions permit appending Z t Z_t Z t and the accepted schedule of R t R_t R t . The result is a full schedule of W W W . Lemma 5.5 supplies precisely the path followed by Algorithm 5, so the schedule actually stored by the algorithm is the one justified by this argument.
Why every feasible root is accepted
The global job set and a local hierarchy node. Throughout this subsection, J J J denotes the fixed padded job set, and F ⊆ 2 J \mathcal{F} \subseteq2^J F ⊆ 2 J is a finite family containing ∅ \varnothing ∅ and J J J . The cut family F c u t ⊆ 2 J \mathcal{F}_{\mathrm{cut}} \subseteq2^J F cut ⊆ 2 J may be chosen independently. Every subset inherits the restriction of the global transitive precedence relation. The symbol W W W denotes the job set of the node currently under consideration. At the root, W = J W = J W = J ; at a proper descendant, W W W is a nonempty subset of its parent’s job set. The global universe remains J J J throughout.
A hierarchy describes how to assemble schedules of larger sets from schedules of smaller sets and selected full slots. The algorithm processes every candidate in F \mathcal{F} F . The completeness proof singles out the candidate sets that occur in one suitable hierarchy.
Definition 5.7 (A hierarchy described by two families). A hierarchy for a feasible full instance on J J J is a finite rooted tree whose nodes are labelled by job sets, with root J J J . At each nonempty node W W W , choose a feasible full schedule S W = ( S 1 , … , S q ) S_W = (S_1,\ldots,S_q) S W = ( S 1 , … , S q ) , q = ∣ W ∣ m q = \frac{|W|}{m} q = m ∣ W ∣ , and choose marked positions 1 ≤ t 1 < ⋯ < t k ≤ q 1 \le t_1 < \cdots< t_k \le q 1 ≤ t 1 < ⋯ < t k ≤ q , 1 ≤ k ≤ q 1 \le k \le q 1 ≤ k ≤ q . The corresponding marked slots are Z i : = S t i Z_i := S_{t_i} Z i := S t i .
Set t 0 : = 0 t_0 := 0 t 0 := 0 and t k + 1 : = q + 1 t_{k+1} := q+1 t k + 1 := q + 1 . For i = 0 , … , k i=0,\ldots,k i = 0 , … , k , define the open gap
A i : = ⋃ t i < t < t i + 1 S t A_i := \bigcup_{t_i < t < t_{i+1}} S_t A i := t i < t < t i + 1 ⋃ S t
where an empty union is ∅ \varnothing ∅ . The schedule is thus divided into the ordered pieces
A 0 , Z 1 , A 1 , Z 2 , … , Z k , A k . A_0,\ Z_1,\ A_1,\ Z_2,\ \ldots,\ Z_k,\ A_k. A 0 , Z 1 , A 1 , Z 2 , … , Z k , A k .
Here a gap denotes the set of jobs in the indicated block of consecutive slots. The children of W W W are exactly its nonempty gap sets A i A_i A i , one child for each such gap. The same construction is made at every nonempty child. An empty root has no children.
The hierarchy is described by ( F , F c u t ) (\mathcal{F},\mathcal{F}_{\mathrm{cut}}) ( F , F cut ) if every node set belongs to F \mathcal{F} F and, at every nonempty node W W W , the prefix L i : = ⋃ t < t i S t L_i := \bigcup_{t<t_i} S_t L i := ⋃ t < t i S t before each marked slot Z i Z_i Z i satisfies L i = W ∩ C i L_i = W \cap C_i L i = W ∩ C i for some global cut C i ∈ F c u t C_i \in\mathcal{F}_{\mathrm{cut}} C i ∈ F cut .
Open gaps, marked slots, and the number of children. For 1 ≤ i < k 1 \le i < k 1 ≤ i < k , the gap A i A_i A i contains exactly the jobs scheduled strictly between Z i Z_i Z i and Z i + 1 Z_{i+1} Z i + 1 . The boundary marked slots are excluded. The set A 0 A_0 A 0 contains the jobs before the first mark, and A k A_k A k contains those after the last mark. These gaps are blocks of occupied slots; the word gap refers to their position between marks. A gap can contain several full slots, or can be empty.
All pieces are disjoint, every ∣ A i ∣ |A_i| ∣ A i ∣ is divisible by m m m , and ∣ W ∣ = m k + ∑ i = 0 k ∣ A i ∣ |W| = mk + \sum_{i=0}^{k} |A_i| ∣ W ∣ = mk + ∑ i = 0 k ∣ A i ∣ . Consequently, every child satisfies
∣ A i ∣ ≤ ∣ W ∣ − m k ≤ ∣ W ∣ − m < ∣ W ∣ . |A_i| \le|W| - mk \le|W| - m < |W|. ∣ A i ∣ ≤ ∣ W ∣ − mk ≤ ∣ W ∣ − m < ∣ W ∣.
This strict decrease permits induction on node size.
The integer k = k ( W ) k = k(W) k = k ( W ) counts marked slots at this particular node. It may vary between nodes and need not be bounded by m m m . There are k + 1 k + 1 k + 1 gaps and at most k + 1 k + 1 k + 1 children. A node with all its slots marked has only empty gaps and is a leaf, even if it contains more than one slot.
Each node has its own witness schedule and its own local slot indices. A child may choose any feasible full schedule of its job set; it need not use the order induced by its parent’s witness.
The states associated with the marked slots. At a fixed node W W W , let R i : = W ∖ ( L i ∪ Z i ) R_i := W \setminus(L_i \cup Z_i) R i := W ∖ ( L i ∪ Z i ) . The triple ( L i , Z i , R i ) (L_i, Z_i, R_i) ( L i , Z i , R i ) consists of all jobs before the mark, the marked slot itself, and all jobs after the mark. In terms of the gap decomposition,
L i = ( ⋃ j = 0 i − 1 A j ) ∪ ( ⋃ j = 1 i − 1 Z j ) , L_i = \left(\bigcup_{j=0}^{i-1} A_j\right) \cup\left(\bigcup_{j=1}^{i-1} Z_j\right), L i = ( j = 0 ⋃ i − 1 A j ) ∪ ( j = 1 ⋃ i − 1 Z j ) ,
R i = ( ⋃ j = i k A j ) ∪ ( ⋃ j = i + 1 k Z j ) . R_i = \left(\bigcup_{j=i}^{k} A_j\right) \cup\left(\bigcup_{j=i+1}^{k} Z_j\right). R i = ( j = i ⋃ k A j ) ∪ ( j = i + 1 ⋃ k Z j ) .
All unions in these formulas are disjoint. In particular, L 1 = A 0 L_1 = A_0 L 1 = A 0 , R k = A k R_k = A_k R k = A k , and, for 1 ≤ i < k 1 \le i < k 1 ≤ i < k , L i + 1 = L i ∪ ˙ Z i ∪ ˙ A i L_{i+1} = L_i \mathbin{\dot\cup} Z_i \mathbin{\dot\cup} A_i L i + 1 = L i ∪ ˙ Z i ∪ ˙ A i , A i = L i + 1 ∖ ( L i ∪ Z i ) A_i = L_{i+1} \setminus(L_i \cup Z_i) A i = L i + 1 ∖ ( L i ∪ Z i ) . Thus the k k k selected marked slots will give k k k state records and k − 1 k - 1 k − 1 connecting edges in the completeness proof. Their record indices in the algorithm need not be 1 , … , k 1,\ldots,k 1 , … , k .
Global cuts and local prefixes. Every C i C_i C i is a subset of the fixed universe J J J . At the root, W = J W = J W = J , so L i = J ∩ C i = C i L_i = J \cap C_i = C_i L i = J ∩ C i = C i . At a smaller node, the cut may contain jobs outside W W W ; only its intersection with W W W determines the local prefix. For a fixed L ⊆ W L \subseteq W L ⊆ W , the sets satisfying W ∩ C = L W \cap C = L W ∩ C = L are precisely C = L ∪ U C = L \cup U C = L ∪ U , U ⊆ J ∖ W U \subseteq J \setminus W U ⊆ J ∖ W . The description requirement asks that at least one such set belong to F c u t \mathcal{F}_{\mathrm{cut}} F cut . Cuts need not be unique or be ideals of J J J . The local prefix is an ideal of W W W , because it is a temporal prefix of a feasible schedule.
Example: three chains and seven full slots. Let m = 3 m=3 m = 3 , and consider three independent precedence chains
a 1 ≺ a 2 ≺ ⋯ ≺ a 7 , a_1 \prec a_2 \prec\cdots\prec a_7, a 1 ≺ a 2 ≺ ⋯ ≺ a 7 ,
b 1 ≺ b 2 ≺ ⋯ ≺ b 7 , b_1 \prec b_2 \prec\cdots\prec b_7, b 1 ≺ b 2 ≺ ⋯ ≺ b 7 ,
c 1 ≺ c 2 ≺ ⋯ ≺ c 7 . c_1 \prec c_2 \prec\cdots\prec c_7. c 1 ≺ c 2 ≺ ⋯ ≺ c 7 .
There are no precedence relations between distinct chains. Put
B t : = { a t , b t , c t } ( 1 ≤ t ≤ 7 ) , J = ⋃ t = 1 7 B t . B_t := \{a_t,b_t,c_t\}\quad(1\le t\le7),\qquad J=\bigcup_{t=1}^{7}B_t. B t := { a t , b t , c t } ( 1 ≤ t ≤ 7 ) , J = t = 1 ⋃ 7 B t .
The blocks B t B_t B t are pairwise disjoint antichains of size three, and ( B 1 , B 2 , B 3 , B 4 , B 5 , B 6 , B 7 ) (B_1,B_2,B_3,B_4,B_5,B_6,B_7) ( B 1 , B 2 , B 3 , B 4 , B 5 , B 6 , B 7 ) is a feasible full schedule of the 21 jobs. No dummy jobs are needed.
At the root W = J W=J W = J , choose the second and sixth slots as marks: k = 2 k=2 k = 2 , Z 1 = B 2 Z_1=B_2 Z 1 = B 2 , Z 2 = B 6 Z_2=B_6 Z 2 = B 6 . The resulting decomposition is
B 1 ⏟ A 0 , B 2 ⏟ Z 1 , B 3 , B 4 , B 5 ⏟ A 1 , B 6 ⏟ Z 2 , B 7 ⏟ A 2 . \underbrace{B_1}_{A_0},\ \underbrace{B_2}_{Z_1},\ \underbrace{B_3,B_4,B_5}_{A_1},\ \underbrace{B_6}_{Z_2},\ \underbrace{B_7}_{A_2}. A 0 B 1 , Z 1 B 2 , A 1 B 3 , B 4 , B 5 , Z 2 B 6 , A 2 B 7 .
Thus A 0 = B 1 A_0=B_1 A 0 = B 1 , A 1 = B 3 ∪ B 4 ∪ B 5 A_1=B_3\cup B_4\cup B_5 A 1 = B 3 ∪ B 4 ∪ B 5 , A 2 = B 7 A_2=B_7 A 2 = B 7 .
The middle gap contains nine jobs in three full slots. The two associated states are
( L 1 , Z 1 , R 1 ) = ( B 1 , B 2 , ⋃ t = 3 7 B t ) , (L_1,Z_1,R_1)=\left(B_1,B_2,\bigcup_{t=3}^{7}B_t\right), ( L 1 , Z 1 , R 1 ) = ( B 1 , B 2 , t = 3 ⋃ 7 B t ) ,
( L 2 , Z 2 , R 2 ) = ( ⋃ t = 1 5 B t , B 6 , B 7 ) . (L_2,Z_2,R_2)=\left(\bigcup_{t=1}^{5}B_t,B_6,B_7\right). ( L 2 , Z 2 , R 2 ) = ( t = 1 ⋃ 5 B t , B 6 , B 7 ) .
Their connecting gap is exactly
L 2 ∖ ( L 1 ∪ Z 1 ) = B 3 ∪ B 4 ∪ B 5 = A 1 . L_2\setminus(L_1\cup Z_1)=B_3\cup B_4\cup B_5=A_1. L 2 ∖ ( L 1 ∪ Z 1 ) = B 3 ∪ B 4 ∪ B 5 = A 1 .
Example continued: a gap becomes a child. The root has the three children B 1 B_1 B 1 , A 1 A_1 A 1 , and B 7 B_7 B 7 . Write W ∗ : = A 1 = B 3 ∪ B 4 ∪ B 5 W_*:=A_1=B_3\cup B_4\cup B_5 W ∗ := A 1 = B 3 ∪ B 4 ∪ B 5 for its middle child. The global set remains J J J , while the current node now contains only nine jobs. Give this child the local schedule ( S 1 ′ , S 2 ′ , S 3 ′ ) = ( B 3 , B 4 , B 5 ) (S'_1,S'_2,S'_3)=(B_3,B_4,B_5) ( S 1 ′ , S 2 ′ , S 3 ′ ) = ( B 3 , B 4 , B 5 ) . Mark its second local slot, so that k ′ = 1 k'=1 k ′ = 1 , t 1 ′ = 2 t'_1=2 t 1 ′ = 2 , Z 1 ′ = B 4 Z'_1=B_4 Z 1 ′ = B 4 . Its decomposition and associated state are A 0 ′ = B 3 A'_0=B_3 A 0 ′ = B 3 , Z 1 ′ = B 4 Z'_1=B_4 Z 1 ′ = B 4 , A 1 ′ = B 5 A'_1=B_5 A 1 ′ = B 5 , ( L 1 ′ , Z 1 ′ , R 1 ′ ) = ( B 3 , B 4 , B 5 ) (L'_1,Z'_1,R'_1)=(B_3,B_4,B_5) ( L 1 ′ , Z 1 ′ , R 1 ′ ) = ( B 3 , B 4 , B 5 ) . The children of W ∗ W_* W ∗ are therefore B 3 B_3 B 3 and B 5 B_5 B 5 .
At each of the four leaves B t B_t B t , t ∈ { 1 , 3 , 5 , 7 } t\in\{1,3,5,7\} t ∈ { 1 , 3 , 5 , 7 } , mark its only slot. This gives the state ( ∅ , B t , ∅ ) (\varnothing,B_t,\varnothing) ( ∅ , B t , ∅ ) and no nonempty child. The hierarchy can be recorded as follows.
Table 2.
The marked slots B 2 , B 6 B_2,B_6 B 2 , B 6 are handled at the root, and B 4 B_4 B 4 is handled at W ∗ W_* W ∗ . Only the nonempty gaps become children.
Example continued: global cuts for these local states. Recall that
P B = { x ∈ J : x ≺ y for some y ∈ B } , D B = { x ∈ J : y ≺ x for some y ∈ B } . P_B=\{x\in J:x\prec y\text{ for some }y\in B\},\qquad D_B=\{x\in J:y\prec x\text{ for some }y\in B\}. P B = { x ∈ J : x ≺ y for some y ∈ B } , D B = { x ∈ J : y ≺ x for some y ∈ B } .
For the root states, take C 1 = P B 2 = B 1 C_1 = P_{B_2} = B_1 C 1 = P B 2 = B 1 , C 2 = P B 6 = ⋃ t = 1 5 B t C_2 = P_{B_6} = \bigcup_{t=1}^{5} B_t C 2 = P B 6 = ⋃ t = 1 5 B t . Since W = J W = J W = J at the root, these cuts are exactly L 1 L_1 L 1 and L 2 L_2 L 2 .
For the child W ∗ W_\ast W ∗ , choose C 1 ′ = P B 4 = B 1 ∪ B 2 ∪ B 3 C'_1 = P_{B_4} = B_1 \cup B_2 \cup B_3 C 1 ′ = P B 4 = B 1 ∪ B 2 ∪ B 3 . This is a global set of nine jobs, whereas the desired local prefix has only three jobs:
W ∗ ∩ C 1 ′ = ( B 3 ∪ B 4 ∪ B 5 ) ∩ ( B 1 ∪ B 2 ∪ B 3 ) = B 3 = L 1 ′ . W_\ast\cap C'_1 = (B_3 \cup B_4 \cup B_5) \cap(B_1 \cup B_2 \cup B_3) = B_3 = L'_1. W ∗ ∩ C 1 ′ = ( B 3 ∪ B 4 ∪ B 5 ) ∩ ( B 1 ∪ B 2 ∪ B 3 ) = B 3 = L 1 ′ .
The jobs in B 1 ∪ B 2 B_1 \cup B_2 B 1 ∪ B 2 lie outside the current node and disappear under intersection. The set B 3 B_3 B 3 is an ideal of W ∗ W_\ast W ∗ , but not of J J J : for example, a 2 ≺ a 3 a_2 \prec a_3 a 2 ≺ a 3 , while a 2 ∉ B 3 a_2 \notin B_3 a 2 ∈ / B 3 .
The alternative cut B 3 ∪ B 7 B_3 \cup B_7 B 3 ∪ B 7 has the same intersection with W ∗ W_\ast W ∗ . This also illustrates that a global cut need not be a temporal prefix of the displayed global schedule. At a leaf, the cut ∅ \varnothing ∅ gives the empty local prefix.
All node sets belong to F = F 17 \mathcal{F} = \mathcal{F}_{17} F = F 17 , and all displayed cuts belong to F c u t = F 6 \mathcal{F}_{\mathrm{cut}} = \mathcal{F}_6 F cut = F 6 , since 4 m + 5 = 17 4m + 5 = 17 4 m + 5 = 17 and m + 3 = 6 m + 3 = 6 m + 3 = 6 for m = 3 m = 3 m = 3 . The sets J J J , ∅ \varnothing ∅ , B t B_t B t , P B t P_{B_t} P B t , D B t D_{B_t} D B t are atoms, and W ∗ = D B 2 ∩ P B 6 W_\ast= D_{B_2} \cap P_{B_6} W ∗ = D B 2 ∩ P B 6 is an exact global description using two atomic occurrences. Indeed, D B 2 = ⋃ t = 3 5 B t D_{B_2} = \bigcup_{t=3}^{5} B_t D B 2 = ⋃ t = 3 5 B t and P B 6 = ⋃ t = 1 5 B t P_{B_6} = \bigcup_{t=1}^{5} B_t P B 6 = ⋃ t = 1 5 B t . The alternative cut B 3 ∪ B 7 B_3 \cup B_7 B 3 ∪ B 7 also uses two atomic occurrences. Hence this is a hierarchy described by ( F 17 , F 6 ) (\mathcal{F}_{17}, \mathcal{F}_6) ( F 17 , F 6 ) .
Notice that ∣ C 1 ′ ∣ = ∣ W ∗ ∣ = 9 |C'_1| = |W_\ast| = 9 ∣ C 1 ′ ∣ = ∣ W ∗ ∣ = 9 . This creates no dependency on a same-size table value: Algorithm 3 uses the incidence vector of C 1 ′ C'_1 C 1 ′ to construct a state, without querying whether C 1 ′ C'_1 C 1 ′ has been accepted.
Theorem 5.8 (A hierarchy with bounded global descriptions). Let m ≥ 3 m \ge3 m ≥ 3 . Every feasible full instance has a hierarchy in the sense of Definition 5.7 such that every node set is represented exactly, on the entire ground set J J J , by a Boolean formula with at most 4 m + 5 4m + 5 4 m + 5 atomic occurrences. For each marked slot, its prefix in its node W W W is W ∩ C W \cap C W ∩ C , where C C C has a global Boolean description with at most m + 3 m + 3 m + 3 atomic occurrences. The atoms are the boundary sets, global predecessor and successor cones, weak cones, rank suffixes, and constants already used by GenerateFamily. Every nonempty node has at least one marked full slot, and every child has at most ∣ W ∣ − m |W| - m ∣ W ∣ − m jobs.
Proof idea and purpose. A described hierarchy supplies a suitable sequence of marked slots at every node. We show that this sequence gives an accepting path in the algorithm’s state graph. The proof proceeds by induction on node size. Each gap is empty or is a smaller hierarchy node, so its table entry has already been accepted. These entries certify the initial prefix, the connecting gaps, and the final suffix. Theorem 5.8 establishes the existence of the required hierarchy for the two families used by the algorithm; the following theorem explains how that hierarchy implies acceptance.
Theorem 5.9 (Completeness from a described hierarchy). Let F ⊆ 2 J \mathcal{F} \subseteq2^J F ⊆ 2 J be a finite family containing ∅ \varnothing ∅ and J J J , and let F c u t ⊆ 2 J \mathcal{F}_{\mathrm{cut}} \subseteq2^J F cut ⊆ 2 J be a finite cut family. If the full instance on J J J has a hierarchy described by ( F , F c u t ) (\mathcal{F}, \mathcal{F}_{\mathrm{cut}}) ( F , F cut ) in the sense of Definition 5.7, then Algorithm 4 accepts every node set of the hierarchy. In particular, it accepts the root J J J .
Proof. We prove by strong induction on ∣ W ∣ |W| ∣ W ∣ that the row of every hierarchy node W W W has value a ( W ) = 1 a(W) = 1 a ( W ) = 1 after it is processed. The empty row is accepted at initialization, with its empty schedule; this also settles an empty root.
Let W W W be a nonempty hierarchy node, and assume the claim for all smaller hierarchy nodes. Since the hierarchy is described by ( F , F c u t ) (\mathcal{F}, \mathcal{F}_{\mathrm{cut}}) ( F , F cut ) , its node set W W W belongs to F \mathcal{F} F . Its witness schedule is full, so m m m divides ∣ W ∣ |W| ∣ W ∣ , and Algorithm 4 does not skip this row.
Use the witness schedule at this node to obtain the ordered decomposition
A 0 , Z 1 , A 1 , Z 2 , … , Z k , A k , k ≥ 1. A_0, Z_1, A_1, Z_2, \ldots, Z_k, A_k, \qquad k \ge1. A 0 , Z 1 , A 1 , Z 2 , … , Z k , A k , k ≥ 1.
Every nonempty A i A_i A i is a child of W W W , belongs to F \mathcal{F} F , and satisfies
∣ A i ∣ ≤ ∣ W ∣ − m k ≤ ∣ W ∣ − m < ∣ W ∣ . |A_i| \le|W| - mk \le|W| - m < |W|. ∣ A i ∣ ≤ ∣ W ∣ − mk ≤ ∣ W ∣ − m < ∣ W ∣.
Its row has therefore already been processed and accepted by the induction hypothesis. Empty gaps have the initialized empty row. It follows that Lookup ( A i ) = 1 \operatorname{Lookup}(A_i)=1 Lookup ( A i ) = 1 (i = 0 , … , k i=0,\ldots,k i = 0 , … , k ). These values stay fixed during the processing of W W W .
For each i = 1 , … , k i=1,\ldots,k i = 1 , … , k , let L i L_i L i be the prefix before Z i Z_i Z i and put R i = W ∖ ( L i ∪ Z i ) R_i=W\setminus(L_i\cup Z_i) R i = W ∖ ( L i ∪ Z i ) . The description hypothesis provides a cut C i ∈ F c u t C_i\in\mathcal{F}_{\mathrm{cut}} C i ∈ F cut such that L i = W ∩ C i L_i=W\cap C_i L i = W ∩ C i . We verify that Algorithm 3 enumerates the triple ( L i , Z i , R i ) (L_i,Z_i,R_i) ( L i , Z i , R i ) .
First, the three sets partition W W W , the marked slot has size ∣ Z i ∣ = m |Z_i|=m ∣ Z i ∣ = m , and both ∣ L i ∣ |L_i| ∣ L i ∣ and ∣ R i ∣ |R_i| ∣ R i ∣ are divisible by m m m . These assertions follow because the partition boundaries occur between complete slots of the witness schedule. The set Z i Z_i Z i is an antichain, since it is one feasible slot. Second, L i L_i L i and L i ∪ Z i L_i\cup Z_i L i ∪ Z i are ideals of W W W . To see this, let U U U be either of these temporal prefixes. If y ∈ U y\in U y ∈ U , x ∈ W x\in W x ∈ W , and x ≺ y x\prec y x ≺ y , feasibility places x x x in a strictly earlier slot than y y y . Hence x ∈ U x\in U x ∈ U . Thus both ideal tests succeed.
Algorithm 3 considers the cut C i C_i C i , obtains L i L_i L i , and enumerates the m m m -set Z i Z_i Z i . All its tests succeed, so a record with the required triple occurs. Choose one such record and denote its actual index by r i r_i r i . Different cuts may produce duplicate records; any one record with the required triple is sufficient.
The first selected record is initial, because L 1 = A 0 L_1=A_0 L 1 = A 0 and Lookup ( A 0 ) = 1 \operatorname{Lookup}(A_0)=1 Lookup ( A 0 ) = 1 . For every i = 1 , … , k − 1 i=1,\ldots,k-1 i = 1 , … , k − 1 , the ordered decomposition gives L_{i+1}=L_i\mathbin{\mathaccent\cdot\cup}Z_i\mathbin{\mathaccent\cdot\cup}A_i . Consequently, L i ∪ Z i ⊆ L i + 1 L_i\cup Z_i\subseteq L_{i+1} L i ∪ Z i ⊆ L i + 1 , L i + 1 ∖ ( L i ∪ Z i ) = A i L_{i+1}\setminus(L_i\cup Z_i)=A_i L i + 1 ∖ ( L i ∪ Z i ) = A i . Since Lookup ( A i ) = 1 \operatorname{Lookup}(A_i)=1 Lookup ( A i ) = 1 , the edge test succeeds and the state graph contains r i ⟶ r i + 1 r_i\longrightarrow r_{i+1} r i ⟶ r i + 1 . Finally, R k = A k R_k=A_k R k = A k and Lookup ( A k ) = 1 \operatorname{Lookup}(A_k)=1 Lookup ( A k ) = 1 , so r k r_k r k is final.
Thus r 1 , … , r k r_1,\ldots,r_k r 1 , … , r k is a path from an initial record to a final record. If k = 1 k=1 k = 1 , the single record is both initial and final, and no edge is needed. Lemma 5.5 guarantees that the reachability procedure marks r k r_k r k . The final inspection in Algorithm 4 therefore finds a reached final record and sets a ( W ) = 1 a(W)=1 a ( W ) = 1 .
This completes the induction. Applying it to the root W = J W=J W = J proves the theorem. □ \square □
Witness schedules and stored schedules. The witness schedule at W W W identifies the sets in the decomposition and proves the required state conditions. The schedule stored for a gap A i A_i A i may be a different feasible full schedule of exactly that job set. It has the same length ∣ A i ∣ / m |A_i|/m ∣ A i ∣/ m . Substituting it within that gap preserves precedence inside the gap by its own feasibility, and preserves precedence between different pieces because their order agrees with the feasible witness schedule. Hence σ ( A 0 ) , Z 1 , σ ( A 1 ) , … , Z k , σ ( A k ) \sigma(A_0),Z_1,\sigma(A_1),\ldots,Z_k,\sigma(A_k) σ ( A 0 ) , Z 1 , σ ( A 1 ) , … , Z k , σ ( A k ) is a feasible full-schedule certificate.
The proof exhibits an accepting path. The deterministic evaluator may select another reached final record or other predecessor pointers; Theorem 5.6 guarantees the validity of the schedule reconstructed from its actual choices.
Acceptance in the seven-slot example. We now follow the induction for the hierarchy constructed after Definition 5.7. The relevant node sizes are three at the leaves, nine at the middle child W ∗ W_\ast W ∗ , and 21 at the root.
For each leaf B t B_t B t , t ∈ { 1 , 3 , 5 , 7 } t\in\{1,3,5,7\} t ∈ { 1 , 3 , 5 , 7 } , the cut ∅ \varnothing ∅ and marked slot B t B_t B t produce the state ( ∅ , B t , ∅ ) (\varnothing,B_t,\varnothing) ( ∅ , B t , ∅ ) . Both its prefix and suffix lookups return one, since Lookup ( ∅ ) = 1 \operatorname{Lookup}(\varnothing)=1 Lookup ( ∅ ) = 1 . The state is simultaneously initial and final, so the leaf is accepted with its one-slot schedule ( B t ) (B_t) ( B t ) .
At W ∗ = B 3 ∪ B 4 ∪ B 5 W_\ast=B_3\cup B_4\cup B_5 W ∗ = B 3 ∪ B 4 ∪ B 5 , the cut P B 4 P_{B_4} P B 4 produces the state ( B 3 , B 4 , B 5 ) (B_3,B_4,B_5) ( B 3 , B 4 , B 5 ) . The leaf rows B 3 B_3 B 3 and B 5 B_5 B 5 have already been accepted. This state is therefore both initial and final, proving that W ∗ W_\ast W ∗ is accepted. Its displayed certificate concatenates σ ( B 3 ) \sigma(B_3) σ ( B 3 ) , B 4 B_4 B 4 , σ ( B 5 ) = ( B 3 , B 4 , B 5 ) \sigma(B_5)=(B_3,B_4,B_5) σ ( B 5 ) = ( B 3 , B 4 , B 5 ) .
At the root, let r 1 , r 2 r_1,r_2 r 1 , r 2 be records with the two triples
( B 1 , B 2 , ⋃ t = 3 7 B t ) , ( ⋃ t = 1 5 B t , B 6 , B 7 ) . \left(B_1,B_2,\bigcup_{t=3}^{7}B_t\right),\qquad\left(\bigcup_{t=1}^{5}B_t,B_6,B_7\right). ( B 1 , B 2 , t = 3 ⋃ 7 B t ) , ( t = 1 ⋃ 5 B t , B 6 , B 7 ) .
The first record is initial because Lookup ( B 1 ) = 1 \operatorname{Lookup}(B_1)=1 Lookup ( B 1 ) = 1 . The edge from the first record to the second is present because L 1 ∪ Z 1 = B 1 ∪ B 2 ⊆ L 2 L_1\cup Z_1=B_1\cup B_2\subseteq L_2 L 1 ∪ Z 1 = B 1 ∪ B 2 ⊆ L 2 and Lookup ( L 2 ∖ ( L 1 ∪ Z 1 ) ) = Lookup ( W ∗ ) = 1 \operatorname{Lookup}(L_2\setminus(L_1\cup Z_1))=\operatorname{Lookup}(W^*)=1 Lookup ( L 2 ∖ ( L 1 ∪ Z 1 )) = Lookup ( W ∗ ) = 1 . The second record is final because Lookup ( B 7 ) = 1 \operatorname{Lookup}(B_7)=1 Lookup ( B 7 ) = 1 . Hence r 1 ⟶ r 2 r_1\longrightarrow r_2 r 1 ⟶ r 2 is an accepting path. The exhibited certificate concatenates σ ( B 1 ) \sigma(B_1) σ ( B 1 ) , B 2 B_2 B 2 , σ ( W ∗ ) \sigma(W^*) σ ( W ∗ ) , B 6 B_6 B 6 , σ ( B 7 ) \sigma(B_7) σ ( B 7 ) , which expands to the full schedule ( B 1 , B 2 , B 3 , B 4 , B 5 , B 6 , B 7 ) (B_1,B_2,B_3,B_4,B_5,B_6,B_7) ( B 1 , B 2 , B 3 , B 4 , B 5 , B 6 , B 7 ) .
The required lookup sets are the three root gaps B 1 , W ∗ , B 7 B_1,W^*,B_7 B 1 , W ∗ , B 7 , the two child gaps B 3 , B 5 B_3,B_5 B 3 , B 5 , and the empty gaps at the leaves. Each is strictly smaller than the parent at which it is queried, as guaranteed by Lemma 5.4 .
Remark 5.10 (Why no closure assumption is needed). Although L = W ∩ C L=W\cap C L = W ∩ C defines a state, the algorithm does not assume that L L L belongs to F \mathcal{F} F . Similarly, an edge difference need not belong to F \mathcal{F} F . An absent nonempty query returns zero. In the successful hierarchy, each nonempty queried gap has its own node description and therefore belongs to the family. The proof requires those specific memberships, not closure under arbitrary intersections or differences.
Lemma 5.11 (Reconstruction has no repeated recursive expansion). An accepting path for W W W contains at most ∣ W ∣ / m |W|/m ∣ W ∣/ m marks. Its marked slots and fetched gaps form an ordered disjoint partition of W W W . Algorithm 5 copies exactly ∣ W ∣ |W| ∣ W ∣ job occurrences into the stored schedule of W W W .
Proof. For a path i 1 , … , i k i_1,\ldots,i_k i 1 , … , i k , the edge inclusions yield
W = L i 1 ∪ ˙ Z i 1 ∪ ˙ ( L i 2 ∖ ( L i 1 ∪ Z i 1 ) ) ∪ ˙ ⋯ ∪ ˙ Z i k ∪ ˙ R i k . W=L_{i_1}\mathbin{\dot\cup}Z_{i_1}\mathbin{\dot\cup}\left(L_{i_2}\setminus(L_{i_1}\cup Z_{i_1})\right)\mathbin{\dot\cup}\cdots
\mathbin{\dot\cup}Z_{i_k}\mathbin{\dot\cup}R_{i_k}. W = L i 1 ∪ ˙ Z i 1 ∪ ˙ ( L i 2 ∖ ( L i 1 ∪ Z i 1 ) ) ∪ ˙ ⋯ ∪ ˙ Z i k ∪ ˙ R i k .
All displayed gaps have successful lookups, and the soundness proof permits their schedules to be concatenated in this order. There are k k k disjoint sets of m m m marked jobs, so k ≤ ∣ W ∣ / m k\leq|W|/m k ≤ ∣ W ∣/ m . Every job appears exactly once in the partition and therefore exactly once in the copied output. State records are accessed directly by their indices. Locating a stored gap schedule by Algorithm 2 follows its incidence vector through the node trie, costing O ( N ) O(N) O ( N ) RAM operations. This search cost and the cost of copying the schedule are included in § 6 .
Theorem 5.12 (Correctness of the deadline and optimization algorithms). For m ≥ 3 m\geq3 m ≥ 3 , Algorithms 6 and 7 decide deadline feasibility exactly and return an optimum schedule, respectively.
Proof. For T < ⌈ n / m ⌉ T<\lceil n/m\rceil T < ⌈ n / m ⌉ , capacity excludes feasibility; for T ≥ n T\geq n T ≥ n , the serial topological schedule is feasible. In the remaining range, adding m T − n mT-n m T − n isolated jobs preserves feasibility in both directions: fill all unused positions with dummy jobs, or delete them from a full padded schedule, as proved in Lemma 5.2 .
The generated families are exactly F 4 m + 5 \mathcal{F}_{4m+5} F 4 m + 5 and F m + 3 \mathcal{F}_{m+3} F m + 3 . If the evaluator accepts the padded root, Theorem 5.6 gives a full schedule, and removing dummies gives a feasible original schedule. If the padded root is feasible, Theorem 5.8 supplies a hierarchy described by these two families. Theorem 5.9 then makes the evaluator accept it. Thus every deadline answer is correct.
For optimization, initially ℓ = ⌈ n / m ⌉ − 1 \ell=\lceil n/m\rceil-1 ℓ = ⌈ n / m ⌉ − 1 is infeasible, u = n u=n u = n is feasible, and σ b e s t \sigma_{\mathrm{best}} σ best witnesses the upper bound. Feasibility is monotone in the deadline. Each update therefore preserves these facts and decreases u − ℓ u-\ell u − ℓ . At termination u = ℓ + 1 u=\ell+1 u = ℓ + 1 , so u u u is the smallest feasible integer deadline. The stored schedule has makespan at most u u u and must be optimum. Lemma 5.1 shows that this integer optimum also equals the continuous-time optimum.
The proof separates the recurrence from its structural completeness argument: § 7 proves the hypothesis used in Theorem 5.9 . The algorithm itself neither receives a hierarchy as input nor computes the normalizations used to prove that a hierarchy exists.
Running-time analysis
This section analyzes Algorithms 1–7 and proves Theorem 1.1 . For n ≥ 2 n \ge2 n ≥ 2 , the simplifications used in the final bounds follow from n + 2 ≤ 2 n n+2 \le2n n + 2 ≤ 2 n , log ( n + 2 ) ≤ log ( 2 n ) = 1 + log n ≤ 2 log n \log(n+2) \le\log(2n)=1+\log n \le2\log n log ( n + 2 ) ≤ log ( 2 n ) = 1 + log n ≤ 2 log n . These are upper bounds, not identities. Thus, for any a , b ≥ 0 a,b \ge0 a , b ≥ 0 ,
( n + 2 ) a log b ( n + 2 ) ≤ 2 a + b n a log b n . (n+2)^a\log^b(n+2) \le2^{a+b}n^a\log^b n. ( n + 2 ) a log b ( n + 2 ) ≤ 2 a + b n a log b n .
For a = E ( m ) = 6 m 2 + 13 m + 1 a=E(m)=6m^2+13m+1 a = E ( m ) = 6 m 2 + 13 m + 1 or a = 2 E ( m ) a=2E(m) a = 2 E ( m ) and b ∈ { 0 , 1 , 2 , 3 } b\in\{0,1,2,3\} b ∈ { 0 , 1 , 2 , 3 } , the extra factor is 2 O ( m 2 ) 2^{O(m^2)} 2 O ( m 2 ) and is absorbed into m O ( m 2 ) m^{O(m^2)} m O ( m 2 ) , since m ≥ 3 m\ge3 m ≥ 3 . The same argument applies to the simpler exponent 11 m 2 11m^2 11 m 2 . This leaves all displayed polynomial degrees unchanged. We retain the intermediate N + 2 N+2 N + 2 estimates below and simplify them when passing from the padded size N N N to n n n .
We count elementary operations on a random access machine (RAM). Sets are stored as Boolean arrays of length N N N , and the transitive precedence relation as an N × N N\times N N × N Boolean matrix. Access to an indexed array entry, an assignment, and arithmetic or comparison of indices and counters cost one operation. Thus a set operation or comparison costs O ( N ) O(N) O ( N ) operations, an ideal or antichain test costs O ( N 2 ) O(N^2) O ( N 2 ) , and exact trie lookup in Algorithm 2 costs O ( N ) O(N) O ( N ) , including an unsuccessful query. Exact insertion has the same cost. State records are accessed by their indices. Words are large enough to hold the working addresses and counters; for the generated families, O ( m 2 log ( N + 2 ) ) O(m^2\log(N+2)) O ( m 2 log ( N + 2 )) bits suffice, which is O ( log ( N + 2 ) ) O(\log(N+2)) O ( log ( N + 2 )) for fixed m m m . No operation treats an entire N N N -bit set as one word. We discuss bit costs at the end.
We use
K n o d e = 4 m + 5 , K c u t = m + 3 , B n o d e = ∣ F ∣ , B c u t = ∣ F c u t ∣ . K_{\mathrm{node}}=4m+5,\qquad K_{\mathrm{cut}}=m+3,\qquad B_{\mathrm{node}}=|\mathcal{F}|,\qquad B_{\mathrm{cut}}=|\mathcal{F}_{\mathrm{cut}}|. K node = 4 m + 5 , K cut = m + 3 , B node = ∣ F ∣ , B cut = ∣ F cut ∣.
Size and generation cost of the candidate families
Lemma 6.1 (Number of candidates). For m ≥ 3 m\ge3 m ≥ 3 , N ≥ m N\ge m N ≥ m , and K ≥ 1 K\ge1 K ≥ 1 , the family size satisfies
B : = ∣ F K ∣ ≤ B 0 : = 2 ⋅ 160 K ( N + 2 ) m K . B:=|\mathcal{F}_K|\le B_0:=2\cdot160^K(N+2)^{mK}. B := ∣ F K ∣ ≤ B 0 := 2 ⋅ 16 0 K ( N + 2 ) m K . For the node and cut budgets, respectively, this gives
B n o d e ≤ B n o d e , 0 : = 2 ⋅ 160 4 m + 5 ( N + 2 ) 4 m 2 + 5 m , B_{\mathrm{node}}\le B_{\mathrm{node},0}:=2\cdot160^{4m+5}(N+2)^{4m^2+5m}, B node ≤ B node , 0 := 2 ⋅ 16 0 4 m + 5 ( N + 2 ) 4 m 2 + 5 m , B c u t ≤ B c u t , 0 : = 2 ⋅ 160 m + 3 ( N + 2 ) m 2 + 3 m . B_{\mathrm{cut}}\le B_{\mathrm{cut},0}:=2\cdot160^{m+3}(N+2)^{m^2+3m}. B cut ≤ B cut , 0 := 2 ⋅ 16 0 m + 3 ( N + 2 ) m 2 + 3 m .
Proof idea. We count normalized formulas by their tree shapes, operation labels, and signed atomic labels, and then sum over the allowed leaf counts.
Proof. A full ordered rooted binary tree has either zero or two children at each vertex, with left and right children distinguished. A formula is normalized if its internal vertices are labelled by ∪ \cup ∪ or ∩ \cap ∩ and its leaves by atoms or their complements. By De Morgan’s laws and double-complement cancellation, every formula in Definition 2.2 has an equivalent normalized formula with the same number of atomic occurrences.
A full binary tree with k k k leaves has exactly k − 1 k-1 k − 1 internal vertices [37 Example 1.3.22, p. 43] . The number t k t_k t k of ordered tree shapes is t k = C k − 1 = 1 k ( 2 k − 2 k − 1 ) ≤ 4 k − 1 t_k=C_{k-1}=\frac{1}{k}\binom{2k-2}{k-1}\le4^{k-1} t k = C k − 1 = k 1 ( k − 1 2 k − 2 ) ≤ 4 k − 1 , by the classical bijection with Dyck words of length 2 ( k − 1 ) 2(k-1) 2 ( k − 1 ) ; see [37 Theorem 1.3.23, p. 44] and [35 Theorems 1.4.1 and 1.5.1] .
Let M M M denote the length of the indexed atomic list, allowing different names to represent the same set. For a fixed tree with k k k leaves, there are 2 k − 1 2^{k-1} 2 k − 1 choices of binary-operation labels and ( 2 M ) k (2M)^k ( 2 M ) k choices of signed atomic labels. Hence the number f k f_k f k of normalized formulas with exactly k k k leaves satisfies f k ≤ 4 k − 1 2 k − 1 ( 2 M ) k = ( 16 M ) k 8 ≤ ( 16 M ) k f_k \le4^{k-1}2^{k-1}(2M)^k = \frac{(16M)^k}{8} \le(16M)^k f k ≤ 4 k − 1 2 k − 1 ( 2 M ) k = 8 ( 16 M ) k ≤ ( 16 M ) k . Every set in F K F_K F K has such a description with at most K K K leaves. Therefore, putting q = 16 M ≥ 16 q=16M\ge16 q = 16 M ≥ 16 and using the finite geometric sum,
B ≤ ∑ k = 1 K f k ≤ ∑ k = 1 K q k = q K + 1 − q q − 1 ≤ q K q q − 1 ≤ 2 q K . B \le\sum_{k=1}^{K} f_k \le\sum_{k=1}^{K} q^k
= \frac{q^{K+1}-q}{q-1} \le q^K\frac{q}{q-1} \le2q^K. B ≤ k = 1 ∑ K f k ≤ k = 1 ∑ K q k = q − 1 q K + 1 − q ≤ q K q − 1 q ≤ 2 q K .
Finally, the atomic list contains five names for every m m m -set, the N + 1 N+1 N + 1 rank suffixes, and the two constants J J J , ∅ \varnothing ∅ . Thus M = 5 ( N m ) + N + 3 ≤ 10 ( N + 2 ) m M=5\binom{N}{m}+N+3\le10(N+2)^m M = 5 ( m N ) + N + 3 ≤ 10 ( N + 2 ) m , and consequently B ≤ 2 ( 16 M ) K ≤ 2 ( 160 ( N + 2 ) m ) K = B 0 B\le2(16M)^K\le2(160(N+2)^m)^K=B_0 B ≤ 2 ( 16 M ) K ≤ 2 ( 160 ( N + 2 ) m ) K = B 0 . Substituting K n o d e = 4 m + 5 K_{\mathrm{node}}=4m+5 K node = 4 m + 5 and K c u t = m + 3 K_{\mathrm{cut}}=m+3 K cut = m + 3 proves the two displayed specializations. In each case, the coefficient 2 ⋅ 160 K 2\cdot160^K 2 ⋅ 16 0 K is 2 O ( m ) 2^{O(m)} 2 O ( m ) .
Lemma 6.2 (Cost of direct family generation). For m ≥ 3 m\ge3 m ≥ 3 , N ≥ m N\ge m N ≥ m , and K ≥ 1 K\ge1 K ≥ 1 , Algorithm 1, using binary tries for exact duplicate detection and including order and atom preprocessing, uses
O ( N 3 + m N ( N m ) + N 2 + K 2 160 K ( N + 2 ) m K + 1 ) O\left(N^3+mN\binom{N}{m}+N^2+K^2\,160^K(N+2)^{mK+1}\right) O ( N 3 + m N ( m N ) + N 2 + K 2 16 0 K ( N + 2 ) m K + 1 ) R A M RAM R A M operations. Generating all layers through K n o d e K_{\mathrm{node}} K node also supplies the cut layer K c u t K_{\mathrm{cut}} K cut .
Proof idea. Each exact insertion costs O ( N ) O(N) O ( N ) . To count the attempted unions and intersections, use the separate bounds for their two source layers; their leaf budgets add to the output budget.
Proof. Let F i \mathcal{F}_i F i denote the list constructed at layer i i i of Algorithm 1. For a fixed layer k k k and split i + ( k − i ) = k i+(k-i)=k i + ( k − i ) = k , the algorithm considers all pairs in F i × F k − i \mathcal{F}_i\times\mathcal{F}_{k-i} F i × F k − i . Lemma 6.1 gives
∣ F i ∣ ∣ F k − i ∣ ≤ ( 2 ⋅ 160 i ( N + 2 ) m i ) ( 2 ⋅ 160 k − i ( N + 2 ) m ( k − i ) ) = 4 ⋅ 160 k ( N + 2 ) m k . |\mathcal{F}_i||\mathcal{F}_{k-i}|
\le(2\cdot160^i(N+2)^{mi})(2\cdot160^{k-i}(N+2)^{m(k-i)})
=4\cdot160^k(N+2)^{mk}. ∣ F i ∣∣ F k − i ∣ ≤ ( 2 ⋅ 16 0 i ( N + 2 ) mi ) ( 2 ⋅ 16 0 k − i ( N + 2 ) m ( k − i ) ) = 4 ⋅ 16 0 k ( N + 2 ) mk .
Hence the total number of attempted pairs is at most
∑ k = 2 K ∑ i = 1 k − 1 ∣ F i ∣ ∣ F k − i ∣ ≤ 4 ⋅ 160 K ( N + 2 ) m K ∑ k = 2 K ( k − 1 ) ≤ 2 K 2 160 K ( N + 2 ) m K . \sum_{k=2}^{K}\sum_{i=1}^{k-1}|\mathcal{F}_i||\mathcal{F}_{k-i}|
\le4\cdot160^K(N+2)^{mK}\sum_{k=2}^{K}(k-1)
\le2K^2 160^K(N+2)^{mK}. k = 2 ∑ K i = 1 ∑ k − 1 ∣ F i ∣∣ F k − i ∣ ≤ 4 ⋅ 16 0 K ( N + 2 ) m K k = 2 ∑ K ( k − 1 ) ≤ 2 K 2 16 0 K ( N + 2 ) m K .
Each pair produces two candidate vectors, its union and its intersection, so the number of attempted insertions is at most twice this quantity.
The source vectors are addressed by their indices. Forming their union and intersection costs O ( N ) O(N) O ( N ) operations. A binary trie stores one path for each incidence vector. Inspecting or creating the path and detecting whether its terminal node was already occupied takes O ( N ) O(N) O ( N ) operations. Thus exact duplicate detection adds no factor proportional to the number of stored sets. The pair loops cost O ( K 2 160 K ( N + 2 ) m K + 1 ) O(K^2 160^K(N+2)^{mK+1}) O ( K 2 16 0 K ( N + 2 ) m K + 1 ) .
Initialization makes at most 2 M 2M 2 M insertion attempts, where M = 5 ( N m ) + N + 3 M=5\binom{N}{m}+N+3 M = 5 ( m N ) + N + 3 , and costs O ( M N ) O(MN) O ( M N ) operations. Copying the preceding layer into the next layer, with its trie, costs O ( N ∣ F k − 1 ∣ ) O(N|\mathcal{F}_{k-1}|) O ( N ∣ F k − 1 ∣ ) per layer. Both contributions fit the preceding bound.
It remains to account for preprocessing. Transitive closure can be computed in O ( N 3 ) O(N^3) O ( N 3 ) operations, and a deterministic topological order in O ( N 2 ) O(N^2) O ( N 2 ) operations. For each of the ( N m ) \binom{N}{m} ( m N ) choices of an m m m -set A A A , constructing
A , P A , D A , P ^ A , D ^ A A,\quad P_A,\quad D_A,\quad\widehat{P}_A,\quad\widehat{D}_A A , P A , D A , P A , D A
uses O ( m N ) O(mN) O ( m N ) operations: for each job, inspect its precedence relation with the m m m jobs of A A A in the precomputed matrix. All boundary atoms therefore cost O ( m N ( N m ) ) O\left(mN\binom{N}{m}\right) O ( m N ( m N ) ) operations. The constants and the N + 1 N+1 N + 1 rank-suffix vectors cost O ( N 2 ) O(N^2) O ( N 2 ) . Adding these costs to the pair, initialization, and copying costs proves the claimed bound. The cut layer is already one of the generated layers, so retaining it does not require a second enumeration.
Algorithm 6 calls Algorithm 1 and passes the node and cut layers to Algorithm 4; Algorithm 7 makes these deadline calls during binary search. The node family supplies candidate sets, and the cut family supplies cuts. The precedence matrix is used to construct the atoms and to perform the ideal and antichain tests in Algorithm 3. The topological ranks define the rank-suffix atoms R h R_h R h .
Evaluation, reconstruction, and optimization
Theorem 6.3 (Cost of the explicit evaluator). Let B n o d e = ∣ F ∣ ≥ 1 B_{\mathrm{node}}=|\mathcal{F}|\ge1 B node = ∣ F ∣ ≥ 1 and B c u t = ∣ F c u t ∣ ≥ 1 B_{\mathrm{cut}}=|\mathcal{F}_{\mathrm{cut}}|\ge1 B cut = ∣ F cut ∣ ≥ 1 , with the distinct family members supplied as N N N -bit incidence vectors and the global transitive order precomputed. For m ≥ 3 m\ge3 m ≥ 3 and N ≥ m N\ge m N ≥ m , Algorithms 2–5 use
O ( poly ( m ) B n o d e B c u t 2 ( N + 2 ) 2 m + 1 ) O\left(\operatorname{poly}(m)B_{\mathrm{node}}B_{\mathrm{cut}}^2(N+2)^{2m+1}\right) O ( poly ( m ) B node B cut 2 ( N + 2 ) 2 m + 1 )
RAM operations, including exact dictionary construction and the stored schedules of all accepted sets.
Proof idea. First bound the number of state records belonging to one parent. Then count the inspections of ordered pairs and the operations in each inspection. Finally, account for constructing the states and copying the already stored schedules during reconstruction.
Proof. Put Q = ( N + 2 ) m Q=(N+2)^m Q = ( N + 2 ) m and S = B c u t Q S=B_{\mathrm{cut}}Q S = B cut Q . Fix a parent W ∈ F W\in\mathcal{F} W ∈ F and let s W s_W s W be the number of state records appended for W W W . Algorithm 3 considers at most B c u t B_{\mathrm{cut}} B cut cuts C C C . Once C C C is fixed, the prefix L = W ∩ C L=W\cap C L = W ∩ C is determined. There are at most ( N m ) \binom{N}{m} ( m N ) choices for the marked slot Z Z Z , and then R = W ∖ ( L ∪ Z ) R=W\setminus(L\cup Z) R = W ∖ ( L ∪ Z ) is determined as well. Each choice produces at most one record, so s W ≤ B c u t ( N m ) ≤ B c u t ( N + 2 ) m = S s_W\le B_{\mathrm{cut}}\binom{N}{m}\le B_{\mathrm{cut}}(N+2)^m=S s W ≤ B cut ( m N ) ≤ B cut ( N + 2 ) m = S . This count includes duplicate records: different choices of C C C may yield the same triple, and we count each appended record.
Consider an ordered pair of records ( i , j ) (i,j) ( i , j ) . Their addresses, reachability flags, and predecessor indices are accessed in constant time. Testing L i ∪ Z i ⊆ L j L_i\cup Z_i\subseteq L_j L i ∪ Z i ⊆ L j and forming the gap L j ∖ ( L i ∪ Z i ) L_j\setminus(L_i\cup Z_i) L j ∖ ( L i ∪ Z i ) require scanning incidence arrays of length N N N , which costs O ( N ) O(N) O ( N ) operations. Algorithm 2 follows this gap’s incidence vector through the exact trie, using O ( N ) O(N) O ( N ) operations whether the gap is found or is absent. Updating the target’s flag and predecessor field costs O ( 1 ) O(1) O ( 1 ) . Consequently, one pair inspection costs
D = O ( N + 2 ) . (3) D=O(N+2). \tag*{(3)} D = O ( N + 2 ) . (3)
The ideal and antichain conditions have already been verified during state construction; they need not be tested again for each pair.
For the parent W W W , Algorithm 4 processes sources in increasing order of ∣ L i ∣ |L_i| ∣ L i ∣ , inspecting at most s W 2 s_W^2 s W 2 ordered pairs in total. Every edge satisfies ∣ L j ∣ ≥ ∣ L i ∣ + m |L_j|\ge|L_i|+m ∣ L j ∣ ≥ ∣ L i ∣ + m , so all incoming edges are processed before a state is used as a source. Lemma 5.5 shows why this one pass suffices to find all reachable records. The cost is at most O ( s W 2 D ) O(s_W^2D) O ( s W 2 D ) ; failed guards only reduce it. Summing over the at most B n o d e B_{\mathrm{node}} B node parents and substituting the bounds on S S S and D D D gives
∑ W ∈ F O ( s W 2 D ) ≤ O ( B n o d e S 2 D ) = O ( B n o d e [ B c u t ( N + 2 ) m ] 2 ( N + 2 ) ) = O ( B n o d e B c u t 2 ( N + 2 ) 2 m + 1 ) . \begin{aligned}
\sum_{W\in\mathcal{F}} O(s_W^2D)\le O(B_{\mathrm{node}}S^2D) \\
&=O\left(B_{\mathrm{node}}\left[B_{\mathrm{cut}}(N+2)^m\right]^2(N+2)\right) \\
&=O\left(B_{\mathrm{node}}B_{\mathrm{cut}}^2(N+2)^{2m+1}\right).
\end{aligned} W ∈ F ∑ O ( s W 2 D ) ≤ O ( B node S 2 D ) = O ( B node [ B cut ( N + 2 ) m ] 2 ( N + 2 ) ) = O ( B node B cut 2 ( N + 2 ) 2 m + 1 ) .
We also count the work outside these pair loops. Across all parents, there are at most B n o d e B c u t Q B_{\mathrm{node}}B_{\mathrm{cut}}Q B node B cut Q candidate states. Constructing their vectors and checking cardinalities, the antichain condition, and the two ideal conditions takes O ( poly ( m ) ( N + 2 ) 2 ) O(\operatorname{poly}(m)(N+2)^2) O ( poly ( m ) ( N + 2 ) 2 ) per candidate. State construction thus costs O ( poly ( m ) B n o d e B c u t ( N + 2 ) m + 2 ) O(\operatorname{poly}(m)B_{\mathrm{node}}B_{\mathrm{cut}}(N+2)^{m+2}) O ( poly ( m ) B node B cut ( N + 2 ) m + 2 ) . There are at most two initial or final lookups per state, giving O ( B n o d e ⋅ S ⋅ N ) ⊆ O ( B n o d e B c u t ( N + 2 ) m + 1 ) O(B_{\mathrm{node}}\cdot S\cdot N)\subseteq O(B_{\mathrm{node}}B_{\mathrm{cut}}(N+2)^{m+1}) O ( B node ⋅ S ⋅ N ) ⊆ O ( B node B cut ( N + 2 ) m + 1 ) .
Constructing the acceptance trie and computing family cardinalities costs O ( B n o d e N ) O(B_{\mathrm{node}}N) O ( B node N ) . A lexicographic traversal of the trie, followed by stable bucketing by cardinality, orders the parents in the specified order within the same bound. For each parent, the states can be bucketed by ∣ L ∣ |L| ∣ L ∣ in O ( s W + N ) O(sW+N) O ( s W + N ) operations; their stored indices need not change. Equal-cardinality buckets have no internal edges. All ordering and initialization costs fit the state-construction bound.
For reconstruction, Lemma 5.11 bounds an accepting path by N / m N/m N / m marked slots and its gaps by N / m + 1 N/m+1 N / m + 1 . There are therefore O ( N ) O(N) O ( N ) searches for stored gap schedules, each costing O ( N ) O(N) O ( N ) . Following predecessor indices and forming the gap vectors costs at most O ( N 2 ) O(N^2) O ( N 2 ) . The gaps and marked slots partition W W W , so concatenation copies exactly ∣ W ∣ ≤ N |W|\leq N ∣ W ∣ ≤ N job occurrences. The gap schedules are already stored; their construction is not recursively repeated. Reconstruction consequently costs O ( N 2 ) O(N^2) O ( N 2 ) per accepted parent and O ( B n o d e N 2 ) O(B_{\mathrm{node}}N^2) O ( B node N 2 ) over all parents.
Since B n o d e , B c u t ≥ 1 B_{\mathrm{node}},B_{\mathrm{cut}}\geq1 B node , B cut ≥ 1 and m ≥ 3 m\geq3 m ≥ 3 , all these additional terms are bounded by
O ( poly ( m ) B n o d e B c u t 2 ( N + 2 ) 2 m + 1 ) O\left(\operatorname{poly}(m)B_{\mathrm{node}}B_{\mathrm{cut}}^2(N+2)^{2m+1}\right) O ( poly ( m ) B node B cut 2 ( N + 2 ) 2 m + 1 )
which proves the claim.
Theorem 6.4 (Overall operation count). Put E ( m ) = 6 m 2 + 13 m + 1 E(m)=6m^2+13m+1 E ( m ) = 6 m 2 + 13 m + 1 . With K n o d e = 4 m + 5 K_{\mathrm{node}}=4m+5 K node = 4 m + 5 and K c u t = m + 3 K_{\mathrm{cut}}=m+3 K cut = m + 3 , deadline feasibility and reconstruction of a schedule use
O ( L ) + m O ( m 2 ) n E ( m ) O(L)+m^{O(m^2)}n^{E(m)} O ( L ) + m O ( m 2 ) n E ( m ) RAM operations. Optimization, including construction of an optimum schedule, uses
O ( L ) + m O ( m 2 ) n E ( m ) log n . O(L)+m^{O(m^2)}n^{E(m)}\log n. O ( L ) + m O ( m 2 ) n E ( m ) log n . In particular, for every m ≥ 3 m\geq3 m ≥ 3 the latter is at most
O ( L ) + m O ( m 2 ) n 11 m 2 . O(L)+m^{O(m^2)}n^{11m^2}. O ( L ) + m O ( m 2 ) n 11 m 2 .
Proof idea. First combine family generation and evaluation for one padded deadline instance. Substitute the two family bounds, express the bound in terms of the original number n n n of jobs, and then account for binary search.
Proof. Instances with n ≤ 1 n\leq1 n ≤ 1 take O ( L + 1 ) O(L+1) O ( L + 1 ) time, so assume n ≥ 2 n\geq2 n ≥ 2 . For one nontrivial deadline test, Lemma 6.1 and Theorem 6.3 give the computational bound
O ( poly ( m ) B n o d e , 0 B c u t , 0 2 ( N + 2 ) 2 m + 1 ) O\left(\operatorname{poly}(m)B_{\mathrm{node},0}B_{\mathrm{cut},0}^2(N+2)^{2m+1}\right) O ( poly ( m ) B node , 0 B cut , 0 2 ( N + 2 ) 2 m + 1 )
Substituting the bounds for B n o d e , 0 B_{\mathrm{node},0} B node , 0 and B c u t , 0 B_{\mathrm{cut},0} B cut , 0 gives
B n o d e , 0 B c u t , 0 2 ( N + 2 ) 2 m + 1 = 8 ⋅ 160 K n o d e + 2 K c u t ( N + 2 ) m K n o d e + 2 m K c u t + 2 m + 1 = 8 ⋅ 160 6 m + 11 ( N + 2 ) 6 m 2 + 13 m + 1 . \begin{aligned}
B_{\mathrm{node},0}B_{\mathrm{cut},0}^2(N+2)^{2m+1}
=8\cdot160^{K_{\mathrm{node}}+2K_{\mathrm{cut}}}(N+2)^{mK_{\mathrm{node}}+2mK_{\mathrm{cut}}+2m+1} \\
&=8\cdot160^{6m+11}(N+2)^{6m^2+13m+1}.
\end{aligned} B node , 0 B cut , 0 2 ( N + 2 ) 2 m + 1 = 8 ⋅ 16 0 K node + 2 K cut ( N + 2 ) m K node + 2 m K cut + 2 m + 1 = 8 ⋅ 16 0 6 m + 11 ( N + 2 ) 6 m 2 + 13 m + 1 .
For completeness, the powers of N + 2 N+2 N + 2 in the main costs are family generation: 4 m 2 + 5 m + 1 4m^2 + 5m + 1 4 m 2 + 5 m + 1 , state construction: 5 m 2 + 9 m + 2 5m^2 + 9m + 2 5 m 2 + 9 m + 2 , transition evaluation: 6 m 2 + 13 m + 1 6m^2 + 13m + 1 6 m 2 + 13 m + 1 , schedule reconstruction: 4 m 2 + 5 m + 2 4m^2 + 5m + 2 4 m 2 + 5 m + 2 .
The transition exponent is largest for m ≥ 3 m \ge3 m ≥ 3 . The transitive closure and atom preprocessing terms of Lemma 6.2 are smaller as well. Thus generation, evaluation, and reconstruction together fit the displayed deadline bound in N N N .
Padding is used only for ⌈ n / m ⌉ ≤ T < n \lceil n/m\rceil\le T < n ⌈ n / m ⌉ ≤ T < n , and hence N = m T ≤ m n N = mT \le mn N = m T ≤ mn . For n ≥ 2 n \ge2 n ≥ 2 , we have N + 2 ≤ m ( n + 2 ) ≤ 2 m n N + 2 \le m(n + 2) \le2mn N + 2 ≤ m ( n + 2 ) ≤ 2 mn . Replacing N + 2 N + 2 N + 2 by 2 m n 2mn 2 mn contributes the factor ( 2 m ) E ( m ) (2m)^{E(m)} ( 2 m ) E ( m ) . The full coefficient depending on m m m is therefore bounded by
poly ( m ) 8 160 6 m + 11 ( 2 m ) E ( m ) = m O ( m 2 ) . \operatorname{poly}(m)\,8\,160^{6m+11}(2m)^{E(m)} = m^{O(m^2)}. poly ( m ) 8 16 0 6 m + 11 ( 2 m ) E ( m ) = m O ( m 2 ) .
Here E ( m ) = O ( m 2 ) E(m) = O(m^2) E ( m ) = O ( m 2 ) and m ≥ 3 m \ge3 m ≥ 3 . One nontrivial deadline call thus costs m O ( m 2 ) n E ( m ) m^{O(m^2)}n^{E(m)} m O ( m 2 ) n E ( m ) operations.
In Algorithm 7, the interval between the infeasible lower bound and feasible upper bound has initial length at most n + 1 n + 1 n + 1 and is halved, up to rounding, after each call. There are therefore O ( log n ) O(\log n) O ( log n ) deadline calls. Every successful call already returns a schedule, and the best one is retained, so there is no additional search for an optimum witness. The total computational term is at most m O ( m 2 ) n E ( m ) log n m^{O(m^2)}n^{E(m)}\log n m O ( m 2 ) n E ( m ) log n .
The original input is read once, contributing O ( L ) O(L) O ( L ) . A supplied binary deadline can be compared with n n n during this reading while retaining only O ( log n ) O(\log n) O ( log n ) bits and a flag for T ≥ n T \ge n T ≥ n . In that case a serial topological schedule suffices; otherwise the retained deadline fits the working word size. The graph data are reused between optimization calls, so the O ( L ) O(L) O ( L ) input term is not multiplied by the number of calls. Immediate rejection by the capacity bound, serial scheduling, and deleting dummy jobs all fit the same overall bound. Consequently, the total number of RAM operations is
O ( L ) + m O ( m 2 ) n E ( m ) log n , O(L) + m^{O(m^2)}n^{E(m)}\log n, O ( L ) + m O ( m 2 ) n E ( m ) log n ,
including construction of an optimum schedule.
Finally, log n = O ( n ) \log n = O(n) log n = O ( n ) and
11 m 2 − ( E ( m ) + 1 ) = 5 m 2 − 13 m − 2 = ( m − 3 ) ( 5 m + 2 ) + 4 ≥ 4 ( m ≥ 3 ) . 11m^2 - (E(m) + 1) = 5m^2 - 13m - 2 = (m - 3)(5m + 2) + 4 \ge4 \qquad(m \ge3). 11 m 2 − ( E ( m ) + 1 ) = 5 m 2 − 13 m − 2 = ( m − 3 ) ( 5 m + 2 ) + 4 ≥ 4 ( m ≥ 3 ) .
Absorbing the logarithm into one power of n n n therefore gives the simpler exponent 11 m 2 11m^2 11 m 2 .
Table 3.
The last column is the degree before the logarithmic factor for optimization. These are conservative accounting bounds for the specified implementation. The qualitative conclusion is the uniform bound m O ( m 2 ) n O ( m 2 ) m^{O(m^2)}n^{O(m^2)} m O ( m 2 ) n O ( m 2 ) , hence polynomial time for every fixed number of machines. The smaller degree uses separate node and cut budgets, exact trie lookup, and acyclic state evaluation, with the structural construction of § 7 unchanged.
Bit complexity. Let w = O ( m 2 log ( N + 2 ) ) w = O(m^2 \log(N + 2)) w = O ( m 2 log ( N + 2 )) be the working word length. If word operations are charged by their operand bit lengths while retaining random access, schoolbook arithmetic and comparisons give a conservative overhead O ( w 2 ) O(w^2) O ( w 2 ) per RAM operation. Thus the preceding bounds incur only an additional factor polynomial in m m m and log n \log n log n in that bit-cost RAM model. Set operations still scan their N N N entries; the trie does not turn an incidence vector into a constant-size integer.
Proposition 6.5 (A conservative multitape bound). The algorithms of this paper can be implemented on a deterministic Turing machine with a fixed number of tapes. Optimization and construction of an optimum schedule take
O ( L ) + m O ( m 2 ) n 12 m 2 + 26 m + 2 log 3 n O(L) + m^{O(m^2)}n^{12m^2+26m+2}\log^3 n O ( L ) + m O ( m 2 ) n 12 m 2 + 26 m + 2 log 3 n steps. A single deadline test uses log 2 n \log^2 n log 2 n in place of log 3 n \log^3 n log 3 n .
Proof idea. A computation with R R R elementary RAM operations touches only O ( R ) O(R) O ( R ) memory words. Store these words sequentially together with their addresses, and find a requested word by a complete scan. This gives a simple quadratic simulation bound without changing the algorithm.
Proof. For a nontrivial padded deadline instance, put E ( m ) = 6 m 2 + 13 m + 1 E(m)=6m^2+13m+1 E ( m ) = 6 m 2 + 13 m + 1 . The proof of Theorem 6.4 bounds the RAM operation count by
R N = 2 O ( m ) poly ( m ) ( N + 2 ) E ( m ) . R_N=2^{O(m)}\operatorname{poly}(m)(N+2)^{E(m)}. R N = 2 O ( m ) poly ( m ) ( N + 2 ) E ( m ) .
All words have w = O ( m 2 log ( N + 2 ) ) w=O(m^2\log(N+2)) w = O ( m 2 log ( N + 2 )) bits. Each operation accesses a constant number of words, so there are only O ( R N ) O(R_N) O ( R N ) addressed records; the initialization of the graph and generated tables is already counted. Represent each record by its address and value, using O ( w ) O(w) O ( w ) bits. A fixed number of tapes suffice to scan these records, compare addresses, and copy or update values. An address not yet stored has its initial value zero. A conservative bound for the scan and elementary word arithmetic is O ( R N w 2 ) O(R_Nw^2) O ( R N w 2 ) tape steps per RAM operation. Thus one deadline test takes
O ( R N 2 w 2 ) = 2 O ( m ) poly ( m ) ( N + 2 ) 2 E ( m ) log 2 ( N + 2 ) . O(R_N^2w^2)=2^{O(m)}\operatorname{poly}(m)(N+2)^{2E(m)}\log^2(N+2). O ( R N 2 w 2 ) = 2 O ( m ) poly ( m ) ( N + 2 ) 2 E ( m ) log 2 ( N + 2 ) .
For n ≥ 2 n\ge2 n ≥ 2 , use N + 2 ≤ 2 m n N+2\le2mn N + 2 ≤ 2 mn and
log ( N + 2 ) ≤ log ( 2 m n ) ≤ ( 2 + log m ) log n . \log(N+2)\le\log(2mn)\le(2+\log m)\log n. log ( N + 2 ) ≤ log ( 2 mn ) ≤ ( 2 + log m ) log n .
The resulting factor ( 2 m ) 2 E ( m ) ( 2 + log m ) 2 (2m)^{2E(m)}(2+\log m)^2 ( 2 m ) 2 E ( m ) ( 2 + log m ) 2 is absorbed into m O ( m 2 ) m^{O(m^2)} m O ( m 2 ) . This gives the claimed deadline bound.
Read the original input once. The distinct arcs and standard vertex labels have O ( n 2 log n ) O(n^2\log n) O ( n 2 log n ) total length. A supplied deadline can be capped at n n n during input processing, since deadlines at least n n n admit a serial topological schedule. Subsequent graph processing is included in the polynomial term, so input reading remains an additive O ( L ) O(L) O ( L ) . Finally, simulate the O ( log n ) O(\log n) O ( log n ) deadline tests of binary search separately, reusing the work tapes. This introduces just one additional logarithmic factor.
For m = 3 m=3 m = 3 , the multitape optimization bound is O ( L ) + O ( n 188 log 3 n ) O(L)+O(n^{188}\log^3 n) O ( L ) + O ( n 188 log 3 n ) . Since jobs are individually listed, n = O ( L ) n=O(L) n = O ( L ) ; hence the simpler bound O ( ( L + 2 ) 189 ) O((L+2)^{189}) O (( L + 2 ) 189 ) also holds.
Proof of Theorem 1.1 . Theorem 5.12 proves feasibility testing and optimum schedule construction. Its completeness input, Theorem 5.8 , is proved in § 7 . Theorem 6.4 gives the RAM operation bound, including its simpler 11 m 2 11m^2 11 m 2 consequence. All families and loops are determined by the input, so the algorithm is uniform. Proposition 6.5 proves the additional multitape bounds without changing the scheduling algorithm.
Structural induction and global descriptions
This section proves Theorem 5.8 . We begin with a feasible full schedule of the padded instance and use it as an existence witness. A mark is a selected full slot of this schedule. The jobs strictly between consecutive marks, or between an exterior boundary and the nearest mark, form the open temporal gaps. These gaps become the children of the current node. Every nonempty node receives at least one marked slot, so every child contains at least m m m fewer jobs than its parent. This makes recursion on the number of jobs possible.
The main difficulty is not merely to find smaller feasible gaps. We must describe their job sets, and the prefixes before their marked slots, by short formulas using the global atoms available to the algorithm. Here global means that a formula is evaluated on the entire ground set J J J , with the original transitive precedence relation interpreted in the current frame.
How the proof is organized. The construction has three connected tasks.
Choose useful marks. We specify a priority order, choose a normalized witness schedule, and find separator slots. A separator relates a cutoff in that priority order to the jobs occurring before a particular time slot. Lemma 7.3 gives the resulting prefix formula, and Lemma 7.4 explains how to move a separator when the cutoff changes.
Keep the stored information bounded. At each interval we maintain a list of global successor-closed sets. The invariants in the next subsection allow this information to pass to children. Later arguments bound the number of surviving entries by m m m and simplify their formulas so that one entry cannot accumulate an unbounded description of its ancestors.
Obtain formulas that the algorithm can enumerate. Each child set must have an exact description on all of J J J . For a marked slot in a node W W W , its prefix must have the form W ∩ C W \cap C W ∩ C , where C C C itself has a bounded global description. The final counting argument bounds the number of atomic occurrences and completes Theorem 5.8 .
The role of the witness schedule. A priority order is specified on the domain being scheduled. Normalization means choosing the lexicographically smallest feasible full schedule for that priority, after sorting the jobs within each slot by priority; the next subsection makes this definition precise. The feasible schedules form a finite nonempty collection, so such a choice exists. This is an existence argument: we do not claim that normalization can be performed efficiently. During the proof, a feasible reordering of an interval may be substituted into its witness while keeping exterior jobs fixed, as justified by Lemma 7.1 . The algorithm already enumerates the truth sets of bounded formulas and tests compatible states. Its completeness proof requires the existence of a suitable hierarchy; it does not require the algorithm to find the witness schedule first.
Temporal domains, priority cutoffs, and global sets. Three distinct objects occur throughout the proof. A temporal domain W = ( a , b ) W = (a,b) W = ( a , b ) consists of the jobs scheduled strictly between boundary positions a a a and b b b . A local cutoff S ⊆ W S \subseteq W S ⊆ W is an initial segment of a specified priority order on W W W ; it need not be an initial segment in time. A global set H ⊆ J H \subseteq J H ⊆ J represents that local cutoff when
H ∩ W = S . H \cap W = S. H ∩ W = S .
This equality determines membership in H H H only for jobs in W W W . It neither asserts H = S H = S H = S nor determines what H H H contains outside W W W . Whenever the proof uses this equality for a particular job, that job must first be known to belong to W W W . The next subsection defines frames, cones, closure properties, priorities, and the stored information in prose; subsequent subsections introduce the additional expressions needed by the construction.
The information maintained at an interval
Global precedence and full witness schedules. Fix an integer m ≥ 3 m \ge3 m ≥ 3 and a finite padded job set J J J with N = ∣ J ∣ N = |J| N = ∣ J ∣ . Every job has processing time one. Write x ≺ + y x \prec_{+} y x ≺ + y if there is a directed path of positive length from job x x x to job y y y in the input precedence graph. This is a strict partial order: it is irreflexive and transitive. Thus a predecessor may be direct or indirect. The subscript + + + identifies the original direction of precedence.
For the structural construction, assume that J J J has a feasible full schedule. Such a schedule is an ordered partition σ = ( S 1 , … , S T ) \sigma= (S_1,\ldots,S_T) σ = ( S 1 , … , S T ) , T = N / m T = N/m T = N / m , in which every S t ⊆ J S_t \subseteq J S t ⊆ J has exactly m m m jobs and x ≺ + y x \prec_{+} y x ≺ + y implies τ + ( x ) < τ + ( y ) \tau_{+}(x) < \tau_{+}(y) τ + ( x ) < τ + ( y ) , where τ + ( x ) = t \tau_{+}(x) = t τ + ( x ) = t means x ∈ S t x \in S_t x ∈ S t . In particular, every slot is an antichain: its jobs are pairwise incomparable. Slot t t t executes during [ t − 1 , t ) [t-1,t) [ t − 1 , t ) , and its jobs execute simultaneously on distinct machines. A complete witness schedule means such a schedule of all of J J J , including the jobs outside any current subproblem. It is used in the existence proof, not supplied to the scheduling algorithm.
Predecessor and successor cones. For any subset A ⊆ J A \subseteq J A ⊆ J , define its strict predecessor cone and strict successor cone by
P A + = { x ∈ J : there exists a ∈ A with x ≺ + a } , P_A^{+} = \{x \in J : \text{there exists } a \in A \text{ with } x \prec_{+} a\}, P A + = { x ∈ J : there exists a ∈ A with x ≺ + a } ,
D A + = { x ∈ J : there exists a ∈ A with a ≺ + x } . D_A^{+} = \{x \in J : \text{there exists } a \in A \text{ with } a \prec_{+} x\}. D A + = { x ∈ J : there exists a ∈ A with a ≺ + x } .
The word cone here simply names a set of jobs related by precedence; no geometric structure is intended. Membership requires a relation to at least one member of A A A , not to every member. The weak cones also contain the boundary set itself: P ^ A + = P A + ∪ A \widehat{P}_A^{+} = P_A^{+} \cup A P A + = P A + ∪ A , D ^ A + = D A + ∪ A \widehat{D}_A^{+} = D_A^{+} \cup A D A + = D A + ∪ A . The adjective strict refers to the strict relation ≺ + \prec_{+} ≺ + . If A A A contains comparable jobs, a strict cone can contain members of A A A . When A A A is a full antichain slot, both strict cones are disjoint from A A A .
Examples of cones and the meaning of a frame. For an example with m = 3 m = 3 m = 3 , let J = { a , b , c , d , e , f , g , h , i } J = \{a,b,c,d,e,f,g,h,i\} J = { a , b , c , d , e , f , g , h , i } , with the chain a ≺ + b ≺ + c a \prec_{+} b \prec_{+} c a ≺ + b ≺ + c and six independent jobs d , … , i d,\ldots,i d , … , i . Take A = { b } A = \{b\} A = { b } . Then
P A + = { a } , D A + = { c } , P ^ A + = { a , b } , D ^ A + = { b , c } . P_A^{+} = \{a\}, \qquad D_A^{+} = \{c\}, \qquad\widehat{P}_A^{+} = \{a,b\}, \qquad\widehat{D}_A^{+} = \{b,c\}. P A + = { a } , D A + = { c } , P A + = { a , b } , D A + = { b , c } .
The unrelated jobs d , … , i d,\ldots,i d , … , i belong to none of these four sets. For another full-slot example with m = 3 m = 3 m = 3 , use the three chains
a 1 ≺ + a 2 ≺ + a 3 , b 1 ≺ + b 2 ≺ + b 3 , c 1 ≺ + c 2 ≺ + c 3 . a_1 \prec_{+} a_2 \prec_{+} a_3,\qquad b_1 \prec_{+} b_2 \prec_{+} b_3,\qquad c_1 \prec_{+} c_2 \prec_{+} c_3. a 1 ≺ + a 2 ≺ + a 3 , b 1 ≺ + b 2 ≺ + b 3 , c 1 ≺ + c 2 ≺ + c 3 .
Put Z i = { a i , b i , c i } Z_i = \{a_i,b_i,c_i\} Z i = { a i , b i , c i } . The schedule ( Z 1 , Z 2 , Z 3 ) (Z_1,Z_2,Z_3) ( Z 1 , Z 2 , Z 3 ) is feasible and full. For the boundary slot Z 2 Z_2 Z 2 , its predecessor cone is Z 1 Z_1 Z 1 , its successor cone is Z 3 Z_3 Z 3 , and its weak cones are Z 1 ∪ Z 2 Z_1 \cup Z_2 Z 1 ∪ Z 2 and Z 2 ∪ Z 3 Z_2 \cup Z_3 Z 2 ∪ Z 3 .
A frame specifies which of two consistent orientations is being used. In the forward frame , denoted f = + f = + f = + , precedence is ≺ + \prec_{+} ≺ + and time is read in the execution order S 1 , S 2 , … , S T S_1,S_2,\ldots,S_T S 1 , S 2 , … , S T . Thus forward time means increasing slot indices: a job with a smaller slot index executes earlier.
In the reversed frame , denoted f = − f = - f = − , reverse both precedence and the complete slot order. Formally,
x ≺ − y ⟺ y ≺ + x , τ − ( x ) = T + 1 − τ + ( x ) . x \prec_{-} y \quad\Longleftrightarrow\quad y \prec_{+} x,\qquad\tau_{-}(x) = T + 1 - \tau_{+}(x). x ≺ − y ⟺ y ≺ + x , τ − ( x ) = T + 1 − τ + ( x ) .
The reversed witness schedule is ( S T , S T − 1 , … , S 1 ) (S_T,S_{T-1},\ldots,S_1) ( S T , S T − 1 , … , S 1 ) . It is feasible for ≺ − \prec_{-} ≺ − : from x ≺ − y x \prec_{-} y x ≺ − y we obtain τ + ( y ) < τ + ( x ) \tau_{+}(y) < \tau_{+}(x) τ + ( y ) < τ + ( x ) and hence τ − ( x ) < τ − ( y ) \tau_{-}(x) < \tau_{-}(y) τ − ( x ) < τ − ( y ) . This is a proof device; it does not instruct the original jobs to run backward in physical time. In the three-chain example, the reversed schedule is ( Z 3 , Z 2 , Z 1 ) (Z_3,Z_2,Z_1) ( Z 3 , Z 2 , Z 1 ) and, for example, a 3 ≺ − a 2 ≺ − a 1 a_3 \prec_{-} a_2 \prec_{-} a_1 a 3 ≺ − a 2 ≺ − a 1 .
Ranks and cone notation in a chosen frame. Fix once and for all a bijective topological rank function rank + : J → { 1 , … , N } \operatorname{rank}_{+}: J \to\{1,\ldots,N\} rank + : J → { 1 , … , N } for the original order. It satisfies x ≺ + y ⇒ rank + ( x ) < rank + ( y ) x \prec_{+} y \Rightarrow\operatorname{rank}_{+}(x) < \operatorname{rank}_{+}(y) x ≺ + y ⇒ rank + ( x ) < rank + ( y ) . Define
rank − ( x ) = N + 1 − rank + ( x ) , R h f = { x ∈ J : rank f ( x ) ≥ h } ( 1 ≤ h ≤ N + 1 ) . \operatorname{rank}_{-}(x) = N + 1 - \operatorname{rank}_{+}(x), \qquad R^{f}_{h} = \{x \in J : \operatorname{rank}_{f}(x) \ge h\} \quad(1 \le h \le N + 1). rank − ( x ) = N + 1 − rank + ( x ) , R h f = { x ∈ J : rank f ( x ) ≥ h } ( 1 ≤ h ≤ N + 1 ) .
In either frame R 1 f = J R^{f}_{1} = J R 1 f = J and R N + 1 f = ∅ R^{f}_{N+1} = \varnothing R N + 1 f = ∅ . Rank is a position in a fixed topological list, not an execution time. Feasible rearrangements of the witness schedule do not change these ranks. Define P A f , D A f P^{f}_{A}, D^{f}_{A} P A f , D A f by the cone formulas above using ≺ f \prec_{f} ≺ f . Then P A − = D A + P^{-}_{A} = D^{+}_{A} P A − = D A + , D A − = P A + D^{-}_{A} = P^{+}_{A} D A − = P A + , R h + = J ∖ R N + 2 − h − R^{+}_{h} = J \setminus R^{-}_{N+2-h} R h + = J ∖ R N + 2 − h − . The weak cones transform in the same way. A superscript rev \operatorname{rev} rev on an expression means that the same subset of J J J is rewritten using reversed-frame atoms. It does not mean complementation of the represented set. For example, the old set P { b } + = { a } P^{+}_{\{b\}} = \{a\} P { b } + = { a } is written as D { b } − = { a } D^{-}_{\{b\}} = \{a\} D { b } − = { a } after reversal. Once a frame is fixed, we omit its superscript and interpret every cone, rank, and time comparison in that frame.
Actual boundary slots, sentinels, and temporal intervals. Fix a complete witness schedule in the current frame. An actual boundary is one of its full slots. If a a a is actual, write jobs ( a ) \operatorname{jobs}(a) jobs ( a ) for its set of m m m jobs and pos ( a ) \operatorname{pos}(a) pos ( a ) for its slot index. We identify a a a with jobs ( a ) \operatorname{jobs}(a) jobs ( a ) when writing cones or set expressions such as P a P_a P a or y ∈ a y \in a y ∈ a .
We also allow two formal boundary symbols, called sentinels . The left sentinel ⊥ \bot ⊥ is placed before every job and the right sentinel ⊤ \top ⊤ after every job: pos ( ⊥ ) = 0 \operatorname{pos}(\bot) = 0 pos ( ⊥ ) = 0 , pos ( ⊤ ) = T + 1 \operatorname{pos}(\top) = T + 1 pos ( ⊤ ) = T + 1 , jobs ( ⊥ ) = jobs ( ⊤ ) = ∅ \operatorname{jobs}(\bot) = \operatorname{jobs}(\top) = \varnothing jobs ( ⊥ ) = jobs ( ⊤ ) = ∅ . Sentinels are not jobs, contain no jobs, consume no machine capacity, and are not extra schedule slots. Their cone values are assigned by convention:
D ⊥ = D ^ ⊥ = J , P ⊥ = P ^ ⊥ = ∅ , D_{\bot} = \widehat{D}_{\bot} = J, \qquad P_{\bot} = \widehat{P}_{\bot} = \varnothing, D ⊥ = D ⊥ = J , P ⊥ = P ⊥ = ∅ ,
P ⊤ = P ^ ⊤ = J , D ⊤ = D ^ ⊤ = ∅ . P_{\top} = \widehat{P}_{\top} = J, \qquad D_{\top} = \widehat{D}_{\top} = \varnothing. P ⊤ = P ⊤ = J , D ⊤ = D ⊤ = ∅ .
These are definitions for formal boundary symbols; they are not obtained by applying the ordinary cone formula to the empty job set. The conventions make endpoint formulas work at the beginning and end without introducing artificial precedence constraints between real jobs. Reversing the frame exchanges the two sentinel roles.
Let a , b a,b a , b be boundaries with pos ( a ) < pos ( b ) \operatorname{pos}(a) < \operatorname{pos}(b) pos ( a ) < pos ( b ) . Their temporal open interval is the job set
W = ( a , b ) = { x ∈ J : pos ( a ) < τ f ( x ) < pos ( b ) } . W = (a,b) = \{x \in J : \operatorname{pos}(a) < \tau_{f}(x) < \operatorname{pos}(b)\}. W = ( a , b ) = { x ∈ J : pos ( a ) < τ f ( x ) < pos ( b )} .
The word open means that jobs in actual boundary slots are excluded. Thus W W W is the union of the complete slots strictly between the boundaries; its size is a multiple of m m m , and it may be empty. An interval with consecutive boundaries is empty, and ( ⊥ , ⊤ ) = J (\bot,\top) = J ( ⊥ , ⊤ ) = J . The expression “at or before a a a ” means τ f ( x ) ≤ pos ( a ) \tau_{f}(x) \le\operatorname{pos}(a) τ f ( x ) ≤ pos ( a ) .
For the three-chain schedule, ( Z 1 , Z 3 ) = Z 2 (Z_{1},Z_{3}) = Z_{2} ( Z 1 , Z 3 ) = Z 2 , while ( ⊥ , Z 3 ) = Z 1 ∪ Z 2 (\bot,Z_{3}) = Z_{1} \cup Z_{2} ( ⊥ , Z 3 ) = Z 1 ∪ Z 2 . These identities concern positions in the chosen witness schedule. In general, ( a , b ) (a,b) ( a , b ) is not the same set as D a ∩ P b D_a \cap P_b D a ∩ P b . For example, schedule nine independent jobs in three full slots and choose the first and third as a , b a,b a , b . Then ( a , b ) (a,b) ( a , b ) is the nonempty middle slot, but D a = P b = ∅ D_a = P_b = \varnothing D a = P b = ∅ . This example explains the temporal notation; an arbitrary interval need not satisfy the additional invariants imposed later in the construction.
The domain of an induced precedence relation. A domain U U U means a specified subset of J J J . Its induced strict order is the restriction of the global order: ≺ U = ≺ f ∩ ( U × U ) \prec_{U} = \prec_{f} \cap(U \times U) ≺ U = ≺ f ∩ ( U × U ) . This restriction retains indirect precedence even when its original path uses jobs outside U U U . For instance, if a ≺ f b ≺ f c a \prec_{f} b \prec_{f} c a ≺ f b ≺ f c and U = { a , c } U = \{a,c\} U = { a , c } , then a ≺ U c a \prec_{U} c a ≺ U c . Deleting b b b from the domain does not remove this relation. The domains used for scheduling are unions of full slots; the definitions of closure and priority below also apply to arbitrary subsets U ⊆ J U \subseteq J U ⊆ J .
Predecessor closure, successor closure, ideals, and upsets. Let U ⊆ J U \subseteq J U ⊆ J be a specified domain. A set I ⊆ U I \subseteq U I ⊆ U is predecessor-closed in U U U , or an ideal of U U U , if ∀ y ∈ I ∀ x ∈ U : x ≺ f y ⟹ x ∈ I \forall y \in I\ \forall x \in U:\ x \prec_f y \implies x \in I ∀ y ∈ I ∀ x ∈ U : x ≺ f y ⟹ x ∈ I . Thus including a job requires including all its direct and indirect predecessors that belong to the stated domain. Predecessors outside U U U are not required to belong to I I I .
A set K ⊆ U K \subseteq U K ⊆ U is successor-closed in U U U , or an upset of U U U , if ∀ x ∈ K ∀ y ∈ U : x ≺ f y ⟹ y ∈ K \forall x \in K\ \forall y \in U:\ x \prec_f y \implies y \in K ∀ x ∈ K ∀ y ∈ U : x ≺ f y ⟹ y ∈ K . Thus including a job requires including all its successors in the stated domain. A global ideal or upset means that the domain is U = J U=J U = J . Whenever the domain is omitted below, it is J J J . These definitions always use the current frame; reversal turns a global ideal into a global upset, and conversely.
For J = { a , b , c , d , e , f , g , h , i } J=\{a,b,c,d,e,f,g,h,i\} J = { a , b , c , d , e , f , g , h , i } with a ≺ b ≺ c a \prec b \prec c a ≺ b ≺ c and the remaining jobs independent, { a , b } \{a,b\} { a , b } is a global ideal and { b , c } \{b,c\} { b , c } is a global upset. The set { b } \{b\} { b } is neither: it omits predecessor a a a and successor c c c . Both ∅ \varnothing ∅ and J J J are ideals and upsets. The complement in U U U of an ideal of U U U is an upset of U U U , and conversely. For a local example, take U = { b , c } U=\{b,c\} U = { b , c } . Then { b } \{b\} { b } is an ideal of U U U , although it is not a global ideal. A global ideal extending it is H = { a , b } H=\{a,b\} H = { a , b } , because H ∩ U = { b } H\cap U=\{b\} H ∩ U = { b } . In general, an identity H ∩ U = S H\cap U=S H ∩ U = S specifies agreement inside U U U , not equality of the global sets H H H and S S S .
The strict and weak predecessor cones of an actual job set are global ideals; the corresponding successor cones are global upsets. For example, if x ∈ D A x\in D_A x ∈ D A and x ≺ y x\prec y x ≺ y , then some a ∈ A a\in A a ∈ A satisfies a ≺ x ≺ y a\prec x\prec y a ≺ x ≺ y , so y ∈ D A y\in D_A y ∈ D A . Rank suffixes R h R_h R h are global upsets for the same reason: ranks increase along precedence.
A priority order has an explicitly specified domain. For a fixed domain U ⊆ J U\subseteq J U ⊆ J , a priority order on U U U is a strict total order ◃ U \triangleleft_U ◃ U on the jobs of U U U that extends their induced precedence order. More explicitly, it is irreflexive and transitive; for distinct x , y ∈ U x,y\in U x , y ∈ U , exactly one of x ◃ U y x\triangleleft_U y x ◃ U y and y ◃ U x y\triangleleft_U x y ◃ U x holds; and
x , y ∈ U , x ≺ f y ⟹ x ◃ U y . x,y\in U,\quad x\prec_f y \quad\Longrightarrow\quad x\triangleleft_U y. x , y ∈ U , x ≺ f y ⟹ x ◃ U y .
The notation x ◃ U y x\triangleleft_U y x ◃ U y means that x x x has earlier or better priority. It says nothing about jobs outside U U U . Equivalently, list U U U as u 1 ◃ U ⋯ ◃ U u s u_1\triangleleft_U\cdots\triangleleft_U u_s u 1 ◃ U ⋯ ◃ U u s and define its priority position ρ U ( u i ) = i \rho_U(u_i)=i ρ U ( u i ) = i . This position can differ from both a job’s numerical label and its fixed global topological rank. A priority order is an order for comparison, not an assignment of execution times.
Priority prefixes and their relation to time. For the priority list u 1 ◃ U ⋯ ◃ U u s u_1\triangleleft_U\cdots\triangleleft_U u_s u 1 ◃ U ⋯ ◃ U u s , its prefix of length k k k is S k = { u 1 , … , u k } S_k=\{u_1,\ldots,u_k\} S k = { u 1 , … , u k } , 0 ≤ k ≤ s 0\leq k\leq s 0 ≤ k ≤ s , with S 0 = ∅ S_0=\varnothing S 0 = ∅ . Every S k S_k S k is an ideal of U U U : if y ∈ S k y\in S_k y ∈ S k and x ∈ U x\in U x ∈ U precedes y y y , then x ◃ U y x\triangleleft_U y x ◃ U y , so x x x occurs among the first k k k jobs as well. In the separator construction a chosen priority prefix is called the low set or cutoff ; the remaining domain jobs are called high. Low therefore means earlier priority, not later or less important priority.
A priority prefix need not be a temporal prefix of the witness schedule. In the three-chain example, use the priority list a 1 , a 2 , a 3 , b 1 , b 2 , b 3 , c 1 , c 2 , c 3 a_1,a_2,a_3,b_1,b_2,b_3,c_1,c_2,c_3 a 1 , a 2 , a 3 , b 1 , b 2 , b 3 , c 1 , c 2 , c 3 . It extends precedence. Its first three jobs form the ideal { a 1 , a 2 , a 3 } \{a_1,a_2,a_3\} { a 1 , a 2 , a 3 } , although these jobs occupy three different slots in ( Z 1 , Z 2 , Z 3 ) (Z_1,Z_2,Z_3) ( Z 1 , Z 2 , Z 3 ) . A temporal prefix, in contrast, consists of all jobs occurring strictly before a specified slot.
The list of global upsets and the meaning of “qualifies.” A node carries an ordered finite list K = ( K 1 , … , K ℓ ) \mathcal{K}=(K_1,\ldots,K_\ell) K = ( K 1 , … , K ℓ ) , where every K i ⊆ J K_i\subseteq J K i ⊆ J is a global upset in the current frame. Entries may overlap, may contain jobs outside the node, and are not required to partition J J J or the node. The empty list is allowed. Define
Q ( K ) = ⋃ i = 1 ℓ K i , Q ( ( ) ) = ∅ . Q(\mathcal{K})=\bigcup_{i=1}^{\ell}K_i,\quad Q(())=\varnothing. Q ( K ) = i = 1 ⋃ ℓ K i , Q (( )) = ∅ .
A job x ∈ J x \in J x ∈ J qualifies with respect to K \mathcal{K} K if x ∈ Q ( K ) x \in Q(\mathcal{K}) x ∈ Q ( K ) . Such a job is called a qualifier. These terms refer only to membership in the current list. They do not mean that the job is ready to run, has passed a scheduling test, or belongs to the current interval. For example, with a ≺ b ≺ c a \prec b \prec c a ≺ b ≺ c and K = ( { b , c } ) \mathcal{K} = (\{b,c\}) K = ({ b , c }) , job b b b qualifies even before its predecessor a a a has completed. Job a a a can be ready without qualifying.
For a qualifier x x x , define its largest membership index and its key by
i K ( x ) = max { i : x ∈ K i } , key K ( x ) = ( i K ( x ) , rank ( x ) ) . i_{\mathcal{K}}(x) = \max\{i : x \in K_i\}, \qquad\operatorname{key}_{\mathcal{K}}(x) = (i_{\mathcal{K}}(x),\operatorname{rank}(x)). i K ( x ) = max { i : x ∈ K i } , key K ( x ) = ( i K ( x ) , rank ( x )) .
These quantities are undefined for a nonqualifier. Compare keys lexicographically: the smaller index comes first, and equal indices are ordered by increasing rank. Thus a job belonging to several entries uses its last entry for comparison. For independent jobs with ranks equal to labels and K 1 = { 1 , 2 , 5 } K_1 = \{1,2,5\} K 1 = { 1 , 2 , 5 } , K 2 = { 2 , 3 , 6 } K_2 = \{2,3,6\} K 2 = { 2 , 3 , 6 } , K 3 = { 4 , 5 , 6 } K_3 = \{4,5,6\} K 3 = { 4 , 5 , 6 } , we have key ( 2 ) = ( 2 , 2 ) \operatorname{key}(2) = (2,2) key ( 2 ) = ( 2 , 2 ) and key ( 5 ) = ( 3 , 5 ) \operatorname{key}(5) = (3,5) key ( 5 ) = ( 3 , 5 ) , although both jobs also belong to K 1 K_1 K 1 .
The key order is a strict total priority order on the domain Q ( K ) Q(\mathcal{K}) Q ( K ) . Indeed, if x ≺ y x \prec y x ≺ y and x x x qualifies, upward closure makes every entry containing x x x also contain y y y . Hence i K ( x ) ≤ i K ( y ) i_{\mathcal{K}}(x) \le i_{\mathcal{K}}(y) i K ( x ) ≤ i K ( y ) ; if the indices tie, rank ( x ) < rank ( y ) \operatorname{rank}(x) < \operatorname{rank}(y) rank ( x ) < rank ( y ) . Restricting the key order gives a priority order on W ∩ Q ( K ) W \cap Q(\mathcal{K}) W ∩ Q ( K ) . It does not, by itself, order the nonqualifying jobs of W W W .
Normalized schedules: the comparison domain and feasible choices. Fix a domain U ⊆ J U \subseteq J U ⊆ J and a priority order ◃ U \triangleleft_U ◃ U on it. When m ∣ ∣ U ∣ m \mid|U| m ∣ ∣ U ∣ , a feasible full schedule of U U U is an ordered partition π = ( A 1 , … , A q ) \pi= (A_1,\ldots,A_q) π = ( A 1 , … , A q ) , q = ∣ U ∣ / m q = |U|/m q = ∣ U ∣/ m , into sets of size m m m , such that x , y ∈ U x,y \in U x , y ∈ U and x ≺ f y x \prec_f y x ≺ f y imply that the slot of x x x is strictly earlier than the slot of y y y . This condition makes each slot an antichain. Denote the collection of these schedules by S f ( U ) \mathcal{S}_f(U) S f ( U ) . Set S f ( U ) = ∅ \mathcal{S}_f(U) = \varnothing S f ( U ) = ∅ if m ∤ ∣ U ∣ m \nmid|U| m ∤ ∣ U ∣ or if no such schedule exists. The collection S f ( ∅ ) \mathcal{S}_f(\varnothing) S f ( ∅ ) consists of the empty schedule.
For π ∈ S f ( U ) \pi\in\mathcal{S}_f(U) π ∈ S f ( U ) , sort the jobs of each A t A_t A t by increasing priority position ρ U \rho_U ρ U , and concatenate the resulting lists. Let enc ◃ U ( π ) \operatorname{enc}_{\triangleleft_U}(\pi) enc ◃ U ( π ) be the resulting sequence of ∣ U ∣ |U| ∣ U ∣ priority positions. Compare two such sequences lexicographically: at the first position where they differ, the sequence with the smaller number is earlier. A schedule π ∗ ∈ S f ( U ) \pi^* \in\mathcal{S}_f(U) π ∗ ∈ S f ( U ) is normalized for ◃ U \triangleleft_U ◃ U if
enc ◃ U ( π ∗ ) ≤ l e x enc ◃ U ( π ) for every π ∈ S f ( U ) . \operatorname{enc}_{\triangleleft_U}(\pi^*) \le_{\mathrm{lex}} \operatorname{enc}_{\triangleleft_U}(\pi)
\qquad\text{for every } \pi\in\mathcal{S}_f(U). enc ◃ U ( π ∗ ) ≤ lex enc ◃ U ( π ) for every π ∈ S f ( U ) .
The feasible comparison class contains schedules of exactly U U U , on exactly ∣ U ∣ / m |U|/m ∣ U ∣/ m full slots, using its induced global precedence order. No exterior jobs are included. If U U U is a contiguous interval of a complete witness, these local slots are placed in its original temporal positions; Lemma 7.1 below shows that every feasible replacement preserves the exterior constraints.
For six independent jobs, m = 3 m = 3 m = 3 , and priority 1 ≺ ⋯ ≺ 6 1 \prec\cdots\prec6 1 ≺ ⋯ ≺ 6 , compare π = ( { 1 , 2 , 3 } , { 4 , 5 , 6 } ) \pi= (\{1,2,3\},\{4,5,6\}) π = ({ 1 , 2 , 3 } , { 4 , 5 , 6 }) , π ′ = ( { 1 , 2 , 4 } , { 3 , 5 , 6 } ) \pi' = (\{1,2,4\},\{3,5,6\}) π ′ = ({ 1 , 2 , 4 } , { 3 , 5 , 6 }) . Their encodings are ( 1 , 2 , 3 , 4 , 5 , 6 ) (1,2,3,4,5,6) ( 1 , 2 , 3 , 4 , 5 , 6 ) and ( 1 , 2 , 4 , 3 , 5 , 6 ) (1,2,4,3,5,6) ( 1 , 2 , 4 , 3 , 5 , 6 ) . The first is smaller at the third position; in fact π \pi π is normalized among all feasible full schedules in this example.
Normalization does not mean dividing a priority list into consecutive groups of m m m . For example, let the only precedence be 4 ≺ 1 4 \prec1 4 ≺ 1 , let m = 3 m = 3 m = 3 , and use the priority list ( 3 , 4 , 1 , 2 , 5 , 6 ) (3,4,1,2,5,6) ( 3 , 4 , 1 , 2 , 5 , 6 ) . Its first three jobs cannot share a slot. The normalized full schedule is instead ( { 3 , 4 , 2 } , { 1 , 5 , 6 } ) (\{3,4,2\},\{1,5,6\}) ({ 3 , 4 , 2 } , { 1 , 5 , 6 }) , whose priority-position encoding is ( 1 , 2 , 4 , 3 , 5 , 6 ) (1,2,4,3,5,6) ( 1 , 2 , 4 , 3 , 5 , 6 ) . The first slot uses the earliest feasible three-job choice in this particular example.
Whenever S f ( U ) \mathcal{S}_f(U) S f ( U ) is nonempty, a normalized schedule exists because it is a finite nonempty collection with a total lexicographic comparison. Sorting within a slot is only a comparison convention: its jobs still execute simultaneously. This convention is separate from storing job labels increasingly in the algorithm. Choosing a normalized witness is used only in the existence proof; no efficient procedure for finding it is assumed here.
The data stored at a node and the three invariants. A node consists of a current frame, a complete feasible witness schedule in that frame, boundaries a , b a,b a , b , their temporal interval W = ( a , b ) W=(a,b) W = ( a , b ) , and a list K \mathcal{K} K of global upsets. The full schedule determines what “before,” “after,” and “at a boundary” mean even for jobs outside W W W . Distinct children may use distinct copies of that complete witness. The construction requires the following three invariants; they are additional properties of its annotated nodes, not consequences of merely being a temporal interval.
(I1) Local cone cover. Qualifiers inside W W W precede the right boundary, and nonqualifiers inside W W W descend from the left boundary:
W ∩ Q ( K ) ⊆ P b , W ∖ Q ( K ) ⊆ D a . W \cap Q(\mathcal{K}) \subseteq P_b,\qquad W \setminus Q(\mathcal{K}) \subseteq D_a. W ∩ Q ( K ) ⊆ P b , W ∖ Q ( K ) ⊆ D a .
In particular W ⊆ P b ∪ D a W \subseteq P_b \cup D_a W ⊆ P b ∪ D a . The two cones may overlap. This property does not say that every predecessor of b b b qualifies or that every descendant of a a a fails to qualify.
(I2) Control of qualifying jobs in the past. Every global qualifier occurring at or before the left boundary belongs to its weak predecessor cone:
{ x ∈ Q ( K ) : τ f ( x ) ≤ pos ( a ) } ⊆ P ^ a . \{x \in Q(\mathcal{K}) : \tau_f(x) \le\operatorname{pos}(a)\} \subseteq\widehat{P}_a. { x ∈ Q ( K ) : τ f ( x ) ≤ pos ( a )} ⊆ P a .
This quantifies over J J J , not just W W W . A qualifying job before a a a must precede some job of a a a ; a qualifying job in a a a is included by the weak cone. The invariant will allow later global formulas to exclude all qualifying jobs in the temporal past.
(I3) No improving exchange at the left boundary. First choose any feasible full reordering of the jobs of W W W within exactly their original slots, keeping every job in J ∖ W J \setminus W J ∖ W fixed. For every pair
x ∈ W ∖ D a , y ∈ jobs ( a ) ∩ Q ( K ) , key K ( x ) < l e x key K ( y ) , x \in W \setminus D_a,\qquad y \in\operatorname{jobs}(a) \cap Q(\mathcal{K}),\qquad\operatorname{key}_{\mathcal{K}}(x) <_{\mathrm{lex}} \operatorname{key}_{\mathcal{K}}(y), x ∈ W ∖ D a , y ∈ jobs ( a ) ∩ Q ( K ) , key K ( x ) < lex key K ( y ) ,
exchanging the slots occupied by x x x and y y y , while leaving all other jobs fixed, must make the complete schedule infeasible. Such an exchange moves the better-priority job x x x to the earlier boundary slot and y y y to x x x ’s former slot. It preserves the number of jobs in each slot, so infeasibility here is a failure of a precedence constraint. The keys and the list remain fixed throughout this test. Property (I1) guarantees that the key of x x x is defined: if x ∈ W x \in W x ∈ W were a nonqualifier, it would belong to D a D_a D a .
The phrase any feasible reordering is part of (I3). The condition must remain true after every permitted rearrangement of the interior, not only in the currently displayed witness. This strength is needed when descendants later choose different feasible schedules.
What “vacuous” means. A universally quantified condition is vacuously true when there is no object satisfying the conditions to which it applies. At a left sentinel there is no job y ∈ jobs ( a ) y \in\operatorname{jobs}(a) y ∈ jobs ( a ) , so there is no pair to test in (I3); it is true for that reason. In addition, D a = J D_a=J D a = J makes W ∖ D a = ∅ W \setminus D_a=\varnothing W ∖ D a = ∅ . The set quantified over in (I2) is also empty, since no real job occurs at or before slot position zero. Vacuous truth is a logical statement about an empty range of possibilities; it does not mean that the invariant is omitted or assumed without a condition.
An example satisfying the invariants. Use the three-chain witness ( Z 1 , Z 2 , Z 3 ) (Z_1,Z_2,Z_3) ( Z 1 , Z 2 , Z 3 ) , with actual boundaries a = Z 1 a=Z_1 a = Z 1 , b = Z 3 b=Z_3 b = Z 3 , interval W = Z 2 W=Z_2 W = Z 2 , and list K = ( J ) \mathcal{K}=(J) K = ( J ) . Then every job qualifies, including jobs outside W W W . Since P b = Z 1 ∪ Z 2 P_b=Z_1\cup Z_2 P b = Z 1 ∪ Z 2 , we have W ∩ Q ( K ) = Z 2 ⊆ P b W\cap Q(\mathcal{K})=Z_2\subseteq P_b W ∩ Q ( K ) = Z 2 ⊆ P b . There are no nonqualifying jobs in W W W , so the other inclusion in (I1) holds. The jobs at or before a a a are exactly Z 1 Z_1 Z 1 , and P ^ a = Z 1 \widehat{P}_a=Z_1 P a = Z 1 , proving (I2). Finally W ⊆ D a W\subseteq D_a W ⊆ D a , so there is no x ∈ W ∖ D a x\in W\setminus D_a x ∈ W ∖ D a ; (I3) is vacuously true.
At the root one uses sentinel boundaries and the list ( J ) (J) ( J ) . Then W = J W=J W = J , P b = J P_b=J P b = J , and (I1) holds; (I2) and (I3) are vacuous at the left sentinel. Later lemmas prove that the construction preserves all three properties at children.
How a priority order on the whole node is specified. The key order above applies only to qualifiers. When normalizing the entire node in the subsequent construction, let O = W ∩ Q ( K ) O = W \cap Q(\mathcal{K}) O = W ∩ Q ( K ) and use the following three consecutive priority blocks:
( W ∖ O ) ∩ P b , O , W ∖ P b . (W \setminus O) \cap P_b,\qquad O,\qquad W \setminus P_b. ( W ∖ O ) ∩ P b , O , W ∖ P b .
Order the first and third blocks by global rank and the second by qualifier key. By (I1), O ⊆ P b O \subseteq P_b O ⊆ P b , so these blocks partition W W W . The first block is an ideal of W W W , and the last is an upset of W W W ; hence no precedence edge points from a later block to an earlier one. The internal orders also respect precedence. This specifies a strict total priority order on exactly W W W , including its nonqualifiers.
Lemma 7.1 (Replacement and prefix minimality). Let U U U be the jobs in a contiguous interval of a complete feasible full witness schedule in a fixed frame. Every feasible full schedule of U U U can replace its current schedule within the same slots, with all jobs outside U U U fixed.
Fix also a priority order on U U U , and suppose its current local schedule is normalized for that priority. Let r r r be one of its slots. After any feasible reordering of the jobs in slots of U U U strictly after r r r , keeping r r r and all earlier slots unchanged, no feasible exchange can replace a job y ∈ r y \in r y ∈ r by a later job x ∈ U x \in U x ∈ U with x ≺ U y x \prec_U y x ≺ U y .
Proof. For replacement, consider every precedence relation. Relations between exterior jobs are unchanged. Relations between interior jobs hold by feasibility of the replacement. If an exterior job precedes an interior job, it occurred before the whole interval: it cannot lie in an interior slot, and feasibility excludes its occurring after the interval. Similarly, an exterior successor of an interior job occurs after the whole interval. The replacement uses exactly the same slots, so both types of exterior relation remain satisfied. Each slot still has m m m jobs.
For prefix minimality, suppose the asserted exchange were feasible after the allowed later reordering. Sort each slot by the fixed priority. Every slot before r r r would agree with the original normalized schedule. At r r r , replacing y y y by the better-priority job x x x makes its sorted list lexicographically smaller: in the sorted union of the old and new slot sets, the first differing job is the newly included x x x , which precedes the removed y y y . Thus the resulting feasible schedule of U U U has a smaller encoding than the normalized schedule, regardless of its later slots. This contradicts the definition of normalization. □ \square □
A separator describes a temporal prefix
We work in one fixed frame, so time, precedence, and all cones are interpreted in that frame. Let U ⊆ J U \subseteq J U ⊆ J be the jobs in a nonempty contiguous interval of a feasible full witness schedule. Write its slots in chronological order as
σ U = ( Z 1 , … , Z q ) , U = Z 1 ∪ ˙ ⋯ ∪ ˙ Z q , ∣ Z i ∣ = m . \sigma_U = (Z_1,\ldots,Z_q),\qquad U = Z_1 \mathbin{\dot\cup}\cdots\mathbin{\dot\cup} Z_q,\qquad|Z_i| = m. σ U = ( Z 1 , … , Z q ) , U = Z 1 ∪ ˙ ⋯ ∪ ˙ Z q , ∣ Z i ∣ = m .
Define the local time map τ U : U → { 1 , … , q } \tau_U: U \to\{1,\ldots,q\} τ U : U → { 1 , … , q } by τ U ( x ) = i \tau_U(x) = i τ U ( x ) = i when x ∈ Z i x \in Z_i x ∈ Z i . For a slot z = Z r z = Z_r z = Z r , write pos U ( z ) = r \operatorname{pos}_U(z) = r pos U ( z ) = r . Comparisons of slot positions, such as s < t s < t s < t , refer to these chronological indices. Its strict temporal prefix is
Pref U ( z ) = { x ∈ U : τ U ( x ) < r } . \operatorname{Pref}_U(z) = \{x \in U : \tau_U(x) < r\}. Pref U ( z ) = { x ∈ U : τ U ( x ) < r } .
Cones such as P z P_z P z and D z D_z D z are still computed on all of J J J . They include indirect predecessors and successors as well as direct ones, even when a witnessing precedence path leaves $U.
What a cutoff means. Fix a strict total priority order u 1 ◃ U u 2 ◃ U ⋯ ◃ U u n u_1 \triangleleft_U u_2 \triangleleft_U \cdots\triangleleft_U u_n u 1 ◃ U u 2 ◃ U ⋯ ◃ U u n , n = ∣ U ∣ n = |U| n = ∣ U ∣ , on precisely the domain U U U . It extends the induced precedence order: if x , y ∈ U x,y \in U x , y ∈ U and x ≺ y x \prec y x ≺ y , then x ◃ U y x \triangleleft_U y x ◃ U y . For 0 ≤ k ≤ n 0 \le k \le n 0 ≤ k ≤ n , the priority cutoff at k k k is the set S k = { u 1 , … , u k } S_k = \{u_1,\ldots,u_k\} S k = { u 1 , … , u k } , S 0 = ∅ S_0 = \varnothing S 0 = ∅ . Thus k k k is a position in the priority list, whereas τ U ( x ) \tau_U(x) τ U ( x ) is a position in the schedule. The jobs of S k S_k S k are called low , and the jobs of U ∖ S k U \setminus S_k U ∖ S k are called high . Here low means a smaller position in the priority order: low jobs have earlier, and hence better, priority.
Every cutoff S k S_k S k is an ideal of the induced order on U U U . Indeed, if y ∈ S k y \in S_k y ∈ S k and x ∈ U x \in U x ∈ U precedes y y y , then x x x occurs earlier in the priority list and also belongs to S k S_k S k . Its complement U ∖ S k U \setminus S_k U ∖ S k is an upset on U U U . A cutoff need not be a temporal prefix: an early-priority job can occur late in a feasible schedule. The definition of a separator below also applies to an arbitrary ideal S ⊆ U S \subseteq U S ⊆ U , without first specifying a priority order.
Definition 7.2 (Separator). Let S S S be an ideal of the induced precedence order on U U U . An actual slot z = Z r z = Z_r z = Z r separates S S S on U U U if
x ∈ U ∖ S , τ U ( x ) < r ⟹ x ∈ P z , x ∈ S , τ U ( x ) > r ⟹ x ∈ D z . \begin{aligned}
x \in U \setminus S,\ \tau_U(x) < r &\Longrightarrow x \in P_z,\\
x \in S,\ \tau_U(x) > r &\Longrightarrow x \in D_z.
\end{aligned} x ∈ U ∖ S , τ U ( x ) < r x ∈ S , τ U ( x ) > r ⟹ x ∈ P z , ⟹ x ∈ D z .
We call these the earlier-high property and the later-low property , respectively. The exterior left boundary a a a has local position 0 0 0 and is a separator when S ⊆ D a S \subseteq D_a S ⊆ D a . It may be an actual boundary slot outside U U U or the left sentinel, with the cone conventions of § 7.1 .
The earlier-high property says that every high job already scheduled before z z z precedes at least one job in z z z . The later-low property says that every low job still scheduled after z z z has at least one predecessor in z z z . Neither condition constrains jobs in z z z itself. Nor does separation require all low jobs to be before z z z , or all high jobs to be after it. For the exterior left boundary there are no earlier domain jobs, so only the condition S ⊆ D a S \subseteq D_a S ⊆ D a remains.
Example: a cutoff crossing a separator. Let m = 3 m = 3 m = 3 , and let J = U J = U J = U consist of three independent chains
a 1 ≺ a 2 ≺ a 3 , b 1 ≺ b 2 ≺ b 3 , c 1 ≺ c 2 ≺ c 3 . a_1 \prec a_2 \prec a_3,\qquad b_1 \prec b_2 \prec b_3,\qquad c_1 \prec c_2 \prec c_3. a 1 ≺ a 2 ≺ a 3 , b 1 ≺ b 2 ≺ b 3 , c 1 ≺ c 2 ≺ c 3 .
Consider the feasible schedule
Z 1 = { a 1 , b 1 , c 1 } , Z 2 = { a 2 , b 2 , c 2 } , Z 3 = { a 3 , b 3 , c 3 } . Z_1 = \{a_1,b_1,c_1\},\qquad Z_2 = \{a_2,b_2,c_2\},\qquad Z_3 = \{a_3,b_3,c_3\}. Z 1 = { a 1 , b 1 , c 1 } , Z 2 = { a 2 , b 2 , c 2 } , Z 3 = { a 3 , b 3 , c 3 } .
Use the priority list ( a 1 , a 2 , a 3 , b 1 , b 2 , b 3 , c 1 , c 2 , c 3 ) (a_1,a_2,a_3,b_1,b_2,b_3,c_1,c_2,c_3) ( a 1 , a 2 , a 3 , b 1 , b 2 , b 3 , c 1 , c 2 , c 3 ) and the cutoff S = { a 1 , a 2 , a 3 } S = \{a_1,a_2,a_3\} S = { a 1 , a 2 , a 3 } . The slot z = Z 2 z = Z_2 z = Z 2 separates S S S : the earlier high jobs b 1 , c 1 b_1,c_1 b 1 , c 1 belong to P z P_z P z , and the later low job a 3 a_3 a 3 belongs to D z D_z D z . The low job a 2 a_2 a 2 lies in the separator slot. Thus the same cutoff has a low job before, at, and after the separator. In particular, S ≠ Pref U ( z ) = { a 1 , b 1 , c 1 } S \ne\operatorname{Pref}_U(z) = \{a_1,b_1,c_1\} S = Pref U ( z ) = { a 1 , b 1 , c 1 } .
Turning separation into a global formula. Let H ⊆ J H \subseteq J H ⊆ J be a global set that agrees with the low set on the domain, meaning H ∩ U = S H \cap U = S H ∩ U = S . Define
B z ( H ) = P z ∪ ( H ∖ D ^ z ) , D ^ z = z ∪ D z . B_z(H) = P_z \cup(H \setminus\widehat{D}_z),\qquad\widehat{D}_z = z \cup D_z. B z ( H ) = P z ∪ ( H ∖ D z ) , D z = z ∪ D z .
The term P z P_z P z includes every earlier high job guaranteed by separation. The second term includes low jobs, but removes the separator slot itself and all its descendants. Using the weak cone is essential: subtracting only D z D_z D z would leave low jobs in z z z , although the prefix is strictly before z z z . This expression is global; the intersection with U U U below restricts its answer to the domain under discussion.
Lemma 7.3. (The prefix selected by a separator). Suppose that z z z is an actual separator of S S S on U U U and H ⊆ J H \subseteq J H ⊆ J satisfies H ∩ U = S H \cap U = S H ∩ U = S . Then
Pref U ( z ) = U ∩ B z ( H ) . \operatorname{Pref}_{U}(z) = U \cap B_z(H). Pref U ( z ) = U ∩ B z ( H ) . Reversing both time and precedence and replacing S S S by U ∖ S U \setminus S U ∖ S preserves separation. If, in addition, H H H is a global ideal, then B z ( H ) B_z(H) B z ( H ) is a global ideal.
Proof. 1. Every job before z z z belongs to the formula. Take x ∈ U x \in U x ∈ U with τ U ( x ) < pos U ( z ) \tau_U(x) < \operatorname{pos}_U(z) τ U ( x ) < pos U ( z ) . If x x x is high, separation gives x ∈ P z x \in P_z x ∈ P z . If x x x is low, then x ∈ S = H ∩ U x \in S = H \cap U x ∈ S = H ∩ U , so x ∈ H x \in H x ∈ H . Moreover, x ∉ z x \notin z x ∈ / z , and x ∉ D z x \notin D_z x ∈ / D z : a successor of a job in z z z must be scheduled after z z z in every feasible schedule. Hence x ∈ H ∖ D ^ z x \in H \setminus\widehat{D}_z x ∈ H ∖ D z . Both cases give x ∈ U ∩ B z ( H ) x \in U \cap B_z(H) x ∈ U ∩ B z ( H ) .
2. Every domain job selected by the formula is before z z z . Take x ∈ U ∩ B z ( H ) x \in U \cap B_z(H) x ∈ U ∩ B z ( H ) . If x ∈ P z x \in P_z x ∈ P z , feasibility puts x x x strictly before z z z . Otherwise, x ∈ H ∖ D ^ z x \in H \setminus\widehat{D}_z x ∈ H ∖ D z . Because x ∈ U x \in U x ∈ U , the equality H ∩ U = S H \cap U = S H ∩ U = S makes x x x low. It cannot be in z z z , since z ⊆ D ^ z z \subseteq\widehat{D}_z z ⊆ D z . It cannot be after z z z , since the later-low property would put it in D z ⊆ D ^ z D_z \subseteq\widehat{D}_z D z ⊆ D z . Therefore it is before z z z . Together, these two steps prove the stated equality.
3. Simultaneous reversal preserves separation. In the reversed frame, the old high set U ∖ S U \setminus S U ∖ S becomes the new low set. It is an ideal in the reversed induced order, because it was an upset in the original induced order. An old low job after z z z becomes a new high job before z z z ; its membership in the old D z D_z D z becomes membership in the new P z P_z P z . An old high job before z z z becomes a new low job after z z z ; its membership in the old P z P_z P z becomes membership in the new D z D_z D z . These are exactly the two required conditions.
4. The global formula is an ideal when H H H is one. The set P z P_z P z is a global ideal by transitivity. The weak successor cone D ^ z \widehat{D}_z D z is a global upset, so its complement J ∖ D ^ z J \setminus\widehat{D}_z J ∖ D z is a global ideal. Under the additional hypothesis on H H H ,
H ∖ D ^ z = H ∩ ( J ∖ D ^ z ) H \setminus\widehat{D}_z = H \cap(J \setminus\widehat{D}_z) H ∖ D z = H ∩ ( J ∖ D z )
is an intersection of ideals, and B z ( H ) B_z(H) B z ( H ) is a union of ideals. It is therefore a global ideal. This additional hypothesis is not needed for the prefix equality.
For an exterior left separator a a a , the same formula selects the empty domain prefix. Indeed, feasibility gives U ∩ P a = ∅ U \cap P_a = \varnothing U ∩ P a = ∅ , and H ∩ U = S ⊆ D a H \cap U = S \subseteq D_a H ∩ U = S ⊆ D a gives U ∩ ( H ∖ D ^ a ) = ∅ U \cap(H \setminus\widehat{D}_a) = \varnothing U ∩ ( H ∖ D a ) = ∅ . These statements also hold with the left sentinel conventions.
Checking the formula in examples. In the three-chain example, take H = S H = S H = S and z = Z 2 z = Z_2 z = Z 2 . Then P z = Z 1 P_z = Z_1 P z = Z 1 , D ^ z = Z 2 ∪ Z 3 \widehat{D}_z = Z_2 \cup Z_3 D z = Z 2 ∪ Z 3 , H ∖ D ^ z = { a 1 } H \setminus\widehat{D}_z = \{a_1\} H ∖ D z = { a 1 } , so U ∩ B z ( H ) = Z 1 U \cap B_z(H) = Z_1 U ∩ B z ( H ) = Z 1 , exactly as required. To see why the H H H term is needed in general, instead take six independent jobs with schedule ( { 1 , 2 , 3 } , { 4 , 5 , 6 } ) (\{1,2,3\}, \{4,5,6\}) ({ 1 , 2 , 3 } , { 4 , 5 , 6 }) . The second slot z = { 4 , 5 , 6 } z = \{4,5,6\} z = { 4 , 5 , 6 } separates S = H = { 1 , 2 , 3 } S = H = \{1,2,3\} S = H = { 1 , 2 , 3 } . Here P z = D z = ∅ P_z = D_z = \varnothing P z = D z = ∅ , yet the unguarded prefix is nonempty: B z ( H ) = H ∖ z = { 1 , 2 , 3 } B_z(H) = H \setminus z = \{1,2,3\} B z ( H ) = H ∖ z = { 1 , 2 , 3 } .
The restriction to U U U is equally necessary. Return to the three chains, but now use the smaller domain U ′ = Z 2 ∪ Z 3 U' = Z_2 \cup Z_3 U ′ = Z 2 ∪ Z 3 , the local ideal S ′ = Z 2 S' = Z_2 S ′ = Z 2 , the global ideal H ′ = Z 1 ∪ Z 2 H' = Z_1 \cup Z_2 H ′ = Z 1 ∪ Z 2 , and separator z ′ = Z 3 z' = Z_3 z ′ = Z 3 . The formula gives B z ′ ( H ′ ) = Z 1 ∪ Z 2 B_{z'}(H') = Z_1 \cup Z_2 B z ′ ( H ′ ) = Z 1 ∪ Z 2 on the entire ground set. Its restriction to U ′ U' U ′ is Z 2 Z_2 Z 2 , the desired local prefix. The jobs of Z 1 Z_1 Z 1 are outside U ′ U' U ′ and must not be counted.
Moving between consecutive priority cutoffs
Now fix a priority order on U U U and normalize its full schedule. For consecutive cutoffs S = S k S = S_k S = S k and S + = S k + 1 = S ∪ { j } S^+ = S_{k+1} = S \cup\{j\} S + = S k + 1 = S ∪ { j } , the job j = u k + 1 j = u_{k+1} j = u k + 1 changes from high to low. We call this change a promotion . It changes the classification of a job, not its time slot. Likewise, the walk below moves a separator position through a fixed normalized schedule; it does not reschedule jobs.
For a current position r r r , call x x x a low exception for a low set L L L if x ∈ L x \in L x ∈ L , τ U ( x ) > pos U ( r ) \tau_U(x) > \operatorname{pos}_U(r) τ U ( x ) > pos U ( r ) , x ∉ D r x \notin D_r x ∈ / D r . Such a job is exactly a violation of the later-low property at r r r . The next position is the earliest later slot containing any low exception. If several exceptions share that slot, the next position is still unambiguous; any one of them can be used in the proof.
Lemma 7.4 (Common-cutoff walk). Fix a full schedule of U U U normalized for a specified priority order. Let S S S and S + = S ∪ { j } S^+ = S \cup\{j\} S + = S ∪ { j } be consecutive prefixes of that order. Suppose that s s s separates S S S , where s s s is an actual slot in U U U or its exterior left boundary. Starting at r = s r = s r = s , repeatedly apply the following rule: if there is a low exception for S + S^+ S + at r r r , replace r r r by the earliest later slot containing such an exception; otherwise stop. The process terminates at a position t ≥ s t \ge s t ≥ s that separates both S S S and S + S^+ S + .
If the priority order is instead specified on a larger domain V ⊇ U V \supseteq U V ⊇ U , use its restriction to U U U and normalize for that restriction. A promotion of a job outside U U U leaves the restricted cutoff and the separator position unchanged.
Proof. We first prove a fact about one advance for a fixed priority prefix L ⊆ U L \subseteq U L ⊆ U . Assume that the current position r r r has the earlier-high property for L L L ; we do not assume that it already has the later-low property. Let t > r t > r t > r be the earliest slot containing a low exception x x x .
1. All domain predecessors of x x x occur strictly before r r r . If p ∈ U p \in U p ∈ U and p ≺ x p \prec x p ≺ x , then p ∈ L p \in L p ∈ L , because L L L is an ideal. Feasibility puts p p p before the slot t t t of x x x . It cannot be in r r r : that would make x x x a descendant of r r r . If it were strictly between r r r and t t t , earliestness of the exception slot would imply p ∈ D r p \in D_r p ∈ D r . Transitivity would again give x ∈ D r x \in D_r x ∈ D r , contrary to the choice of x x x . Thus every such predecessor is strictly before r r r . If r r r is exterior, this says that x x x has no predecessor in U U U .
2. Every high job from r r r up to t t t has a successor by t t t . Let y ∈ U ∖ L y \in U \setminus L y ∈ U ∖ L satisfy
pos U ( r ) ≤ τ U ( y ) < pos U ( t ) . \operatorname{pos}_U(r) \le\tau_U(y) < \operatorname{pos}_U(t). pos U ( r ) ≤ τ U ( y ) < pos U ( t ) .
Suppose, for a contradiction, that y y y has no successor in U U U scheduled at or before t t t . Exchange x x x and y y y . Moving x x x to the old slot of y y y crosses no predecessor of x x x , by Step 1. Moving y y y to t t t crosses no successor of y y y , by the supposition. The other precedence inequalities remain valid, and each slot still contains exactly m m m jobs. Exterior constraints remain valid by Lemma 7.1. The exchange is therefore feasible.
Since L L L is a priority prefix, the low job x x x has better priority than the high job y y y . The first changed slot is the old slot of y y y ; replacing y y y by x x x makes its priority-sorted list lexicographically smaller. This contradicts normalization. Consequently, y y y has a successor y 1 ∈ U y_1 \in U y 1 ∈ U at or before t t t . The successor is also high, because U ∖ L U \setminus L U ∖ L is an upset.
3. Such high jobs actually precede a job in t t t . If y 1 y_1 y 1 is in t t t , this is already established. Otherwise apply Step 2 to y 1 y_1 y 1 , obtaining a later high successor y 2 y_2 y 2 still at or before t t t . Continuing gives a chain
y ≺ y 1 ≺ y 2 ≺ ⋯ . y \prec y_1 \prec y_2 \prec\cdots. y ≺ y 1 ≺ y 2 ≺ ⋯ .
The slot indices strictly increase and are bounded above by the index of t t t . Thus the chain must reach a high job in t t t . In particular, every high job at or after r r r and before t t t belongs to P t P_t P t .
4. The earlier-high property survives the advance. Step 3 deals with the high jobs between r r r and t t t , including those in r r r . If r r r is internal and a high job y y y is earlier than r r r , the assumed earlier-high property gives a job w ∈ r w \in r w ∈ r with y ≺ w y \prec w y ≺ w . The job w w w is high, by upward closure. Step 3 puts w w w in P t P_t P t , and transitivity puts y y y in P t P_t P t . At an exterior r r r there are no earlier jobs of U U U to consider. Every high job before t t t therefore belongs to P t P_t P t .
5. Apply this fact to the new cutoff S + S^+ S + . Initially s s s has the earlier-high property for S + S^+ S + , since U ∖ S + ⊆ U ∖ S U \setminus S^+ \subseteq U \setminus S U ∖ S + ⊆ U ∖ S . Steps 1–4 preserve this property at every advance. On termination there is no later low exception for S + S^+ S + , which is precisely its later-low property. Thus the final position separates S + S^+ S + . 6. The final position also separates the old cutoff S S S . If there is no advance, t = s t=s t = s already separates S S S . Otherwise, the first exception must be j j j : every old low job after s s s lies in D s D_s D s , because s s s separates S S S . At the first target slot, j j j is in the slot itself, so it is not an earlier high job for the old cutoff. All other old high jobs are high for S + S^{+} S + ; Step 4 has already established the required predecessor relation for them. The first target therefore has the earlier-high property for S S S as well as for S + S^{+} S + .
At every subsequent advance, j j j is at or before the current position. Hence any later exception belongs to the old set S S S . The earliest exception slot for S + S^{+} S + is now also the earliest exception slot for S S S . We may apply Steps 1–4 with L = S L=S L = S , which preserves the earlier-high property for the old cutoff. Finally, the later-low property for S + S^{+} S + implies that for S ⊆ S + S \subseteq S^{+} S ⊆ S + . Both separator conditions for S S S hold at the end.
7. Termination and exterior promotions. Each advance strictly increases the slot index, and there are only q q q actual slots, so the process terminates. For consecutive prefixes A A A and A ∪ { j } A \cup\{j\} A ∪ { j } of an order on V ⊇ U V \supseteq U V ⊇ U , if j ∉ U j \notin U j ∈ / U then
A ∩ U = ( A ∪ { j } ) ∩ U . A \cap U = (A \cup\{j\}) \cap U. A ∩ U = ( A ∪ { j }) ∩ U .
The local low set has not changed, so its existing separator remains valid and the position is left unchanged. If j ∈ U j \in U j ∈ U , the restricted prefixes differ by exactly this one job, and the preceding argument applies. □ \square □
Example: one promotion requiring two advances. Let m = 3 m=3 m = 3 and U = J = { a , b , c , d , e , x , j , h , k } U=J=\{a,b,c,d,e,x,j,h,k\} U = J = { a , b , c , d , e , x , j , h , k } . The only precedence edges are a ≺ x a \prec x a ≺ x , b ≺ d b \prec d b ≺ d , c ≺ e c \prec e c ≺ e , j ≺ h j \prec h j ≺ h , and use the priority list ( a , b , c , d , e , x , j , h , k ) (a,b,c,d,e,x,j,h,k) ( a , b , c , d , e , x , j , h , k ) . The normalized full schedule is Z 1 = { a , b , c } Z_1=\{a,b,c\} Z 1 = { a , b , c } , Z 2 = { d , e , j } Z_2=\{d,e,j\} Z 2 = { d , e , j } , Z 3 = { x , h , k } Z_3=\{x,h,k\} Z 3 = { x , h , k } . To verify normalization, the lexicographically smallest possible first slot is { a , b , c } \{a,b,c\} { a , b , c } , and the displayed schedule completes it. For the second slot, the three smallest remaining jobs { d , e , x } \{d,e,x\} { d , e , x } would leave { j , h , k } \{j,h,k\} { j , h , k } for the last slot, which is infeasible because j ≺ h j \prec h j ≺ h . The next smallest choice { d , e , j } \{d,e,j\} { d , e , j } admits the displayed completion. Thus the schedule is lexicographically smallest among feasible full schedules.
Start with the cutoff S = { a , b , c , d , e , x } S=\{a,b,c,d,e,x\} S = { a , b , c , d , e , x } and position s = Z 1 s=Z_1 s = Z 1 . It is a separator: there are no earlier high jobs, and the later low jobs d , e , x d,e,x d , e , x all belong to D Z 1 = { d , e , x } D_{Z_1}=\{d,e,x\} D Z 1 = { d , e , x } . Promote j j j , so that S + = S ∪ { j } S^{+}=S\cup\{j\} S + = S ∪ { j } .
At Z 1 Z_1 Z 1 , the newly low job j j j is later and does not belong to D Z 1 D_{Z_1} D Z 1 . The first exception is in Z 2 Z_2 Z 2 , so move to Z 2 Z_2 Z 2 .
At Z 2 Z_2 Z 2 , the old low job x x x is still later, but D Z 2 = { h } D_{Z_2}=\{h\} D Z 2 = { h } does not contain x x x . Thus move again, to Z 3 Z_3 Z 3 .
At Z 3 Z_3 Z 3 there are no later jobs, so the walk stops. For the old cutoff S S S , the only earlier high job is j j j , and j ≺ h j \prec h j ≺ h puts it in P Z 3 P_{Z_3} P Z 3 . For the new cutoff S + S^{+} S + , the high jobs h , k h,k h , k are in Z 3 Z_3 Z 3 itself. Both cutoffs are therefore separated at the final position.
The changing descendant cones explain why reaching the promoted job does not necessarily finish the walk: x x x was covered by D Z 1 D_{Z_1} D Z 1 but is not covered by D Z 2 D_{Z_2} D Z 2 . The proof’s exchange argument is also visible here. Swapping the low job x x x with the old high job j j j would improve the second slot, but would put j j j into the same slot as its successor h h h . That successor is precisely the obstruction used in the proof.
Why the common cutoff matters for the hierarchy. The starting position s s s separates S S S , and the final position t t t separates both S S S and S + S^{+} S + . Thus s s s and t t t share the old cutoff S S S . If H ∩ U = S H \cap U=S H ∩ U = S , Lemma 7.3 describes both endpoint prefixes using the same global set H H H . This is information needed when the construction forms the open child interval between the endpoints. Intermediate positions of a walk need not separate either cutoff: in the example, Z 2 Z_2 Z 2 fails the later-low condition because of x x x . The construction therefore retains the final endpoint of a promotion, rather than marking every intermediate advance.
Corollary 7.5 (An actual separator). Every priority prefix in a nonempty normalized full schedule has an actual separator. Every ideal of a feasible nonempty full-slot domain has an actual separator in some feasible full schedule of that domain.
Proof. For the first assertion, begin at the first actual slot Z 1 Z_1 Z 1 with the empty cutoff S 0 = ∅ S_0 = \varnothing S 0 = ∅ . There are no earlier domain jobs and no low jobs, so both separator conditions hold. Promote the jobs one by one in priority order. Lemma 7.4 supplies a separator for the new cutoff after each promotion. The position either remains at an actual slot or advances to another actual slot. Induction therefore gives an actual separator for every cutoff, including the empty and full cutoffs.
For the second assertion, let I ⊆ U I \subseteq U I ⊆ U be an arbitrary ideal. Choose a topological order of the induced order on I I I and then a topological order on U ∖ I U \setminus I U ∖ I , and concatenate them. No precedence can point from U ∖ I U \setminus I U ∖ I into I I I , by the ideal property, so this is a priority order on all of U U U extending precedence. In that order I I I is a prefix. A feasible full schedule exists by hypothesis; normalize among such schedules for the chosen priority and apply the first assertion. The resulting separator is in this chosen normalized schedule. The assertion does not require every feasible schedule to contain a separator for I I I .
The construction at one node
We now construct the marked slots and children of a nonempty node W = ( a , b ) W = (a,b) W = ( a , b ) . The node comes with a complete feasible witness schedule, a current frame, and a list K = ( K 1 , … , K ℓ ) \mathcal{K} = (K_1,\ldots,K_\ell) K = ( K 1 , … , K ℓ ) of global upsets satisfying (I1)–(I3). An empty node needs no construction. All precedence relations, cones, ranks, and time comparisons below use the current frame until a reversal is explicitly made.
A mark is an actual full slot retained by the construction. The center v v v is one distinguished marked slot: we first construct the part before v v v in the current frame, then process the part after v v v in the reversed frame. A child is the job set in a nonempty open gap between consecutive retained boundaries. A child before the center inherits the current frame and is called a same-direction child . A child on the other side inherits the reversed frame and is an opposite-side child . These names describe how the child is processed; they do not assert that all its jobs are precedence-related to the center.
The old qualifier priority order. Here old means belonging to the parent list K \mathcal{K} K before we construct a child’s list. Recall
Q ( K ) = ⋃ i = 1 ℓ K i , O = W ∩ Q ( K ) . Q(\mathcal{K}) = \bigcup_{i=1}^{\ell} K_i,\qquad O = W \cap Q(\mathcal{K}). Q ( K ) = i = 1 ⋃ ℓ K i , O = W ∩ Q ( K ) .
Thus Q ( K ) Q(\mathcal{K}) Q ( K ) is the set of global qualifiers, whereas O O O contains only qualifiers inside the current node. For x ∈ Q ( K ) x \in Q(\mathcal{K}) x ∈ Q ( K ) , put
i K ( x ) = max { i : x ∈ K i } , key K ( x ) = ( i K ( x ) , rank ( x ) ) . i_{\mathcal{K}}(x) = \max\{i : x \in K_i\},\qquad\operatorname{key}_{\mathcal{K}}(x) = (i_{\mathcal{K}}(x),\operatorname{rank}(x)). i K ( x ) = max { i : x ∈ K i } , key K ( x ) = ( i K ( x ) , rank ( x )) .
The old qualifier priority order is the increasing lexicographic order of these keys on the specified domain Q ( K ) Q(\mathcal{K}) Q ( K ) . The first coordinate is compared first; the rank breaks ties. If a job occurs in several entries, its last membership determines the first coordinate. Restricting this order to O O O gives the order in which the node’s qualifiers will be promoted. This order compares jobs; it does not specify their time slots.
Suffixes and carries. For an ordered list ( x 1 , … , x s ) (x_1,\ldots,x_s) ( x 1 , … , x s ) , a suffix is a final segment ( x k , … , x s ) (x_k,\ldots,x_s) ( x k , … , x s ) , including its first retained element. The entire list and the empty list are also allowed suffixes. For example, ( x 3 , x 4 , x 5 ) (x_3,x_4,x_5) ( x 3 , x 4 , x 5 ) is a suffix of ( x 1 , x 2 , x 3 , x 4 , x 5 ) (x_1,x_2,x_3,x_4,x_5) ( x 1 , x 2 , x 3 , x 4 , x 5 ) . We use a suffix of the qualifier order to keep the jobs whose old keys are at least a specified threshold.
A carry is the ordered list of global sets representing the retained suffix. For an entry index 1 ≤ d ≤ ℓ 1 \le d \le\ell 1 ≤ d ≤ ℓ and a global rank threshold 1 ≤ r ≤ N + 1 1 \le r \le N+1 1 ≤ r ≤ N + 1 , define
R r = { x ∈ J : rank ( x ) ≥ r } , carry d , r ( K ) = ( K d ∩ R r , K d + 1 , … , K ℓ ) . R_r = \{x \in J : \operatorname{rank}(x) \ge r\}, \qquad\operatorname{carry}_{d,r}(\mathcal{K}) = (K_d \cap R_r, K_{d+1}, \ldots, K_\ell). R r = { x ∈ J : rank ( x ) ≥ r } , carry d , r ( K ) = ( K d ∩ R r , K d + 1 , … , K ℓ ) .
Here r r r is a number in the global rank order, not a time slot. This operation discards entries before K d K_d K d , restricts the first retained entry by rank, and keeps every later entry unchanged. Its qualifier union is exactly
{ x ∈ Q ( K ) : key K ( x ) ≥ l e x ( d , r ) } . \{x \in Q(\mathcal{K}) : \operatorname{key}_{\mathcal{K}}(x) \ge_{\mathrm{lex}} (d,r)\}. { x ∈ Q ( K ) : key K ( x ) ≥ lex ( d , r )} .
The empty carry is the empty list, whose union is ∅ \varnothing ∅ . It is used when there are no jobs to retain. Even when the threshold is selected using jobs of W W W , the carried entries remain global subsets of J J J and can contain exterior jobs.
Example of overlapping entries and a suffix carry. Take six independent jobs with ranks equal to their labels and
K 1 = { 1 , 2 , 5 } , K 2 = { 2 , 3 , 6 } , K 3 = { 4 , 5 , 6 } . K_1 = \{1,2,5\}, \qquad K_2 = \{2,3,6\}, \qquad K_3 = \{4,5,6\}. K 1 = { 1 , 2 , 5 } , K 2 = { 2 , 3 , 6 } , K 3 = { 4 , 5 , 6 } .
Every set here is an upset because there are no precedences. The largest membership indices give the keys
( 1 , 1 ) , ( 2 , 2 ) , ( 2 , 3 ) , ( 3 , 4 ) , ( 3 , 5 ) , ( 3 , 6 ) (1,1), \quad(2,2), \quad(2,3), \quad(3,4), \quad(3,5), \quad(3,6) ( 1 , 1 ) , ( 2 , 2 ) , ( 2 , 3 ) , ( 3 , 4 ) , ( 3 , 5 ) , ( 3 , 6 )
for jobs 1 , 2 , 3 , 4 , 5 , 6 1,2,3,4,5,6 1 , 2 , 3 , 4 , 5 , 6 , respectively. In particular, job 5 uses its membership in K 3 K_3 K 3 , although it also belongs to K 1 K_1 K 1 . The threshold ( d , r ) = ( 2 , 3 ) (d,r)=(2,3) ( d , r ) = ( 2 , 3 ) gives
carry 2 , 3 ( K ) = ( { 3 , 6 } , { 4 , 5 , 6 } ) . \operatorname{carry}_{2,3}(\mathcal{K}) = (\{3,6\},\{4,5,6\}). carry 2 , 3 ( K ) = ({ 3 , 6 } , { 4 , 5 , 6 }) .
Its qualifier union is the old suffix { 3 , 4 , 5 , 6 } \{3,4,5,6\} { 3 , 4 , 5 , 6 } . The numerical entry indices have changed, but the relative priority order of these four jobs is still 3 , 4 , 5 , 6 3,4,5,6 3 , 4 , 5 , 6 .
Pruning a list on a child. For any ordered list L = ( L 1 , … , L s ) \mathcal{L}=(L_1,\ldots,L_s) L = ( L 1 , … , L s ) of global sets and any child domain V V V , pruning on V V V deletes exactly the entries L i L_i L i satisfying L i ∩ V = ∅ L_i \cap V = \varnothing L i ∩ V = ∅ . The surviving entries keep their order and are then numbered consecutively. We write the result as prune V ( L ) \operatorname{prune}_V(\mathcal{L}) prune V ( L ) . Every retained entry is the whole global set L i L_i L i . In particular, pruning does not replace it by L i ∩ V L_i \cap V L i ∩ V .
For the carried list ( { 3 , 6 } , { 4 , 5 , 6 } ) (\{3,6\},\{4,5,6\}) ({ 3 , 6 } , { 4 , 5 , 6 }) above, take V = { 1 , 2 , 3 } V=\{1,2,3\} V = { 1 , 2 , 3 } . The first entry meets V V V at job 3 and is retained; the second does not meet V V V and is deleted. Thus
prune V ( ( { 3 , 6 } , { 4 , 5 , 6 } ) ) = ( { 3 , 6 } ) . \operatorname{prune}_V((\{3,6\},\{4,5,6\})) = (\{3,6\}). prune V (({ 3 , 6 } , { 4 , 5 , 6 })) = ({ 3 , 6 }) .
Job 6 remains a global qualifier even though it lies outside V V V . In general, pruning preserves precisely the qualifiers inside V V V :
V ∩ Q ( prune V ( L ) ) = V ∩ Q ( L ) . V \cap Q(\operatorname{prune}_V(\mathcal{L})) = V \cap Q(\mathcal{L}). V ∩ Q ( prune V ( L )) = V ∩ Q ( L ) .
It can change global membership and the keys of exterior jobs.
An injection is a newly appended global upset. An injection is a new entry added to the end of a carried list. It is not a function or a movement of jobs. For boundary sets A , B A, B A , B in a fixed frame, define its job set by
I ( A , B ) = D A ∖ P B . I(A,B)=D_A\setminus P_B. I ( A , B ) = D A ∖ P B .
It contains the descendants of A A A that do not precede any job in B B B . This is a global upset: D A D_A D A is an upset, P B P_B P B is an ideal, and I ( A , B ) = D A ∩ ( J ∖ P B ) I(A,B)=D_A\cap(J\setminus P_B) I ( A , B ) = D A ∩ ( J ∖ P B ) is an intersection of upsets. Sentinel boundaries use the cone conventions from § 7.1 .
In the node construction the fresh entry is I ( a , b ) I(a,b) I ( a , b ) . By (I1), W ⊆ D a ∪ P b W\subseteq D_a\cup P_b W ⊆ D a ∪ P b , and therefore
W ∩ I ( a , b ) = W ∖ P b . W\cap I(a,b)=W\setminus P_b. W ∩ I ( a , b ) = W ∖ P b .
Indeed, a job of W W W outside P b P_b P b must belong to D a D_a D a . The injection supplies exactly this part of the parent domain. The entry itself may contain additional jobs outside W W W . Appending it last puts its jobs in the last priority block. Jobs selected only by the carry come before that block. A job in both the injection and a carried entry uses the injection’s later index.
For a concrete example, let A = { a 1 , b 1 , c 1 } A=\{a_1,b_1,c_1\} A = { a 1 , b 1 , c 1 } , W = { a 2 , b 2 , c 2 } W=\{a_2,b_2,c_2\} W = { a 2 , b 2 , c 2 } , and B = { a 3 , b 3 , c 3 } B=\{a_3,b_3,c_3\} B = { a 3 , b 3 , c 3 } be three consecutive full slots. Use the chains a 1 ≺ a 2 ≺ a 3 a_1\prec a_2\prec a_3 a 1 ≺ a 2 ≺ a 3 and b 1 ≺ b 2 ≺ b 3 b_1\prec b_2\prec b_3 b 1 ≺ b 2 ≺ b 3 , the relation c 1 ≺ c 2 c_1\prec c_2 c 1 ≺ c 2 , and no other precedence involving the c c c -jobs. Then
D A = { a 2 , a 3 , b 2 , b 3 , c 2 } , P B = { a 1 , a 2 , b 1 , b 2 } , I ( A , B ) = { a 3 , b 3 , c 2 } . D_A=\{a_2,a_3,b_2,b_3,c_2\},\qquad P_B=\{a_1,a_2,b_1,b_2\},\qquad I(A,B)=\{a_3,b_3,c_2\}. D A = { a 2 , a 3 , b 2 , b 3 , c 2 } , P B = { a 1 , a 2 , b 1 , b 2 } , I ( A , B ) = { a 3 , b 3 , c 2 } .
Its restriction to W W W is just { c 2 } = W ∖ P B \{c_2\}=W\setminus P_B { c 2 } = W ∖ P B . The boundary jobs a 3 , b 3 a_3,b_3 a 3 , b 3 remain in the global entry.
Lemma 7.6 (Carry and pruning comparisons). A suffix carry retains exactly the global qualifiers whose old keys are at least its threshold ( d , r ) (d,r) ( d , r ) , and preserves their relative key order. For pruning, let L ′ = prune V ( L ) L'=\operatorname{prune}_V(L) L ′ = prune V ( L ) . If x ∈ V ∩ Q ( L ′ ) x\in V\cap Q(L') x ∈ V ∩ Q ( L ′ ) and y ∈ Q ( L ′ ) y\in Q(L') y ∈ Q ( L ′ ) satisfy
key L ′ ( x ) < lex key L ′ ( y ) , \operatorname{key}_{L'}(x)<_{\operatorname{lex}}\operatorname{key}_{L'}(y), key L ′ ( x ) < lex key L ′ ( y ) , then the same strict comparison holds for their keys in L L L , before pruning. All entries obtained by carrying, appending an injection, and pruning remain global upsets.
Proof. Carry membership and order. Let i i i be a job’s largest old membership index. If i < d i<d i < d , every entry containing it is discarded. If i = d i=d i = d , it survives exactly when its rank is at least r r r . If i > d i>d i > d , its membership in K i K_i K i survives unchanged. These are precisely the conditions for an old key at least ( d , r ) (d,r) ( d , r ) . For surviving jobs, the largest index becomes i − d + 1 i-d+1 i − d + 1 , and ranks do not change. This increasing renumbering preserves every relative key comparison.
Pruning comparisons. Temporarily refer to retained entries by their original indices. For a job z z z , write M ( z ) M(z) M ( z ) for its largest index before pruning and M ′ ( z ) M'(z) M ′ ( z ) for its largest retained original index. Every entry containing x ∈ V x\in V x ∈ V meets V V V , so none of those entries is removed. Hence M ′ ( x ) = M ( x ) M'(x)=M(x) M ′ ( x ) = M ( x ) . For the possibly exterior job y y y , some memberships may disappear, but M ′ ( y ) ≤ M ( y ) M'(y)\leq M(y) M ′ ( y ) ≤ M ( y ) . Consecutive renumbering of retained indices preserves their order. If the new comparison is decided by indices, then M ( x ) = M ′ ( x ) < M ′ ( y ) ≤ M ( y ) M(x)=M'(x)<M'(y)\leq M(y) M ( x ) = M ′ ( x ) < M ′ ( y ) ≤ M ( y ) . If retained indices tie, either M ( y ) > M ( x ) M(y)>M(x) M ( y ) > M ( x ) already, or the old indices also tie and the unchanged ranks decide the comparison. In both cases the old key of x x x is smaller. The requirement x ∈ V x\in V x ∈ V is essential to this argument.
Closure. Rank suffixes are upsets because ranks increase along precedence. Intersecting the first carried entry with a rank suffix preserves upward closure. Injections are upsets by the argument above, and pruning only deletes entries. ∎
Notation and order of the construction. We now work at a nonempty node W = ( a , b ) W=(a,b) W = ( a , b ) with its currently chosen frame and its inherited list K = ( K 1 , … , K ℓ ) \mathcal{K}=(K_1,\ldots,K_{\ell}) K = ( K 1 , … , K ℓ ) . All cones, ranks, and temporal comparisons refer to this frame unless we explicitly reverse it. Write
Q = Q ( K ) , O = W ∩ Q . Q=Q(\mathcal{K}),\qquad O=W\cap Q. Q = Q ( K ) , O = W ∩ Q .
Thus Q Q Q is a global upset, while O O O is the set of qualifiers in W W W . An associated cutoff S S S will always be a subset of W W W ; its complement W ∖ S W\setminus S W ∖ S consists of the jobs called high for that cutoff. The interval between two retained boundary positions p < q p<q p < q will be denoted V = ( p , q ) V=(p,q) V = ( p , q ) . The letters p , q p,q p , q refer to slots or sentinels , while V V V is their open job set. In Step 3 the symbols a , b a,b a , b are reused after reversing the frame; they then denote the new left and right boundaries, respectively.
The construction has four operations. First it determines a normalized schedule and a center slot v v v . Next it creates the gaps before v v v . It then processes the opposite side in the reversed frame. Finally it gives every nonempty gap a new list of global upsets. The cutoffs used to describe the gaps are witness data ; no cutoff or normalized schedule has to be computed by the scheduling algorithm in § 2 –§ 6 .
Step 1: normalize the whole parent and choose a center. Purpose. We want separator positions whose associated cutoffs have a particularly simple description in terms of the old list. To that end, arrange the jobs of W W W in the following three priority blocks (a block is a consecutive portion of a priority list):
( W ∖ O ) ∩ P b O W ∖ P b . (4) (W\setminus O)\cap P_b
\qquad
O
\qquad
W\setminus P_b . \tag*{(4)} ( W ∖ O ) ∩ P b O W ∖ P b . (4)
Empty blocks are permitted. Within the first and third blocks use increasing global rank; within the second block use increasing old qualifier key key K \operatorname{key}_{\mathcal{K}} key K .
Why is this a precedence extension? By (I1), O ⊆ P b O\subseteq P_b O ⊆ P b , so the blocks are disjoint and cover exactly W W W . Since Q Q Q is a global upset, W ∖ O W\setminus O W ∖ O is an ideal of the order induced on W W W . The predecessor cone P b P_b P b is a global ideal. Their intersection, the first block, is therefore an ideal of W W W . The third block is the complement in W W W of the ideal W ∩ P b W\cap P_b W ∩ P b , and hence an upset of W W W . No precedence can consequently point from a later block to an earlier one. Increasing rank respects precedence in the first and third blocks; the qualifier key order respects precedence in the second. This proves that the concatenation in (4) is a priority order on all of W W W .
Replace the current schedule of W W W , within its existing temporal positions, by a feasible full schedule normalized for this priority. Lemma 7.1 justifies this replacement without moving any job outside W W W . Normalization is chosen only for the existence proof.
The initial low cutoff is the first priority block,
S 0 = ( W ∖ O ) ∩ P b . S_0=(W\setminus O)\cap P_b. S 0 = ( W ∖ O ) ∩ P b .
Every job of S 0 S_0 S 0 is a nonqualifier, so invariant (I1) implies S 0 ⊆ D a S_0\subseteq D_a S 0 ⊆ D a . Hence the exterior left boundary a a a separates S 0 S_0 S 0 and serves as the starting position of the separator walk.
Retained separator positions and marked slots. We distinguish a separator position from a marked slot . Initially, the boundary a a a is the only retained separator position . It is an exterior boundary, not a marked slot of W W W .
Promote the jobs of O O O one by one in increasing old key order. Suppose that the next promoted job is j j j , and write S S S for the low cutoff immediately before its promotion. The new cutoff is S + = S ∪ { j } S^+=S\cup\{j\} S + = S ∪ { j } . Starting at the current retained separator position p p p , apply the walk of Lemma 7.4 until it stops at a position q ≥ p q\ge p q ≥ p . We call q q q the final separator position of this promotion. The common-cutoff conclusion of Lemma 7.4 states that both p p p and q q q separate S S S , and that q q q also separates S + S^{+} S + .
If q > p q>p q > p , retain q q q as the new separator position. Because q q q is an actual full slot of W W W , we call that slot a marked slot , or simply a mark . If q = p q=p q = p , update the cutoff to S + S^{+} S + but retain no additional position and create no new mark. A single promotion may visit several slots before its walk stops; these intermediate positions are not marked. Thus only distinct final separator positions of completed promotion walks become marks.
After each promotion the low cutoff is S 0 S_0 S 0 together with the jobs of O O O promoted so far. Since the separator walks never move backward in time, the retained positions are strictly increasing. If a promotion advances from a retained position p p p to a new retained position q q q , the open interval ( p , q ) (p,q) ( p , q ) is assigned the cutoff S S S before that promotion. Both endpoints separate this common cutoff by Lemma 7.4 ; this fact is used in Step 2 and Lemma 7.7 .
After all jobs of O O O have been promoted, the exhausted cutoff is
S e n d = S 0 ∪ O = W ∩ P b . S_{\mathrm{end}} = S_0 \cup O = W \cap P_b. S end = S 0 ∪ O = W ∩ P b .
The term exhausted refers only to the second block: the jobs of W ∖ P b W \setminus P_b W ∖ P b have not been promoted. If the walk has reached an actual position, call its last distinct actual endpoint v v v ; repeated promotions preserve the separator property, so v v v separates S e n d S_{\mathrm{end}} S end . If all positions stayed at the exterior boundary a a a , use Corollary 7.5 to select an actual separator v v v for S e n d S_{\mathrm{end}} S end . This slot is the center . At the root, b b b is the right sentinel, P b = J P_b=J P b = J , and the last actual slot may be chosen as v v v , leaving no opposite side to process.
Step 2: form the same-direction gaps. Purpose. The marks from Step 1 partition the portion of W W W preceding v v v into open gaps. The crucial point is that the two endpoints of each gap have a common low cutoff.
List the distinct retained positions in increasing time order, including the exterior starting boundary and the center:
a = p 0 < p 1 < ⋯ < p r = v . a=p_0<p_1<\cdots<p_r=v. a = p 0 < p 1 < ⋯ < p r = v .
For consecutive positions p < q p<q p < q put
V = ( p , q ) = { x ∈ J : pos ( p ) < τ f ( x ) < pos ( q ) } . V=(p,q)=\{x\in J:\operatorname{pos}(p)<\tau_f(x)<\operatorname{pos}(q)\}. V = ( p , q ) = { x ∈ J : pos ( p ) < τ f ( x ) < pos ( q )} .
Here τ f \tau_f τ f is the slot number in the current frame, defined in Section 7.1. An empty gap has no child; a nonempty gap becomes a same-direction child , inheriting this frame. Both boundary slots themselves are excluded from V V V .
If the retained position moved from p p p to q q q during a promotion, associate with ( p , q ) (p,q) ( p , q ) the cutoff S S S immediately before that promotion. The shared-cutoff conclusion of Lemma 7.4 gives
p separates S , q separates S . p\text{ separates }S,\qquad q\text{ separates }S. p separates S , q separates S .
Promotions which repeated at p p p have already changed the cutoff, and therefore must be included in this pre-promotion value of S S S . For a center appended after an entirely exterior walk, use S = S e n d S=S_{\mathrm{end}} S = S end . Every associated same-direction cutoff is contained in W ∩ P b W\cap P_b W ∩ P b .
It is useful to deduce the two localization inclusions already here. If x ∈ V ∩ S x\in V\cap S x ∈ V ∩ S , then x x x is low and occurs after p p p ; the later-low separator condition at p p p puts x x x in D p D_p D p , and the cutoff inclusion puts it in P b P_b P b . If x ∈ V ∖ S x\in V\setminus S x ∈ V ∖ S , then it is high and occurs before q q q ; the earlier-high separator condition at q q q puts it in P q P_q P q . Therefore
V ∩ S ⊆ D p ∩ P b , V ∖ S ⊆ P q . V\cap S\subseteq D_p\cap P_b,\qquad V\setminus S\subseteq P_q. V ∩ S ⊆ D p ∩ P b , V ∖ S ⊆ P q .
These inclusions are the first assertion of Lemma 7.7 .
Step 3: process the other side in reversed time. Purpose. Rather than prove a second separator-walk lemma for right-to-left processing, apply the same lemma after reversing time, precedence, and rank simultaneously.
The part of W W W following the center in the current frame is processed in the reversed frame of § 7.1 . In that frame, old successor cones become predecessor cones, and the old right boundary becomes the new left boundary. From now until the end of the opposite-side construction, rename the new boundaries a , b a,b a , b and interpret all cones, keys, ranks, and times in this reversed frame. The job set W W W and the actual center slot v v v remain the same.
In the old frame v v v separated W ∩ P b o l d W \cap P_b^{\mathrm{old}} W ∩ P b old . Reversal of the separator property, Lemma 7.3 , says that in the new frame v v v separates the complement of this cutoff in W W W . Since P b o l d P_b^{\mathrm{old}} P b old becomes D a D_a D a , that complement is
X : = W ∖ D a . X := W \setminus D_a. X := W ∖ D a .
The set X X X is an ideal of W W W , because D a D_a D a is an upset. The reversed form of the cone-cover invariant (I1) implies W ⊆ D a ∪ P b W \subseteq D_a \cup P_b W ⊆ D a ∪ P b ; hence X ⊆ P b X \subseteq P_b X ⊆ P b .
Let
be the open side before v v v in the new frame (the side that was after v v v originally). If E = ∅ E = \varnothing E = ∅ , nothing more is required on this side. Otherwise consider on W W W the two-block priority order
X , W ∖ X = W ∩ D a , X,\qquad W \setminus X = W \cap D_a, X , W ∖ X = W ∩ D a ,
with increasing new-frame rank inside each block. Since X X X is an ideal, this is a precedence extension. Normalize only the contiguous interval E E E for the restriction of this priority order, keeping all other slots, including v v v , fixed. Lemma 7.1 ensures feasibility; in particular, this reordering cannot disturb the marked slots already chosen before v v v in the old frame.
Start at the new left exterior boundary a a a with empty low set on E E E . Promote the jobs of X X X by increasing new-frame rank. For a rank threshold h h h , the corresponding global-on-W W W low cutoff is
S h = X ∩ { x ∈ J : rank ( x ) < h } , 1 ≤ h ≤ N + 1. (5) S_h = X \cap\{x \in J : \operatorname{rank}(x) < h\}, \qquad1 \le h \le N+1. \tag*{(5)} S h = X ∩ { x ∈ J : rank ( x ) < h } , 1 ≤ h ≤ N + 1. (5)
The low cutoff actually used by the walk on E E E is S h ∩ E S_h \cap E S h ∩ E . Promoting a job of X ∖ E X \setminus E X ∖ E changes no local cutoff and leaves the separator unchanged. For a moving promotion retain only the final actual endpoint and attach the pre-promotion cutoff S h S_h S h to its gap. The endpoint-separation statements of these moves are on E E E , not automatically on all of W W W .
After the final promotion set h = N + 1 h = N+1 h = N + 1 and hence S h = X S_h = X S h = X . Add the terminal open gap from the last retained position (or a a a if none exists) to v v v , with cutoff X X X . The left endpoint separates X ∩ E X \cap E X ∩ E on E E E . The center separates X X X on all of W W W , so its separator inequalities apply to jobs of E E E . Every opposite-side gap therefore has a cutoff S = S h ⊆ X ⊆ P b S = S_h \subseteq X \subseteq P_b S = S h ⊆ X ⊆ P b with the required endpoint inequalities on the processed domain. For the terminal right endpoint v v v , these inequalities come directly from the center’s separation on W W W .
The historical predicate required by Step 4. One more object is needed before the new lists can be stated. For a nonroot node W W W , its incoming edge is the already constructed parent-to-child link by which the gap W W W was created. It records whether the link was same-direction or opposite-side, its associated low cutoff in the historical parent, and a global ideal extension H ∗ H_* H ∗ of that cutoff in the frame of that incoming edge. An extension of a low set S ⊆ U S \subseteq U S ⊆ U means precisely H ∗ ∩ U = S H_* \cap U = S H ∗ ∩ U = S , where U U U is the historical parent. It need not coincide with S S S outside U U U .
When Step 3 reverses the frame, this already recorded global ideal becomes a global upset on the same set of jobs. Write u , d u,d u , d for the historical parent boundaries in the new frame, and write c , b c,b c , b for the current node boundaries in that frame, so c = a c = a c = a in the notation of Step 3. If the historical incoming edge was opposite-side, also denote its historical center by w w w . Define the new global predicate by
G = D u ∩ ( J ∖ P ^ c ) ∩ H ∗ (same-direction incoming edge), G = D_u \cap(J \setminus\widehat{P}_c) \cap H_\ast\qquad\text{(same-direction incoming edge),} G = D u ∩ ( J ∖ P c ) ∩ H ∗ (same-direction incoming edge),
and
G = D u ∩ ( J ∖ P ^ c ) ∩ ( J ∖ P ^ w ) ∩ H ∗ (opposite-side incoming edge). G = D_u \cap(J \setminus\widehat{P}_c) \cap(J \setminus\widehat{P}_w) \cap H_\ast\qquad\text{(opposite-side incoming edge).} G = D u ∩ ( J ∖ P c ) ∩ ( J ∖ P w ) ∩ H ∗ (opposite-side incoming edge).
Lemma 7.9 , proved below using the already constructed incoming edge , establishes
W ∖ D c ⊆ G , G ∩ { x ∈ J : τ f ( x ) ≤ pos ( c ) } = ∅ . W \setminus D_c \subseteq G, \qquad G \cap\{x \in J : \tau_f(x) \le\operatorname{pos}(c)\} = \varnothing. W ∖ D c ⊆ G , G ∩ { x ∈ J : τ f ( x ) ≤ pos ( c )} = ∅ .
These are not additional properties assumed of an unknown child. Their use in Lemma 7.7 is part of an induction over hierarchy depth: the incoming edge is available before the outgoing opposite-side children are defined. The root needs no such predicate, because its opposite side is empty.
Step 4: assign a list to each nonempty child. Purpose. For a gap V = ( p , q ) V = (p,q) V = ( p , q ) with associated low cutoff S ⊆ W S \subseteq W S ⊆ W , we need a new ordered list L V \mathcal{L}_V L V of global upsets whose qualifier set inside V V V is exactly its high part V ∖ S V \setminus S V ∖ S . We first establish the stronger identity on the parent W W W , then prune the list on V V V .
Same-direction children. The cutoff S S S contains the entire first priority block from (4) and an initial segment of the qualifiers O O O in their old key order. The unpromoted qualifiers O ∖ S O \setminus S O ∖ S therefore form a suffix of that order. If this suffix is nonempty, let ( d , r ) (d,r) ( d , r ) be its least old key and take
C = carry d , r ( K ) = ( K d ∩ R r , K d + 1 , … , K ℓ ) . C = \operatorname{carry}_{d,r}(\mathcal{K}) = (K_d \cap R_r, K_{d+1}, \ldots, K_\ell). C = carry d , r ( K ) = ( K d ∩ R r , K d + 1 , … , K ℓ ) .
Otherwise take the empty carry C = ( ) C = () C = ( ) . By Lemma 7.6, W ∩ Q ( C ) = O ∖ S W \cap Q(C) = O \setminus S W ∩ Q ( C ) = O ∖ S . Recall that C C C is a list of global upsets and may contain jobs outside W W W .
The remaining high parent jobs are the third priority block W ∖ P b W \setminus P_b W ∖ P b . They are selected by the fresh injection
I ( a , b ) : = D a ∖ P b , W ∩ I ( a , b ) = W ∖ P b , I(a,b) := D_a \setminus P_b, \qquad W \cap I(a,b) = W \setminus P_b, I ( a , b ) := D a ∖ P b , W ∩ I ( a , b ) = W ∖ P b ,
where the equality follows from (I1). Append I ( a , b ) I(a,b) I ( a , b ) as the last entry of the carry, writing
L V = ( C , I ( a , b ) ) . \mathcal{L}_V = (C, I(a,b)). L V = ( C , I ( a , b )) .
This denotes list concatenation, not a two-element set whose first element is C C C . The qualifier set on W W W is now
W ∩ Q ( L V ) = ( O ∖ S ) ∪ ( W ∖ P b ) = W ∖ S . \begin{aligned}
W \cap Q(\mathcal{L}_V) &= (O \setminus S) \cup(W \setminus P_b) \\
&= W \setminus S.
\end{aligned} W ∩ Q ( L V ) = ( O ∖ S ) ∪ ( W ∖ P b ) = W ∖ S .
The union on the first line is disjoint because O ⊆ P b O \subseteq P_b O ⊆ P b . The carry preserves the relative key order of the unpromoted old qualifiers, while placing the injection last gives every job of the third priority block a later largest membership index. The resulting key order on W ∖ S W \setminus S W ∖ S agrees with the parent priority order in Step 1.
Opposite-side children. For a nonempty gap V = ( p , q ) V = (p,q) V = ( p , q ) produced in Step 3, let S = S h S = S_h S = S h be its associated rank cutoff (h = N + 1 h = N + 1 h = N + 1 for the final gap). Form the unpruned list
L V = ( G ∩ R h , D a ) \mathcal{L}_V = (G \cap R_h, D_a) L V = ( G ∩ R h , D a )
in the reversed frame, and prune it on V V V . The historical predicate G G G has the coverage W \ D a ⊆ G W\backslash D_a\subseteq G W \ D a ⊆ G ; its construction and proof are deferred to Lemma 7.9 . Lemma 7.7 now verifies the child membership and cone properties.
Unlike the same-direction update, this operation discards the old list and introduces a new initial group of two entries. Both entries are global upsets. Recall that X = W \ D a ⊆ G X=W\backslash D_a\subseteq G X = W \ D a ⊆ G . On X X X the companion D a D_a D a is absent, and the first entry selects exactly
X ∩ R h = X \ S h . X\cap R_h=X\backslash S_h. X ∩ R h = X \ S h .
On W ∩ D a W\cap D_a W ∩ D a the second entry selects every job, whether or not it also belongs to the first entry. Hence
W ∩ Q ( L V ) = ( X \ S h ) ∪ ( W ∩ D a ) = W \ S h . W\cap Q(\mathcal{L}_V)=(X\backslash S_h)\cup(W\cap D_a)=W\backslash S_h. W ∩ Q ( L V ) = ( X \ S h ) ∪ ( W ∩ D a ) = W \ S h .
Jobs selected only through the first entry have largest index 1; jobs in the second entry have largest index 2, even on an overlap. Rank breaks ties in each part, reproducing the two-block priority of Step 3. The past-exclusion property of G G G , which is not needed for this membership calculation, will be used for (I2).
Pruning in either case. Finally delete from L V \mathcal{L}_V L V every entry with empty intersection with V V V , and retain each surviving entry as its original global set; denote the resulting list by prune V ( L V ) \operatorname{prune}_V(\mathcal{L}_V) prune V ( L V ) . Such pruning does not remove membership of any job of V V V , nor change the relative key order of the retained child qualifiers by Lemma 7.6. In particular,
V ∩ Q ( prune V ( L V ) ) = V \ S . V\cap Q(\operatorname{prune}_V(\mathcal{L}_V))=V\backslash S. V ∩ Q ( prune V ( L V )) = V \ S .
The next lemma formalizes the cone and priority properties obtained from these four steps.
Lemma 7.7 (Child cone properties and list labels). Every nonempty child V = ( p , q ) V=(p,q) V = ( p , q ) has an actual right endpoint in its own frame and an associated cutoff S ⊆ W ∩ P b S\subseteq W\cap P_b S ⊆ W ∩ P b such that
V ∩ S ⊆ D p ∩ P b , V \ S ⊆ P q . V\cap S\subseteq D_p\cap P_b,\qquad V\backslash S\subseteq P_q. V ∩ S ⊆ D p ∩ P b , V \ S ⊆ P q . For the unpruned list L V \mathcal{L}_V L V assigned in Step 4,
W ∩ Q ( L V ) = W \ S . W\cap Q(\mathcal{L}_V)=W\backslash S. W ∩ Q ( L V ) = W \ S . Its key order on W \ S W\backslash S W \ S agrees with the priority order specified in Step 1 or Step 3, respectively (in Step 3 the normalization uses its restriction to E E E ). Pruning preserves the qualifier set and relative key order inside V V V . In particular, the child satisfies (I1).
Proof idea. A shared pair of separators places low jobs of the gap in a successor cone of its left endpoint, and high jobs in a predecessor cone of its right endpoint. The carry/injection and switch-pair identities say that the new qualifiers are exactly the high jobs. Pruning leaves all memberships of child jobs unchanged.
Proof. Endpoints and cones. For a same-direction gap the right endpoint q q q is a retained actual position of Step 1 or its actual center. For an opposite-side gap it is a retained actual position of Step 3 or that same center. Thus q q q is actual in the child’s frame. Take x ∈ V ∩ S x\in V\cap S x ∈ V ∩ S . Since x x x occurs strictly after p p p and p p p separates S S S on the relevant walk domain, x ∈ D p x\in D_p x ∈ D p . Furthermore, every associated cutoff was chosen inside W ∩ P b W\cap P_b W ∩ P b , so x ∈ P b x\in P_b x ∈ P b . This proves the first inclusion. If x ∈ V \ S x\in V\backslash S x ∈ V \ S , then x x x is high and occurs strictly before q q q . Separation at q q q gives x ∈ P q x\in P_q x ∈ P q . On an opposite-side gap with q ≺ v q\prec v q ≺ v , these conditions apply on E E E . For the terminal gap q = v q=v q = v , use the center’s separation of X X X on W W W directly. This suffices because V ⊆ E ⊆ W V\subseteq E\subseteq W V ⊆ E ⊆ W . Same-direction list. By Lemma 7.6, the suffix carry selects O ∖ S O \setminus S O ∖ S inside W W W and preserves their relative old keys. By (I1), the injection selects W ∖ P b W \setminus P_b W ∖ P b . Since O ⊆ P b O \subseteq P_b O ⊆ P b and S S S contains the entire first block,
W ∖ S = ( O ∖ S ) ∪ ˙ ( W ∖ P b ) . W \setminus S = (O \setminus S) \mathbin{\dot\cup} (W \setminus P_b). W ∖ S = ( O ∖ S ) ∪ ˙ ( W ∖ P b ) .
Consequently the new qualifier union is exactly W ∖ S W \setminus S W ∖ S . Appending the injection last places the third Step 1 priority block last and uses rank within it; the carry supplies the correct earlier key order.
Opposite-side list. Use X = W ∖ D a ⊆ G X = W \setminus D_a \subseteq G X = W ∖ D a ⊆ G and S = S h S = S_h S = S h . The first switched entry selects X ∖ S h X \setminus S_h X ∖ S h on X X X , while the second selects W ∩ D a W \cap D_a W ∩ D a . Their union is W ∖ S h W \setminus S_h W ∖ S h . Their respective largest indices are 1 and 2, with rank ordering within each block. This is the Step 3 priority on high jobs of the parent cutoff.
Pruning and (I1). Pruning deletes no entry containing a job of V V V . Thus it preserves V ∩ Q ( L V ) = V ∖ S V \cap Q(\mathcal{L}_V) = V \setminus S V ∩ Q ( L V ) = V ∖ S , and Lemma 7.6 preserves the relative keys of these child jobs. Together with the cone inclusions proved above,
V ∩ Q ( prune V ( L V ) ) = V ∖ S ⊆ P q , V \cap Q(\operatorname{prune}_V(\mathcal{L}_V)) = V \setminus S \subseteq P_q, V ∩ Q ( prune V ( L V )) = V ∖ S ⊆ P q ,
V ∖ Q ( prune V ( L V ) ) = V ∩ S ⊆ D p . V \setminus Q(\operatorname{prune}_V(\mathcal{L}_V)) = V \cap S \subseteq D_p. V ∖ Q ( prune V ( L V )) = V ∩ S ⊆ D p .
These are exactly the two clauses of child (I1), using p , q p,q p , q as its new boundaries. The global past condition (I2) and the exchange condition (I3) are proved below.
Example: a promotion skips an unmarked slot. We illustrate how the parent qualifiers, the low cutoff, the retained separator positions, and the list assigned to a child fit together. The important point is that a single promotion can move the separator past an intermediate slot without marking that slot.
The instance and the parent list. Let m = 3 m = 3 m = 3 and consider the nine jobs
W = { a , b , c , d , e , x , j , h , k } , W = \{a,b,c,d,e,x,j,h,k\}, W = { a , b , c , d , e , x , j , h , k } ,
with generating precedence relations
a ≺ x , b ≺ d , c ≺ e , j ≺ h , a \prec x,\qquad b \prec d,\qquad c \prec e,\qquad j \prec h, a ≺ x , b ≺ d , c ≺ e , j ≺ h ,
and no other relations among these jobs. Add three further jobs α , β , γ \alpha,\beta,\gamma α , β , γ that are independent of every job, and write A = { α , β , γ } A = \{\alpha,\beta,\gamma\} A = { α , β , γ } for the full exterior left boundary. The global job set is J = A ∪ ˙ W J = A \mathbin{\dot\cup} W J = A ∪ ˙ W ; the right boundary is the sentinel ⊤ \top ⊤ . Choose the global topological rank order
α , β , γ , a , b , c , d , e , x , j , h , k . \alpha,\beta,\gamma,a,b,c,d,e,x,j,h,k. α , β , γ , a , b , c , d , e , x , j , h , k .
The complete witness schedule is
A , Z 1 = { a , b , c } , Z 2 = { d , e , j } , Z 3 = { x , h , k } . A,\qquad Z_1 = \{a,b,c\},\qquad Z_2 = \{d,e,j\},\qquad Z_3 = \{x,h,k\}. A , Z 1 = { a , b , c } , Z 2 = { d , e , j } , Z 3 = { x , h , k } .
Thus the current node is the open interval W = ( A , ⊤ ) W = (A,\top) W = ( A , ⊤ ) . The three boundary jobs are outside W W W , even though the job a ∈ W a \in W a ∈ W has a similar name to the boundary A A A .
Take the inherited one-entry list
K = ( W ) , K 1 = W . \mathcal{K} = (W),\qquad K_1 = W. K = ( W ) , K 1 = W .
The set W W W is a global upset because all successors of its jobs belong to W W W ; the exterior jobs in A A A are independent. Consequently
Q ( K ) = W , O : = W ∩ Q ( K ) = W . Q(\mathcal{K}) = W,\qquad O := W \cap Q(\mathcal{K}) = W. Q ( K ) = W , O := W ∩ Q ( K ) = W .
In particular, all nine jobs are parent qualifiers . Each has key ( 1 , rank ( z ) ) (1,\operatorname{rank}(z)) ( 1 , rank ( z )) , so the old qualifier order is
a , b , c , d , e , x , j , h , k . a,b,c,d,e,x,j,h,k. a , b , c , d , e , x , j , h , k .
Since P ⊤ = J P_{\top}=J P ⊤ = J , the three Step 1 priority blocks are
( W ∖ O ) ∩ P ⊤ , O , W ∖ P ⊤ . (W\setminus O)\cap P_{\top},\qquad O,\qquad W\setminus P_{\top}. ( W ∖ O ) ∩ P ⊤ , O , W ∖ P ⊤ .
Thus the initial low cutoff is S 0 = ∅ S_0=\varnothing S 0 = ∅ , and all promotions are taken from O O O in the displayed key order. The parent invariant (I1) holds because O = W ⊆ P ⊤ O=W\subseteq P_{\top} O = W ⊆ P ⊤ . Parent (I2) holds because no qualifier occurs at or before A A A , and parent (I3) is vacuous because no job of A A A qualifies.
Why the displayed schedule is normalized. The first three priority jobs a , b , c a,b,c a , b , c are incomparable and admit a feasible completion, so the first slot of a normalized schedule is Z 1 = { a , b , c } Z_1=\{a,b,c\} Z 1 = { a , b , c } . Among the remaining jobs, the earliest-priority triple would be { d , e , x } \{d,e,x\} { d , e , x } . Choosing it as the second slot would leave { j , h , k } \{j,h,k\} { j , h , k } for the last slot, which is infeasible since j ≺ h j\prec h j ≺ h . The next possible triple in lexicographic priority order is { d , e , j } \{d,e,j\} { d , e , j } , which admits the final slot { x , h , k } \{x,h,k\} { x , h , k } . Hence the displayed schedule is normalized. Notice especially that x x x has better priority than j j j but is scheduled later: the precedence j ≺ h j\prec h j ≺ h prevents replacing j j j in the second slot by x x x .
The separator walk and its marks. The successor cones relevant to the walk are
D A = ∅ , D Z 1 = { d , e , x } , D Z 2 = { h } , D Z 3 = ∅ . D_A=\varnothing,\qquad D_{Z_1}=\{d,e,x\},\qquad D_{Z_2}=\{h\},\qquad D_{Z_3}=\varnothing. D A = ∅ , D Z 1 = { d , e , x } , D Z 2 = { h } , D Z 3 = ∅ .
Initially the separator is the exterior boundary A A A and the low cutoff is empty. Promoting a a a makes a a a a low job scheduled after A A A but outside D A D_A D A ; the earliest low exception is in Z 1 Z_1 Z 1 . The separator therefore moves from A A A to Z 1 Z_1 Z 1 . Since Z 1 Z_1 Z 1 is the final endpoint of this promotion, it becomes the first marked slot. Promotions of b , c b,c b , c do not move the separator because both jobs already lie in Z 1 Z_1 Z 1 . Promotions of d , e , x d,e,x d , e , x also leave the separator at Z 1 Z_1 Z 1 , since these three jobs belong to D Z 1 D_{Z_1} D Z 1 .
Immediately before promoting j j j , the low cutoff and current retained separator are
S = { a , b , c , d , e , x } , p = Z 1 . S=\{a,b,c,d,e,x\},\qquad p=Z_1. S = { a , b , c , d , e , x } , p = Z 1 .
Promoting j j j changes the cutoff to S + = S ∪ { j } S^+=S\cup\{j\} S + = S ∪ { j } . Since j ∈ Z 2 j\in Z_2 j ∈ Z 2 but j ∉ D Z 1 j\notin D_{Z_1} j ∈ / D Z 1 , the walk first advances from Z 1 Z_1 Z 1 to Z 2 Z_2 Z 2 . It cannot stop there: the previously promoted job x x x occurs later, in Z 3 Z_3 Z 3 , but
x ∉ D Z 2 = { h } . x\notin D_{Z_2}=\{h\}. x ∈ / D Z 2 = { h } .
Thus x x x is a new low exception at Z 2 Z_2 Z 2 , and the walk must advance a second time, from Z 2 Z_2 Z 2 to Z 3 Z_3 Z 3 . No job of W W W occurs after Z 3 Z_3 Z 3 , so there is no later-low exception at Z 3 Z_3 Z 3 . The high jobs for S + S^+ S + are h , k h,k h , k , both in Z 3 Z_3 Z 3 ; hence the earlier-high condition also holds. Therefore the complete walk is
Z 1 ⟶ Z 2 ⟶ Z 3 . Z_1\longrightarrow Z_2\longrightarrow Z_3. Z 1 ⟶ Z 2 ⟶ Z 3 .
Only Z 3 Z_3 Z 3 is the final separator position of this promotion and hence a new mark; Z 2 Z_2 Z 2 is merely an intermediate position and is not marked.
It is important that the new endpoint Z 3 Z_3 Z 3 also separates the old cutoff S S S . Indeed, the high jobs for S S S are { j , h , k } \{j,h,k\} { j , h , k } , and the only one strictly before Z 3 Z_3 Z 3 is j j j . Since j ≺ h j\prec h j ≺ h and h ∈ Z 3 h\in Z_3 h ∈ Z 3 , we have j ∈ P Z 3 j\in P_{Z_3} j ∈ P Z 3 . The later-low property at Z 3 Z_3 Z 3 is automatic. Thus both Z 1 Z_1 Z 1 and Z 3 Z_3 Z 3 separate the same cutoff S S S , as required by Lemma 7.4 . The later promotions of h h h and k k k leave the separator at Z 3 Z_3 Z 3 . Hence the distinct actual marks are Z 1 , Z 3 Z_1,Z_3 Z 1 , Z 3 , and the center is v = Z 3 v=Z_3 v = Z 3 .
The child and its associated cutoff. The two retained marks enclose the nonempty same-direction gap
V = ( Z 1 , Z 3 ) = Z 2 = { d , e , j } . (6) V=(Z_1,Z_3)=Z_2=\{d,e,j\}. \tag*{(6)} V = ( Z 1 , Z 3 ) = Z 2 = { d , e , j } . (6)
The associated cutoff is the one before the promotion that moved the retained separator from Z 1 Z_1 Z 1 to Z 3 Z_3 Z 3 , namely
S = { a , b , c , d , e , x } . S = \{a,b,c,d,e,x\}. S = { a , b , c , d , e , x } .
It is not the cutoff S + S^{+} S + after promoting j j j . Consequently the low and high parts of the child are respectively
V ∩ S = { d , e } , V ∖ S = { j } . V \cap S = \{d,e\}, \qquad V \setminus S = \{j\}. V ∩ S = { d , e } , V ∖ S = { j } .
In particular, j j j is high relative to the child’s associated cutoff even though its promotion caused the separator advance.
The carry, the injection, and pruning. Recall that the parent qualifier set is O = W O = W O = W . At the associated cutoff, the unpromoted parent qualifiers are
O ∖ S = { j , h , k } . O \setminus S = \{j,h,k\}. O ∖ S = { j , h , k } .
Their least old key is ( 1 , rank ( j ) ) = ( 1 , 10 ) (1,\operatorname{rank}(j)) = (1,10) ( 1 , rank ( j )) = ( 1 , 10 ) . Since K = ( K 1 ) \mathcal{K} = (K_1) K = ( K 1 ) with K 1 = W K_1 = W K 1 = W , the suffix carry of Step 4 is
C = carry 1 , 10 ( K ) = ( W ∩ R 10 ) = ( { j , h , k } ) . C = \operatorname{carry}_{1,10}(\mathcal{K}) = (W \cap R_{10}) = (\{j,h,k\}). C = carry 1 , 10 ( K ) = ( W ∩ R 10 ) = ({ j , h , k }) .
The fresh injection is
I ( A , ⊤ ) = D A ∖ P ⊤ = ∅ , I(A,\top) = D_A \setminus P_{\top} = \varnothing, I ( A , ⊤ ) = D A ∖ P ⊤ = ∅ ,
so the unpruned list is L V = ( { j , h , k } , ∅ ) \mathcal{L}_V = (\{j,h,k\},\varnothing) L V = ({ j , h , k } , ∅ ) . In particular, the parent-wide identity from Lemma 7.7 is visible directly:
W ∩ Q ( L V ) = { j , h , k } = W ∖ S . W \cap Q(\mathcal{L}_V) = \{j,h,k\} = W \setminus S. W ∩ Q ( L V ) = { j , h , k } = W ∖ S .
Pruning on V V V deletes the empty second entry but retains the complete global first entry because { j , h , k } ∩ V = { j } ≠ ∅ \{j,h,k\} \cap V = \{j\} \ne\varnothing { j , h , k } ∩ V = { j } = ∅ . Thus
K V = prune V ( L V ) = ( { j , h , k } ) , O V : = V ∩ Q ( K V ) = { j } . \mathcal{K}_V = \operatorname{prune}_V(\mathcal{L}_V) = (\{j,h,k\}), \qquad O_V := V \cap Q(\mathcal{K}_V) = \{j\}. K V = prune V ( L V ) = ({ j , h , k }) , O V := V ∩ Q ( K V ) = { j } .
The distinction between O = W O = W O = W , the nine parent qualifiers , and O V = { j } O_V = \{j\} O V = { j } , the only child qualifier , is crucial. The jobs h , k h,k h , k remain in the global list entry even though they belong to the marked slot Z 3 Z_3 Z 3 outside V V V . Pruning deletes whole entries; it does not restrict retained global upsets to the child domain.
Verification of the child cone invariant. The left and right boundaries of the child are p = Z 1 p = Z_1 p = Z 1 and q = Z 3 q = Z_3 q = Z 3 . We have
V ∖ S = { j } ⊆ P Z 3 because j ≺ h , h ∈ Z 3 , V \setminus S = \{j\} \subseteq P_{Z_3} \quad\text{because } j \prec h,\ h \in Z_3, V ∖ S = { j } ⊆ P Z 3 because j ≺ h , h ∈ Z 3 ,
and
V ∩ S = { d , e } ⊆ D Z 1 because b ≺ d , c ≺ e . V \cap S = \{d,e\} \subseteq D_{Z_1} \quad\text{because } b \prec d,\ c \prec e. V ∩ S = { d , e } ⊆ D Z 1 because b ≺ d , c ≺ e .
Since P ⊤ = J P_{\top} = J P ⊤ = J , the additional inclusion V ∩ S ⊆ P ⊤ V \cap S \subseteq P_{\top} V ∩ S ⊆ P ⊤ is automatic. Combining the cone relations with O V = V ∖ S O_V = V \setminus S O V = V ∖ S proves
V ∩ Q ( K V ) = { j } ⊆ P Z 3 , V ∖ Q ( K V ) = { d , e } ⊆ D Z 1 , V \cap Q(\mathcal{K}_V) = \{j\} \subseteq P_{Z_3}, \qquad V \setminus Q(\mathcal{K}_V) = \{d,e\} \subseteq D_{Z_1}, V ∩ Q ( K V ) = { j } ⊆ P Z 3 , V ∖ Q ( K V ) = { d , e } ⊆ D Z 1 ,
which is exactly invariant (I1) for the child. In this example (I2) and (I3) also hold trivially: no global qualifier of the child occurs at or before Z 1 Z_1 Z 1 , and no job in Z 1 Z_1 Z 1 qualifies.
Feasibility and strict progress. The final marked slots and their intervening open gaps partition W W W in chronological order. Every nonempty gap is a union of full slots of the feasible witness schedule and is therefore feasible. The opposite-side normalization changes only slots beyond the center in the original frame; it does not move jobs across an already selected same-direction mark, so its separator statements remain valid. Every child excludes the full center slot of m m m jobs and therefore contains at most ∣ W ∣ − m |W| - m ∣ W ∣ − m jobs. This is the size decrease used in the later induction.
Shortening stored information before a reversal
Purpose and terminology. At a node U U U , the construction works with an exact ordered list K U \mathcal{K}_U K U of global upsets. The list determines the qualifiers and their priority keys, including the memberships of jobs outside U U U . In Step 4 of § 7.4 a same-direction child inherits a suffix of this list, appends one injection , and prunes entries that do not meet the child. An opposite-side child instead replaces the list by a new switch pair . Hence a switch pair may be inherited through several successive same-direction steps, together with injections introduced later. A subsequent switch replaces the entire inherited list.
There are two separate issues. First, the exact entries inherited from ancestors can have complicated formulas. We shall describe their union on the current descendant by a simpler, or flat , expression (Lemma 7.8). Second, when a later switch reverses the frame, the construction needs a new global upset that also controls jobs outside the current node. This is obtained from a recorded historical cutoff (Lemma 7.9 ). The local replacement in the first step is not a global replacement of the exact list.
Birth groups. Entries are grouped according to the operation that introduced them. The root’s entry J J J is one initial group. A switch introduces the ordered pair ( G 0 ∩ R h , D c ) (G_0 \cap R_h,D_c) ( G 0 ∩ R h , D c ) as one initial group; its two entries may overlap. Each subsequent injection I ( A , B ) = D A ∖ P B I(A,B)=D_A\setminus P_B I ( A , B ) = D A ∖ P B forms a separate group. The birth domain of a group is the node on which it was introduced. On a chain of same-direction descendants, the exact list consists of surviving entries of the initial group, followed by surviving injections in their birth order. A suffix carry restricts only its first retained entry by a rank suffix; pruning deletes entire entries but never replaces a retained global entry by its intersection with a node. In particular, the first entry of a switch pair cannot be kept by a suffix carry while its later companion is discarded by that same suffix operation. The companion may nevertheless have been deleted by pruning.
How an inherited switch pair occurs. For example, suppose a switch on V 0 V_0 V 0 creates the list ( G 0 ∩ R h 0 , D c ) (G_0 \cap R_{h_0},D_c) ( G 0 ∩ R h 0 , D c ) . At a same-direction descendant V 1 V_1 V 1 , its suffix carry may retain both entries, possibly increasing the first threshold to t 1 t_1 t 1 , and append an injection I 1 I_1 I 1 :
K V 1 = ( G 0 ∩ R t 1 , D c , I 1 ) . \mathcal{K}_{V_1}=(G_0 \cap R_{t_1},D_c,I_1). K V 1 = ( G 0 ∩ R t 1 , D c , I 1 ) .
A further same-direction descendant V 2 V_2 V 2 may carry these entries and add I 2 I_2 I 2 . The switch-group assertion below concerns only the first two entries, not the injections I 1 , I 2 I_1,I_2 I 1 , I 2 . At a new switch, the inherited list is discarded and a new initial pair is created. The displayed sequence is schematic: any particular carry or pruning step may delete entries.
Lemma 7.8 (Flat unions on descendants). The following identities concern restrictions to descendants of the respective birth domains.
(a) Injection. Suppose I ( A , B ) = D A ∖ P B I(A,B)=D_A\setminus P_B I ( A , B ) = D A ∖ P B was introduced on a node V V V satisfying the birth cone cover V ⊆ D A ∪ P B V\subseteq D_A\cup P_B V ⊆ D A ∪ P B . For every descendant U ⊆ V U\subseteq V U ⊆ V ,
U ∩ I ( A , B ) = U ∩ ( J ∖ P B ) . (7) U\cap I(A,B)=U\cap(J\setminus P_B). \tag*{(7)} U ∩ I ( A , B ) = U ∩ ( J ∖ P B ) . (7)
If a later suffix carry rank-restricts this injection by R t R_t R t , then the corresponding restrictions also agree after intersecting both sides of (7) with R t R_t R t .
(b) Switch group. Suppose a switch introduces the two entries
( G 0 ∩ R h , D c ) (G_0\cap R_h,D_c) ( G 0 ∩ R h , D c )
on a birth domain V V V , and its historical coverage property is
V ∖ D c ⊆ G 0 . (8) V\setminus D_c\subseteq G_0. \tag*{(8)} V ∖ D c ⊆ G 0 . (8)
Let U ⊆ V U \subseteq V U ⊆ V be a descendant reached through subsequent same-direction child constructions. Assume that the first switch entry is still retained, with accumulated outer rank restriction R t R_t R t ; thus the retained first entry has the exact form G 0 ∩ R t G_0 \cap R_t G 0 ∩ R t . Then the union of the surviving entries of this switch group alone, restricted to U U U , equals
U ∩ ( D c ∪ R t ) . (9) U \cap(D_c \cup R_t). \tag*{(9)} U ∩ ( D c ∪ R t ) . (9)
This is true both when the companion D c D_c D c is still present and when it was deleted by pruning at an intermediate ancestor of U U U . Injections introduced after the switch are not included in (9) ; they must be added separately. If the first switch entry has disappeared, assertion (b) is not applied to the switch group.
Proof idea. Within a birth domain, a job not in the right predecessor cone of an injection is already forced into its left successor cone. For a switch, every job outside D c D_c D c is already in G 0 G_0 G 0 ; its membership in the first entry is therefore determined only by the current rank suffix. The companion handles all jobs inside D c D_c D c , when it is present.
Proof. (a). The inclusion from left to right in (7) follows directly from I ( A , B ) = D A ∖ P B I(A,B) = D_A \setminus P_B I ( A , B ) = D A ∖ P B . Conversely, take x ∈ U ∖ P B x \in U \setminus P_B x ∈ U ∖ P B . Since U ⊆ V U \subseteq V U ⊆ V and V ⊆ D A ∪ P B V \subseteq D_A \cup P_B V ⊆ D A ∪ P B , we must have x ∈ D A x \in D_A x ∈ D A . Hence x ∈ I ( A , B ) x \in I(A,B) x ∈ I ( A , B ) . Intersecting an equality of sets with R t R_t R t preserves it.
(b). Since U ⊆ V U \subseteq V U ⊆ V , the birth cover implies
U ∖ D c ⊆ G 0 . U \setminus D_c \subseteq G_0. U ∖ D c ⊆ G 0 .
First suppose both switch entries are present. Partition U U U into U ∩ D c U \cap D_c U ∩ D c and U ∖ D c U \setminus D_c U ∖ D c . The companion selects all jobs of the first part. Every job of the second part already belongs to G 0 G_0 G 0 , so the first entry selects it exactly when it belongs to R t R_t R t . Formally,
U ∩ ( ( G 0 ∩ R t ) ∪ D c ) = ( U ∩ D c ) ∪ ( ( U ∖ D c ) ∩ G 0 ∩ R t ) = ( U ∩ D c ) ∪ ( ( U ∖ D c ) ∩ R t ) = U ∩ ( D c ∪ R t ) . \begin{aligned}
U \cap((G_0 \cap R_t) \cup D_c)
&= (U \cap D_c) \cup((U \setminus D_c) \cap G_0 \cap R_t) \\
&= (U \cap D_c) \cup((U \setminus D_c) \cap R_t) \\
&= U \cap(D_c \cup R_t).
\end{aligned} U ∩ (( G 0 ∩ R t ) ∪ D c ) = ( U ∩ D c ) ∪ (( U ∖ D c ) ∩ G 0 ∩ R t ) = ( U ∩ D c ) ∪ (( U ∖ D c ) ∩ R t ) = U ∩ ( D c ∪ R t ) .
If D c D_c D c was pruned at an intermediate node U ′ U' U ′ with U ⊆ U ′ ⊆ V U \subseteq U' \subseteq V U ⊆ U ′ ⊆ V , then U ′ ∩ D c = ∅ U' \cap D_c = \varnothing U ′ ∩ D c = ∅ , and hence U ∩ D c = ∅ U \cap D_c = \varnothing U ∩ D c = ∅ . The birth cover now yields U ⊆ G 0 U \subseteq G_0 U ⊆ G 0 , so
U ∩ ( G 0 ∩ R t ) = U ∩ R t = U ∩ ( D c ∪ R t ) . U \cap(G_0 \cap R_t) = U \cap R_t = U \cap(D_c \cup R_t). U ∩ ( G 0 ∩ R t ) = U ∩ R t = U ∩ ( D c ∪ R t ) .
This proves the same expression for the surviving first entry. No assertion is made about the entire current list or about global equality outside U U U .
Flat expressions for complete suffix carries. We now make the replacement used below explicit. Fix a current node U U U and a suffix carry C = ( E 1 , … , E s ) C = (E_1,\ldots,E_s) C = ( E 1 , … , E s ) of its exact inherited list. In the application to a same-direction gap, this carry represents the unpromoted qualifiers at the associated cutoff, before the fresh injection for that gap is appended. A flat expression for C C C on U U U means a global Boolean set F ⊆ J F \subseteq J F ⊆ J such that
U ∩ F = U ∩ Q ( C ) . (10) U \cap F = U \cap Q(C). \tag*{(10)} U ∩ F = U ∩ Q ( C ) . (10)
It is sufficient, and useful later, to choose F F F to be a global upset. Equality in (10) is only an equality after intersection with U U U .
All surviving injections in the carry are denoted by I ( A i , B i ) = D A i ∖ P B i I(A_i,B_i) = D_{A_i} \setminus P_{B_i} I ( A i , B i ) = D A i ∖ P B i , in their retained order. The symbol R t R_t R t refers to the current outer rank restriction on the first entry of the carry, with R 1 = J R_1 = J R 1 = J when no nontrivial restriction is present. In every case, there is at most one such current restriction. The following formulas exhaust the possible surviving initial groups.
Case 1: the first switch entry survives. The first switch-group entry is G 0 ∩ R t G_0 \cap R_t G 0 ∩ R t ; its companion D c D_c D c is either present or was pruned earlier. It is followed by s s s surviving injections. By Lemma 7.8, the switch group’s contribution on U U U is D c ∪ R t D_c \cup R_t D c ∪ R t , and each injection’s contribution is J ∖ P B i J \setminus P_{B_i} J ∖ P B i . Thus we may take
F = D c ∪ R t ∪ ⋃ i = 1 s ( J ∖ P B i ) . (11) F = D_c \cup R_t \cup\bigcup_{i=1}^{s}(J \setminus P_{B_i}). \tag*{(11)} F = D c ∪ R t ∪ i = 1 ⋃ s ( J ∖ P B i ) . (11)
If the companion was pruned, then U ∩ D c = ∅ U \cap D_c = \varnothing U ∩ D c = ∅ , so retaining D c D_c D c in this expression does not alter its restriction to U U U . The exact switch-group entries remain separate in C C C : the flat union does not record their individual membership indices.
Case 2: only the switch companion survives. If the first switch entry has disappeared, the companion D c D_c D c is the first retained entry of this group. Its current rank-restricted form is D c ∩ R t D_c \cap R_t D c ∩ R t , followed by surviving injections. Here we do not use the switch identity (9) ; instead, directly take
F = ( D c ∩ R t ) ∪ ⋃ i = 1 s ( J ∖ P B i ) . (12) F = (D_c \cap R_t) \cup\bigcup_{i=1}^{s}(J \setminus P_{B_i}). \tag*{(12)} F = ( D c ∩ R t ) ∪ i = 1 ⋃ s ( J ∖ P B i ) . (12)
The intersection D c ∩ R t D_c \cap R_t D c ∩ R t in this case must not be confused with the union D c ∪ R t D_c \cup R_t D c ∪ R t in Case 1.
Case 3: the root entry survives. If the initial group is the root entry J J J and it is still retained, its current form is J ∩ R t = R t J \cap R_t = R_t J ∩ R t = R t . Thus
F = R t ∪ ⋃ i = 1 s ( J ∖ P B i ) . (13) F = R_t \cup\bigcup_{i=1}^{s}(J \setminus P_{B_i}). \tag*{(13)} F = R t ∪ i = 1 ⋃ s ( J ∖ P B i ) . (13)
Case 4: the initial group has disappeared. The carry then begins with an injection. If it contains s ≥ 1 s \ge1 s ≥ 1 injections, the first one may have the outer restriction R t R_t R t , while the others are untrimmed. Thus
F = ( ( J ∖ P B 1 ) ∩ R t ) ∪ ⋃ i = 2 s ( J ∖ P B i ) . (14) F = ((J \setminus P_{B_1}) \cap R_t) \cup\bigcup_{i=2}^{s}(J \setminus P_{B_i}). \tag*{(14)} F = (( J ∖ P B 1 ) ∩ R t ) ∪ i = 2 ⋃ s ( J ∖ P B i ) . (14)
For the empty carry, define F = ∅ F = \varnothing F = ∅ .
All five formulas consist of unions and intersections of global upsets. Thus each F F F is a global upset, and Lemma 7.8 proves (10) . The exact list is nevertheless retained unchanged for priority keys, pruning, and the boundary invariants. In particular, a flat expression must not replace its exact entries outside U U U . In Lemma 7.12 we will bound the number of surviving birth groups; together with the formulas above, this will bound the number of atomic occurrences in F F F , independently of the hierarchy depth.
The historical cutoff and its global ideal extension. We next explain the information needed for a later reversal. Let U = ( a U , b U ) U = (a_U, b_U) U = ( a U , b U ) be an already constructed node, and suppose one of its gaps has become a child W W W . The edge U → W U \to W U → W is the incoming historical edge of W W W . Let S ⊆ U S \subseteq U S ⊆ U be the low cutoff associated with this edge, in the frame used when the edge was constructed. The construction records a set H ∗ ⊆ J H_* \subseteq J H ∗ ⊆ J satisfying
H ∗ is a global ideal , H ∗ ∩ U = S . (15) H_* \text{ is a global ideal}, \qquad H_* \cap U = S. \tag*{(15)} H ∗ is a global ideal , H ∗ ∩ U = S . (15)
We call such a set a *global ideal extension of S S S from U U U . Being an ideal here means predecessor closure in the entire poset J J J . The equality means that H ∗ H_* H ∗ selects exactly the cutoff jobs among the jobs of U U U ; it may contain other jobs outside U U U . An extension is not unique. We need a particular one with a short global Boolean formula.
An elementary example of an extension. Suppose J J J consists of m m m independent chains, each with three successive jobs, and let B 1 , B 2 , B 3 B_1, B_2, B_3 B 1 , B 2 , B 3 be their three full chronological slots. For U = B 2 ∪ B 3 U = B_2 \cup B_3 U = B 2 ∪ B 3 and the local ideal S = B 2 S = B_2 S = B 2 , the set S S S is not a global ideal: its jobs have predecessors in B 1 B_1 B 1 . But H ∗ = B 1 ∪ B 2 H_\ast= B_1 \cup B_2 H ∗ = B 1 ∪ B 2 is a global ideal satisfying H ∗ ∩ U = S H_\ast\cap U = S H ∗ ∩ U = S . This example illustrates the term extension ; the following construction additionally ensures that the extension has a short formula in the permitted global atoms.
For clarity, we derive that extension from the cutoffs of Step 1 instead of assuming the formula. Write
O U = U ∩ Q ( K U ) O_U = U \cap Q(K_U) O U = U ∩ Q ( K U )
for the qualifiers at U U U . If the incoming edge was same-direction, its cutoff S S S contains the entire first priority block ( U ∖ O U ) ∩ P b U (U \setminus O_U) \cap P_{b_U} ( U ∖ O U ) ∩ P b U and an initial segment of O U O_U O U . The remaining, unpromoted qualifiers are O U ∖ S O_U \setminus S O U ∖ S . Let C \mathcal{C} C be the suffix carry of those qualifiers, before appending the fresh injection for the edge. By the suffix-carry assertion of Lemma 7.6,
U ∩ Q ( C ) = O U ∖ S . (16) U \cap Q(\mathcal{C}) = O_U \setminus S. \tag*{(16)} U ∩ Q ( C ) = O U ∖ S . (16)
Indeed, the unpromoted qualifiers form precisely the final segment of the old key order, and the carry retains that segment; if none remain, C \mathcal{C} C is empty. Since O U ⊆ P b U O_U \subseteq P_{b_U} O U ⊆ P b U by parent (I1), we have
U ∩ P b U = ( ( U ∖ O U ) ∩ P b U ) ∪ ˙ O U . U \cap P_{b_U} = ((U \setminus O_U) \cap P_{b_U}) \mathbin{\dot\cup} O_U. U ∩ P b U = (( U ∖ O U ) ∩ P b U ) ∪ ˙ O U .
Removing the unpromoted qualifiers leaves exactly the low cutoff. Equivalently,
S = U ∩ ( P b U ∖ Q ( C ) ) . (17) S = U \cap(P_{b_U} \setminus Q(\mathcal{C})). \tag*{(17)} S = U ∩ ( P b U ∖ Q ( C )) . (17)
Choose the flat expression F F F for C \mathcal{C} C on U U U from one of the explicit cases above. Then U ∩ F = U ∩ Q ( C ) U \cap F = U \cap Q(\mathcal{C}) U ∩ F = U ∩ Q ( C ) , and a set calculation gives
S = U ∩ ( P b U ∖ Q ( C ) ) = ( U ∩ P b U ) ∖ ( U ∩ Q ( C ) ) = ( U ∩ P b U ) ∖ ( U ∩ F ) = U ∩ ( P b U ∖ F ) . (18) \begin{aligned}
S &= U \cap(P_{b_U} \setminus Q(\mathcal{C})) \\
&= (U \cap P_{b_U}) \setminus(U \cap Q(\mathcal{C})) \\
&= (U \cap P_{b_U}) \setminus(U \cap F) \\
&= U \cap(P_{b_U} \setminus F). \tag*{(18)}
\end{aligned} S = U ∩ ( P b U ∖ Q ( C )) = ( U ∩ P b U ) ∖ ( U ∩ Q ( C )) = ( U ∩ P b U ) ∖ ( U ∩ F ) = U ∩ ( P b U ∖ F ) . (18)
The substitution uses equality only on U U U ; it does not require F = Q ( C ) F = Q(\mathcal{C}) F = Q ( C ) globally. Hence the specific choice H ∗ = P b U ∖ F H_\ast= P_{b_U} \setminus F H ∗ = P b U ∖ F satisfies the extension property (15) . Because P b U P_{b_U} P b U is an ideal and F F F an upset, H ∗ = P b U ∩ ( J ∖ F ) H_\ast= P_{b_U} \cap(J \setminus F) H ∗ = P b U ∩ ( J ∖ F ) is a global ideal.
For an opposite-side historical edge, Step 3 already provides the low cutoff as a rank prefix of X = U ∖ D a U X = U \setminus D_{a_U} X = U ∖ D a U . Its extension therefore has a simple form without a carry. The next lemma records both cases and explains how the recorded extension is used after reversal.
Lemma 7.9 (Historical extension and switch localization). Let U = ( a U , b U ) U = (a_U, b_U) U = ( a U , b U ) be the historical parent of an already constructed edge U → W U \to W U → W , and let S ⊆ U S \subseteq U S ⊆ U be its associated low cutoff. In the frame in which this edge was constructed, define
H ∗ = P b U ∖ F if the edge was same-direction, (19) H_\ast= P_{b_U} \setminus F \quad\text{if the edge was same-direction,} \tag*{(19)} H ∗ = P b U ∖ F if the edge was same-direction, (19) where F F F is the flat expression for the suffix carry before the fresh injection, and define
H ∗ = ( J ∖ D a U ) ∩ { x ∈ J : rank ( x ) < h } if the edge was opposite-side, (20) H_\ast= (J \setminus D_{a_U}) \cap\{x \in J : \operatorname{rank}(x) < h\} \quad\text{if the edge was opposite-side,} \tag*{(20)} H ∗ = ( J ∖ D a U ) ∩ { x ∈ J : rank ( x ) < h } if the edge was opposite-side, (20) where h h h is the rank cutoff recorded on that edge. In both cases H ∗ H_\ast H ∗ is a global ideal satisfying H ∗ ∩ U = S H_\ast\cap U = S H ∗ ∩ U = S .
Now suppose that the construction is about to switch while processing W W W . Reverse time, precedence, and rank, but regard H ∗ H_\ast H ∗ as the same subset of J J J . Write U = ( u , d ) U=(u,d) U = ( u , d ) and W = ( c , b ) W=(c,b) W = ( c , b ) for the historical parent and current node in the new frame. In the opposite-side historical case, let w w w be the previously recorded historical center, with temporal positions u < w ≤ c < b ≤ d u<w\le c<b\le d u < w ≤ c < b ≤ d (inequalities of boundary positions). Define
G = D u ∩ ( J ∖ P ^ c ) ∩ H ∗ for a same-direction historical edge, (21) G=D_u\cap(J\setminus\widehat{P}_c)\cap H_\ast\qquad\text{for a same-direction historical edge,} \tag*{(21)} G = D u ∩ ( J ∖ P c ) ∩ H ∗ for a same-direction historical edge, (21)
and
G = D u ∩ ( J ∖ P ^ c ) ∩ ( J ∖ P ^ w ) ∩ H ∗ for an opposite-side historical edge. (22) G=D_u\cap(J\setminus\widehat{P}_c)\cap(J\setminus\widehat{P}_w)\cap H_\ast\qquad\text{for an opposite-side historical edge.} \tag*{(22)} G = D u ∩ ( J ∖ P c ) ∩ ( J ∖ P w ) ∩ H ∗ for an opposite-side historical edge. (22)
Then G G G is a global upset and
W ∖ D c ⊆ G , G ∩ { x ∈ J : τ f ( x ) ≤ pos ( c ) } = ∅ . (23) W\setminus D_c\subseteq G,\qquad G\cap\{x\in J:\tau_f(x)\le\operatorname{pos}(c)\}=\varnothing. \tag*{(23)} W ∖ D c ⊆ G , G ∩ { x ∈ J : τ f ( x ) ≤ pos ( c )} = ∅ . (23)
These properties depend only on the already constructed incoming historical edge; they do not assume an invariant of a future child of W W W .
What has to be proved. There are two groups of assertions, and they refer to different frames.
(A) In the frame in which the incoming edge U → W U\to W U → W was constructed, the prescribed set H ∗ H_\ast H ∗ is a global ideal and satisfies H ∗ ∩ U = S H_\ast\cap U=S H ∗ ∩ U = S .
(B) In the reversed frame, the prescribed set G G G is a global upset, contains W ∖ D c W\setminus D_c W ∖ D c , and contains no job at or before c c c . The last two assertions are exactly (23) .
Here H ∗ H_\ast H ∗ is always the same subset of J J J . Reversing the frame changes which closure property it has: an old-frame ideal becomes a new-frame upset. The identity H ∗ ∩ U = S H_\ast\cap U=S H ∗ ∩ U = S may be used for a job only after that job has been shown to belong to U U U .
Proof idea. First construct the global ideal representing the historical low cutoff. Next reverse the frame. The historical separator properties imply W ∖ D c ⊆ S ⊆ D u W\setminus D_c\subseteq S\subseteq D_u W ∖ D c ⊆ S ⊆ D u , which gives the required coverage. To exclude a possible member of G G G at or before c c c , first use its time and its membership in D u D_u D u to place it inside U U U . It then belongs to the historical low cutoff S S S . The old later-low separator property forces it into a weak predecessor cone excluded from G G G . For an opposite-side historical edge, two temporal ranges must be distinguished, because the right endpoint separates the cutoff only on the processed side; the historical center handles the other range.
Proof. Step 1: distinguish the two frames and the boundary names. Use superscripts old and new on cones, and the corresponding subscripts on ranks and times. The old frame is the frame in which the incoming edge was actually constructed. For an opposite-side historical edge, this is already the frame used in Step 3 of the historical parent’s construction.
In the old frame write
U = ( a U , b U ) , W = ( p , q ) . U=(a_U,b_U),\qquad W=(p,q). U = ( a U , b U ) , W = ( p , q ) .
After reversal, the same boundary slots receive the names
u = b U , d = a U , c = q , b = p . u=b_U,\qquad d=a_U,\qquad c=q,\qquad b=p. u = b U , d = a U , c = q , b = p .
Consequently U = ( u , d ) U=(u,d) U = ( u , d ) and W = ( c , b ) W=(c,b) W = ( c , b ) in the new frame. The sets U , W , S , H ∗ U,W,S,H_\ast U , W , S , H ∗ themselves do not change. If the complete schedule has T T T slots, then
x ≺ n e w y ⟺ y ≺ o l d x , τ n e w ( x ) = T + 1 − τ o l d ( x ) . (24) x\prec_{\mathrm{new}}y\Longleftrightarrow y\prec_{\mathrm{old}}x,\qquad\tau_{\mathrm{new}}(x)=T+1-\tau_{\mathrm{old}}(x). \tag*{(24)} x ≺ new y ⟺ y ≺ old x , τ new ( x ) = T + 1 − τ old ( x ) . (24)
Boundary positions transform in the same way, including sentinel positions 0 and T + 1 T+1 T + 1 . In particular,
P b U o l d = D u n e w , P q o l d = D c n e w , D q o l d = P c n e w . P^{\mathrm{old}}_{b_U}=D^{\mathrm{new}}_{u},\quad P^{\mathrm{old}}_{q}=D^{\mathrm{new}}_{c},\quad D^{\mathrm{old}}_{q}=P^{\mathrm{new}}_{c}. P b U old = D u new , P q old = D c new , D q old = P c new .
In the opposite-side historical case, write v v v for the historical center in the old frame and w = v w=v w = v for that same slot in the new frame. The boundary orders are
a U ≤ p < q ≤ v < b U in the old frame , a_U \le p < q \le v < b_U \quad\text{in the old frame}, a U ≤ p < q ≤ v < b U in the old frame ,
u < w ≤ c < b ≤ d in the new frame . u < w \le c < b \le d \quad\text{in the new frame}. u < w ≤ c < b ≤ d in the new frame .
All inequalities here concern temporal positions. The case q = v q=v q = v , equivalently c = w c=w c = w , is the terminal opposite-side gap.
For reference, the boundary correspondence is summarized below. Each row refers to the same boundary slot before and after reversal.
Table 1 (PDF p. 53).
The last row applies only to opposite-side history. In its terminal case, q = v q=v q = v and therefore c = w c=w c = w .
Step 2: prove (A) for a same-direction historical edge. All cones and ranks in this step are interpreted in the old frame. Let O = U ∩ Q ( K U ) O=U\cap Q(K_U) O = U ∩ Q ( K U ) be the historical parent’s qualifiers. The construction orders U U U in three blocks:
( U ∖ O ) ∩ P b U o l d , O , U ∖ P b U o l d . (U\setminus O)\cap P^{\mathrm{old}}_{b_U},\qquad O,\qquad U\setminus P^{\mathrm{old}}_{b_U}. ( U ∖ O ) ∩ P b U old , O , U ∖ P b U old .
Its associated cutoff S S S consists of the whole first block and an initial segment of O O O . The remaining qualifiers O ∖ S O\setminus S O ∖ S form the suffix represented by the carry C C C , before the fresh injection is appended. Hence
U ∩ Q ( C ) = O ∖ S . U\cap Q(C)=O\setminus S. U ∩ Q ( C ) = O ∖ S .
The parent cone invariant gives O ⊆ P b U o l d O\subseteq P^{\mathrm{old}}_{b_U} O ⊆ P b U old . Therefore
U ∩ P b U o l d = ( ( U ∖ O ) ∩ P b U o l d ) ∪ ˙ O . U\cap P^{\mathrm{old}}_{b_U}=\bigl((U\setminus O)\cap P^{\mathrm{old}}_{b_U}\bigr)\mathbin{\dot\cup}O. U ∩ P b U old = ( ( U ∖ O ) ∩ P b U old ) ∪ ˙ O .
Deleting precisely O ∖ S O\setminus S O ∖ S from this disjoint union leaves S S S . The flat expression satisfies U ∩ F = U ∩ Q ( C ) U\cap F=U\cap Q(C) U ∩ F = U ∩ Q ( C ) , so
S = ( U ∩ P b U o l d ) ∖ ( O ∖ S ) = ( U ∩ P b U o l d ) ∖ ( U ∩ Q ( C ) ) = ( U ∩ P b U o l d ) ∖ ( U ∩ F ) = U ∩ ( P b U o l d ∖ F ) = U ∩ H ∗ . \begin{aligned}
S&=(U\cap P^{\mathrm{old}}_{b_U})\setminus(O\setminus S)\\
&=(U\cap P^{\mathrm{old}}_{b_U})\setminus(U\cap Q(C))\\
&=(U\cap P^{\mathrm{old}}_{b_U})\setminus(U\cap F)\\
&=U\cap(P^{\mathrm{old}}_{b_U}\setminus F)=U\cap H_*.
\end{aligned} S = ( U ∩ P b U old ) ∖ ( O ∖ S ) = ( U ∩ P b U old ) ∖ ( U ∩ Q ( C )) = ( U ∩ P b U old ) ∖ ( U ∩ F ) = U ∩ ( P b U old ∖ F ) = U ∩ H ∗ .
This calculation uses only equality on U U U ; it does not require the global equality F = Q ( C ) F=Q(C) F = Q ( C ) .
It remains to prove global predecessor closure. The set P b U o l d P^{\mathrm{old}}_{b_U} P b U old is a global ideal and F F F is a global upset. Thus J ∖ F J\setminus F J ∖ F is a global ideal, and
H ∗ = P b U o l d ∩ ( J ∖ F ) H_*=P^{\mathrm{old}}_{b_U}\cap(J\setminus F) H ∗ = P b U old ∩ ( J ∖ F )
is an intersection of global ideals. Explicitly, if y ∈ H ∗ y\in H_* y ∈ H ∗ and x ≺ o l d y x\prec_{\mathrm{old}}y x ≺ old y with x ∈ J x\in J x ∈ J , then x ∈ P b U o l d x\in P^{\mathrm{old}}_{b_U} x ∈ P b U old . If x x x belonged to F F F , upward closure would put y y y in F F F , a contradiction. Hence x ∈ H ∗ x\in H_* x ∈ H ∗ . This proves both assertions in (A) for this case.
Step 3: prove (A) for an opposite-side historical edge. In the old frame put
X = U ∖ D a U o l d , L h = { x ∈ J : rank o l d ( x ) < h } . X = U \setminus D_{aU}^{\mathrm{old}}, \qquad L_h = \{x \in J : \operatorname{rank}_{\mathrm{old}}(x) < h\}. X = U ∖ D a U old , L h = { x ∈ J : rank old ( x ) < h } .
Step 3 of the construction records the cutoff S = X ∩ L h S = X \cap L_h S = X ∩ L h , including h = N + 1 h = N + 1 h = N + 1 for the terminal gap. The prescribed set is
H ∗ = ( J ∖ D a U o l d ) ∩ L h . H_* = (J \setminus D_{aU}^{\mathrm{old}}) \cap L_h. H ∗ = ( J ∖ D a U old ) ∩ L h .
Intersecting with U U U gives exactly
U ∩ H ∗ = ( U ∖ D a U o l d ) ∩ L h = X ∩ L h = S . U \cap H_* = (U \setminus D_{aU}^{\mathrm{old}}) \cap L_h = X \cap L_h = S. U ∩ H ∗ = ( U ∖ D a U old ) ∩ L h = X ∩ L h = S .
The first factor of H ∗ H_* H ∗ is a global ideal, because D a U o l d D_{aU}^{\mathrm{old}} D a U old is a global upset. The rank prefix L h L_h L h is also a global ideal: if y ∈ L h y \in L_h y ∈ L h and x ≺ o l d y x \prec_{\mathrm{old}} y x ≺ old y , then
rank o l d ( x ) < rank o l d ( y ) < h . \operatorname{rank}_{\mathrm{old}}(x) < \operatorname{rank}_{\mathrm{old}}(y) < h. rank old ( x ) < rank old ( y ) < h .
Thus x ∈ L h x \in L_h x ∈ L h . The intersection defining H ∗ H_* H ∗ is consequently a global ideal. This completes (A) in both historical cases.
Step 4: write down exactly which historical separator facts will be used. A slot r r r separates a cutoff L L L on a domain V V V when every high job of V V V strictly before r r r lies in P r P_r P r , and every low job of V V V strictly after r r r lies in D r D_r D r . The latter condition applies only to strict inequality. A job at r r r belongs to the slot itself. Thus, whenever separation applies on a domain containing z z z ,
z ∈ L , τ ( z ) ≥ pos ( r ) ⟹ z ∈ D r ∪ r = D ^ r . z \in L,\quad\tau(z) \ge\operatorname{pos}(r) \quad\Longrightarrow\quad z \in D_r \cup r = \widehat{D}_r. z ∈ L , τ ( z ) ≥ pos ( r ) ⟹ z ∈ D r ∪ r = D r .
The equality case is supplied by z ∈ r z \in r z ∈ r , not by the later-low condition.
For a same-direction historical edge, Step 2 of the construction records a cutoff satisfying
S ⊆ U ∩ P b U o l d , q separates S on all of U . S \subseteq U \cap P_{bU}^{\mathrm{old}}, \qquad q\text{ separates }S\text{ on all of }U. S ⊆ U ∩ P b U old , q separates S on all of U .
For a moving promotion, this is the pre-promotion cutoff, and the common-cutoff walk proves separation at its final endpoint q q q . For an appended center, it is the exhausted cutoff, which the center separates. In either case every job of W ∖ S W \setminus S W ∖ S is a high job before q q q and belongs to P q o l d P_q^{\mathrm{old}} P q old .
For an opposite-side historical edge, the recorded data are
X = U ∖ D a U o l d , E = ( a U , v ) in the old frame , X = U \setminus D_{aU}^{\mathrm{old}}, \qquad E = (a_U,v)\text{ in the old frame}, X = U ∖ D a U old , E = ( a U , v ) in the old frame ,
S ⊆ X ⊆ P b U o l d , v separates X on all of U . S \subseteq X \subseteq P_{bU}^{\mathrm{old}}, \qquad v\text{ separates }X\text{ on all of }U. S ⊆ X ⊆ P b U old , v separates X on all of U .
The inclusion X ⊆ P b U o l d X \subseteq P_{bU}^{\mathrm{old}} X ⊆ P b U old follows from the historical parent’s cone cover U ⊆ D a U o l d ∪ P b U o l d U \subseteq D_{aU}^{\mathrm{old}} \cup P_{bU}^{\mathrm{old}} U ⊆ D a U old ∪ P b U old . If q < v q < v q < v , the common-cutoff walk on E E E gives
q separates S ∩ E on E . q\text{ separates }S \cap E\text{ on }E. q separates S ∩ E on E .
If q = v q = v q = v , the gap is terminal, its cutoff is S = X S = X S = X , and the center separates that cutoff on all of U U U . Since W ⊆ E W \subseteq E W ⊆ E , the earlier-high property again yields W ∖ S ⊆ P q o l d W \setminus S \subseteq P_q^{\mathrm{old}} W ∖ S ⊆ P q old in either case.
The center’s separation remains valid when E E E is normalized: all moved jobs remain strictly before v v v , so neither the sets before and after v v v nor the relevant cones change. Similarly, later reordering within W W W changes no job’s side of its boundary q q q or of the historical center.
We have therefore obtained, in both historical cases,
S ⊆ P b U o l d , W ∖ S ⊆ P q o l d . S \subseteq P_{bU}^{\mathrm{old}}, \qquad W \setminus S \subseteq P_q^{\mathrm{old}}. S ⊆ P b U old , W ∖ S ⊆ P q old .
Rewriting these same sets in the new frame gives
S ⊆ D u n e w , W ∖ S ⊆ D c n e w . S \subseteq D_u^{\mathrm{new}}, \qquad W \setminus S \subseteq D_c^{\mathrm{new}}. S ⊆ D u new , W ∖ S ⊆ D c new .
In particular, if x ∈ W ∖ D c n e w x \in W \setminus D_c^{\mathrm{new}} x ∈ W ∖ D c new , then x ∉ S x \notin S x ∈ / S would contradict the second inclusion. Hence
W ∖ D c n e w ⊆ S ⊆ D u n e w . W \setminus D_c^{\mathrm{new}} \subseteq S \subseteq D_u^{\mathrm{new}}. W ∖ D c new ⊆ S ⊆ D u new .
These facts come directly from the already constructed edge and its separators. They do not use the list of a future child.
Step 5: prove that G G G is a global upset in the new frame. First, H ∗ H_* H ∗ is a global upset in that frame. Indeed, if x ∈ H ∗ x \in H_* x ∈ H ∗ and x ≺ n e w y x \prec_{\mathrm{new}} y x ≺ new y , then y ≺ o l d x y \prec_{\mathrm{old}} x y ≺ old x . The old-frame ideal property proved in Steps 2–3 therefore gives y ∈ H ∗ y \in H_* y ∈ H ∗ .
The sets D u n e w D_u^{\mathrm{new}} D u new and J ∖ P ^ c n e w J \setminus\widehat{P}_c^{\mathrm{new}} J ∖ P c new are global upsets as well: a successor cone is upward closed, and the complement of a weak predecessor cone is upward closed. In the opposite-side historical case, J ∖ P ^ w n e w J \setminus\widehat{P}_w^{\mathrm{new}} J ∖ P w new has the same property. Every factor in the relevant definition of G G G is thus a global upset. Their intersection is a global upset. This proves the first assertion of (B).
For the remainder of the proof, cones without a superscript are in the new frame.
Step 6: prove the first condition in (23) , namely W ∖ D c ⊆ G W \setminus D_c \subseteq G W ∖ D c ⊆ G . Take any x ∈ W ∖ D c x \in W \setminus D_c x ∈ W ∖ D c . We check each factor defining G G G .
(i) Step 4 gives x ∈ S ⊆ D u x \in S \subseteq D_u x ∈ S ⊆ D u .
(ii) Since x ∈ S = H ∗ ∩ U x \in S = H_* \cap U x ∈ S = H ∗ ∩ U , we have x ∈ H ∗ x \in H_* x ∈ H ∗ .
(iii) Since x ∈ W = ( c , b ) x \in W = (c,b) x ∈ W = ( c , b ) , it occurs strictly after c c c . It is not a job in c c c . It cannot precede a job in c c c either, because the schedule is feasible. Hence x ∉ P ^ c x \notin\widehat{P}_c x ∈ / P c .
(iv) For an opposite-side historical edge, w ≤ c w \leq c w ≤ c . Thus x x x also occurs strictly after w w w , and the same reasoning gives x ∉ P ^ w x \notin\widehat{P}_w x ∈ / P w .
For a same-direction historical edge, items (i)–(iii) put x x x in every factor of (21) . For an opposite-side historical edge, all four items put x x x in every factor of (22) . Therefore x ∈ G x \in G x ∈ G , as required.
Step 7: begin the proof of the second condition by placing a hypothetical past member inside U U U . Suppose, for a contradiction, that
z ∈ G , τ n e w ( z ) ≤ pos n e w ( c ) . z \in G,\qquad\tau_{\mathrm{new}}(z) \leq\operatorname{pos}_{\mathrm{new}}(c). z ∈ G , τ new ( z ) ≤ pos new ( c ) .
The factor D u D_u D u gives z ∈ D u z \in D_u z ∈ D u . If u u u is actual, feasibility then places z z z strictly after u u u . If u u u is the left sentinel, every real job is strictly after it, so the same conclusion holds. As c < d c < d c < d , we obtain
pos n e w ( u ) < τ n e w ( z ) ≤ pos n e w ( c ) < pos n e w ( d ) . \operatorname{pos}_{\mathrm{new}}(u) < \tau_{\mathrm{new}}(z) \leq\operatorname{pos}_{\mathrm{new}}(c) < \operatorname{pos}_{\mathrm{new}}(d). pos new ( u ) < τ new ( z ) ≤ pos new ( c ) < pos new ( d ) .
Thus z ∈ U = ( u , d ) z \in U = (u,d) z ∈ U = ( u , d ) . Membership in G G G also gives z ∈ H ∗ z \in H_* z ∈ H ∗ , and only now do we apply the extension identity:
z ∈ H ∗ ∩ U = S . z \in H_* \cap U = S. z ∈ H ∗ ∩ U = S .
Membership in D u D_u D u alone would not have been sufficient to place z z z inside U U U ; the upper bound on its time is essential.
Step 8: exclude that past member for a same-direction historical edge. Reversing the inequality τ n e w ( z ) ≤ pos n e w ( c ) \tau_{\mathrm{new}}(z) \leq\operatorname{pos}_{\mathrm{new}}(c) τ new ( z ) ≤ pos new ( c ) , where c = q c=q c = q , gives
τ o l d ( z ) ≥ pos o l d ( q ) . \tau_{\mathrm{old}}(z) \geq\operatorname{pos}_{\mathrm{old}}(q). τ old ( z ) ≥ pos old ( q ) .
We already know z ∈ S ⊆ U z \in S \subseteq U z ∈ S ⊆ U , and q q q separates S S S on all of U U U . If equality holds, z z z lies in the slot q = c q = c q = c , so z ∈ P ^ c z \in\widehat{P}_c z ∈ P c . If the inequality is strict, the old later-low property at q q q gives
z ∈ D q o l d = P c n e w ⊆ P ^ c . z \in D^{\mathrm{old}}_q = P^{\mathrm{new}}_c \subseteq\widehat{P}_c. z ∈ D q old = P c new ⊆ P c .
Both cases contradict the factor J ∖ P ^ c J \setminus\widehat{P}_c J ∖ P c in G G G . This proves the second condition of (23) for same-direction history.
Step 9: exclude that past member for an opposite-side historical edge. Here u < w ≤ c < b ≤ d u < w \leq c < b \leq d u < w ≤ c < b ≤ d . Split the possible time of z z z into the following two ranges.
First range: τ n e w ( z ) ≤ pos n e w ( w ) \tau_{\mathrm{new}}(z) \leq\operatorname{pos}_{\mathrm{new}}(w) τ new ( z ) ≤ pos new ( w ) . In the old frame this says that z z z occurs at or after the historical center v = w v = w v = w :
τ o l d ( z ) ≥ pos o l d ( v ) . \tau_{\mathrm{old}}(z) \geq\operatorname{pos}_{\mathrm{old}}(v). τ old ( z ) ≥ pos old ( v ) .
We know z ∈ S ⊂ X z \in S \subset X z ∈ S ⊂ X and z ∈ U z \in U z ∈ U . The center separates X X X on all of U U U , so its later-low condition is applicable. If z z z occurs strictly after v v v , it gives
z ∈ D v o l d = P w n e w . z \in D^{\mathrm{old}}_v = P^{\mathrm{new}}_w. z ∈ D v old = P w new .
If z z z occurs at v v v , then z ∈ v = w z \in v = w z ∈ v = w . In either case z ∈ P ^ w z \in\widehat{P}_w z ∈ P w , contradicting the factor J ∖ P ^ w J \setminus\widehat{P}_w J ∖ P w in G G G .
Second range: pos n e w ( w ) < τ n e w ( z ) ≤ pos n e w ( c ) \operatorname{pos}_{\mathrm{new}}(w) < \tau_{\mathrm{new}}(z) \leq\operatorname{pos}_{\mathrm{new}}(c) pos new ( w ) < τ new ( z ) ≤ pos new ( c ) . Reversing these inequalities gives
pos o l d ( q ) ≤ τ o l d ( z ) < pos o l d ( v ) . \operatorname{pos}_{\mathrm{old}}(q) \leq\tau_{\mathrm{old}}(z) < \operatorname{pos}_{\mathrm{old}}(v). pos old ( q ) ≤ τ old ( z ) < pos old ( v ) .
In particular q < v q < v q < v . Also a U < q a_U < q a U < q , so z ∈ E = ( a U , v ) z \in E = (a_U, v) z ∈ E = ( a U , v ) in the old frame. We now have exactly the domain membership needed for the local separator assertion: z ∈ S ∩ E z \in S \cap E z ∈ S ∩ E , and q q q separates S ∩ E S \cap E S ∩ E on E E E . If z z z occurs strictly after q q q , the old later-low property yields
z ∈ D q o l d = P c n e w . z \in D^{\mathrm{old}}_q = P^{\mathrm{new}}_c. z ∈ D q old = P c new .
If it occurs at q q q , then z ∈ q = c z \in q = c z ∈ q = c . Thus z ∈ P ^ c z \in\widehat{P}_c z ∈ P c in both cases, contradicting its exclusion from G G G .
The two ranges cover every possible time at or before c c c . When w = c w = c w = c , the second range is empty and the first range handles the terminal gap. Therefore
G ∩ { z ∈ J : τ n e w ( z ) ≤ pos n e w ( c ) } = ∅ . G \cap\{z \in J : \tau_{\mathrm{new}}(z) \leq\operatorname{pos}_{\mathrm{new}}(c)\} = \varnothing. G ∩ { z ∈ J : τ new ( z ) ≤ pos new ( c )} = ∅ .
This proves the second condition of (23) also for opposite-side history, and completes (B).
Step 10: verify the stated dependence on the incoming edge. The proof used the recorded cutoff, its carry or rank threshold, the already established separators of U → W U \to W U → W , and feasibility of the complete witness schedule. None of these facts assumes an invariant of a future child of W W W . Reordering jobs inside W = ( c , b ) W = (c, b) W = ( c , b ) preserves W W W as a set, fixes its boundary slots, and changes no job at or before c c c . It also leaves all precedence cones and the recorded sets unchanged. Consequently both conditions in (23) remain valid under the subsequent allowed reordering of W W W . All assertions of the lemma have now been proved. □
Exact global forms after the reversal. The flat expression is used to define the historical ideal H ∗ H_* H ∗ , but the new switch entry is still stored exactly as G ∩ R t G \cap R_t G ∩ R t ; it is not replaced by a flat local predicate. We record its two possible forms, which are used in the formula count later. On a same-direction historical edge, H ∗ = P b u ∖ F h i s t H_* = P_{bu} \setminus F_{\mathrm{hist}} H ∗ = P b u ∖ F hist in the old frame. After reversal the cone P b u P_{bu} P b u becomes D u D_u D u , and F h i s t r e v F_{\mathrm{hist}}^{\mathrm{rev}} F hist rev means the same subset of J J J expressed in reversed-frame atoms. Intersecting the resulting switch predicate with its current outer rank suffix gives
G ∩ R t = D u ∩ ( J ∖ P ^ c ) ∩ ( J ∖ F h i s t r e v ) ∩ R t . (25) G \cap R_t = D_u \cap(J \setminus\widehat{P}_c) \cap(J \setminus F_{\mathrm{hist}}^{\mathrm{rev}}) \cap R_t. \tag*{(25)} G ∩ R t = D u ∩ ( J ∖ P c ) ∩ ( J ∖ F hist rev ) ∩ R t . (25)
The frozen expression F h i s t r e v F_{\mathrm{hist}}^{\mathrm{rev}} F hist rev may itself contain an old rank condition. This condition is part of the recorded history and is not merged with the new outer suffix R t R_t R t .
On an opposite-side historical edge, the old complement J ∖ D a U J \setminus D_{aU} J ∖ D a U becomes J ∖ P d J \setminus P_d J ∖ P d in the new frame. The old prefix { rank o l d < h } \{\operatorname{rank}_{\mathrm{old}} < h\} { rank old < h } becomes a new suffix R k R_k R k , where k = N + 2 − h k = N + 2 - h k = N + 2 − h . Therefore
G = D u ∩ ( J ∖ P ^ c ) ∩ ( J ∖ P ^ w ) ∩ ( J ∖ P d ) ∩ R k . (26) G = D_u \cap(J \setminus\widehat{P}_c) \cap(J \setminus\widehat{P}_w) \cap(J \setminus P_d) \cap R_k. \tag*{(26)} G = D u ∩ ( J ∖ P c ) ∩ ( J ∖ P w ) ∩ ( J ∖ P d ) ∩ R k . (26)
An additional outer suffix R t R_t R t may be merged with R k R_k R k , because R k ∩ R t = R max { k , t } R_k \cap R_t = R_{\max\{k,t\}} R k ∩ R t = R m a x { k , t } . This merge does not change the local flat identity: outside the switch companion, the birth cover already forces membership in the exact initial predicate. These two global forms, together with the explicit flat carry cases above, are the inputs to the leaf-count argument in Lemma 7.15 .
Why the invariants hold at every child
Induction order and terminology. At a node W = ( a , b ) W = (a,b) W = ( a , b ) , the parent list K \mathcal{K} K consists of global upsets, and Q ( K ) Q(\mathcal{K}) Q ( K ) denotes their union. All times, cones and priorities are taken in the frame in which the child under consideration is constructed. In particular, for an opposite-side child this is the reversed frame of Step 3 in § 7.4 . A carried qualifier is a job in the union of the suffix carry C \mathcal{C} C selected before the new injection is appended; it may lie outside W W W . A strict-step child is a nonempty gap ( p , q ) (p,q) ( p , q ) for which q > p q > p q > p is the final actual separator position of a promotion that advances from the previous retained position p p p . The associated cutoff S S S is the cutoff before that promotion. A birth group is as defined in § 7.5 : the root entry, the pair created by a switch (counted as one group), or an individual subsequently appended injection. We call a list genuine if it is a list actually obtained by the operations of § 7.4 , including pruning; arbitrary lists of global upsets are not covered by the counting assertion below.
We induct over the depth of the annotated hierarchy. Assume (I1)–(I3) for the current parent and its ancestors. The construction and Lemma 7.7 establish child (I1). For opposite-side children the historical predicate G G G is already available from Lemma 7.9 , using the incoming edge of W W W and no invariant of the child. We next prove child (I2), then child (I3), and only afterwards apply the list bound. This order prevents the use of any unproved child invariant.
Lemma 7.10 (The past-boundary invariant). Assume that (I1)–(I3) hold for a parent W W W and its ancestors. For every nonempty child V = ( p , q ) V = (p,q) V = ( p , q ) , with unpruned list L V \mathcal{L}_V L V and pruned list K V = prune V ( L V ) \mathcal{K}_V = \operatorname{prune}_V(\mathcal{L}_V) K V = prune V ( L V ) ,
{ x ∈ Q ( K V ) : τ ( x ) ≤ pos ( p ) } ⊆ P ^ p . \{x \in Q(\mathcal{K}_V) : \tau(x) \le\operatorname{pos}(p)\} \subseteq\widehat{P}_p. { x ∈ Q ( K V ) : τ ( x ) ≤ pos ( p )} ⊆ P p . Consequently K V \mathcal{K}_V K V satisfies (I2).
Proof idea. A new qualifier lying in the parent interval is high at the associated cutoff and is handled by the left separator. A qualifier occurring before the parent’s left boundary can occur only in an inherited same-direction carry. Parent (I2) connects it to a qualifier in the left boundary slot. The first strict separator advance, together with parent (I3), forces this boundary qualifier to precede a job in the first target slot; the normalized walk propagates the chain to the child’s left boundary.
Proof. Write W = ( a , b ) W = (a,b) W = ( a , b ) in the frame used for the child, and let x ∈ Q ( K V ) x \in Q(\mathcal{K}_V) x ∈ Q ( K V ) satisfy τ ( x ) ≤ pos ( p ) \tau(x) \le\operatorname{pos}(p) τ ( x ) ≤ pos ( p ) . We prove x ∈ P ^ p = P p ∪ jobs ( p ) x \in\widehat{P}_p = P_p \cup\operatorname{jobs}(p) x ∈ P p = P p ∪ jobs ( p ) . If p p p is the left sentinel, no real job satisfies the stated time inequality, so assume p p p otherwise.
Jobs strictly after $a. Suppose τ ( x ) > pos ( a ) \tau(x) > \operatorname{pos}(a) τ ( x ) > pos ( a ) . If x x x occurs at p p p , the conclusion is immediate. Otherwise a < x < p a < x < p a < x < p in temporal position. Thus x x x belongs to the parent domain W W W (and, for an opposite-side child, to the processed domain E E E ). By Lemma 7.7 ,
W ∩ Q ( K V ) = W ∖ S . W \cap Q(\mathcal{K}_V) = W \setminus S. W ∩ Q ( K V ) = W ∖ S .
Therefore x x x is high for the associated cutoff on the relevant walk domain. Its left endpoint p p p separates that cutoff there; the earlier-high separator condition gives x ∈ P p x \in P_p x ∈ P p . This covers both child directions, including a terminal gap in the reversed processed domain.
Jobs at or before a a a . Suppose τ ( x ) ≤ pos ( a ) \tau(x) \le\operatorname{pos}(a) τ ( x ) ≤ pos ( a ) . For an opposite-side child the two unpruned entries are G ∩ R h G \cap R_h G ∩ R h and D a D_a D a . Lemma 7.9 gives G ∩ { z : τ ( z ) ≤ pos ( a ) } = ∅ G \cap\{z : \tau(z) \le\operatorname{pos}(a)\} = \varnothing G ∩ { z : τ ( z ) ≤ pos ( a )} = ∅ ; the same exclusion holds for D a D_a D a by feasibility (or the left sentinel convention). Hence this case cannot occur for an opposite-side child. For a same-direction child the fresh injection D a ∖ P b D_a \setminus P_b D a ∖ P b also contains no such job. Consequently x x x lies in the suffix carry C C C of the old list K \mathcal{K} K . In particular x ∈ Q ( K ) x \in Q(\mathcal{K}) x ∈ Q ( K ) ; parent (I2) implies x ∈ P ^ a x \in\widehat{P}_a x ∈ P a . If a a a is actual, choose y ∈ jobs ( a ) y \in\operatorname{jobs}(a) y ∈ jobs ( a ) with x = y x = y x = y or x ≺ y x \prec y x ≺ y . Since Q ( C ) Q(C) Q ( C ) is a global upset, y ∈ Q ( C ) ⊆ Q ( K ) y \in Q(C) \subseteq Q(\mathcal{K}) y ∈ Q ( C ) ⊆ Q ( K ) . The sentinel case cannot arise here, because there is no real job at or before the left sentinel. If p = a p = a p = a , then x ∈ P ^ p x \in\widehat{P}_p x ∈ P p , as required.
Now assume p > a p > a p > a . Remember the assumptions here: y ∈ jobs ( a ) ∩ Q ( C ) y \in\operatorname{jobs}(a) \cap Q(C) y ∈ jobs ( a ) ∩ Q ( C ) and x = y x = y x = y or x ≺ y x \prec y x ≺ y . Let S S S be the cutoff assigned to this child; the fixed carry C C C consists of the parent qualifiers unpromoted at S S S . Therefore every job of Q ( C ) Q(C) Q ( C ) that belongs to W W W is high for every cutoff occurring in the separator walk from a a a to p p p , including its intermediate advances. Moreover, each promotion preceding this child has old key smaller than the key of y y y : membership of y y y in the final suffix carry gives precisely this comparison.
The first strict advance from a a a . Let t t t be its first target slot. The current separator is a a a , and the cutoff immediately before the promotion is an ideal L L L separated by a a a . If j j j is the job just promoted, then every old-low job scheduled after a a a lies in D a D_a D a . Hence the first low exception causing the advance must be j j j itself, with j ∉ D a j \notin D_a j ∈ / D a and j ∈ t j \in t j ∈ t . Since j j j was promoted before S S S , key K ( j ) < key K ( y ) \operatorname{key}_{\mathcal{K}}(j) < \operatorname{key}_{\mathcal{K}}(y) key K ( j ) < key K ( y ) . Also j ∈ W ∖ D a j \in W \setminus D_a j ∈ W ∖ D a , so parent (I1) makes it a qualifier.
We check the feasibility of the boundary exchange rather than assuming it. Every predecessor z ≺ j z \prec j z ≺ j in W W W is in L L L , because the parent priority order extends precedence and j j j is the next promoted job. As a a a separates L L L , each such z z z occurring after a a a belongs to D a D_a D a , and thus j ∈ D a j \in D_a j ∈ D a by transitivity, a contradiction. A predecessor of j j j in the boundary slot a a a gives the same contradiction; a predecessor outside W W W cannot occur strictly between a a a and t t t . Therefore every predecessor of j j j in the complete witness occurs strictly before a a a .
Suppose that y y y had no successor scheduled at or before t t t . Swapping j j j (in t t t ) with y y y (in a a a ) would then be feasible: j j j crosses none of its predecessors, while y y y crosses none of its successors. The two slots remain full and all other jobs keep their times. This is forbidden by parent (I3), which applies after the present feasible reordering of W W W . Thus y y y has a strict successor z z z scheduled at or before t t t . It lies after a a a , and it belongs to Q ( C ) Q(C) Q ( C ) because this union is a global upset. If z z z lies in t t t , we already have a carry-successor of y y y in t t t . Otherwise z z z is a high job in W W W strictly between a a a and t t t . The high-job propagation proved in Steps 2–3 of Lemma 7.4 gives a strict high successor of z z z in t t t . Upward closure again keeps that successor in Q ( C ) Q(C) Q ( C ) . Hence in either case there exists z t ∈ t ∩ Q ( C ) z_t \in t \cap Q(C) z t ∈ t ∩ Q ( C ) with y ≺ z t y \prec z_t y ≺ z t .
Propagation through the remaining advances. Consider any following advance r → t ′ r \to t' r → t ′ before the final retained position p p p , whether it is an intermediate advance within one promotion or part of a later promotion. The job previously reached in r r r belongs to Q ( C ) ∩ W Q(C) \cap W Q ( C ) ∩ W , and is therefore high for the current cutoff. Steps 2–3 of Lemma 7.4 , applied to that advance in the normalized parent schedule, supply a strict high successor in t ′ t' t ′ . Iterating along the finitely many advances produces z p ∈ p z_p \in p z p ∈ p such that y ≺ z p y \prec z_p y ≺ z p . Because x = y x = y x = y or x ≺ y x \prec y x ≺ y , we conclude x ∈ P ^ p x \in\widehat{P}_p x ∈ P p . The opposite-side normalization performed after the same-direction marks are chosen does not move jobs across p p p , so this conclusion persists.
We have proved (I2) for the unpruned list. Pruning only deletes entries and cannot introduce a new qualifier; hence Q ( K V ) ⊆ Q ( L V ) Q(\mathcal{K}_V) \subseteq Q(\mathcal{L}_V) Q ( K V ) ⊆ Q ( L V ) and the assertion holds for the child’s actual list. □
Lemma 7.11 (The exchange invariant for all child reorderings). Under the same induction hypotheses, every nonempty child with its pruned list satisfies (I3), for every feasible reordering
of the child’s interior slots.
Proof idea. When the child’s left boundary is a slot of the normalized parent (or of the normalized reversed processed side), a feasible exchange would improve that normalized schedule at its first changed slot. When the left boundary is inherited from the parent, comparison of carried keys reduces the exchange to the parent’s (I3).
Proof. Let V = ( p , q ) V=(p,q) V = ( p , q ) and fix an arbitrary feasible full reordering of its interior slots while all exterior slots stay fixed. Put K ′ = prune V ( L V ) K'=\operatorname{prune}_{V}(L_V) K ′ = prune V ( L V ) . Suppose, seeking a contradiction, that the exchange described in (I3) is feasible for some
x ∈ V ∖ D p , y ∈ jobs ( p ) ∩ Q ( K ′ ) , key K ′ ( x ) < l e x key K ′ ( y ) . x \in V \setminus D_p,\qquad y \in\operatorname{jobs}(p)\cap Q(K'),\qquad\operatorname{key}_{K'}(x) <_{\mathrm{lex}} \operatorname{key}_{K'}(y). x ∈ V ∖ D p , y ∈ jobs ( p ) ∩ Q ( K ′ ) , key K ′ ( x ) < lex key K ′ ( y ) .
Child (I1), already proved, gives x ∈ V ∩ Q ( K ′ ) x\in V\cap Q(K') x ∈ V ∩ Q ( K ′ ) , so both keys are defined. The pruning comparison of Lemma Lemma 7.6 lifts this strict inequality to the unpruned list. Write S S S for the cutoff associated with V V V .
An internal left endpoint p p p . By “internal” we mean that p p p is an actual slot belonging to the domain normalized when these marks were selected: W W W for a same-direction child, or E E E for an opposite-side child. Both x x x and y y y then lie in that domain. Since they qualify for L V L_V L V on W W W , Lemma Lemma 7.7 gives x , y ∈ W ∖ S x,y\in W\setminus S x , y ∈ W ∖ S . Its key-order assertion turns the lifted inequality into x ◃ y x\mathrel{\triangleleft}y x ◃ y in the fixed priority order used for that normalization. For an opposite-side child we restrict the Step 3 priority to E E E .
The current rearrangement of V V V affects only slots strictly after p p p . All other normalizations and later subtree reorderings relevant to the present construction leave the normalized prefix ending at p p p unchanged. If the proposed exchange were feasible, the resulting feasible local schedule of the normalized domain would agree with its normalized witness in every slot before p p p , but would replace y y y by higher-priority x x x in slot p p p . This contradicts the prefix minimality conclusion of Lemma Lemma 7.1 , which explicitly allows arbitrary feasible later reorderings.
An inherited left endpoint p = a p=a p = a . If a a a is a sentinel there is no boundary job y y y . For an opposite-side child, the first entry G ∩ R h G\cap R_h G ∩ R h has no job at or before a a a by Lemma Lemma 7.9 , and neither does D a D_a D a ; hence no y y y qualifies. For a same-direction child, the appended injection D a ∖ P b D_a\setminus P_b D a ∖ P b contains neither x x x (since x ∉ D a x\notin D_a x ∈ / D a ) nor y y y (since an actual slot is an antichain). Both jobs must therefore qualify through the suffix carry. Carrying preserves their relative old-key order, and pruning lifts their comparison by Lemma Lemma 7.6, because x ∈ V x\in V x ∈ V is an interior job. Thus key K ( x ) < l e x key K ( y ) \operatorname{key}_{K}(x)<_{\mathrm{lex}}\operatorname{key}_{K}(y) key K ( x ) < lex key K ( y ) . As V ⊆ W V\subseteq W V ⊆ W , and p = a p=a p = a , the proposed exchange is exactly one of the exchanges forbidden by parent (I3). In particular, the feasible normalizations of the parent’s interior followed by the arbitrary reordering of V V V form a feasible interior reordering to which that invariant applies (by Lemma Lemma 7.1 ). We obtain a contradiction in this case as well.
Counting groups at a marked endpoint. A switch pair is treated as one birth group even if both of its entries survive. We count a birth group as nonempty at a node precisely when at least one of its retained entries meets the current node. For a strict-step child ( p , q ) (p,q) ( p , q ) the final separator advance provides a job in q q q that cannot be reached from the old-high jobs. We first prove that separate surviving groups cannot be charged to the same job in q q q , then handle children not coming from a strict advance.
Lemma 7.12 (A spare endpoint and at most m m m entries). Every genuine pruned list has at most m − 1 m-1 m − 1 nonempty birth groups and at most m m m entries. Among its entries only the first can have a current outer rank-suffix restriction; rank conditions already frozen inside the historical first entry are not counted as current outer restrictions.
Proof idea. For a strict separator move, charge each surviving group to a distinct job in its final endpoint slot. A low exception causing the last advance cannot receive a charge, leaving at most m − 1 m-1 m − 1 slots for charges. Other child types start from one group or from a fresh injection alone.
Proof. The spare job for a strict advance. Consider a strict-step child V = ( p , q ) V=(p,q) V = ( p , q ) of a parent W W W . The endpoint q q q was retained after a promotion from cutoff S S S to S + = S ∪ { j } S^{+}=S\cup\{j\} S + = S ∪ { j } . Let r → q r\to q r → q be the last individual advance of that promotion, and choose a low exception e ∈ jobs ( q ) e\in\operatorname{jobs}(q) e ∈ jobs ( q ) causing this advance. If it is the first advance, the only newly low job is j j j ; previously low jobs were already covered by D p D_p D p . Hence e = j e=j e = j . Because S S S is a priority prefix, every predecessor of j j j in the parent belongs to S S S . If an earlier advance occurred, then j j j lies at or before r r r . Thus the exception e e e in the later slot q q q belongs to the old cutoff S S S ; all of its parent-domain predecessors lie in S S S , since S S S is an ideal. In either case we obtain
there is no z ∈ W ∖ S with z ≺ e . \text{there is no } z\in W\setminus S\text{ with }z\prec e. there is no z ∈ W ∖ S with z ≺ e .
For an opposite-side strict step the walk was performed on E ⊆ W E\subseteq W E ⊆ W . The old-high jobs in W ∖ E W\setminus E W ∖ E occur at or after the center, hence cannot precede e ∈ q ⊆ E e\in q\subseteq E e ∈ q ⊆ E . Thus the spare-job property holds for the entire parent also in this case.
Disjointness of different birth groups on current nodes. We establish by induction along a chain of genuine list updates that distinct groups have disjoint qualifier sets on the current node. It holds for the root’s single group and immediately after a switch, which discards all older groups and creates one new group. At a same-direction update from a parent W = ( a , b ) W=(a,b) W = ( a , b ) , every old group is a subset of the union of the parent’s old qualifiers. By parent (I1), those qualifiers that belong to W W W lie in P b P_b P b . The new injection I ( a , b ) = D a ∖ P b I(a,b)=D_a\setminus P_b I ( a , b ) = D a ∖ P b is therefore disjoint from all old groups on W W W . Suffix carrying and pruning only remove memberships or entire entries; in particular, they cannot create an overlap on a descendant V ⊆ W V\subseteq W V ⊆ W between different old groups. This proves the induction step. Note that the entries of the same switch group may overlap, and different groups may overlap outside the current node; neither phenomenon affects the argument.
Charging at a strict-step child. Let B B B be a group surviving pruning on V V V . There is a job x ∈ V x\in V x ∈ V belonging to this group. By Lemma 7.7 , x x x is high for the associated cutoff S S S , so separation at the right endpoint q q q gives x ≺ y x\prec y x ≺ y for some y ∈ jobs ( q ) y\in\operatorname{jobs}(q) y ∈ jobs ( q ) . Since every entry in B B B is a global upset, the successor y y y belongs to B B B .
Before restriction to the child V V V , distinct updated groups are already disjoint on the whole parent W W W : carried groups retain the parent’s disjointness, and the fresh injection is disjoint from every carried group on W W W . An opposite-side update has only one switch group. Since the endpoint slot q q q lies in W W W , this parent-domain disjointness applies to the charged jobs y ∈ jobs ( q ) y\in\operatorname{jobs}(q) y ∈ jobs ( q ) . Thus distinct surviving groups receive distinct jobs of the full m m m -job endpoint slot. No group can be charged to the spare job e e e , by the spare-job property. There are consequently at most m − 1 m-1 m − 1 surviving groups.
Other child types and the number of entries. For a same-direction terminal gap associated with the exhausted cutoff S e n d = W ∩ P b S_{\mathrm{end}}=W\cap P_b S end = W ∩ P b , the carry of unpromoted qualifiers is empty; only the fresh injection can survive. Every opposite-side child is created by a switch and thus has just one birth group (its two-entry pair). At the root there is one group. These are the remaining cases: every other same-direction nonempty child arises from a strict retained advance. Since m ≥ 3 m\ge3 m ≥ 3 , one group also satisfies the bound m − 1 m-1 m − 1 .
The root group has one entry, a switch group at most two, and every injection group one. There is at most one initial switch group in a genuine list, so m − 1 m-1 m − 1 groups yield at most ( m − 1 ) + 1 = m (m-1)+1=m ( m − 1 ) + 1 = m entries. Each suffix carry can rank-restrict only its first retained entry; multiple such restrictions merge into a single threshold. New injections are appended without an outer rank restriction, and pruning only deletes entries. A historical rank restriction frozen inside a switched first entry is part of that entry’s predicate, not an additional outer restriction on a later entry. This proves all assertions.
Proposition 7.13 (Existence of the annotated hierarchy). Every feasible full instance admits a finite hierarchy whose nodes carry the frames, complete witness schedules, boundary slots, genuine lists and recorded incoming-edge information of § 7.1 –§ 7.5 . Each node satisfies (I1)–(I3), its list has at most m m m entries, every nonempty node has at least one marked full slot, and each of its children has at most ∣ W ∣ − m |W|-m ∣ W ∣ − m jobs.
Proof idea. Construct the children only from verified parent information; prove their three invariants before recursing. The marked center supplies a uniform decrease of at least m m m jobs.
Proof. Use the forward frame, the two sentinel boundaries, W = J W=J W = J and list ( J ) (J) ( J ) at the root. The sentinel cone conventions give (I1); invariants (I2) and (I3) are vacuous. The root has one group and one entry.
Suppose the parent and its ancestors have been constructed and satisfy the asserted properties. Lemma 7.1 allows each required normalization while keeping the exterior slots fixed. Lemma 7.4 and Corollary 7.5 supply the separator walks and the actual center. The gaps are unions of full slots and hence have feasible full schedules. The lists for same-direction children are obtained by carrying, injecting and pruning. For opposite-side children the parent has an incoming edge; Lemmas 7.8 and 7.9 construct the switch predicate from previously recorded information. At the root no such predicate is needed, because its opposite side is empty.
Lemma 7.7 now establishes (I1) for every new child. Lemma 7.10 establishes (I2), and Lemma 7.11 establishes (I3). The counting Lemma 7.12 , applied to the resulting genuine pruned lists, bounds their groups and entries. Thus every hypothesis needed to use a child as the parent of the next level has been verified, without invoking any property of a future node.
Finally the center is a marked slot of exactly m m m jobs, and no child contains any of its jobs. Hence each child’s set has cardinality at most ∣ W ∣ − m |W|-m ∣ W ∣ − m . This strict decrease makes the hierarchy finite, completing the induction.
Exact formulas and their sizes
Purpose, domains, and interpretation of a formula. Proposition 7.13 constructs a finite annotated hierarchy. To prove Theorem 5.8 , we must also describe the job set of every node and the temporal prefix before every marked slot by Boolean formulas from Definition 2.2 . All such formulas are evaluated on the fixed global ground set J J J ; their value is not an expression whose universe changes when we pass to a child.
We distinguish three objects throughout this subsection. The parent domain W = ( a , b ) W=(a,b) W = ( a , b ) consists of the jobs strictly between its two boundary slots in the complete feasible witness. A child domain V = ( p , q ) V=(p,q) V = ( p , q ) is an open temporal gap within W W W . The associated low cutoff S ⊆ W S\subseteq W S ⊆ W is a priority prefix in the frame in which that gap was constructed. The child jobs in V ∩ S V\cap S V ∩ S are called low , and those in V ∖ S V\setminus S V ∖ S are called high . These classifications refer to priority, not to execution time. We write Q ′ = Q ( K V ) Q'=Q(K_V) Q ′ = Q ( K V ) for the union of the entries of the child’s genuine pruned list K V K_V K V . Its entries, and hence Q ′ Q' Q ′ , are global sets; in particular, Q ′ Q' Q ′ may contain jobs outside V V V .
Unless stated otherwise, each assertion below is made in the working frame of the particular child. For a same-direction child this is the parent’s frame; for an opposite-side child it is the reversed frame of Step 3 of Section 7.3. In either frame, τ ( x ) \tau(x) τ ( x ) denotes the slot of x x x in the complete witness and pos ( r ) \operatorname{pos}(r) pos ( r ) the position of boundary slot r r r . For an actual boundary r r r we use
P r = { x ∈ J : ∃ u ∈ jobs ( r ) , x ≺ u } , D r = { x ∈ J : ∃ u ∈ jobs ( r ) , u ≺ x } , P_r=\{x\in J:\exists u\in\operatorname{jobs}(r),\ x\prec u\},\qquad D_r=\{x\in J:\exists u\in\operatorname{jobs}(r),\ u\prec x\}, P r = { x ∈ J : ∃ u ∈ jobs ( r ) , x ≺ u } , D r = { x ∈ J : ∃ u ∈ jobs ( r ) , u ≺ x } ,
and P ^ r = P r ∪ jobs ( r ) \widehat{P}_r = P_r \cup\operatorname{jobs}(r) P r = P r ∪ jobs ( r ) , D ^ r = D r ∪ jobs ( r ) \widehat{D}_r = D_r \cup\operatorname{jobs}(r) D r = D r ∪ jobs ( r ) . We retain the sentinel conventions of § 7.1 .
Feasibility implies the following elementary temporal consequences:
x ∈ P r ⟹ τ ( x ) < pos ( r ) , x ∈ D r ⟹ τ ( x ) > pos ( r ) . x \in P_r \Longrightarrow\tau(x) < \operatorname{pos}(r), \qquad x \in D_r \Longrightarrow\tau(x) > \operatorname{pos}(r). x ∈ P r ⟹ τ ( x ) < pos ( r ) , x ∈ D r ⟹ τ ( x ) > pos ( r ) .
Conversely, the corresponding time inequalities do not by themselves imply cone membership. The separator conditions are needed whenever a proof makes such an inference.
Two previously established identities. For every genuine child, Lemmas 7.7, 7.10 and the pruning rule give
V ∩ Q ′ = V ∖ S , V ∩ S ⊆ D p ∩ P b , V ∖ S ⊆ P q , (27) V \cap Q' = V \setminus S, \qquad V \cap S \subseteq D_p \cap P_b, \qquad V \setminus S \subseteq P_q, \tag*{(27)} V ∩ Q ′ = V ∖ S , V ∩ S ⊆ D p ∩ P b , V ∖ S ⊆ P q , (27)
and the child’s past-boundary invariant
x ∈ Q ′ , τ ( x ) ≤ pos ( p ) ⟹ x ∈ P ^ p . (28) x \in Q',\ \tau(x) \leq\operatorname{pos}(p) \Longrightarrow x \in\widehat{P}_p. \tag*{(28)} x ∈ Q ′ , τ ( x ) ≤ pos ( p ) ⟹ x ∈ P p . (28)
These statements have different logical roles: the first identifies which child jobs qualify ; the second rules out false qualifiers outside the child. In particular, it would be incorrect to substitute Q ′ = V ∖ S Q' = V \setminus S Q ′ = V ∖ S as a global set identity. For same-direction children, if C C C denotes the suffix carry of unpromoted parent qualifiers before the new injection, § 7.5 supplies a global upset formula F F F satisfying
W ∩ F = W ∩ Q ( C ) = O ∖ S , O : = W ∩ Q ( K W ) . (29) W \cap F = W \cap Q(C) = O \setminus S, \qquad O := W \cap Q(K_W). \tag*{(29)} W ∩ F = W ∩ Q ( C ) = O ∖ S , O := W ∩ Q ( K W ) . (29)
The same construction gives
S = W ∩ ( P b ∖ F ) . (30) S = W \cap(P_b \setminus F). \tag*{(30)} S = W ∩ ( P b ∖ F ) . (30)
Indeed S S S contains the first priority block ( W ∖ O ) ∩ P b (W \setminus O) \cap P_b ( W ∖ O ) ∩ P b and the promoted qualifiers, whereas O ∖ S O \setminus S O ∖ S is precisely the unpromoted carry. Neither (29) nor (30) is asserted outside W W W . For opposite-side children let
X : = W ∖ D a , L h : = { x ∈ J : rank ( x ) < h } = J ∖ R h , H h : = ( J ∖ D a ) ∩ L h . X := W \setminus D_a, \qquad L_h := \{x \in J : \operatorname{rank}(x) < h\} = J \setminus R_h, \qquad H_h := (J \setminus D_a) \cap L_h. X := W ∖ D a , L h := { x ∈ J : rank ( x ) < h } = J ∖ R h , H h := ( J ∖ D a ) ∩ L h .
Here h h h is the rank threshold attached to the child, so that
S = S h = X ∩ L h = W ∩ H h . (31) S = S_h = X \cap L_h = W \cap H_h. \tag*{(31)} S = S h = X ∩ L h = W ∩ H h . (31)
The processed side is E = ( a , v ) E = (a,v) E = ( a , v ) , where v v v is the center in the reversed working frame. The center separates X X X on W W W . If q < v q < v q < v , then q q q separates S h ∩ E S_h \cap E S h ∩ E on E E E . If q = v q = v q = v , the gap is terminal and the center’s separator properties on W W W are used directly.
Lemma 7.14 (Exact global localization of a child). Let V = ( p , q ) V = (p,q) V = ( p , q ) be a nonempty genuine child of W = ( a , b ) W = (a,b) W = ( a , b ) , let S ⊆ W S \subseteq W S ⊆ W be its associated cutoff, and let Q ′ = Q ( K V ) Q' = Q(K_V) Q ′ = Q ( K V ) be the global union of its pruned list. In the child’s working frame, the high part has the global set identity
V ∖ S = ( Q ′ ∩ P q ) ∖ P ^ p . (32) V \setminus S = (Q' \cap P_q) \setminus\widehat{P}_p. \tag*{(32)} V ∖ S = ( Q ′ ∩ P q ) ∖ P p . (32) If V V V is same-direction and F F F is the flat formula of (29) , then
V ∩ S = ( D p ∩ P b ) ∖ ( D ^ q ∪ F ) . (33) V \cap S = (D_p \cap P_b) \setminus(\widehat{D}_q \cup F). \tag*{(33)} V ∩ S = ( D p ∩ P b ) ∖ ( D q ∪ F ) . (33) If V V V is opposite-side, write E = ( a , v ) E = (a,v) E = ( a , v ) and use the threshold h h h of (31) . Then
V ∩ S = ( D p ∩ P b ∩ ( J ∖ D a ) ∩ L h ) ∖ ( D ^ q ∪ D ^ v ) . (34) V \cap S = (D_p \cap P_b \cap(J \setminus D_a) \cap L_h) \setminus(\widehat{D}_q \cup\widehat{D}_v). \tag*{(34)} V ∩ S = ( D p ∩ P b ∩ ( J ∖ D a ) ∩ L h ) ∖ ( D q ∪ D v ) . (34) All right-hand sides are formulas evaluated on J J J . In each case their high and low parts are disjoint and have union exactly V V V as a subset of J J J .
Proof idea and purpose. The locally known identity V ∩ Q ′ = V ∖ S V \cap Q' = V \setminus S V ∩ Q ′ = V ∖ S must be made global. The cone P q P_q P q places high qualifiers before the right endpoint, and (13) eliminates qualifiers at or before the left endpoint. For low jobs, D p ∩ P b D_p \cap P_b D p ∩ P b first establishes membership in the parent , so that a local cutoff formula may legitimately be used. The exclusions of weak successor cones then enforce the right temporal boundary. On the opposite side, a second separator at the center is needed to localize the job to the processed domain E E E .
Proof. High part: inclusion from left to right. Take x ∈ V ∖ S x \in V \setminus S x ∈ V ∖ S . By (27) , x ∈ Q ′ x \in Q' x ∈ Q ′ and x ∈ P q x \in P_q x ∈ P q . Also τ ( x ) > pos ( p ) \tau(x) > \operatorname{pos}(p) τ ( x ) > pos ( p ) because x ∈ ( p , q ) x \in(p,q) x ∈ ( p , q ) . If x ∈ P ^ p x \in\widehat{P}_p x ∈ P p , either x x x would be in the slot p p p , or some job of p p p would be scheduled after x x x ; both are incompatible with τ ( x ) > pos ( p ) \tau(x) > \operatorname{pos}(p) τ ( x ) > pos ( p ) and feasibility. Hence x ∉ P ^ p x \notin\widehat{P}_p x ∈ / P p , proving the first inclusion in (32) .
High part: inclusion from right to left. Take x ∈ ( Q ′ ∩ P q ) ∖ P ^ p x \in(Q' \cap P_q) \setminus\widehat{P}_p x ∈ ( Q ′ ∩ P q ) ∖ P p . Since x ∈ P q x \in P_q x ∈ P q , feasibility gives τ ( x ) < pos ( q ) \tau(x) < \operatorname{pos}(q) τ ( x ) < pos ( q ) . If τ ( x ) ≤ pos ( p ) \tau(x) \le\operatorname{pos}(p) τ ( x ) ≤ pos ( p ) , then x ∈ Q ′ x \in Q' x ∈ Q ′ and (28) imply x ∈ P ^ p x \in\widehat{P}_p x ∈ P p , a contradiction. Therefore
pos ( p ) < τ ( x ) < pos ( q ) . \operatorname{pos}(p) < \tau(x) < \operatorname{pos}(q). pos ( p ) < τ ( x ) < pos ( q ) .
This is exactly x ∈ V x \in V x ∈ V . Now and only now we apply the first identity of (27) : x ∈ V ∩ Q ′ = V ∖ S x \in V \cap Q' = V \setminus S x ∈ V ∩ Q ′ = V ∖ S . This proves (32) globally, without any assumption about qualifiers elsewhere in J J J .
Same-direction low part: inclusion from left to right. Take x ∈ V ∩ S x \in V \cap S x ∈ V ∩ S . Lemma 7.7 gives x ∈ D p ∩ P b x \in D_p \cap P_b x ∈ D p ∩ P b . Since x x x occurs strictly before q q q , it belongs neither to the slot q q q nor to D q D_q D q ; thus x ∉ D ^ q x \notin\widehat{D}_q x ∈ / D q . Also x ∈ W ∩ S x \in W \cap S x ∈ W ∩ S , while (29) says that W ∩ F = O ∖ S W \cap F = O \setminus S W ∩ F = O ∖ S . As S ∩ ( O ∖ S ) = ∅ S \cap(O \setminus S) = \varnothing S ∩ ( O ∖ S ) = ∅ , we have x ∉ F x \notin F x ∈ / F . This proves the first inclusion in (33) .
Same-direction low part: inclusion from right to left. Take
x ∈ ( D p ∩ P b ) ∖ ( D ^ q ∪ F ) . x \in(D_p \cap P_b) \setminus(\widehat{D}_q \cup F). x ∈ ( D p ∩ P b ) ∖ ( D q ∪ F ) .
The membership x ∈ D p x \in D_p x ∈ D p implies pos ( p ) < τ ( x ) \operatorname{pos}(p) < \tau(x) pos ( p ) < τ ( x ) , also when p p p is the left sentinel by its cone convention. Membership x ∈ P b x \in P_b x ∈ P b implies τ ( x ) < pos ( b ) \tau(x) < \operatorname{pos}(b) τ ( x ) < pos ( b ) , also at the right sentinel. Because the two child endpoints satisfy pos ( a ) ≤ pos ( p ) < pos ( q ) ≤ pos ( b ) \operatorname{pos}(a) \le\operatorname{pos}(p) < \operatorname{pos}(q) \le\operatorname{pos}(b) pos ( a ) ≤ pos ( p ) < pos ( q ) ≤ pos ( b ) , it follows that
pos ( a ) < τ ( x ) < pos ( b ) , hence x ∈ W . \operatorname{pos}(a) < \tau(x) < \operatorname{pos}(b), \qquad\text{hence } x \in W. pos ( a ) < τ ( x ) < pos ( b ) , hence x ∈ W .
Only with this domain membership can we use (30) . From x ∈ W ∩ P b x \in W \cap P_b x ∈ W ∩ P b and x ∉ F x \notin F x ∈ / F it follows that x ∈ S x \in S x ∈ S . The right endpoint q q q separates S S S on W W W . If τ ( x ) = pos ( q ) \tau(x) = \operatorname{pos}(q) τ ( x ) = pos ( q ) , then x ∈ jobs ( q ) ⊆ D ^ q x \in\operatorname{jobs}(q) \subseteq\widehat{D}_q x ∈ jobs ( q ) ⊆ D q ; if τ ( x ) > pos ( q ) \tau(x) > \operatorname{pos}(q) τ ( x ) > pos ( q ) , the later-low separator condition gives x ∈ D q ⊆ D ^ q x \in D_q \subseteq\widehat{D}_q x ∈ D q ⊆ D q . Both possibilities contradict the assumption. Consequently τ ( x ) < pos ( q ) \tau(x) < \operatorname{pos}(q) τ ( x ) < pos ( q ) , and with τ ( x ) > pos ( p ) \tau(x) > \operatorname{pos}(p) τ ( x ) > pos ( p ) this yields x ∈ V ∩ S x \in V \cap S x ∈ V ∩ S . This proves (33) .
Opposite-side low part: inclusion from left to right. We work throughout in the reversed frame used to construct the opposite-side child. Take x ∈ V ∩ S x \in V \cap S x ∈ V ∩ S . The cone inclusions of Lemma 7.7 give x ∈ D p ∩ P b x \in D_p \cap P_b x ∈ D p ∩ P b . By (31) , x ∈ S ⊆ W ∩ H h x \in S \subseteq W \cap H_h x ∈ S ⊆ W ∩ H h , so x ∈ ( J ∖ D a ) ∩ L h x \in(J \setminus D_a) \cap L_h x ∈ ( J ∖ D a ) ∩ L h . Furthermore V = ( p , q ) ⊆ E = ( a , v ) V = (p,q) \subseteq E = (a,v) V = ( p , q ) ⊆ E = ( a , v ) and τ ( x ) < pos ( q ) ≤ pos ( v ) \tau(x) < \operatorname{pos}(q) \le\operatorname{pos}(v) τ ( x ) < pos ( q ) ≤ pos ( v ) . Feasibility implies that x x x is in neither D ^ q \widehat{D}_q D q nor D ^ v \widehat{D}_v D v . Thus it belongs to the right-hand side of (34) .
Opposite-side low part: inclusion from right to left. Take x x x in the right-hand side of (34) . As in the same-direction case, x ∈ D p ∩ P b x \in D_p \cap P_b x ∈ D p ∩ P b and p ≥ a p \ge a p ≥ a place it in the parent W = ( a , b ) W = (a,b) W = ( a , b ) : namely pos ( a ) < τ ( x ) < pos ( b ) \operatorname{pos}(a) < \tau(x) < \operatorname{pos}(b) pos ( a ) < τ ( x ) < pos ( b ) . Since also x ∈ ( J ∖ D a ) ∩ L h x \in(J \setminus D_a) \cap L_h x ∈ ( J ∖ D a ) ∩ L h , we may use (31) to conclude
x ∈ W ∩ H h = S h = S ⊆ X . x \in W \cap H_h = S_h = S \subseteq X. x ∈ W ∩ H h = S h = S ⊆ X .
We next show explicitly why x ∈ E x \in E x ∈ E . The center v v v separates X X X on the whole parent W W W . If τ ( x ) = pos ( v ) \tau(x) = \operatorname{pos}(v) τ ( x ) = pos ( v ) , then x ∈ jobs ( v ) ⊆ D ^ v x \in\operatorname{jobs}(v) \subseteq\widehat{D}_v x ∈ jobs ( v ) ⊆ D v . If τ ( x ) > pos ( v ) \tau(x) > \operatorname{pos}(v) τ ( x ) > pos ( v ) , the later-low property for X X X at v v v , applied to x ∈ X ∩ W x \in X \cap W x ∈ X ∩ W , yields x ∈ D v ⊆ D ^ v x \in D_v \subseteq\widehat{D}_v x ∈ D v ⊆ D v . Both contradict the exclusion of D ^ v \widehat{D}_v D v . Hence τ ( x ) < pos ( v ) \tau(x) < \operatorname{pos}(v) τ ( x ) < pos ( v ) . Since x ∈ D p x \in D_p x ∈ D p and p ≥ a p \ge a p ≥ a , it follows that
pos ( a ) < τ ( x ) < pos ( v ) , so x ∈ E . \operatorname{pos}(a) < \tau(x) < \operatorname{pos}(v), \qquad\text{so } x \in E. pos ( a ) < τ ( x ) < pos ( v ) , so x ∈ E .
Now x ∈ S h ∩ E x \in S_h \cap E x ∈ S h ∩ E , exactly the local low cutoff on which the separator assertion for q q q is available. If τ ( x ) = pos ( q ) \tau(x) = \operatorname{pos}(q) τ ( x ) = pos ( q ) , then x ∈ D ^ q x \in\widehat{D}_q x ∈ D q ; if τ ( x ) > pos ( q ) \tau(x) > \operatorname{pos}(q) τ ( x ) > pos ( q ) , the later-low property at q q q on E E E implies x ∈ D q x \in D_q x ∈ D q . When q = v q = v q = v , the same conclusion follows from the center’s separator property on W W W . Both contradict x ∉ D ^ q x \notin\widehat{D}_q x ∈ / D q . Thus τ ( x ) < pos ( q ) \tau(x) < \operatorname{pos}(q) τ ( x ) < pos ( q ) , and the membership x ∈ D p x \in D_p x ∈ D p places it after p p p . We obtain x ∈ V ∩ S x \in V \cap S x ∈ V ∩ S . This proves (34) and the lemma.
The exact counting convention. The atomic language is precisely the one in Definition 2.2. A leaf is one occurrence of a permitted atom: J J J , ∅ \varnothing ∅ , a rank suffix R h R_h R h , or a boundary set A A A of size m m m and one of P A P_A P A , D A D_A D A , P ^ A \widehat{P}_A P A , D ^ A \widehat{D}_A D A . The chosen boundary slot has m m m jobs, so its set and cones are permitted atoms. A sentinel cone denotes the appropriate constant J J J or ∅ \varnothing ∅ by the conventions of Section 7.1. A rank prefix L h = J ∖ R h L_h = J \setminus R_h L h = J ∖ R h costs one leaf (the complement operation does not add a leaf). Likewise, a set difference B ∖ C B \setminus C B ∖ C is shorthand for B ∩ ( J ∖ C ) B \cap(J \setminus C) B ∩ ( J ∖ C ) , where the J J J in the complement notation does not introduce another atomic occurrence. Union, intersection, and complement themselves cost no leaves; repeated appearances of an atom are counted repeatedly. A standalone constant such as J J J or ∅ \varnothing ∅ has one leaf. The leaf count of a union is at most the sum of the leaf counts of the displayed subformulas; no Boolean simplification is being assumed unless explicitly described.
We also distinguish the exact entries of a list from a flat carry . A flat formula F F F need only satisfy U ∩ F = U ∩ Q ( C ) U \cap F = U \cap Q(C) U ∩ F = U ∩ Q ( C ) for the specified current domain U U U ; it cannot replace the global entries when defining Q ′ Q' Q ′ or applying (I2). By contrast, the formulas counted for Q ′ Q' Q ′ below are exact on all of J J J .
Lemma 7.15 (A linear formula budget). For m ≥ 3 m \ge3 m ≥ 3 , the hierarchy of Proposition 7.13 has the following properties, with leaf counts in the atomic language of Definition 2.2:
Every suffix carry from a genuine pruned list has a flat global upset formula on its parent domain with at most m m m leaves.
The possible complicated first exact entry of a genuine list has at most m + 3 m + 3 m + 3 leaves.
The exact global qualifier union of every genuine pruned list has a formula with at most 3 m 3m 3 m leaves.
Every genuine node set, evaluated as a subset of J J J , has a formula with at most 4 m + 5 4m + 5 4 m + 5 leaves.
For every marked slot z z z at every node W W W , there is a global formula C z C_z C z with at most m + 3 m + 3 m + 3 leaves such that W ∩ C z W \cap C_z W ∩ C z is the set of jobs occurring strictly before z z z in the original input frame.
Frame changes do not enlarge the leaf count of any set formula: they merely exchange the permitted predecessor and successor cone atoms and replace rank suffixes by complemented rank suffixes. In (5), the input-time prefix is represented directly by a working-time prefix or suffix formula. Thus frame conversion requires no additional boundary-set leaf.
Proof idea and purpose. Use Lemma 7.12 to bound surviving birth groups, then inspect the exhaustive flat-union cases of Section 7.4. An exact historical entry can be complicated, but there is at most one such entry in any current list, and it is the initial one. Count these exact entries before using the two global localization formulas of Lemma 7.14.
Finally, construct both temporal sides of each separator directly. Choose its working-time prefix or suffix according to its orientation relative to the input frame. This preserves the distinction between working time and input time without adding a boundary-set leaf.
Proof. (1) Flat carries. Fix a parent node U U U and a suffix carry C C C selected from its genuine pruned list. A birth group surviving in the carry also survived in the parent list, so Lemma 7.12 provides at most m − 1 m-1 m − 1 groups. The flat formulas (11) –(14) of § 7.5 , together with the empty-carry formula, cover all possible surviving initial groups. We count them explicitly.
If the first switch entry G 0 ∩ R t G_0 \cap R_t G 0 ∩ R t survives, its switch group contributes the two atoms D c D_c D c and R t R_t R t through the flat expression D c ∪ R t D_c \cup R_t D c ∪ R t . If the companion was pruned, the same expression still agrees with the group on U U U , as proved in Lemma 7.8.
If only the switch companion survives as the initial entry, its contribution is D c ∩ R t D_c \cap R_t D c ∩ R t , at most two leaves. (With no nontrivial rank restriction one may omit the factor R 1 = J R_1=J R 1 = J .)
If the initial group has disappeared, the carry begins with an injection. The first injection contributes ( J ∖ P B 1 ) ∩ R t (J \setminus P_{B_1}) \cap R_t ( J ∖ P B 1 ) ∩ R t on U U U , at most two leaves; later injections contribute J ∖ P B i J \setminus P_{B_i} J ∖ P B i . The identity is only after intersection with U U U , as required for a flat expression.
Every later injection group contributes just one additional atom P B i P_{B_i} P B i to the flat union. If a switch group survives, there are at most ( m − 1 ) − 1 = m − 2 (m-1)-1=m-2 ( m − 1 ) − 1 = m − 2 injection groups, hence at most 2 + ( m − 2 ) = m 2+(m-2)=m 2 + ( m − 2 ) = m leaves. If no switch group survives, the first remaining group uses at most two leaves and the other at most m − 2 m-2 m − 2 groups contribute one each, again at most m m m .
The empty case uses one leaf. Thus the bound m m m holds in every case. Each displayed flat formula is a global upset: rank suffixes, complements of predecessor cones, and successor cones are upsets, and unions/intersections preserve that property.
(2) The complicated exact entry. The operations of § 7.4 imply that an inherited list starts with a surviving part of one root/switch group or with an injection; a later switch discards the entire earlier list. An injection has the exact two-leaf predicate D A ∖ P B D_A \setminus P_B D A ∖ P B . Only the first entry of a switch pair can have the historically complicated form. Carrying can only intersect the first retained entry with a current outer rank suffix, and pruning can only remove entries. Therefore no later entry can become a new complicated historical entry.
For a same-direction historical incoming edge, the exact form (23) of § 7.5 , interpreted in the new frame, is
G ∩ R t = D u ∩ ( J ∖ P ^ c ) ∩ ( J ∖ F h i s t r e v ) ∩ R t . G \cap R_t = D_u \cap(J \setminus\widehat{P}_c) \cap(J \setminus F_{\mathrm{hist}}^{\mathrm{rev}}) \cap R_t. G ∩ R t = D u ∩ ( J ∖ P c ) ∩ ( J ∖ F hist rev ) ∩ R t .
The frozen flat formula F h i s t F_{\mathrm{hist}} F hist was formed from an earlier genuine pruned list; by (1), it has at most m m m leaves. The remaining factors contribute exactly three additional atomic occurrences: D u D_u D u , P ^ c \widehat{P}_c P c , and R t R_t R t . Hence this exact entry has at most m + 3 m+3 m + 3 leaves. Here F h i s t r e v F_{\mathrm{hist}}^{\mathrm{rev}} F hist rev denotes the same subset of J J J written in the reversed atomic language; it is not the set complement of F h i s t F_{\mathrm{hist}} F hist .
For an opposite-side historical incoming edge, the exact formula (26) is
G = D u ∩ ( J ∖ P ^ c ) ∩ ( J ∖ P ^ w ) ∩ ( J ∖ P d ) ∩ R k . G = D_u \cap(J \setminus\widehat{P}_c) \cap(J \setminus\widehat{P}_w) \cap(J \setminus P_d) \cap R_k. G = D u ∩ ( J ∖ P c ) ∩ ( J ∖ P w ) ∩ ( J ∖ P d ) ∩ R k .
It uses five leaves. An additional current outer suffix R t R_t R t can be merged with R k R_k R k because R k ∩ R t = R max { k , t } R_k \cap R_t = R_{\max\{k,t\}} R k ∩ R t = R m a x { k , t } in the same frame. Thus the bound m + 3 m+3 m + 3 holds for either historical type (m ≥ 3 m \ge3 m ≥ 3 ). Rank conditions already frozen inside F h i s t F_{\mathrm{hist}} F hist are not treated as another current outer suffix.
(3) Exact global qualifier unions. Let K \mathcal{K} K be a genuine pruned list, and write Q ( K ) Q(\mathcal{K}) Q ( K ) as the union of its exact retained entries. By Lemma 7.12 , it has at most m − 1 m-1 m − 1 nonempty birth groups. The exceptional case is a surviving complicated first entry of a switch group. This group has at most one additional companion entry, costing one cone leaf, and there are at most m − 2 m-2 m − 2 other groups, each an injection with an exact two-leaf formula. Thus
# leaves ( Q ( K ) ) ≤ ( m + 3 ) + 1 + 2 ( m − 2 ) = 3 m . \#\operatorname{leaves}(Q(\mathcal{K})) \le(m+3)+1+2(m-2)=3m. # leaves ( Q ( K )) ≤ ( m + 3 ) + 1 + 2 ( m − 2 ) = 3 m .
If no complicated switch entry survives, a remaining root entry or simple switch companion has at most two leaves. A first injection may instead have the three-leaf formula ( D A ∖ P B ) ∩ R t (D_A \setminus P_B) \cap R_t ( D A ∖ P B ) ∩ R t . Each later injection costs two leaves. Thus, with 1 ≤ g ≤ m − 1 1 \le g \le m-1 1 ≤ g ≤ m − 1 nonempty groups, the total is at most 3 + 2 ( g − 1 ) ≤ 2 m − 1 3 + 2(g-1) \le2m-1 3 + 2 ( g − 1 ) ≤ 2 m − 1 ; the empty list is represented by the one-leaf constant ∅ \varnothing ∅ . These counts are no greater than 3 m 3m 3 m for m ≥ 3 m \ge3 m ≥ 3 . Hence there is an exact global formula for Q ( K ) Q(\mathcal{K}) Q ( K ) using at most 3 m 3m 3 m leaves.
(4) Exact node sets. At any nonroot node V V V , Lemma 7.14 expresses V V V as the disjoint union of its high and low parts. The high-part formula (32) uses the exact qualifier union Q ′ Q' Q ′ of the child’s pruned list and the two weak/strict predecessor-cone atoms P q P_q P q and P ^ p \widehat{P}_p P p . Its leaf count is therefore at most
For a same-direction child, (33) adds the m m m -leaf flat formula of its parent carry and the three cone occurrences D p D_p D p , P b P_b P b , D ^ q \widehat{D}_q D q . Thus its low part has at most m + 3 m+3 m + 3 leaves, and the complete set V V V has at most
( 3 m + 2 ) + ( m + 3 ) = 4 m + 5 (3m+2)+(m+3)=4m+5 ( 3 m + 2 ) + ( m + 3 ) = 4 m + 5
leaves. For an opposite-side child, formula (34) has six atomic occurrences: D p D_p D p , P b P_b P b , D a D_a D a , R h R_h R h , D ^ q \widehat{D}_q D q , D ^ v \widehat{D}_v D v . The complete set consequently has at most
( 3 m + 2 ) + 6 = 3 m + 8 ≤ 4 m + 5 ( m ≥ 3 ) (3m+2)+6=3m+8\le4m+5 \qquad(m\ge3) ( 3 m + 2 ) + 6 = 3 m + 8 ≤ 4 m + 5 ( m ≥ 3 )
leaves. The root set J J J is already a single atom. These formulas are exact on all of J J J ; no uncounted occurrence of the parent formula is used to localize the child.
(5) Global cuts for marked prefixes. We describe both temporal sides of a separator directly. This avoids an additional boundary-set leaf when its working frame is reversed relative to the original input frame.
Suppose that an actual slot z z z separates a cutoff S S S on a domain U U U , and let H ⊆ J H \subseteq J H ⊆ J satisfy U ∩ H = S U \cap H=S U ∩ H = S . Define
B z ( H ) = P z ∪ ( H ∖ D ^ z ) , T z ( H ) = D z ∪ ( ( J ∖ H ) ∖ P ^ z ) . B_z(H)=P_z\cup(H\setminus\widehat{D}_z), \qquad T_z(H)=D_z\cup\bigl((J\setminus H)\setminus\widehat{P}_z\bigr). B z ( H ) = P z ∪ ( H ∖ D z ) , T z ( H ) = D z ∪ ( ( J ∖ H ) ∖ P z ) .
Then U ∩ B z ( H ) U\cap B_z(H) U ∩ B z ( H ) is the strict working-time prefix of z z z by Lemma 7.3 , and U ∩ T z ( H ) U\cap T_z(H) U ∩ T z ( H ) is its strict working-time suffix. To see the latter identity, every low job after z z z belongs to D z D_z D z , and every high job after z z z belongs to J ∖ H J\setminus H J ∖ H but not to P ^ z \widehat{P}_z P z . Conversely, a job of D z D_z D z is after z z z , while a selected high job can be neither in z z z nor before it: in the latter case the earlier-high separator property would put it in P z P_z P z . Thus both formulas are exact on the domain. If H H H uses k k k leaves, each formula uses at most k + 2 k+2 k + 2 leaves.
Same-direction marks. Let z z z be a retained actual separator from Step 1, including the center. For a strict retained advance, choose its pre-promotion cutoff S z S_z S z ; for the center, choose the exhausted cutoff W ∩ P b W\cap P_b W ∩ P b . In each case z z z separates S z S_z S z on the whole parent W W W . Let F z F_z F z be the flat formula for the unpromoted carry at that cutoff. The global ideal H z = P b ∖ F z H_z=P_b\setminus F_z H z = P b ∖ F z satisfies W ∩ H z = S z W\cap H_z=S_z W ∩ H z = S z and uses at most m + 1 m+1 m + 1 leaves. Hence the prefix and suffix formulas B z ( H z ) B_z(H_z) B z ( H z ) and T z ( H z ) T_z(H_z) T z ( H z ) both use at most m + 3 m+3 m + 3 leaves. Choose C z = B z ( H z ) C_z=B_z(H_z) C z = B z ( H z ) if the working frame is the input frame, and C z = T z ( H z ) C_z=T_z(H_z) C z = T z ( H z ) otherwise. In both cases W ∩ C z W\cap C_z W ∩ C z is exactly the strict input-time prefix. The later opposite-side normalization changes no job’s side of a same-direction mark.
Opposite-side marks. Work in the reversed frame used in Step 3, and put
W = ( a , b ) , E = ( a , v ) , X = W ∖ D a , H 0 = J ∖ D a . W=(a,b), \qquad E=(a,v), \qquad X=W\setminus D_a, \qquad H_0=J\setminus D_a. W = ( a , b ) , E = ( a , v ) , X = W ∖ D a , H 0 = J ∖ D a .
where v v v is the center and separates X X X on all of W W W . For a retained mark q < v q<v q < v , let
L h = J ∖ R h , H h = H 0 ∩ L h , S h = W ∩ H h . L_h=J\setminus R_h, \qquad H_h=H_0\cap L_h, \qquad S_h=W\cap H_h. L h = J ∖ R h , H h = H 0 ∩ L h , S h = W ∩ H h .
The slot q q q separates S h ∩ E S_h \cap E S h ∩ E on E E E . Define
A q = P q ∪ ( H h ∖ ( D ^ q ∪ D ^ v ) ) , A_q = P_q \cup\left(H_h \setminus\left(\widehat{D}_q \cup\widehat{D}_v\right)\right), A q = P q ∪ ( H h ∖ ( D q ∪ D v ) ) ,
Z q = D q ∪ D ^ v ∪ ( ( J ∖ H h ) ∖ P ^ q ) . Z_q = D_q \cup\widehat{D}_v \cup\left((J \setminus H_h) \setminus\widehat{P}_q\right). Z q = D q ∪ D v ∪ ( ( J ∖ H h ) ∖ P q ) .
We claim that W ∩ A q W \cap A_q W ∩ A q is the strict working-time prefix of q q q and W ∩ Z q W \cap Z_q W ∩ Z q its strict working-time suffix.
For the prefix, every earlier high job lies in E E E and hence in P q P_q P q ; every earlier low job belongs to H h H_h H h and avoids both weak successor cones. Conversely, a selected job of W ∩ H h = S h ⊆ X W \cap H_h = S_h \subseteq X W ∩ H h = S h ⊆ X cannot be at or after v v v , because the center’s separator property would put it in D ^ v \widehat{D}_v D v . It therefore lies in E E E , where separation at q q q excludes its being at or after q q q . The term P q P_q P q contains only jobs before q q q , by feasibility.
For the suffix, D q D_q D q and D ^ v \widehat{D}_v D v contain only jobs strictly after q q q , using q < v q < v q < v . A selected high job cannot be in q q q , and if it were before q q q the separator on E E E would put it in P q P_q P q . Conversely, a high job after q q q is selected by the last term. A low job after q q q but before v v v belongs to D q D_q D q by the local separator, and a low job at or after v v v belongs to D ^ v \widehat{D}_v D v by the center separator. These arguments prove both identities. Notice that L h L_h L h restricts only the low predicate H h H_h H h , not the term P q P_q P q : an earlier high job need not have rank below h h h .
The formula for A q A_q A q uses the five occurrences P q , D a , R h , D ^ q , D ^ v P_q,D_a,R_h,\widehat{D}_q,\widehat{D}_v P q , D a , R h , D q , D v ; that for Z q Z_q Z q uses D q , D ^ v , D a , R h , P ^ q D_q,\widehat{D}_v,D_a,R_h,\widehat{P}_q D q , D v , D a , R h , P q . If q = v q = v q = v , use the center directly: the terminal cutoff is X X X , so B v ( H 0 ) B_v(H_0) B v ( H 0 ) and T v ( H 0 ) T_v(H_0) T v ( H 0 ) give the two sides with three leaves each. In particular, the displayed formula for Z q Z_q Z q for q < v q < v q < v is not used at q = v q = v q = v , where its weak-center term would include the marked slot. Choose the prefix formula when this working frame equals the input frame, and the suffix formula otherwise.
All these are global Boolean formulas whose restrictions to W W W are the required temporal prefixes; the formulas need not be global ideals. Rewriting their cones and rank conditions in the original atomic language preserves leaf counts. Combining the two types of marks gives
K c u t ≤ max { m + 3 , 5 } = m + 3 ( m ≥ 3 ) . K_{\mathrm{cut}} \le\max\{m+3,5\} = m+3 \qquad(m \ge3). K cut ≤ max { m + 3 , 5 } = m + 3 ( m ≥ 3 ) .
This completes all five assertions.
Completion of the structural theorem. We have now obtained two different types of globally valid descriptions: an exact formula for each node set and a possibly different formula for each marked prefix cut. The latter need not describe a node and need not be a global ideal.
Proof of Theorem 5.8. Proposition 7.13 provides a finite hierarchy of feasible full-slot intervals. Every nonempty node has a marked slot and every nonempty child has at most ∣ W ∣ − m |W| - m ∣ W ∣ − m jobs. At the root the set W = J W = J W = J is a one-leaf atom. Every other node is a genuine child of its parent, so Lemma 7.14 represents its job set by an exact global Boolean formula and Lemma 7.15 (4) bounds its leaf count by 4 m + 5 4m + 5 4 m + 5 . Consequently every node set lies in F n o d e = F 4 m + 5 \mathcal{F}_{\mathrm{node}} = \mathcal{F}_{4m+5} F node = F 4 m + 5 , the family constructed by Algorithm 1.
For a marked full slot z z z of any node W W W , use Lemma 7.15 (5) in the original input frame. There is a global formula C z C_z C z with at most m + 3 m + 3 m + 3 leaves such that
W ∩ C z = { x ∈ W : τ + ( x ) < pos + ( z ) } . W \cap C_z = \{x \in W : \tau_+(x) < \operatorname{pos}_+(z)\}. W ∩ C z = { x ∈ W : τ + ( x ) < pos + ( z )} .
Thus C z ∈ F c u t = F m + 3 C_z \in\mathcal{F}_{\mathrm{cut}} = \mathcal{F}_{m+3} C z ∈ F cut = F m + 3 . Here τ + \tau_+ τ + is the time map of the node’s chosen complete witness after it has been oriented in the original input frame. Different hierarchy nodes may use different complete witnesses; no single time map is being imposed across all nodes. If a child’s witness was constructed in reversed time, reverse its full-slot order when interpreting it as the input-frame witness. The induced precedence order is then respected by the definition of simultaneous frame reversal. The marked slots still define full temporal gaps, although their order is reversed when necessary.
Definition 5.7 requires exactly the two memberships just established: each node set belongs to F n o d e \mathcal{F}_{\mathrm{node}} F node , and each local marked prefix is the intersection of that node with a global cut in F c u t \mathcal{F}_{\mathrm{cut}} F cut . It does not require W ∩ C z W \cap C_z W ∩ C z itself to belong to either family. Therefore the annotated hierarchy becomes a hierarchy described by ( F n o d e , F c u t ) (\mathcal{F}_{\mathrm{node}}, \mathcal{F}_{\mathrm{cut}}) ( F node , F cut ) , which proves Theorem 5.8 .
The bounds depend only on m m m , not on the depth of the hierarchy. The scheduling algorithm enumerates the two Boolean-description families; it neither constructs the normalized witness schedules nor checks the semantic invariants used in this existence argument.
Summary and open problem
We have given an explicit deterministic exact algorithm for unit-job precedence scheduling on every fixed number m ≥ 3 m \ge3 m ≥ 3 of identical machines. The structural hierarchy has at most m − 1 m-1 m − 1 surviving birth groups and at most m m m active entries at a node. Exact global localization and the separate treatment of local flat carries give the node family F 4 m + 5 \mathcal{F}_{4m+5} F 4 m + 5 and the prefix-cut family F m + 3 \mathcal{F}_{m+3} F m + 3 . Exact binary tries and an acyclic state-path evaluation make these structural descriptions algorithmic.
The algorithm decides a deadline, constructs a feasible witness when one exists, and finds an optimum schedule by deadline search. Its optimization bound is
O ( L ) + m O ( m 2 ) n 6 m 2 + 13 m + 1 log n O(L) + m^{O(m^2)} n^{6m^2+13m+1} \log n O ( L ) + m O ( m 2 ) n 6 m 2 + 13 m + 1 log n
on the stated word RAM, and
O ( L ) + m O ( m 2 ) n 12 m 2 + 26 m + 2 log 3 n O(L) + m^{O(m^2)} n^{12m^2+26m+2} \log^3 n O ( L ) + m O ( m 2 ) n 12 m 2 + 26 m + 2 log 3 n
on a deterministic Turing machine with a fixed number of tapes. The latter bound explicitly accounts for sequential memory access. For m = 3 , 4 , 5 m=3,4,5 m = 3 , 4 , 5 , the RAM degrees are 94, 149, 216, and the multitape degrees are 188, 298, 432, apart from the displayed logarithmic factors. A single deadline test saves one logarithmic search factor in either model. The analysis includes generation, all unsuccessful tests, exact lookup and reconstruction.
Further improvement. An extended manuscript, in preparation for posting on arXiv [18 ] , uses additional structural and counting and other arguments using annotated records and weighted evaluation. These yield an improved RAM and multitape bound
O ( L ) + 2 O γ ( m 2 ) n 3 m 2 − 3 m + 6 + m 2 4 ( m + 1 ) + γ m O(L) + 2^{O_{\gamma}(m^2)} n^{3m^2-3m+6+\frac{m^2}{4(m+1)}+\gamma m} O ( L ) + 2 O γ ( m 2 ) n 3 m 2 − 3 m + 6 + 4 ( m + 1 ) m 2 + γ m
For m = 3 , 4 m=3,4 m = 3 , 4 , and 5 machines, the respective polynomial degrees (with fixing γ = 0.01 \gamma=0.01 γ = 0.01 ) in n n n are 24,5925, 42,084 and 67,091. The improved algorithms and proofs will be presented in an extended version.
Open problem. Can the quadratic dependence of the exponent on the number of machines be reduced to linear dependence? More precisely, does there exist a computable function g g g and an absolute constant c c c such that exact optimization and schedule construction are possible in
O ( L ) + g ( m ) n c m ? O(L) + g(m)n^{cm}? O ( L ) + g ( m ) n c m ?
This formulation is equivalent to the one with base n + 2 n+2 n + 2 : the factor 2 c m 2^{cm} 2 c m can be absorbed into the arbitrary computable function g ( m ) g(m) g ( m ) . The present description families use O ( m ) O(m) O ( m ) boundary atoms, each specified by an m m m -job set. Reducing this information, or sharing its choices across descriptions, is a possible route, but the current proofs do not give an O ( m ) O(m) O ( m ) exponent.
The charging argument in Lemma 7.12 bounds how many birth groups survive, but does not express the historical boundary sets defining their entries in terms of a common smaller collection of choices. These historical sets enter the exact global qualifier union Q ′ Q' Q ′ used in Lemma 7.14. The shorter flat carry formulas agree with the corresponding qualifier sets only after restriction to their specified domains, so they cannot simply replace Q ′ Q' Q ′ in the global localization identities. Consequently, the current enumeration in Lemma 6.1 still contains the factor ( N + 2 ) m K (N+2)^{mK} ( N + 2 ) m K , with K = O ( m ) K=O(m) K = O ( m ) . One possible route is to construct a smaller sufficient family that shares boundary choices while preserving the global identities required by the proof.
A running-time exponent linear in m m m appears to be a natural goal. Bodlaender and Fellows [2 ] proved that precedence-constrained unit-job scheduling is W [ 2 ] W[2] W [ 2 ] -hard when parameterized by the number of machines. Thus, unless FPT = W [ 2 ] W[2] W [ 2 ] , an algorithm with running time f ( m ) n O ( 1 ) f(m)n^{O(1)} f ( m ) n O ( 1 ) cannot exist (for explicitly represented precedence constraints). It is also interesting whether stronger, quantitative lower bounds on the dependence of the exponent on m m m can be established. In particular, can running times f ( m ) n o ( m ) f(m)n^{o(m)} f ( m ) n o ( m ) be excluded under suitable fine-grained complexity assumptions? This includes bounds of the form f ( m ) n O ( m 1 − δ ) f(m)n^{O(m^{1-\delta})} f ( m ) n O ( m 1 − δ ) or f ( m ) n O ( m / log b m ) f(m)n^{O(m/\log^b m)} f ( m ) n O ( m / l o g b m ) , for fixed 0 < δ < 1 0<\delta<1 0 < δ < 1 and b > 0 b>0 b > 0 . Such conclusions require appropriate quantitative reductions and do not follow from W [ 2 ] W[2] W [ 2 ] -hardness alone.
Examples of quantitative reductions in related settings include lower bounds for planar and geometric approximation schemes [26 ] and for parameterized approximation of Dominating Set [19 ] . Transferring such bounds to the present scheduling problem requires a reduction that controls the resulting number of machines. For the classical ETH-based lower-bound framework, see Lokshtanov, Marx, and Saurabh [25 ] . Connections between faster SAT algorithms, Dominating Set, and SUM problems are developed by Pătraşcu and Williams [33 ] .
Recent developments also affect the choice of complexity assumptions. Subexponential algorithms for 3-SAT have been reported by OpenAI and Anthropic [31 , 7 ] , challenging the classical Exponential Time Hypothesis. Moreover, recent algorithms for 3-SUM and odd-arity k k k -SUM [1 , 4 ] refute the corresponding standard fine-grained hypotheses, with the odd-arity k k k -SUM improvements applying to randomized algorithms on integer inputs. Other quantitative assumptions, including suitable hypotheses for even-arity k k k -SUM, may remain relevant. We have preliminary results with a linear lower bound O ( m ) O(m) O ( m ) in the exponent of n n n based on different assumption and will discuss them in a separate paper. Determining the precise dependence on m m m therefore remains an interesting open problem.
Declaration of Use of Generative AI
The development of this work involved extensive and iterative discussions with OpenAI’s ChatGPT. The author formulated the research questions, contributed mathematical and algorithmic ideas, identified relevant techniques and connections to previous research, and guided the overall direction of the investigation. ChatGPT assisted in organizing the presentation, and preparing portions of the manuscript in LaTeX. The author takes full responsibility for the scientific content, mathematical correctness, originality, attribution and conclusions of the manuscript.