Periodic Assignment Problem

• Periodic Assignment Problem is a set of scheduling models that assign recurring tasks to resources under cyclic and capacity constraints.
• It encompasses various formulations such as cyclic interval scheduling and Windows Scheduling, differing in time discretization and fairness measures.
• Algorithmic solutions range from O(n log n) exact methods to reinforcement-learning heuristics, providing practical approaches for robust periodic assignments.

Periodic Assignment Problem denotes a family of scheduling and resource-allocation problems in which recurring tasks, jobs, or messages must be assigned to workers, processors, slots, or cyclic routes over an infinite or repeating horizon. Across formulations, the common structure is periodic demand together with non-overlap or capacity constraints; the main modeling axes are whether time is slotted or continuous, whether periods are exact or lower bounds, whether resources are identical or route-based, and whether the objective is feasibility, worker minimization, or fairness over time (Jacobs et al., 2014, Lieshout et al., 6 Jul 2025, Gachet et al., 2024).

1. Core formulations

One prominent formulation models a fixed set of tasks that repeat every period $T$. Each task $i$ is a $T$-periodic open interval $(a_i,b_i)\subset[0,T)$, possibly wrapping around the end of the period, with duration $c(i)=[b_i-a_i]_T$. Transitions between tasks define a complete directed graph with arc lengths $c_{ij}=[a_j-b_i]_T$. A periodic assignment is a 1-in-1-out directed subgraph on the task set, hence a disjoint union of directed cycles; each cycle represents a cyclic route of tasks executed period after period. The classical objective is to minimize total transition time, equivalently the number of workers needed in steady state (Lieshout et al., 6 Jul 2025).

A second canonical model is Windows Scheduling, also known as the Pinwheel Problem. Time is slotted, jobs recur infinitely often, and each job $j$ has processing length $\ell_j$ and period parameter $p_j$. In the inexact version, the time between consecutive executions of job $j$ is at most $i$0; in the exact version it is exactly $i$1. The single-machine variant schedules at most one job per slot, while multi-machine variants allow either fixed machine assignment or migration across identical machines (Jacobs et al., 2014).

A third formulation, motivated by weekly cyclic rosters, uses continuous time with a normalized week of length $i$2. Task $i$3 is specified by a half-open interval $i$4 with $i$5, and its $i$6-th occurrence occupies $i$7. With $i$8 identical employees, an assignment is a map

$i$9

subject to the basic feasibility rule that overlapping task occurrences cannot be assigned to the same worker. This model isolates long-run equity questions by defining balance taskwise, rather than via total load alone (Gachet et al., 2024).

These formulations are not interchangeable, but they describe the same broad object: repeated assignment under periodic recurrence. The main differences concern the representation of time, the granularity of resources, and whether the assignment is interpreted as a schedule of execution slots, a cyclic route decomposition, or a long-run worker-task rotation.

2. Feasibility conditions and structural invariants

The most basic feasibility invariant is utilization or density. In Windows Scheduling, a necessary condition on one machine is

$T$0

which reduces to $T$1 for unit-length jobs; with $T$2 machines the corresponding necessary bound is $T$3. In the inexact model, density $T$4 is especially rigid: if a feasible schedule exists at density $T$5, then jobs must in fact run with exact periods, because otherwise some job would consume more than its budget share (Jacobs et al., 2014).

In the cyclic interval model, the analogous invariant is the load

$T$6

where $T$7 is the number of tasks active at time $T$8. Every feasible periodic assignment needs at least $T$9 workers. Moreover, for a feasible assignment $(a_i,b_i)\subset[0,T)$0, optimality is characterized by the equivalence

$(a_i,b_i)\subset[0,T)$1

and

$(a_i,b_i)\subset[0,T)$2

together with the existence of some $(a_i,b_i)\subset[0,T)$3 at which no transition is active. In this model the optimal worker count is exactly $(a_i,b_i)\subset[0,T)$4 (Lieshout et al., 6 Jul 2025).

For balanced worker-task rotation, feasibility acquires an additional combinatorial layer. In the weekly common-period model, an assignment is balanced if for every task $(a_i,b_i)\subset[0,T)$5 and employee $(a_i,b_i)\subset[0,T)$6,

$(a_i,b_i)\subset[0,T)$7

A central result states that a balanced feasible assignment exists if and only if there exists a feasible assignment with an employee performing each task at least once. When balance is feasible, a periodic balanced assignment also exists, with period bounded by $(a_i,b_i)\subset[0,T)$8 (Gachet et al., 2024).

These conditions show that feasibility in PAP is usually governed by two layers: a load-like resource inequality and a compatibility structure controlling how recurring assignments can be interleaved. In some models the first layer is almost sufficient; in others, especially when fairness or exact periodicity is imposed, the second layer becomes decisive.

3. Computational complexity and combinatorial equivalences

The complexity landscape is sharply model-dependent. For exact-period Windows Scheduling with one machine and unit-length jobs, feasibility is polynomial-time equivalent to Partial Coding, a combinatorial encoding problem in which symbols defined on subsets of attributes must be pairwise distinguishable on some shared attribute. This equivalence yields NP-completeness and transfers hardness machinery between scheduling and coding viewpoints (Jacobs et al., 2014).

The same paper proves stronger negative results. Single-machine Windows Scheduling with unit-length jobs and exact periods does not admit a pseudo-polynomial time algorithm unless SAT can be solved by a randomized method in expected time $(a_i,b_i)\subset[0,T)$9. The same lower bound extends to the inexact-period variant by a density-$c(i)=[b_i-a_i]_T$0 construction. For multiple machines without migration, the problem reduces in polynomial time to the single-machine case. With migration, the landscape becomes harder still: the unit-length exact-period problem is co-NP-hard, in addition to inheriting NP-hardness from the single-machine setting (Jacobs et al., 2014).

The hardness picture is not uniform across all PAP variants. In the interval-cycle model, both the efficiency problem and the fair variant are solvable exactly in $c(i)=[b_i-a_i]_T$1, because the circular interval geometry induces a highly structured transition cost function (Lieshout et al., 6 Jul 2025). In the weekly common-period balanced-assignment model, deciding whether a balanced feasible assignment exists can also be done in polynomial time, although constructing one is polynomial-time only when the number of employees $c(i)=[b_i-a_i]_T$2 is fixed (Gachet et al., 2024).

The literature also contains corrected complexity claims. Jacobs and Longo report an error in an earlier hardness proof for the multi-machine no-migration Windows Scheduling variant and replace it with a reduction to the single-machine case. This does not weaken the hardness conclusion, but it changes the structural interpretation: the no-migration multi-machine case is essentially the same complexity class as the single-machine case, rather than a separate source of hardness (Jacobs et al., 2014).

4. Exact, approximate, and packing-based algorithms

In the cyclic interval model, the main exact algorithm for efficiency is Shift-Sort-and-Match. After shifting time so that a point of maximum load becomes the origin, it sorts all start and end events, scans them once, and matches ends to starts so that no transition crosses the origin. This yields an $c(i)=[b_i-a_i]_T$3 optimal solution to PAP. For the fair variant, Nearest Neighbor constructs a Hamiltonian cycle in $c(i)=[b_i-a_i]_T$4 and always returns a fair periodic assignment with at most $c(i)=[b_i-a_i]_T$5 workers. The exact $c(i)=[b_i-a_i]_T$6 algorithm, Patching, starts from an optimal PAP solution and merges disjoint cycles whenever overlapping transition arcs occur inside the same idle interval; it returns a fair solution with $c(i)=[b_i-a_i]_T$7 workers when one exists, and otherwise falls back to Nearest Neighbor, which is then optimal in worker count (Lieshout et al., 6 Jul 2025).

A different algorithmic line exploits geometric equivalence. For non-preemptive zero-jitter periodic scheduling with harmonic periods, periodic scheduling can be transformed into a special 2D packing problem: jobs become rectangles of width $c(i)=[b_i-a_i]_T$8 and height proportional to the number of occurrences in the hyperperiod, and schedule feasibility becomes non-overlap in a ruled or height-divisible packing. One paper generalizes a powers-of-two equivalence to arbitrary harmonic periods and derives an additive approximation via a modified FFDH procedure,

$c(i)=[b_i-a_i]_T$9

for minimizing the frame size $c_{ij}=[a_j-b_i]_T$0 (Hanen et al., 2020).

The packing perspective has been pushed further with an explicit bijection between harmonic periodic scheduling and height-divisible 2D packing, together with a CP formulation that uses pack global constraints over recursively defined sub-bins. In reported experiments on difficult synthesized instances, this CP approach outperformed a state-of-the-art ILP baseline; for example, on the set $c_{ij}=[a_j-b_i]_T$1, ILP solved $c_{ij}=[a_j-b_i]_T$2 instances within the time limit while CP solved $c_{ij}=[a_j-b_i]_T$3, and on $c_{ij}=[a_j-b_i]_T$4 the counts were $c_{ij}=[a_j-b_i]_T$5 and $c_{ij}=[a_j-b_i]_T$6, respectively. The same work introduces the Rectangle-Guided First Fit heuristic, whose optimistic variant outperformed baseline first-fit and best-fit heuristics on high-utilization instances (Grus et al., 2024).

For balanced assignments in the common-period worker model, the constructive method is graph-theoretic rather than geometric. It builds a directed multigraph $c_{ij}=[a_j-b_i]_T$7 on the set of tasks that overlap the period boundary, proves that balance exists exactly when this graph is Eulerian, and then uses a pebble process on an arc-colored Eulerian digraph to generate a periodic sequence of feasible assignments with equal asymptotic task frequencies across workers (Gachet et al., 2024).

5. Fairness, balancedness, and cyclic equity

Fairness in PAP is not a single notion. In the common-period worker model, fairness is asymptotic and taskwise: every worker must execute every task with limiting frequency $c_{ij}=[a_j-b_i]_T$8. In the cyclic-route PAP of the interval model, fairness is stricter: all workers must follow the same cyclic sequence of tasks up to phase shifts, which is equivalent to requiring that the selected transition subgraph be a Hamiltonian cycle (Gachet et al., 2024, Lieshout et al., 6 Jul 2025).

These notions lead to different structural criteria. In the balanced worker model, existence reduces to the “one employee touches every task once” condition, and when balance exists it can be realized by a periodic assignment. In the fair cyclic-route model, the key object is the idle interval graph: nodes are maximal periods of underload, tasks become arcs between the idle intervals containing their start and end points, and an instance admits a fair solution with $c_{ij}=[a_j-b_i]_T$9 workers if and only if this idle interval graph is weakly connected (Gachet et al., 2024, Lieshout et al., 6 Jul 2025).

The efficiency–fairness trade-off is unusually sharp in the fair cyclic-route setting. The price of fairness is at most one extra worker: if $j$0 workers suffice for PAP, then FPAP needs either $j$1 or $j$2 workers, and the relative price of fairness is $j$3. Moreover, allowing aperiodic schedules never reduces that price; an instance admits a balanced assignment with $j$4 workers if and only if it admits a fair periodic assignment with $j$5 workers (Lieshout et al., 6 Jul 2025).

Two common misconceptions are therefore false in general. First, aperiodicity does not necessarily help: in the fair cyclic-route model it never improves the worker bound (Lieshout et al., 6 Jul 2025). Second, more flexible recurrence assumptions do not automatically simplify the theory: in Windows Scheduling, the inexact model remains pseudo-polynomially intractable under the same complexity assumption as the exact model (Jacobs et al., 2014). At the same time, the common-period balance theorem is not universal: with irrational task periods, the equivalence between balanced feasibility and “one employee performs every task at least once” can fail (Gachet et al., 2024).

6. Dynamic, learning-based, and adjacent models

A broader operational interpretation treats PAP as a repeated or rolling-horizon assignment problem. In a reinforcement-learning formulation for assignment with time constraints, tasks have efforts $j$6, workers have capacities $j$7, and the state consists of current task efforts, remaining worker capacities, the time index, and the last completed task. Actions assign the current task to a worker, infeasible workers are masked, and reward is the negative assignment cost together with a term reflecting the number of workers used. The policy is trained with PPO and can be reused on modified instances drawn from the same distribution without retraining. This suggests direct use as a fast heuristic for periodic or repeated assignment, where each day or shift is a new episode with updated tasks and capacities (Pathan et al., 2021).

The empirical contrast with exact solvers is substantial in the reported assignment experiments. For AP20–AP50, Google OR-Tools times grow from $j$8 min to $j$9 min, while RL inference after training is about $\ell_j$0–$\ell_j$1 min. The same framework is also demonstrated on bin packing and capacitated vehicle routing, reinforcing the interpretation of repeated assignment as sequential decision-making under dynamic capacities (Pathan et al., 2021).

Adjacent assignment theory supplies additional techniques that are not PAP models per se but are structurally relevant. In $\ell_j$2-restricted assignment makespan minimization, jobs are either heavy of size $\ell_j$3 or light of size $\ell_j$4, the configuration LP is rounded through a compact $\ell_j$5-LP, canonical instances, and Lovász Local Lemma–based rounding, and the main result is a polynomial-time $\ell_j$6-approximation, while approximation better than $\ell_j$7 is NP-hard (Chakrabarty et al., 2014). A plausible implication is that heavy/light decompositions, cut conditions such as

$\ell_j$8

and canonical-instance regularization are transferable design patterns for multi-period PAP variants in which recurring large tasks create a base load and smaller tasks absorb residual slack (Chakrabarty et al., 2014).

Taken together, these extensions show that PAP now spans exact combinatorial scheduling, graph-theoretic fairness, packing equivalences, CP and ILP formulations, fast constructive heuristics, and adaptive RL policies. The unifying theme is still the same: periodic demand induces recurring assignment constraints, but the tractability and suitable methodology depend strongly on whether the model emphasizes exact recurrence, cyclic geometry, worker equity, or online adaptation.