Result 110, Theoretical computer science

Optimal-order randomized k-server on arbitrary metrics

Establishes a randomized competitive ratio O(log⁡2(k+1))O(\log^2(k+1)) for k-server on every metric space, matching the worst-case lower-bound order. One policy serves every finite oblivious request sequence, including on infinite unbounded metrics. On finite rational metrics, a uniform implementation has polynomial preprocessing and per-request bit cost in the input length and log⁡(t+1)\log(t+1) at request t, with a finite instance-dependent additive movement constant.

Lean formalization New or sharp bound

The bigger picture

Why it matters

The k-server problem asks how to move k servers to satisfy requests arriving one at a time while limiting total travel. The manuscripts claim an optimal-order guarantee despite the algorithm not knowing future requests.

What changes?

The manuscript reports an expected movement cost at most a constant times the square of log(k+1) times the cost of an optimal plan knowing all requests, plus an additive constant. Requests must be oblivious: fixed independently of the algorithm's random choices. For each metric space, whose distances define movement costs, and initial configuration, one policy handles every finite sequence, even in infinite, unbounded spaces. With distinct starting positions, no additive term is needed.

What does that help mathematicians do?

Combined with the stated worst-case lower bound, this would identify the best possible order of dependence on the number of servers for randomized algorithms across all metric spaces. Researchers could rule out a universally smaller-order competitive ratio under the same request model. This does not rule out better guarantees on special spaces, and optimal order does not mean the leading constant is optimal.

Are there practical applications?

A companion manuscript reports a uniform implementation for finite spaces with rational distances. Preprocessing and per-request bit costs are polynomial in input length, with request t also depending polynomially on log(t+1). This connects the guarantee to finite computation, rather than existence alone. It does not establish practical speed: the finite, instance-dependent additive movement constant may be enormous.

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.

2 manuscripts

Squared-logarithmic randomized k-server on arbitrary metrics

September 24, 2026 71 pages

We prove that randomized k-server has competitive ratio O((log⁡(k+1))2)O((\log(k+1))^2) on every metric space against oblivious request sequences, matching the known worst-case lower bound. For each metric and initial configuration, one policy works for all finite request sequences, including on infinite and unbounded spaces. When the initial server positions are distinct, no additive term is needed.

PDF LaTeX source
Cite (BibTeX) 
@misc{OAI:Squared-logarithmic-randomized-k-server-on-arbitrary-metrics-September-24-2026,
  author = {{OpenAI}},
  title = {{Squared-logarithmic randomized $k$-server on arbitrary metrics}},
  howpublished = {OpenAI Math Release preprint
                  \href{https://github.com/openai/math/blob/main/preprints/Squared-logarithmic-randomized-k-server-on-arbitrary-metrics-September-24-2026/Squared-logarithmic-randomized-k-server-on-arbitrary-metrics-September-24-2026.pdf}{OAI:Squared-logarithmic-randomized-k-server-on-arbitrary-metrics-September-24-2026}},
  year = {2026}
}

Uniform computation of the squared-logarithmic k-server bound

September 24, 2026 16 pages

We construct a uniform randomized k-server algorithm on finite rational metrics with competitive ratio O(log⁡2(k+1))O(\log^2(k+1)) against oblivious request sequences. Preprocessing is polynomial in the input length, and per-request bit complexity is polynomial in that length and the binary request-counter length. The additive movement constant is finite and instance-dependent, but may be enormous. The construction uses the companion squared-logarithmic existence theorem.

PDF LaTeX source
Cite (BibTeX) 
@misc{OAI:Uniform-computation-of-the-squared-logarithmic-k-server-bound-September-24-2026,
  author = {{OpenAI}},
  title = {{Uniform computation of the squared-logarithmic $k$-server bound}},
  howpublished = {OpenAI Math Release preprint
                  \href{https://github.com/openai/math/blob/main/preprints/Uniform-computation-of-the-squared-logarithmic-k-server-bound-September-24-2026/Uniform-computation-of-the-squared-logarithmic-k-server-bound-September-24-2026.pdf}{OAI:Uniform-computation-of-the-squared-logarithmic-k-server-bound-September-24-2026}},
  year = {2026}
}

Lean formalization

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

Optimal-order randomized k-server on arbitrary metrics

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

Scope

The formalization proves an O((log⁡(k+1))2)O((\log(k+1))^2) competitive ratio for randomized kk-server against oblivious finite request sequences. For every k≥2k\ge2, every metric space containing at least k+1k+1 points, and every initial configuration, one policy works for all request sequences, including in infinite and unbounded spaces.

The bound permits a configuration-dependent additive constant, which is zero when the initial server positions are distinct. The universal multiplicative constant is independent of the metric and kk.

The formalization constructs one uniform randomized bit algorithm for kk-server on finite rational metrics, for 2≤k<n2\le k<n. Its expected movement on every oblivious finite request sequence is at most an absolute multiple of (log⁡(k+1))2(\log(k+1))^2 times the offline optimum, plus a finite instance-dependent additive constant.

Preprocessing is polynomial in the encoded input length, and each request is processed in time polynomial in that length and the binary length of the request counter. Every processed request returns a legal server index. The additive movement constant is not claimed to be polynomially bounded.

Comparator links

Result Comparator statement
Squared-logarithmic randomized kk-server on arbitrary metrics KServer.lean
Uniform bit algorithm for the squared-logarithmic kk-server bound UniformKServer.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.