Weighted Chairman Assignment and Flow-Time Scheduling (2511.18546v1)
Abstract: Given positive integers $m, n$, a fractional assignment $x \in [0,1]{m \times n}$ and weights $d \in \mathbb{R}n_{>0}$, we show that there exists an assignment $y \in {0,1}{m \times n}$ so that for every $i\in[m]$ and $t\in [n]$, [ \Big|\sum_{j \in [t]} d_j (x_{ij} - y_{ij}) \Big| < \max_{j \in [n]} d_j. ] This generalizes a result of Tijdeman (1973) on the unweighted version, known as the chairman assignment problem. This also confirms a special case of the single-source unsplittable flow conjecture with arc-wise lower and upper bounds due to Morell and Skutella (IPCO 2020). As an application, we consider a scheduling problem where jobs have release times and machines have closing times, and a job can only be scheduled on a machine if it is released before the machine closes. We give a $3$-approximation algorithm for maximum flow-time minimization.
Sponsor
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Overview
This paper is about making fair choices over time when you can only pick one option each time, even though a “fair plan” might want to split choices across several options. The authors solve a new, weighted version of a classic fairness problem (the “chairman assignment problem”) and use it to design a good scheduling algorithm that keeps people from waiting too long for their jobs to finish.
Imagine you have several states (or teams) and each year you must choose one chairman (or team lead). A fair plan might say “this year, state A deserves 0.3 of a chairman, state B 0.5, state C 0.2,” but you can only pick one person in reality. The goal is to pick real chairmen, year by year, so that the running totals stay close to the fair plan. This paper handles the harder case where different years have different importance (weights), and shows how to keep things fair very tightly. Then, it uses this idea to schedule jobs on machines so that the longest wait (flow-time) is close to the best possible.
Key questions
- How can we turn a “fractional plan” (splitting choices across options) into real, one-at-a-time choices, while staying very close to the fair plan at every step?
- Does this still work when different times or jobs have different weights (importance or size)?
- Can this fairness trick help us schedule jobs on machines so the longest waiting time is small?
- What are the limits—how close can we get, and are there cases where we can’t do better?
How they approached it
Think of the fractional plan as a promise: for each state (row) and each time up to t (the first t years), it promises a certain total share. The real plan chooses exactly one state each year. The difference between “promised share” and “chosen share” is called discrepancy. The goal is to keep that discrepancy small for every state and every prefix (first t years).
To do this, the paper uses a simple, fast algorithm:
- It looks at which states are “due” for a pick, based on how far behind they are compared to their promised share.
- It assigns the current choice to the state whose deadline (the time by which it must be picked to stay fair) comes soonest.
- It repeats this process year by year.
In everyday terms: at each step, choose the option that most needs attention now to avoid falling behind its fair share. This keeps everyone’s running totals very close to the fair plan.
Technical ideas, in simple language:
- Fractional assignment: imagining that each year’s choice could be split (like giving 0.3 of a pick to one state), used as the fairness guideline.
- Integral assignment: the real-world plan where each year you pick exactly one state.
- Weights: some years or jobs matter more than others (e.g., a big job takes longer). The algorithm respects these weights.
- Prefix sums: looking at the total from the start up to time t, so fairness is maintained at every point, not just at the end.
- Deadlines and candidates: the algorithm tracks who must be picked soon to stay fair and picks them in the best order.
It runs in linear time, which means it scales efficiently with the number of choices and options.
Main findings and why they matter
- Weighted fairness guarantee
- Main theorem: given m states and n times with positive weights, you can compute a real plan such that, for every state and every prefix of time, the difference between promised and actual weighted totals is at most (1 − 1/(2m − 2)) times the largest weight.
- Plainly: your plan stays within about “one big year’s worth” of fairness, with a small bonus factor that depends on how many states you have.
- This generalizes a classic result (unweighted case) and confirms a special case of a well-known network flow conjecture. That connects the idea to routing things through networks in a “single-path” way while staying close to an ideal flow.
- Scheduling jobs with release and closing times
- Application: jobs are released over time, and machines close at certain times. A job can only go to a machine if it’s released before that machine closes. The goal is to minimize the maximum flow-time (waiting plus processing).
- Result: the authors give a (3 − 1/(m − 1))-approximation algorithm. This means their schedule’s longest wait is at most about 3 times the best possible, improving slightly with more machines.
- Importance: it confirms a conjecture (that a constant-factor approximation should be possible) in this special setting.
- Limits and lower bounds
- They show examples proving you cannot hope to do better than their fairness bound in general (it’s tight).
- They also show that a simple greedy scheduling rule (FIFO: first-in-first-out) can be much worse (Ω(log m)) when machines have closing times, so a smarter method is needed.
- Another limit: you can’t keep fairness within 1 for every possible interval (not just the first t), meaning you can’t directly improve the scheduling guarantee to 2 by the same rounding trick.
Implications and impact
- Fair rounding in weighted settings: The paper extends fairness from the classic “equal-weight” case to the more realistic “different importance” case, with a clean, fast algorithm and strong, tight guarantees. This is useful anywhere you must make one-at-a-time choices that should follow a proportional plan—like selecting representatives over time or distributing limited resources fairly.
- Better scheduling: The new algorithm offers a near-3× guarantee for minimizing the longest wait in a practical scheduling problem with machine closing times, improving over naive methods and backing up a conjecture about what’s achievable.
- Broader connections: By confirming a special case of the Morell–Skutella “unsplittable flow” conjecture, the work strengthens ties between fairness rounding, network flows, and scheduling. It also clearly marks the boundaries of what is possible, guiding future research.
In short, the paper shows how to fairly convert ideal, split plans into real, one-at-a-time decisions with strong guarantees—even when different choices matter differently—and turns that into a useful scheduling tool that keeps waits reasonably short.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a single, concise list of what remains unresolved or unexplored in the paper, phrased to be actionable for future research.
- Prove the single-source unsplittable flow conjecture (Morell–Skutella) in full generality: design a polynomial-time rounding from a fractional flow to an unsplittable flow with arc-wise discrepancy at most
max_j d_jon arbitrary DAGs (beyond currently known special cases such as divisibility chains of demands and acyclic planar/series-parallel digraphs). - Establish a constant-factor resolution of the weighted carpooling problem (Conjecture 1): develop a constructive rounding algorithm that respects the support constraints (
y_{ij}=0wheneverx_{ij}=0) and achieves prefix discrepancy≤ max_j d_j, improving the current best boundsmin{2m, O(√log n)} * max_j d_j. - Characterize the best achievable interval discrepancy constant: the paper disproves a universal bound of
1for intervals (Proposition 4) but does not determine the optimal constantc(m)(orc(m,n)) for which∑_{j∈[s,t]} d_j (x_{ij}-y_{ij}) ≤ c(m) * max_j d_jis always achievable; identify tight lower and upper bounds and whetherc(m)can be independent ofm. - Improve the scheduling approximation beyond
3 - 1/(m-1)for machine closing times: either devise a rounding that yields interval discrepancies strictly below2 - 1/(m-1)(implying better than3 - 1/(m-1)flow-time), or prove hardness/integrality-gap lower bounds showing this constant is tight. - Extend constant-factor approximation guarantees from the closing-times special case to the general restricted assignment maximum flow-time problem (as conjectured by prior work): provide an
O(1)-approximation (or integrality-gap bound) for arbitrary eligibility setsM_j(without closing-time structure), or pinpoint structural barriers preventing such guarantees. - Resolve the non-uniform per-machine processing times setting (Conjecture 5): determine whether a prefix discrepancy
≤ max_{i,j} d_{ij}is achievable when weights depend on both job and machine, and provide a polynomial-time rounding algorithm or a counterexample. - Solve the weighted committee assignment variants (Conjectures 6 and 7): prove existence and construct algorithms that (i) handle integral column totals
n_j, (ii) respect zero-support constraints, and (iii) achieve prefix discrepancies bounded bymax_j d_j(ormax_{i,j} d_{ij}in the fully general case). - Develop improved discrepancy bounds that adapt to instance structure: replace the worst-case
max_j d_jdependence with finer measures (e.g., tail sums, norms, sparsity of columns, or distributional properties of weights), yielding improved guarantees under realistic or structured instances. - Determine tight lower bounds for the weighted carpooling discrepancy beyond
m=3: generalize Proposition 3 to largermto understand how the best achievable constant scales with the number of rows under support constraints. - Identify graph classes (beyond planar and series-parallel) where the Morell–Skutella conjecture holds: characterize additional structural properties of DAGs that suffice for arc-wise discrepancy
≤ max_j d_j, and unify these cases under a common rounding framework. - Explore online and recourse models for weighted chairman/carpooling: devise algorithms with constant discrepancy using polylogarithmic recourse (as suggested in the related-work section) and establish matching lower bounds where appropriate.
- Provide explicit integrality-gap lower bounds for the LP relaxation in the closing-times setting: quantify whether the gap can approach
3 - 1/(m-1)or is strictly smaller, guiding the search for better rounding schemes or stronger relaxations. - Investigate whether interval-discrepancy barriers can be bypassed under closing-time structure: despite Proposition 4, determine if the closing-times constraints permit stronger interval bounds than in the general case, enabling improved scheduling approximations.
- Optimize implementation aspects for large-scale instances: the rounding algorithm runs in linear time in
mn, but practical deployments may need streaming/online versions, memory-efficient data structures, or parallelization; delineate these algorithm-engineering directions and their impact on discrepancy guarantees.
Glossary
- Acyclic planar digraphs: Directed graphs that are both acyclic (contain no directed cycles) and planar (can be drawn without edge crossings); often permit specialized flow or routing guarantees. Example: "and for special digraphs such as acyclic planar digraphs"
- Approximation ratio: The worst-case factor by which an algorithm’s solution exceeds the optimal value. Example: "We also show that FIFO has approximation ratio at least for the setting of closing times."
- Arc-wise lower and upper bounds: Constraints specifying per-arc lower and upper limits on flow values in a network. Example: "single-source unsplittable flow conjecture with arc-wise lower and upper bounds due to Morell and Skutella (IPCO 2020)."
- Beck-Fiala problem (2-sparse prefix): A discrepancy problem where each element appears in at most two sets, here restricted to prefix intervals; important in bounding assignment discrepancies. Example: "known as the 2-sparse prefix Beck-Fiala problem"
- Carpooling problem: An assignment variant where an item can be assigned to an agent only if a fractional assignment entry is nonzero, focusing on feasibility under sparsity constraints. Example: "A variant of the chairman assignment problem is the carpooling problem"
- Capacity constraints: Limits imposed on the amount of flow that can traverse an arc or network component. Example: "by adding capacity constraints to the flow polytope we can find an integral flow "
- Chairman assignment problem: A discrepancy-minimization assignment problem seeking integral selections that track fractional weights across prefixes. Example: "This is known as the chairman assignment problem due to Tijdeman"
- Diameter (digraphs): The maximum shortest-path length between any pair of nodes in a directed graph; small diameter can enable stronger rounding results. Example: "Their approach also solves the Morell-Skutella conjecture for digraphs of diameter 2."
- Earliest Deadline Algorithm: A rounding strategy that assigns items to rows based on the earliest computed deadline among eligible candidates. Example: "Earliest Deadline Algorithm"
- FIFO (first-in-first-out): A greedy scheduling policy that processes jobs in order of arrival/release. Example: "a greedy algorithm (first-in-first-out, or FIFO)"
- Flow polytope: The polyhedral set of all feasible flows in a network subject to conservation and capacity constraints. Example: "to the flow polytope we can find an integral flow "
- Flow-time: For a job, the elapsed time from its release until completion; minimizing the maximum flow-time is a scheduling objective. Example: "The flow-time of a job is defined as the time elapsed from its release to completion."
- Hall's theorem: A classical result characterizing perfect matchings in bipartite graphs; used to construct integral assignments with bounded discrepancy. Example: "based on an application of Hall's theorem to a carefully constructed bipartite graph."
- Integrality gap: The ratio between the optimal integral solution and the optimal fractional (LP) solution, measuring the strength of a relaxation. Example: "a natural linear programming relaxation has integrality gap "
- Iterated rounding: A technique that repeatedly rounds variables while maintaining feasibility to obtain integral solutions with bounded loss. Example: "due to Bansal and Kulkarni via iterated rounding"
- Linear programming relaxation: A formulation obtained by relaxing integrality constraints to allow fractional values, used to bound or guide rounding. Example: "a natural linear programming relaxation has integrality gap "
- Makespan minimization: Scheduling objective minimizing the completion time of the last job (overall schedule length). Example: "The special case where release times are all zero corresponds to makespan minimization"
- Maximum flow-time minimization: Scheduling objective minimizing the maximum flow-time across all jobs. Example: "We give a $3$-approximation algorithm for maximum flow-time minimization."
- Oblivious adversaries: Adversaries in online models that fix sequences independently of the algorithm’s random choices, used in lower-bound analyses. Example: "a lower bound~\cite{AjtaiAspnesNaorRabaniSchulmanWaarts1995SODA} for oblivious adversaries."
- Prefix discrepancy: Discrepancy measured over all prefixes (initial segments) of columns/indices, central in balancing assignments over time. Example: "fits within the broader framework of prefix discrepancy"
- Recourse: The ability of an online algorithm to revise earlier decisions a limited number of times, trading stability and optimality. Example: "the online carpooling problem with recourse"
- Restricted assignment: Scheduling model where each job can only be processed on a specified subset of machines. Example: "This is a special case of the restricted assignment variant of maximum flow-time minimization"
- Series-parallel digraphs: Directed graphs formed by series and parallel composition, enabling strong structural and algorithmic properties. Example: "for stronger guarantees for series-parallel digraphs."
- Single-source unsplittable flow conjecture: The claim that any fractional single-source flow can be approximated by an unsplittable flow with bounded per-arc discrepancy. Example: "single-source unsplittable flow conjecture with arc-wise lower and upper bounds due to Morell and Skutella (IPCO 2020)."
- Unsplittable flow: A flow where each demand is routed along a single path from source to sink, without splitting across multiple paths. Example: "We say a flow is unsplittable if for each there is a single path from to that carries units of flow"
- Weighted carpooling problem: The carpooling problem with nonuniform job weights, seeking low-discrepancy integral assignments under support constraints. Example: "The weighted carpooling problem, which remains open, can also be viewed as a special case of Conjecture \ref{conj:ssuf}"
- Weighted chairman assignment problem: The chairman assignment problem generalized with per-column weights, aiming to bound weighted prefix discrepancies. Example: "We study the weighted chairman assignment problem where each has an associated weight "
Practical Applications
Practical Applications of “Weighted Chairman Assignment and Flow-Time Scheduling”
The paper introduces a linear-time rounding algorithm (Earliest Deadline Algorithm) for the weighted chairman assignment problem with provable discrepancy bounds, connects it to unsplittable flow rounding in graphs, and provides a new approximation algorithm for maximum flow-time scheduling with machine closing times. Below are actionable applications derived from these results.
Immediate Applications
- Scheduling with machine closing times (manufacturing, cloud/data centers, healthcare)
- Use case: Assign released jobs to machines that will be available until a closing time (e.g., shift-end, maintenance windows) to minimize the maximum flow-time.
- Tool/workflow: Solve LP relaxation (Eq. (max_flow-time) in the paper), then apply the provided rounding to obtain a (3 − 1/(m−1))-approximate assignment. Schedule jobs by release order respecting machine availability.
- Assumptions/dependencies:
- Release times and machine closing times known in advance (offline setting).
- Jobs have nonnegative processing times and can be scheduled any time after release and before the machine’s closing time.
- Fractional solution x must be feasible (can be found via LP solvers).
- Non-preemptive scheduling implied; interval discrepancy bound relies on the closing-time construction.
- Fair rotation scheduling (academia, corporate governance, teams)
- Use case: Unbiased rotation (e.g., chairpersons, meeting facilitators, on-call rosters) that tracks and respects weighted entitlements over time with small prefix discrepancy.
- Tool/workflow: Maintain cumulative “value” per entity (x), apply the Earliest Deadline Algorithm to select the assignee each period, ensuring prefix discrepancy is bounded by max weight.
- Assumptions/dependencies:
- Periodic contributions/entitlements are quantifiable (weights d_j).
- Fairness constraint is about prefix tracking (not all sub-intervals); interval-level fairness requires caution due to the paper’s lower bound for arbitrary intervals.
- Multi-robot/task allocation with battery/shift constraints (robotics, warehousing)
- Use case: Assign tasks released over time to robots that will remain active until a closing time (battery threshold, end of shift), minimizing maximum “wait-to-completion” time.
- Tool/workflow: Construct fractional assignment based on feasibility and load, then round using the algorithm with closing-time adaptation (Proposition on open_time).
- Assumptions/dependencies:
- Each robot’s availability window is known (closing time).
- Tasks have release times and known processing durations.
- Data center job placement with maintenance windows (software/DevOps)
- Use case: Schedule batch jobs to servers that have planned downtime, minimizing the longest flow-time from job release to completion.
- Tool/workflow: LP + rounding pipeline; implement the Earliest Deadline Algorithm; enforce server closing-time constraints via the “reverse-time” trick used in Lemma on closing_time.
- Assumptions/dependencies:
- Known maintenance windows and job release times.
- Offline planning; online FIFO may be suboptimal (paper shows Ω(log m) lower bound for closing times).
- Educational timetabling under room availability (education)
- Use case: Assign exams/labs with release times (ready-to-run) to rooms with closing times, minimizing maximum completion delay across courses.
- Tool/workflow: Model as restricted assignment with closing times; solve LP, round with the proposed algorithm.
- Assumptions/dependencies:
- Known room availability intervals, exam durations, release constraints.
- Feasible fractional assignments exist.
- Lightweight fairness engine for content/editorial scheduling (media, academic journals)
- Use case: Balance assignments (e.g., editor-of-the-week, featured reviewer) according to weighted contributions while keeping prefix discrepancies small.
- Tool/workflow: Implement the algorithm as a microservice that maintains prefix sums P_t and N_t and selects the next assignee by earliest deadline.
- Assumptions/dependencies:
- Periodic contributions can be quantified (weights d_j).
- Fairness target is prefix-based; interval discrepancy guarantees do not extend universally beyond prefixes.
Long-Term Applications
- Constant-factor approximation for general restricted assignment scheduling (software, manufacturing, cloud)
- Use case: Achieve 3-approximation for maximum flow-time in broader restricted assignment settings (beyond closing times) if the weighted carpooling conjecture is resolved with a constant bound.
- Potential tools/products: General-purpose scheduler that rounds LP solutions with guaranteed interval discrepancy across arbitrary machine subsets.
- Dependencies:
- Requires progress on Conjecture 2 (weighted carpooling) or related prefix discrepancy bounds for intervals.
- Current best-known bounds are O(√log n); the paper disproves a blanket interval bound of 1, highlighting necessary care.
- Robust traffic engineering via unsplittable flow rounding with bounded arc discrepancy (telecommunications, SDN)
- Use case: Convert fractional multi-commodity flows to unsplittable routes with per-arc deviation at most the max demand, enabling stable routing with limited capacity shock.
- Potential tools/products: TE solvers integrating discrepancy-aware rounding; deployment for acyclic or structured networks.
- Dependencies:
- General Morell–Skutella conjecture is open; the paper resolves a special case via a tailored DAG (prefix paths).
- Broader applicability would need graph-general results or restrictions (e.g., planar, series-parallel).
- Unrelated machines scheduling with non-uniform per-machine processing times (HPC, cloud)
- Use case: Assign jobs with machine-dependent processing durations d_ij while maintaining bounded prefix discrepancy if Conjecture 3 (non-uniform weights) is proven.
- Potential tools/products: Extended rounding libraries for heterogeneous clusters.
- Dependencies:
- Non-uniform weighted chairman assignment requires new theory; current bounds hold in non-prefix (t=n) cases only.
- Committee assignment with multi-seat columns (public sector, academia)
- Use case: Assign multiple seats per period (integer column sums n_j) while bounding prefix discrepancy per member (Conjecture 4).
- Potential tools/products: Apportionment systems for multi-seat bodies with weighted fairness guarantees.
- Dependencies:
- Requires new discrepancy bounds for multi-seat weighted columns and possibly carpool constraints (y_ij=0 whenever x_ij=0).
- Online scheduling with bounded recourse and near-constant discrepancy (operations, logistics)
- Use case: Real-time assignment with small adjustments (recourse) that maintains near-constant prefix discrepancy.
- Potential tools/products: Online schedulers with controlled recourse budgets.
- Dependencies:
- Open problems remain for constant bounds with polylog recourse; existing online bounds are Θ(log m) or O(√log n) in special cases.
- Interval-level fairness mechanisms with buffering (policy, workforce management)
- Use case: Achieve fairness guarantees not just on prefixes but across arbitrary intervals by integrating buffers or slack in assignments.
- Potential tools/products: Interval-aware fairness scheduling platforms that combine prefix discrepancy algorithms with dynamic smoothing.
- Dependencies:
- The paper’s Proposition on interval lower bounds (>1) shows prefix guarantees do not directly generalize; requires new techniques (e.g., buffered quotas, recourse).
In all cases, effective deployment benefits from:
- A pipeline that obtains fractional assignments via LP, then applies the linear-time rounding algorithm.
- Data fidelity on releases, processing times, machine availability.
- Awareness that guarantees are prefix-based unless stated otherwise; interval fairness may need additional design choices (buffers, recourse, or specialized graph structures).
Collections
Sign up for free to add this paper to one or more collections.