Result 124, Theoretical computer science

Polynomial-time scheduling on three identical machines

Resolves the three-processor unit-job scheduling problem of Garey and Johnson: a deterministic polynomial-time algorithm minimizes makespan for nonpreemptive unit-length jobs with arbitrary precedence constraints on three identical parallel machines. For an explicitly given precedence graph, it decides deadline feasibility exactly and constructs a feasible schedule.

Lean formalization Algorithm or complexity result

The bigger picture

Why it matters

When tasks depend on one another, even three identical machines can be difficult to coordinate. This manuscript claims an exact, polynomial-time way to finish equal-duration tasks as early as possible in that setting.

What changes?

The unreviewed manuscript reports a deterministic polynomial-time algorithm for exactly three identical parallel machines and jobs that each take one unit of time. A precedence graph explicitly lists the jobs and which must finish before others begin; these requirements may be arbitrary. Jobs cannot be interrupted once started. The algorithm minimizes makespan, the time when the last job finishes. It also decides exactly whether a specified deadline is achievable and constructs a feasible schedule when one exists.

What does that help mathematicians do?

The proposed proof identifies a compact way to represent scheduling choices: it breaks schedules into intervals, describes their job sets with bounded-size information, and searches polynomially many descriptions using dynamic programming. Boundary conditions and control of information inherited between intervals keep that search small. This would explain how exact optimization can avoid enumerating all schedules despite arbitrary dependencies, providing a structural tool for understanding this scheduling problem.

Are there practical applications?

The direct relevance is to scheduling tasks with dependencies on three interchangeable processors, provided every task has the same duration and runs without interruption. Within that model, the claimed algorithm would give exact deadline and optimal completion-time answers. Polynomial runtime alone does not establish practical speed, and the result does not cover unequal task lengths or other machine counts.

This section was generated by GPT-6 Astra Medium. This explanation is based on the result summary and manuscript abstracts below. This context is separate from OpenAI's source text.

Manuscript

A Polynomial-Time Algorithm for Three-Machine Unit-Job Scheduling

September 24, 2026 22 pages

We give a uniform deterministic polynomial-time algorithm for scheduling unit-length jobs with arbitrary precedence constraints on three identical parallel machines. The algorithm constructs a schedule of minimum makespan and decides exactly whether all jobs can finish by a specified deadline. The proof reorganizes feasible schedules into intervals whose job sets have descriptions of bounded size. A dynamic program searches a family containing polynomially many such descriptions. Global boundary conditions and simplification of inherited information keep the descriptions bounded throughout the decomposition.

PDF LaTeX source
Cite (BibTeX) 
@misc{OAI:A-polynomial-time-algorithm-for-three-machine-unit-job-scheduling-September-24-2026,
  author = {{OpenAI}},
  title = {{A Polynomial-Time Algorithm for Three-Machine Unit-Job Scheduling}},
  howpublished = {OpenAI Math Release preprint
                  \href{https://github.com/openai/math/blob/main/preprints/A-polynomial-time-algorithm-for-three-machine-unit-job-scheduling-September-24-2026/paper.pdf}{OAI:A-polynomial-time-algorithm-for-three-machine-unit-job-scheduling-September-24-2026}},
  year = {2026}
}

Lean formalization

OpenAI's note on what the formalization covers, from lean/docs/124.md.

Polynomial-time scheduling on three identical machines

The following describes the scope of the Lean formalization related to the following accompanying paper(s):

Scope

The formalization gives a deterministic polynomial-time algorithm for scheduling nonempty collections of unit-length jobs with arbitrary acyclic precedence constraints on three identical parallel machines. It constructs a schedule of minimum makespan and decides exactly whether a valid specified deadline can be met. The algorithm is one fixed finite machine, and its running time is bounded by a polynomial in the binary input length.

Comparator links

Result Comparator statement
Optimal three-machine unit-job scheduling ThreeMachine.lean

Data from github.com/openai/math at commit adc7f12, committed October 6, 2026 at 21:58 UTC, last checked for changes about 8 hours ago. Titles, subjects, summaries, abstracts and Lean notes are OpenAI's; page counts are read from the PDFs. The map, related results, search, kinds of results and the named-problem index are Emergent Mind's, built with text embeddings and an LLM, and may contain errors.

An Emergent Mind Labs project. Emergent Mind is not affiliated with OpenAI. None of these results has been peer reviewed. Cite the manuscripts themselves, using the BibTeX on each result's page.