The September 24 update reduced the font loaded on every page, moved repeated directory artwork into a shared SVG, and changed how styles and offscreen content are handled. It also made prefetching follow the structure of the index, where featured articles and directory rows have different browsing patterns.¹

The changes address different parts of the path from a request to readable content. Their file-size effects can be measured directly, while their mechanisms explain where the browser can avoid or reuse work.

The document’s critical path

A static page still needs to be parsed and rendered. The browser receives HTML, discovers its styles and fonts, constructs the document, computes layout, and paints. During navigation, some resources can be reused, but the new article introduces its own markup and layout.

This creates several independent costs. Large HTML takes work to parse. A font discovered late can delay final typography. Repeated artwork expands the document even when it compresses well on the network. A stylesheet for a feature absent from the page adds processing without contributing to that page’s appearance.

The implementation commit records the exact changes.¹ The payload measurements below refer to its 70-post publication build. Subsequent article revisions change document sizes, while the underlying resource choices remain inspectable in the source.

The Inter subset

The site previously preloaded a 345,588-byte Inter WOFF2 file. The Latin subset used for browser text is 100,176 bytes, a reduction of 245,412 bytes, or about 71 percent, for that font resource.

Subsetting works because the browser text uses only part of the original font’s glyph coverage. The unicode-range declaration identifies the characters served by the face, and font-display determines how text appears while the font is loading. Preloading makes the font discoverable before the browser would otherwise find it through the rendered text.²

The original Inter file remains available to social-card generation, which has a different coverage requirement. Browser text and build-time image rendering therefore use separate resources suited to their inputs.

This saving applies most directly to a first visit that needs the font. A warm visit may reuse an existing response from the browser cache. Page latency also includes HTML, styles, layout, and other resources, so the percentage reduction in the font file describes one component of the load.

Font selection and layout

The update also serves selected mono faces locally instead of importing a broader font package. Body text, headings, and code have different font requirements; loading the faces used by those elements makes the dependency explicit.

A preload gives a resource priority. The useful set is the faces needed early in the page, since preloading every available weight makes them compete for network capacity. The selected heading weight and body face are more likely to contribute to the first viewport than a face used only deep in an article.

Coverage affects layout as well as download size. Accented names, punctuation, code symbols, and non-Latin characters can invoke fallback fonts when a subset does not contain them. Different metrics can change line breaks. That is why the subset and the page’s actual character coverage are considered together.

Shared SVG artwork

The directory originally embedded each row’s generated SVG paths directly in the homepage. The new implementation stores those definitions in /thumbnails.svg and gives each row a small <use> reference. Featured cards and article banners remain inline.¹

On the same 70-post corpus, the publication build’s homepage was approximately 177 KB. Expanding the row references back into inline artwork would make it approximately 309 KB, a difference of about 132 KB in the document. The shared sprite was about 143 KB uncompressed and 13 KB with gzip.

The distinction between document size and transfer size is important here. Gzip compresses repeated markup effectively, so moving paths into a separate file does not remove 132 KB from the compressed first-visit transfer. The cold transfer totals are similar. The main document contains less markup to parse, and the artwork becomes a separately reusable resource.

The cache boundary now follows the content boundary. A change to article text does not inherently change the SVG definitions, and a page using a row reference does not have to repeat the paths in its HTML. The actual reuse still follows the response’s cache policy and validation behavior.

Rendering the sprite in context

Each row retains its dimensions and surrounding theme styles. The external symbol supplies the drawing. This preserves the role of the artwork while changing where its markup lives.

The important rendering cases are the light and dark themes, a fresh index load, and returning to the index through client navigation. A valid <use> element establishes the reference, while the visible paths establish that the resource loaded and inherited the expected appearance.

Article banners stay inline because they represent one article at a time. Downloading the entire directory sprite for a single banner would introduce unrelated artwork into that request. Keeping the two representations separate follows their reuse patterns.

Math styles as an article dependency

The Markdown pipeline records whether an article contains math. The article layout uses that result to include a separate KaTeX stylesheet. Pages without math avoid the dependency; pages with equations load the rules and font resources needed to display them.¹

This is a build-time decision. The browser receives the appropriate stylesheet link with the article rather than discovering the requirement through a later script.

Currency notation makes the classification slightly more involved. Markdown math delimiters also use dollar signs, so money prose can be parsed as inline math. The accompanying currency pass recognizes common price patterns before the page’s math flag is determined. Actual equations retain the math path.

Client navigation exercises the dependency in both directions. A math article needs its stylesheet when reached from a non-math page, and a fresh context establishes that the page is not relying on a stylesheet retained from an earlier visit. These cases connect the build-time classification to the browser’s resource lifecycle.

Offscreen rendering

Long articles contain blocks with substantial layout and paint work: code listings, figures, tables, equations, and diagrams. The stylesheet applies content-visibility: auto to selected blocks and supplies an estimated intrinsic size.³

Supporting browsers can skip some rendering work for those blocks while they are offscreen. The content remains in the document, and its network bytes are still part of the page. The saving is in when rendering work is performed.

The intrinsic-size estimate gives the browser a provisional layout before it renders the block. As the actual content becomes relevant, its true dimensions replace that estimate. Tall code blocks, wide tables, and anchor navigation make this behavior visible, because their geometry affects the position of surrounding content.

The table of contents also moved from a global per-scroll update loop to intersection-observer-driven updates. The top gradient uses a CSS scroll-driven animation where supported. These changes reduce the amount of JavaScript tied directly to scrolling while preserving the navigation and visual behavior.¹

Prefetching follows browsing intent

Astro supports prefetch strategies based on hover, focus, viewport entry, and other triggers.⁴ The index uses viewport-based prefetching for featured links and hover or focus for directory rows.

The difference follows the page’s structure. Featured articles are a small set of likely destinations. The directory is a large collection that readers may scan without opening most of it. Warming every row as it enters the viewport can transfer many articles that are never visited.

Hover and focus provide a more selective signal for the directory. They allow the browser to begin fetching a chosen article before activation. A touch interaction has less advance notice, so its request sequence can differ from the pointer path.

Prefetching and prerendering perform different amounts of work. Prefetching obtains resources in advance; prerendering can prepare a document for a later navigation.⁵ The configuration enables Astro’s supported client-prerender path, with actual behavior determined by browser support and policy.

The useful tradeoff is between work before the click and time after it. Recording prefetched bytes and subsequent visits establishes how much of the background work contributes to navigation. A lower click-to-content time and a smaller total browsing transfer are related but distinct objectives.

Reproducing the payload measurements

The current build can be inspected with:

bun install --frozen-lockfile
bun run build
bun -e 'import { statSync } from "node:fs"; for (const p of ["dist/index.html", "dist/thumbnails.svg", "public/fonts/Inter.woff2", "public/fonts/Inter-latin.woff2"]) console.log(p, statSync(p).size)'
gzip -c dist/index.html | wc -c
gzip -c dist/thumbnails.svg | wc -c

The file sizes separate raw document storage from compressed transfer payload. The same corpus and build settings isolate the effect of an implementation change. Comparing an older 61-post index with a newer 70-post index would combine engineering changes with content growth.

Browser verification adds the execution context: a fresh homepage, a warm article switch, a math article, and a long mobile page. The publication checks covered article rendering, artwork, math-style loading, and mobile overflow. These establish that the changed resource paths still deliver the intended content.

Field timing answers the remaining performance question. Click-to-usable-content distributions, separated by device and cache state, show how the resource changes affect readers. The established result is the reduced font resource and lighter homepage markup, together with more selective loading and rendering. Each addresses a specific cost in delivering the same technical material.

References

This gives the term several related meanings. Benchmark progress measures capability on defined tasks. Efficiency progress changes the resources needed to obtain a result. Deployment progress makes the capability available in a working system. The distinction explains why different accounts of the frontier emphasize different kinds of progress.

The quality-cost frontier

In a quality-cost comparison, a system is dominated when another is at least as good on both dimensions and strictly better on one. The remaining systems form a Pareto frontier. Several systems can belong to it because a gain in quality may require more time or compute.

Consider an illustrative document-extraction workload:

B dominates C under these measurements. A, B, and D remain useful at different operating points. A new system matching B’s quality at A’s cost would expand the set of choices even without introducing a new category of task.

The definition of correctness determines the comparison. Requiring every field in a document to be correct is stricter than averaging field-level accuracy. Abstentions and human review also change the cost of a completed result. A frontier is therefore attached to a task and measurement procedure, rather than to a model name alone.

Adding privacy, memory, or hardware requirements introduces more dimensions. A local model can occupy a useful point even if a hosted system has higher maximum quality, because local execution satisfies a constraint that the hosted option does not.

Capability and usable reliability

A capability result establishes that a system can perform a task under specified conditions. Reliability describes how consistently it succeeds across the conditions that matter to the application. Deployment combines that behavior with tools, data access, recovery, and an operating budget.

A coding benchmark may provide a prepared repository, a precise issue, and an executable test suite. A deployed coding agent may also need to identify the repository, interpret an incomplete request, preserve unrelated changes, and verify the resulting application. The model contributes to all of this, but the surrounding execution system determines which capabilities become usable.

HELM evaluates models across multiple scenarios and dimensions, including properties beyond accuracy.¹ This supports a broader account of improvement: calibration matters when confidence determines an action, robustness matters when inputs vary, and efficiency matters when the application must serve many requests.

A reproducible comparison identifies the model revision, prompt, tools, retry policy, time budget, and evaluator. Improvements in any of those can move the system-level frontier. Recording them separates a model improvement from an improvement in the way the model is used.

Task duration as a capability measure

Longer tasks introduce state, dependencies, and opportunities for recovery. METR’s work measures agent performance against task duration as experienced by human professionals, at a specified success probability.² The human duration provides a measure of task difficulty; it is distinct from the time the AI spends executing it.

This makes a capability claim more specific. A 50-percent-success horizon and an 80-percent-success horizon describe different levels of reliability on the same task distribution. Their relationship is useful for understanding how performance changes as work becomes longer.

A simple model illustrates the compounding effect. If a workflow required 50 independent steps and each succeeded with probability 0.99, the probability that every step succeeded would be about 0.605. At 0.999 per step it would be about 0.951.

Real workflows have correlated errors, unequal step difficulty, and recovery, so the calculation is a simplified example. Its significance is that local competence and completed-task reliability are different quantities. An agent that detects and repairs a failed tool call can improve the second without changing the first.

Long-task evaluation therefore includes completed artifacts, interventions, recovery behavior, and the state retained between steps. These measurements connect progress in the model to the amount of work the system can reliably carry forward.

Amodei and the rate of capability growth

Dario Amodei’s September 2026 essay treats the frontier as a rate-of-progress problem. His concern is that increasingly capable AI can accelerate subsequent AI development faster than alignment and operational safeguards improve. He proposes embedded external evaluators, coordination among companies in democratic countries, and broader international coordination.³

The embedded-evaluator proposal gives the argument an operational component. Ongoing access to development and evaluation processes would allow outside teams to examine adherence to commitments and report findings. Coordination would then have a source of evidence beyond each company’s own account.

This position connects capability advancement to the time available for evaluation, alignment, and institutional response. The relevant boundary is the pace at which systems gain consequential abilities relative to the mechanisms used to understand and manage them.

OpenAI and coordination around deployment

Sam Altman and Jakub Pachocki’s June 2026 plan also addresses coordination, including a proposed international body that could respond when safety and social resilience fall behind frontier development. OpenAI’s Frontier Governance Framework describes risk assessment, outside input, and incident response.⁴

The emphasis is on how decisions about powerful systems are made and which institutions participate. Assessments and response procedures connect a capability result to a deployment decision. A model’s measured ability becomes one input to a broader process involving safeguards and the conditions of use.

These proposals overlap with Amodei’s concern about the relationship between capability and preparedness, while differing in their mechanisms. The comparison turns on evaluator access, decision authority, and the information available to external participants. The essays and frameworks are primary sources for the positions their authors advocate.

Huang and the infrastructure frontier

Jensen Huang’s five-layer account of AI places models within a larger system of energy, chips, infrastructure, and applications.⁵ In this view, the frontier moves through the capacity to train, serve, and apply increasingly capable systems.

NVIDIA’s account of open and proprietary AI presents both as parts of that development. Open models broaden the set of organizations that can adapt and deploy AI, while proprietary systems continue to contribute capabilities and products.

The infrastructure view explains a different constraint on progress. A capability that requires unavailable compute or uneconomic serving costs has limited reach. Better accelerators, networking, runtimes, and model efficiency can make the same capability useful at a much larger scale.

This is closely related to the quality-cost frontier. Reducing the resources required for an accepted result expands the feasible set of applications, even when the maximum benchmark score is unchanged.

Delangue and access to the frontier

Clément Delangue’s account of open-source AI robotics describes openness across models, datasets, and hardware. The practical effect is that more participants can inspect, modify, and build on the components of a system.

Hugging Face’s summer 2026 open-model report adds evidence about how that ecosystem is used. Its observations distinguish attention around new releases from download activity concentrated in established models.⁶ A model can attract interest as a frontier release while smaller, older models continue to support much of the deployed work.

Access therefore has several layers. Weights allow local execution and adaptation. A suitable license permits the intended use. Runtime support and hardware make execution practical. Data and methodological detail help other teams understand and reproduce the result.

These layers determine how far a capability spreads. An open model that fits existing machines can change who is able to build an application, while a larger model may primarily change what the best-resourced teams can attempt.

From a general capability to a local application

A university maintenance assistant illustrates how the different frontiers meet. The model must recognize urgent failures, understand the languages used in requests, and route uncertain cases to staff. The application also needs data access, a review process, and enough serving capacity to respond within its deadline.

A held-out set of ordinary and difficult cases measures the capability relevant to that setting. Fixing the review budget and response-time target makes the comparison operational. Missed urgent cases and harmless routing errors have different consequences, so their rates remain separate in the result.

A shadow deployment can measure predictions before they affect real queues. If the system reduces review work while preserving the required handling of urgent cases, it has moved an operational boundary. Better inference efficiency may make that result affordable; local deployment may make its data handling acceptable; recovery may make it reliable across longer workflows.

This is how frontier progress becomes usable. Capability, efficiency, access, and operating reliability each remove a different constraint. Describing which constraint changed makes the result understandable to the next team trying to build with it.

References

Anthropic’s managed-agent architecture separates the session log, the harness that runs the model/tool loop, and the sandbox that executes work.¹ Meta’s Muse architecture makes another implementation of the same broad distinction, separating the agent runtime from durable application state, credentials, and permission enforcement.²

These boundaries allow a long-running task to outlive any individual model call or worker. They also make failures local: a lost process becomes something the system can recover from using the records it already holds.

The task state machine

A task moves through a small set of states:

queued -> running -> waiting_on_tool -> running -> done
                   -> needs_user
                   -> failed -> retry or stop

Each state identifies what can happen next. A running task belongs to a worker. A waiting task records the operation or event that can wake it. A task needing user input retains the question and the point at which work paused. Completion records the resulting artifact and the checks that establish it.

The task record contains the objective, owner, allowed operations, deadline, remaining budget, and current status. These fields remain authoritative even when the model’s context is compacted. A summary can help the next model call understand the task, while the durable record determines what it is permitted and expected to do.

An event log records transitions such as tool_requested, tool_completed, checkpoint_saved, and user_approved. Sequence numbers establish their order. The current state can be reconstructed from those events or stored alongside them for efficient lookup.

Session state and working files

Three forms of state have different roles:

The distinction makes recovery precise. A worker can reconstruct its context from the session history, identify the current artifact revision, and resume according to the task state. A container’s filesystem alone does not contain all three guarantees.

A small implementation can represent them with a few tables:

tasks(id, objective, status, owner, lease_until, version, deadline, budget)
events(task_id, sequence, kind, payload, created_at)
actions(id, task_id, request_key, status, external_id, result)
checkpoints(task_id, last_sequence, summary, artifact_revision)

Unique event sequences and action request keys give each record a stable identity. A transaction can update the task state and append its corresponding event together, avoiding a status change without an explanation in the log.

Checkpoints and context reconstruction

A checkpoint records the last processed event, a compact account of the work, and the artifact revision it describes. Recovery loads that checkpoint and the subsequent events. The worker does not need to replay every model call to discover the next unfinished operation.

Raw events remain useful after compaction. A summary may omit the details of a failed command or the reason an alternative was rejected. Keeping the original result allows the agent or a reviewer to retrieve it when it becomes relevant again. Anthropic’s managed-agent design explicitly separates durable session history from the model’s working context.¹

Long-term facts have a different lifecycle from task events. A project decision, user preference, or file pointer benefits from a source and update time. Retrieval selects the relevant facts for the current task, while the event log retains the complete execution record.

Model-level context management complements this storage. Meta describes context compaction and subagent coordination in Muse Spark 1.1. The model can use context more effectively, while the surrounding system preserves information across restarts and decides which state remains current.

Recovery across an external action

The most difficult restart boundary occurs after an external action succeeds but before the worker records the result. Consider an agent submitting a report. The remote service accepts it, then the worker crashes before saving the returned identifier. Locally, the action still appears unfinished.

Recording the request before sending it establishes intent, but the outcome is uncertain until it can be reconciled. Recovery follows one of three paths:

1. Retry with the same idempotency key under the external service’s documented contract.
2. Query the service using a stable identifier or request metadata.
3. Retain an uncertain state for resolution when neither operation is available.

Stripe’s idempotency API is a concrete example of the first mechanism.³ The key identifies the operation across attempts. Its retention period, parameter matching, and handling of errors determine which retries the guarantee covers.

A local events table and a remote API usually do not share a transaction. The action record bridges them by retaining the information needed to discover what happened. This is what prevents an ordinary process restart from becoming a duplicate message, report, or purchase.

Worker leases and fencing

A lease assigns a task to a worker for a limited period. The worker renews it while active; after expiry, another worker can take over. This provides recovery when a process disappears without releasing its task.

Expiry does not guarantee that the original process has stopped. A paused worker can resume after a new owner has started. A monotonically increasing ownership version resolves that case: each state-changing operation includes the version, and the store rejects an older owner’s writes.

This fencing check also matters at the tool boundary. Rejecting a stale database write after an external action has already happened cannot undo the action. The executor needs enough ownership information to reject stale work before performing it.

Artifact revisions provide a related check for collaborative work. A checkpoint can name a commit or content hash. On resume, a difference between that revision and the current workspace identifies changes made by another worker or a person. Recovery can then reconcile the new state rather than restoring an obsolete copy.

The restart sequence

With these records in place, resuming a task has a defined sequence:

claim task and obtain the current ownership version
load objective, permissions, checkpoint, and later events
reconcile pending actions with their external systems
compare artifact revision with the current workspace
construct context from the current task and relevant evidence
continue within the remaining budget

The sequence resolves uncertainty before asking the model for its next action. It also reduces unnecessary work: a completed deployment or tool call can be observed and recorded rather than launched again.

Waiting becomes inexpensive under this design. A task waiting for a build does not need a continuously running model loop. A completion event can wake a replaceable worker, which resumes from the durable state.

Permission as application state

An approval has a scope: the action, destination, and artifact it authorizes. Binding it to the action arguments or an artifact revision makes it usable during recovery. The worker can determine whether the operation now being attempted is the one that was approved.

Authorization is enforced by the executor. A tool may technically support deletion while the current task permits only reading. The task’s permission record restricts the operation independently of what the model proposes.

Meta’s published Muse design places permission enforcement and credential handling outside its agent runtime.² That separation lets the application check external actions without making the generated code responsible for protecting the credentials it could otherwise access.

Provenance serves a similar role for information. A document or web page is task data, even when its contents resemble instructions. Retaining that distinction in context and checking actions against the task record limits how external text can redefine the work.

Completion and evaluation

Completion can be expressed as a predicate over recorded evidence. A code task may require a saved diff and passing checks. A research task may require a report with source-backed claims. A deployment task may require a successful build and a verified live artifact.

Anthropic’s long-running development work treats evaluation as part of the agent system.⁴ Separating the evaluator from the worker’s self-assessment gives the completion record meaning beyond the model saying it has finished.

Recovery tests exercise the same design at its boundaries: before a tool call, during execution, after remote completion, and after checkpoint persistence. Duplicate wake events, expired leases, and revoked permissions test whether the task remains coherent under changes in ownership and authority.

Budgets bound the lifetime of unsuccessful work. Elapsed time, model spending, tool invocations, and repeated failures can each have a limit. A transient transport error can be retried; an invalid request or revoked permission needs a different transition.

The resulting system has continuity that can be inspected. Its last checkpoint, pending action, wake condition, and remaining budget describe what is happening even while no model call is running. That is the operational basis for an agent that can resume work reliably over hours or days.

References

These developments act at different levels, which is what makes them complementary. A model can become cheaper to run without changing its weights, more capable through training, or more reliable through an execution policy that adds tools and verification. Understanding the mechanism identifies where each improvement belongs in an application.

Four places where computation changes

The baseline differs in each row. A kernel comparison holds weights and inputs fixed. A training comparison holds the evaluation task and resource budget fixed. A deployment comparison asks whether another model satisfies the application’s requirements. An inference-policy comparison includes all attempts and checks used to produce the answer.

This separation also explains why gains cannot generally be multiplied together. Two changes may reduce the same part of the execution, and an improvement at one layer can expose a bottleneck at another.

Attention as a memory-system problem

Conventional attention forms a score matrix, normalizes it, and multiplies the resulting probabilities by the value matrix. Materializing those intermediates creates substantial off-chip memory traffic. The original FlashAttention algorithm reorganizes exact attention around tiling and online softmax, reducing transfers between high-bandwidth memory and on-chip storage.¹

The scale is visible from the intermediate alone. A 32,768-by-32,768 matrix contains about 1.07 billion entries. At two bytes per entry, one such matrix occupies 2 GiB. This calculation describes the straightforward materialized representation for one head, before other tensors are included.

A tiled algorithm works on smaller blocks and retains the running statistics needed to produce the same attention operation. Avoiding the full intermediate reduces both storage and memory traffic. Numerical differences can still arise from floating-point ordering, as with other fused implementations.

This is an execution improvement that can benefit existing weights. Its value depends on how much attention contributes to the workload, which differs between training, prefill, and decode.

FlashAttention-4 and asymmetric hardware scaling

FlashAttention-4 targets Blackwell’s change in the balance between matrix throughput and supporting resources. Tensor-core compute grows faster than some of the bandwidth and non-matrix operations needed to feed it. The work combines algorithm changes with a revised kernel pipeline to keep those resources coordinated.²

The paper reports B200 results against specified cuDNN and Triton baselines. The useful engineering lesson is the dependency between algorithm and hardware: increasing matrix throughput changes which operations must be reduced, overlapped, or reorganized.

The end-to-end gain follows the fraction of time affected. If attention occupies 30 percent of a workload and a new kernel makes it twice as fast, normalized total time becomes:

0.70 + 0.30 / 2 = 0.85

That is an overall speedup of about 1.18x. If attention occupies 5 percent, the same local improvement gives about 1.026x overall. The calculation connects a kernel result to the application profile.

The attention-kernel guide develops the underlying tiling and memory argument. The recent work extends it to a different balance of hardware resources.

Training agents against executable outcomes

An agent produces a trajectory of observations and actions. When the environment can evaluate the result, training can reward completed work: a patch passes checks, a tool sequence reaches a target state, or an output satisfies a verifier.

OpenEnv addresses the infrastructure needed to run these experiments through consistent environment interfaces.³ Observations, actions, resets, and outcomes become repeatable parts of a rollout. That makes it easier to collect experience across tasks and compare changes in the policy.

The environment defines the learning signal. In a coding task with reward 1 for passing tests and 0 otherwise, the evaluator must distinguish implementing the feature from changing the tests or hard-coding the fixture. Hidden cases and protected evaluation code preserve that distinction.

Infrastructure reliability matters for the same reason. A dependency service failing during a run creates an unsuccessful outcome even when the proposed code is correct. Recording tool failures, invalid actions, and timeouts separately helps distinguish environment problems from the behavior being trained.

Generalization depends on the task distribution

A training improvement is useful when it carries to new work. Near-duplicate tasks can make a random split unusually easy, so repository, template, or time-based splits can expose different kinds of generalization.

The tool environment also defines the distribution. A policy trained with unrestricted access can behave differently when deployed with a scoped filesystem or fewer tools. Matching the relevant execution conditions connects the training result to the intended agent.

Task success, number of attempts, intervention rate, and resource use describe different aspects of that transfer. A policy may improve completion while using more tool calls, or become more efficient while preserving its success rate. Both changes can be valuable under different operating budgets.

The persistent-agent architecture supplies the corresponding deployment machinery: durable state, recoverable actions, and explicit completion conditions. Better learned behavior and better execution support contribute to the same completed task.

Open multimodal models on local hardware

The Gemma 4 ecosystem announcement describes multimodal model variants and integration across runtimes including MLX and llama.cpp.⁴ The practical change is a broader set of tasks that can be implemented with locally available weights and execution.

Multimodal deployment includes more than the text decoder. A document assistant may resize an image, encode visual content, retrieve relevant context, and generate a response. Each stage contributes to latency and memory use. A text-only token rate measures only part of that path.

A useful local workload therefore begins with the original input. For a scanned document, this includes rotation, small print, tables, handwriting, and language variation. An answer linked to its supporting page or region connects extraction quality to the evidence in the document.

The model variant and runtime determine which inputs and operations are supported. Quantization changes storage and execution. The complete configuration includes those choices alongside the model’s license and the hardware available to run it.

Capacity creates new application choices

A compact model that meets a task’s quality requirement can shift execution from a hosted service to a local device. This changes latency, availability, and data movement as well as inference cost.

The memory budget includes weights, modality encoders, temporary tensors, and the attention cache. Long inputs can move the limiting factor from weight storage to activations or cached state. The MLX hardware comparison separates capacity, bandwidth, and compute for that reason.

Local execution also changes where document contents travel. The inference step can remain on the device while model downloads, telemetry, or a separate OCR service use the network. Describing those stages independently gives an accurate account of the application’s data path.

The resulting choice is task-specific. A smaller local model may provide the required extraction quality at low latency, while difficult synthesis remains on a larger system. The application can combine those paths rather than assigning every request to the same model.

Inference-time reasoning and parallel attempts

Training determines the model’s behavior, while an inference policy determines how much work it performs for a particular request. Additional reasoning, tools, independent attempts, and verification can improve difficult-task success without applying the same cost to every request.

Meta’s Muse Spark report discusses both efficient reasoning and parallel work on difficult tasks.⁵ These address two different parts of the budget: the work within an attempt and the number of attempts available for selection.

Under a simplified independence assumption, if one attempt succeeds with probability p, the chance that at least one of k attempts succeeds is:

1 - (1 - p)^k

With p = 0.4 and k = 4, that is about 87 percent. This describes the opportunity available to a selector. The final result also depends on whether the correct candidate can be recognized, and correlated errors reduce the benefit of additional attempts.

Executable code tests can provide a strong selection signal for some tasks. For factual synthesis, retrieving evidence may contribute more than another answer generated from the same information. The most useful additional computation addresses the source of uncertainty.

Allocation across requests

A serving policy can use a short path for routine tasks and reserve verification or additional attempts for a difficult subset. Its performance includes the quality of the routing decision: sending a hard task to the short path can erase the saving through failure or rework.

Total cost per accepted result captures generation, selection, tools, and retries. Wall-clock time distinguishes serial reasoning from parallel work. These measurements explain whether extra computation produces a useful result within the application’s budget.

The recent developments expand the available design space at each layer. Kernels lower the execution cost, environments improve what agents learn, local models change where tasks can run, and inference policies decide where additional work is valuable. Their shared effect is finer control over the relationship between capability and resources.

References

This architecture explains the different gains seen in prompt processing and token generation. Prefill provides large matrix operations that benefit from more compute. Small-batch decode repeatedly reads weights and attention state, making memory bandwidth a major limit. Memory capacity determines which models and context lengths can be held in the first place.

The M3-to-M6 progression changes all three quantities, but by different amounts. Comparing them separately gives a useful account of local model performance.

GPU accelerators and the Neural Engine

The Neural Engine is a dedicated processor block. The Neural Accelerators introduced in M5 are inside the GPU cores and are reached through the GPU programming path. Apple describes MLX using Metal 4 Tensor Operations and Metal Performance Primitives to use this matrix hardware.¹

An MLX operation dispatched to the GPU therefore remains GPU execution even when those accelerators perform its matrix work. Core ML and other system frameworks provide a separate deployment path whose hardware placement depends on supported operations and runtime decisions.

The distinction also applies to specifications. More Neural Engine compute does not directly imply the same increase in MLX generation speed. The relevant quantities for an MLX workload are the GPU operations it executes, their efficiency on the selected hardware, and the memory traffic supplying them.

Hardware progression

The specifications come from Apple’s M3 announcement, M5 announcement, M5 Pro/Max announcement, and M6/M5 Ultra announcement.² The M6 entry describes the announced base chip in Mac mini.

M5 adds matrix throughput within each GPU core. M6 extends that GPU design to twelve cores and increases base-chip memory bandwidth. M5 Ultra occupies a different capacity class, with a much larger memory pool and higher bandwidth for models that exceed the base chips’ working sets.

These are separate ways to improve a workload. More capacity admits larger models or more live sequences. More bandwidth supplies weights and cache state faster. More matrix throughput accelerates operations with enough arithmetic to use it.

Unified memory and the working set

MLX arrays can be used by CPU and GPU operations without explicit transfers between separate host and device allocations.³ This makes mixed execution straightforward: a GPU operation can produce an array that a CPU operation subsequently consumes in the same memory system.

The shared pool still has finite capacity and bandwidth. Model weights, attention caches, temporary arrays, runtime allocations, and other applications compete for it. A model’s checkpoint size is therefore only one part of its execution footprint.

For a dense model with 8 billion parameters, raw two-byte weights occupy about 16 GB. Four-bit weights have an idealized storage cost of 4 GB. Quantization metadata and tensors retained at higher precision add to that lower bound. The KV cache grows separately with context length and the number of live sequences.

Mixture-of-experts models make the distinction between storage and computation especially visible. Active parameter count describes the experts used for a token. Total parameter count describes the collection of weights that may need to remain resident. A model with 30 billion total parameters and a few billion active parameters has a larger storage requirement than its active count suggests.

Unified memory makes these larger working sets accessible to the GPU, but fitting them remains an explicit allocation problem. Swapping changes the data path and can dominate the benefit of faster arithmetic.

Prefill uses matrix throughput

Prefill processes the input sequence and constructs the attention state used during generation. Many token positions participate in the layer operations, producing matrix workloads with substantial parallelism and reuse.

Apple’s M5 study compares selected Qwen and GPT-OSS models on similarly configured M4 and M5 MacBook Pros. It uses 4,096-token prompts and reports TTFT separately from generation speed.¹ The GPU matrix hardware has a larger effect on prompt processing than on the subsequent token stream.

This phase matters most when a request contains a long document and produces a short answer, or when the application starts a new context frequently. Prefix caching changes the balance by reusing previously computed state. A warm-prefix request can have a much shorter prefill even on unchanged hardware.

A hardware comparison therefore has two meaningful prefill cases: a new context that requires the full computation, and a repeated prefix that allows reuse. They describe different application behavior.

Decode and memory bandwidth

At batch size one, dense-model decoding often spends much of each step supplying weights from memory. A simplified lower bound is the weight bytes read divided by sustained bandwidth.

For an illustrative 4 GB of weight reads per generated token:

at 120 GB/s: 4 / 120 seconds ≈ 33 ms per token
at 150 GB/s: 4 / 150 seconds ≈ 27 ms per token

Those bounds correspond to about 30 and 37.5 tokens/s before attention traffic, dequantization, synchronization, and other work. They describe a bandwidth model, not measured rates for a particular Mac.

Batching changes the arithmetic because a weight read can serve several token positions. Sparse expert activation changes which weights are used. Cache residency and implementation details change the achieved traffic. These effects explain why aggregate throughput and the speed of one interactive stream are different measurements.

Apple’s reported M5 generation improvements range from 19 to 27 percent across its tested models, with the memory-bandwidth increase from 120 to 153 GB/s identified as the main contribution.¹ M6’s 170 GB/s is roughly 11 percent above base M5. A bandwidth-bound workload can benefit from that increase, with its actual gain determined by the rest of the execution path.

Lazy execution and timing

MLX builds computation lazily. Constructing an array expression records work that may execute only when the result is needed. Evaluation boundaries therefore matter when timing an operation.⁴

An array benchmark can measure graph construction, execution, or both. Materializing the result establishes that the computation has completed. Without that boundary, a short elapsed time may describe only the creation of an expression.

Language-model measurements add their own phases: loading the model, first-run initialization, processing the prompt, and generating output. A cold-start experiment includes the first two. A warm serving experiment begins with the model already available. Keeping those intervals separate explains where a change in storage, runtime, or chip affects the result.

MLX LM and reproducible execution

MLX LM supplies model-loading, generation, and quantization workflows on top of MLX.⁵ Its release history also records changes to batching, caching, model support, and generation behavior. The software version is part of a performance configuration alongside the hardware.

An isolated environment and package record can be created with:

uv venv .venv
uv pip install --python .venv/bin/python mlx-lm
uv run --no-project --python .venv/bin/python python -c 'import mlx.core; import mlx_lm'
uv pip freeze --python .venv/bin/python > requirements-benchmark.txt

The model repository and immutable revision identify the weights separately from the Python environment. Quantization, tokenizer, sampling settings, and prompt content complete the configuration. Apple’s M5 research note also specifies macOS 26.2 or later for the accelerator path it describes.¹

This record makes comparisons interpretable. A cache-policy change can lower TTFT on the same machine, while a different quantization can change both memory use and output quality.

Workload-level comparison

A compact experiment matrix covers the main execution regimes:

TTFT, completion time, output count, and peak memory describe each run. Quality establishes whether the configurations perform the same useful task. Power mode, battery state, competing GPU work, and sustained thermal behavior explain variation between repeated runs.

The practical ordering follows the architecture. Capacity determines whether the workload fits. Prefill and decode measurements determine which resource limits it. The runtime determines how effectively the available hardware is used. This is why a larger previous-generation system can be the better fit for one model while a newer base chip is faster on another.

References

Jev, released by TypeSafe in early access on September 15, 2026, makes this the model interface. Application state and typed questions go in; values and probabilities come back. TypeSafe calls this a System One model, borrowing the distinction between fast judgment and extended deliberation to describe the kind of work it is optimized for.¹

This changes how a model fits into a program. A decision can be composed with thresholds, rules, and downstream functions directly, while generation remains available for the parts of the workflow that need language.

State, questions, and return types

A request contains a description of the current state and one or more questions about it. The question defines the answer space. TypeSafe exposes three question types:²

The distinction matters to the caller. A queue selection is categorical. A score depends on the scale and rubric. A probability describes a specified event. These values support different operations even when each can be represented by a number.

A support workflow might be described as follows. This is a conceptual request, with the exact API representation defined in the documentation.

State:
    Customer reports a failed payment and a duplicate charge.
    Account history and the relevant support policy are attached.

Questions:
    route: choose [billing, fraud, technical]
    urgent: probability that the ticket requires a response within one hour
    refund_risk: score against the supplied refund-risk rubric

The application can send the ticket to billing, raise its priority, and request a human review independently. A generative model can then draft the response using those decisions and the same underlying evidence. Routing and writing have separate outputs and can be improved separately.

Parallel decisions within a request

TypeSafe describes the questions in a request as evaluated in parallel against the same state. Its launch reports end-to-end service latency of 70 to 500 ms and a training method called Reinforcement Learning for Calibrated Decisions.¹ The intended workload is a collection of bounded judgments that would otherwise be expressed through generated text.

This is useful for decisions on a frequently executed path. A tool router runs before the selected tool. A moderation decision runs before content is accepted. A retrieval filter runs before a larger model reads the remaining candidates. Latency at these boundaries is paid repeatedly, so reducing the work between state and decision can improve the whole interaction.

Parallel evaluation also makes decomposition useful. A support policy may depend on urgency, customer status, and the likelihood of a duplicate charge. Each can be a separate question, with application code combining the results. A policy change can then alter the combination without changing the definition of every individual judgment.

The joint probability still requires care. Knowing the probability of “urgent” and the probability of “billing” does not determine the probability of “urgent and billing.” Multiplying the two assumes independence. Where the joint event drives the action, it needs an explicit definition and evaluation.

Type safety, accuracy, and calibration

Three properties determine whether a returned decision is useful.

Type safety means the value belongs to the declared output space. A Choice answer selects from the available options. A numeric answer satisfies its representation constraints. The application receives a value it can process.

Accuracy concerns the judgment itself. A valid queue name may still be the wrong destination for the ticket.

Calibration concerns the relationship between probabilities and observed outcomes. Among cases assigned probability 0.8, the event should occur about 80 percent of the time over the relevant population. Calibration research treats this separately from classification accuracy.³

The definitions of the questions establish what can be measured. “Urgent” could mean a safety incident, an unhappy customer, or a response due within an hour. A labeling guide turns that ambiguity into a repeatable target. Cases with missing information can have their own outcome rather than being forced into a confident label.

Score has a similar dependency on its rubric. A risk score of 0.8 is not necessarily an 80 percent probability of a future loss. The application needs to preserve the meaning of the returned quantity when it uses it in a formula or threshold.

From probability to action

The threshold for taking an action follows from the relative costs of its errors. Consider a simplified moderation policy. Let p be a calibrated probability that a submission violates a rule. Assign a cost of 100 units to allowing a violation and 2 units to blocking a valid submission.

The expected losses are:

allow: 100 × p
block:   2 × (1 - p)

Blocking has lower expected loss when p exceeds 2/102, approximately 0.0196. The low threshold follows from the large cost assigned to a missed violation. The numbers are illustrative; the calculation shows how a policy threshold can be derived from consequences.

Human review introduces a third action. If perfect review costs 0.5 units, it is cheaper than allowing once p exceeds 0.005, and cheaper than blocking while p remains below 0.75. Under those assumptions, the middle range goes to review. Reviewer error, delay, and limited capacity extend the model with additional costs.

This separation gives the application a useful control point. The model estimates the event; the policy decides what to do about it. A change in review capacity or error cost can move the threshold without changing the question sent to the model.

Deterministic conditions fit naturally before or after that step. Missing required fields can route directly to review. A known duplicate can follow a fixed rule. The decision model handles the cases where the state requires judgment.

Measuring calibration

For binary outcomes, the Brier score averages the squared difference between each predicted probability and its observed zero-or-one label. A reliability plot groups predictions and compares the average probability with the observed event frequency.³

For example, suppose 100 held-out tickets receive probabilities between 0.75 and 0.85, averaging 0.80. If 58 are urgent under the labeling guide, the predictions are overconfident in that group. If 82 are urgent, the observed frequency is closer to the prediction, with uncertainty from the finite sample.

Breaking the result down by language, ticket length, and customer type identifies where the estimate transfers well. A model may be calibrated on common English requests while systematically overestimating urgency for another segment. Time-based holdouts are useful when policies and incoming traffic change, because near-duplicate conversations can otherwise appear on both sides of a random split.

Base rates provide another reference point. If only 1 percent of submissions violate a rule, a model that always predicts 0.01 may have a low aggregate error while offering little ranking value. Precision, recall, review volume, and expected cost at the chosen threshold describe what the application gains from the model.

The application path

The model call is one stage in a larger request. Input preparation, network transport, policy execution, and any fallback all contribute to completion time. An application-level outline is:

load policy and question definitions
validate the required state
request typed decisions within the remaining deadline

if the request completes:
    combine decisions with deterministic rules
    choose the action under the current policy
else:
    use the fallback queue

record the model, policy, probabilities, and action

The record makes the result reproducible. A later change in queue assignment can be traced to the model, question definition, threshold, or input. Retaining only the final label loses that distinction.

Deadlines connect this design to the rest of the system. A synchronous call inside a 300 ms interaction has a different budget from an asynchronous queue processor. Retries and review also contribute to total cost per completed workflow, even when the initial decision call is inexpensive.

Where the interface is useful

A bounded decision model fits applications with repeated judgments and explicit outcomes: classification, routing, ranking, scoring, and branching. A text model fits explanation, writing, code, and synthesis. Rules remain efficient for conditions that can be specified exactly.

Comparisons become clearer at that workflow boundary. Decision quality, calibration, schema failures, latency, timeout rate, and review cost can be measured on the same cases. TypeSafe’s published workflow evaluation uses reference-model probabilities for parts of its comparison; independently labeled application outcomes answer a separate question about correctness.¹

The architectural value is composability. A probability can feed a threshold, a Choice can select a function, and a score can order a queue. Giving these judgments explicit types and measurable outcomes makes them ordinary components of software, with the same scope for testing and improvement as the code around them.

References

The leverage comes from feedback. A trace identifies where time goes; a correctness check constrains the implementation; a benchmark determines whether the candidate improved the path. Each result gives the next iteration more information than the original description of the problem.

Anthropic’s account of its claude.ai performance work describes this approach across user journeys and local benchmarks.¹ The method applies more broadly because the essential components are ordinary profiling, experimentation, and software review.

The optimization objective

A useful objective begins and ends with observable application behavior. Opening a project may begin with a click and end when its records are rendered and search accepts input. Sending a message may end when the interface displays the submitted message and is ready for the next action.

These boundaries determine which work is part of the problem. A spinner marks progress, but it does not establish that the requested content is usable. Receiving a response establishes network completion, while parsing and rendering may still be on the critical path.

A concrete task definition can be expressed as:

Journey: open a project containing 10,000 records.
Start: the user activates its link.
End: visible records are rendered and search accepts input.
Behavior: preserve ordering, selection, navigation, and result counts.
Objective: reduce p95 duration within a defined memory budget.
Evidence: profiles, raw timing samples, checks, and the implementation diff.

The fixture and behavior define the work being optimized. Keeping them stable allows a sequence of candidate implementations to be compared against the same task. A correction to the benchmark itself is a separate change, with its own explanation.

The profile connects a symptom to a mechanism

Elapsed time contains both execution and waiting. CPU sampling identifies active functions. A timeline reveals sequential requests, scheduling gaps, and blocked work. Resource measurements show whether the execution is limited by CPU, memory, storage, or another service.

Brendan Gregg’s USE method organizes resource investigation around utilization, saturation, and errors.² The distinction is useful here: an idle CPU waiting on storage presents a different optimization problem from a saturated CPU repeatedly parsing the same input.

Suppose a 500 ms operation spends 300 ms parsing, 150 ms waiting for data, and 50 ms rendering. Making parsing twice as fast reduces completion time to 350 ms, a 1.43x speedup. Eliminating all rendering work would save at most 50 ms. The phase breakdown provides an upper bound on the value of each candidate.

A measured mechanism then gives the agent a tractable task. Building an index once can replace repeated scans. Reusing a parsed representation can remove repeated decoding. Overlapping independent requests can reduce serial wait. Each proposal identifies both the work removed and the condition under which that saving should appear.

The experiment loop

reproduce the path
    -> profile its execution
    -> propose a change tied to the profile
    -> run behavioral checks
    -> repeat the benchmark
    -> inspect the result and implementation
    -> retain or revert the candidate

Small changes make this loop informative. When one candidate changes parsing, caching, and scheduling together, a gain or regression is harder to attribute. A sequence of focused changes produces an explanation for each improvement and makes later regressions easier to locate.

A useful experiment record includes failed candidates as well as successful ones:

The record preserves information about the workload. A rejected candidate may become useful at another scale, while its failure explains why it was unsuitable for the current path.

Measuring a browser journey

Browser User Timing marks provide application-defined start and end events.³ They make it possible to measure a particular interaction rather than treating all page activity as one load metric.

The end event depends on the result. Data arrival, DOM update, layout, and paint are distinct stages. An input can appear before its event handling is ready, and a framework can finish a render before the browser displays the frame. The timing boundary should correspond to the application behavior being studied.

Browser traces complement the interval with an explanation. Long tasks identify stretches where input handling competes with other main-thread work. Layout and style recalculation show how a small data update can trigger a large amount of rendering work. Network timing identifies resources that are discovered late or requested serially.

The same principle applies outside a browser. A CLI’s start-to-exit duration includes process and module initialization. A database request includes query execution and result transfer. A model request includes queueing and output generation. The boundary follows the task.

Stable proxies for a fast inner loop

Wall-clock measurements include variation from scheduling, caches, and shared resources. Counts of instructions, allocations, queries, or rendering operations can provide more stable feedback for a narrow path.

Anthropic’s article describes using local metrics and checking that improvements in those metrics translated into elapsed-time gains.¹ The connection is what makes a proxy useful. Fewer instructions may still leave a memory bottleneck unchanged. Fewer queries may transfer more data. Fewer DOM mutations may require a larger replacement operation.

A proxy therefore has two roles. It gives the agent a low-noise measure while exploring, and it can become a regression check after its relationship to the user journey is established. Wall-clock and field measurements remain the connection back to the application.

Experimental variation

Warmup, caching, thermal behavior, and background load affect the comparison. Alternating baseline and candidate runs reduces the chance that a changing environment consistently favors one version. A steady-state benchmark warms the relevant JIT and caches; a cold-start benchmark measures those costs explicitly.

Individual samples preserve the shape of the result. A median describes typical behavior, while the tail exposes occasional expensive paths. A p95 estimated from twenty runs depends on roughly the slowest one or two observations, so its stability is different from a percentile estimated from thousands of requests.

Input variation is equally important. A parser improvement can depend on text encoding. A lookup improvement can depend on collection size. A cache can perform well until updates invalidate it. A second fixture with different size or structure shows whether the mechanism extends beyond the case used during optimization.

For UI changes, behavior includes keyboard navigation, selection, scroll position, and the next interaction. Deferring work can improve opening time while moving the delay to the first keystroke. Measuring the adjacent action reveals that transfer.

Different workloads expose different levers

The objective leaves room for the implementation to change. A request to reduce opening time can lead to an algorithmic improvement, a cache, or a better schedule. Prescribing memoization in advance narrows the search before the profile has identified the expensive work.

Correctness checks define the allowable search space. Exact CLI output, query results, model-quality criteria, and browser interactions each establish what the faster implementation must continue to do.

Load and tail latency

An isolated request measures service cost under little contention. A deployed service also has queues. Reducing service time can improve both the request itself and the waiting time of subsequent requests. Shared caches, larger batches, and additional concurrency can change that relationship.

The Tail at Scale describes why occasional delays become significant in large services.⁴ A request that depends on many components can inherit the slowest of them, making tail behavior a system-level property.

Arrival-rate experiments expose this effect. Error rates and rejected requests remain part of the result, since dropping slow work can otherwise look like a latency improvement. For interactive software, slower devices reveal contention that may be almost invisible on a development machine.

From a local result to a maintained improvement

A release connects the experiment to field behavior. Comparing the same journey by build, device class, and cache state shows where the gain appears. A mismatch between local and field results identifies a difference in workload or critical path that the next experiment can address.

Once a metric is stable and correlated with the application, it can protect the improvement in CI. The threshold represents an observed property of the implementation, with enough tolerance for the measurement method. The profile and experiment record explain the reason for the threshold.

The agent’s contribution is the speed of the loop: more candidate explanations can be investigated, implemented, and measured. The quality of the outcome comes from the objective and the feedback. Together they turn a vague report of slowness into a set of specific, maintainable changes.

References

Separating these phases turns optimization into a sequence of measurable decisions. The workload determines the objective, the profile identifies the limiting resource, and a configuration sweep finds the operating point. The result is a latency and capacity curve for the actual service.

Latency accounting

A generated response has an initial wait followed by a sequence of token arrivals. For N output tokens:

end-to-end latency = TTFT + sum of the remaining inter-token gaps
mean TPOT = (completion time - first-token time) / (N - 1)

Time to first token, or TTFT, includes queueing, prompt processing, and transport when measured at the client. Time per output token, or TPOT, describes the generation phase. A one-token response has no subsequent token gap, so TPOT is undefined under this formulation.

The arithmetic identifies where a change pays off. A request with 400 ms TTFT and 199 gaps averaging 25 ms takes 5.375 seconds. Halving TTFT saves 200 ms. Reducing each gap by 5 ms saves 995 ms. A one-token classification request has the opposite allocation: nearly all its latency is in the path to the first token.

For agents, this accounting extends across calls. Ten sequential model steps accumulate ten queue waits and ten prefills, as well as tool execution. Per-call improvements matter in proportion to their contribution to the trajectory.

Workload shape selects the optimization

The same model can occupy several rows depending on the application. A document assistant and an autocomplete service may share weights while needing different replica configurations. Prompt and output length distributions, arrival rates, and shared-prefix structure define the workload more precisely than the model name.

Quantization reduces the bytes used for weights and can reduce memory traffic. Its effect on completed work also depends on output quality and response length. A faster token stream that requires more retries may consume more total resources per successful request.

Prefix caching removes repeated prefill

An attention cache records state for the preceding tokens. When another request begins with the same token prefix, that state can be reused. Automatic prefix caching therefore saves computation on shared instructions, documents, or earlier conversation turns.¹

The position of changing content matters. A request-specific timestamp near the beginning breaks the shared prefix before the reusable document. Placing stable instructions and common context first exposes a larger reusable region where the application semantics allow it.

The saving applies to repeated prefill. Every newly generated token still requires decode work. A service dominated by long outputs therefore sees a different gain from a service repeatedly asking short questions about the same long document.

Cache residency connects reuse to capacity. Frequently reused blocks are valuable only while they remain available. A workload with many unrelated long prefixes can evict them, so hit rate depends on the traffic mix and memory budget as well as prompt construction.

Paged storage increases useful cache capacity

The KV cache grows as a sequence generates tokens and shrinks when the request completes. Reserving contiguous space for the maximum possible length wastes memory and makes sharing difficult. PagedAttention addresses this with logical blocks mapped to physical cache storage.²

The block table lets a sequence grow without a single large contiguous allocation. Shared prefixes can refer to the same physical blocks, while later tokens occupy separate blocks. This increases the number of live sequences that fit in a fixed memory budget.

For a conventional full-attention decoder, approximate cache storage is:

KV bytes = 2 × layers × cached tokens
             × KV heads × head dimension × bytes per element

The factor of two accounts for keys and values. Grouped-query attention uses the number of KV heads in this expression, rather than the larger number of query heads. Sliding-window and compressed-cache architectures change the storage model.

For 32 layers, 8 KV heads, head dimension 128, and two-byte elements, each cached token occupies 128 KiB. An 8,192-token sequence needs 1 GiB, and sixteen such sequences need about 16 GiB before weights, temporary buffers, and allocation overhead. Weight quantization and cache quantization are separate choices.

This is why cache management can improve throughput without changing the speed of an individual matrix multiplication. More of the memory holds active work, so more sequences can share the cost of reading weights.

Chunked prefill controls interference

A long prefill and a one-token decode step have different execution shapes. Running the entire prefill at once can delay requests that are already streaming. Chunking divides the prompt into smaller scheduling units so the engine can interleave the two kinds of work.

SARATHI develops this combination of chunked prefills and decode work.³ The chunk size controls the tradeoff. Larger chunks give prompt processing more work per scheduling step. Smaller chunks give ongoing decodes more frequent opportunities to run.

The scheduler’s token budget links TTFT, TPOT, and throughput. A configuration that finishes one large prompt sooner may lengthen the token gaps of every other request. vLLM’s tuning documentation describes the corresponding scheduling and memory controls.⁴ Their useful values depend on the distribution of prompt lengths and the service objective.

Speculation changes the amount of work per target call

Speculative decoding uses a cheaper model to propose several tokens, then has the target model verify them together. Exact speculative sampling includes a correction procedure that preserves the target distribution within numerical limits.⁵

Its gain comes from completing several accepted tokens during a verification pass whose cost is lower than producing those tokens through separate target calls. The draft model adds work, so acceptance rate and draft latency jointly determine the result.

A small draft with moderate acceptance can outperform a larger, more accurate draft if it is substantially cheaper. Longer proposals can increase accepted tokens per pass while also increasing wasted work after rejection. The useful measurements are draft time, verification time, accepted tokens, and end-to-end generation time.

Speculation is especially attractive when the target has spare parallel compute during small-batch decoding. At high utilization, the additional work can interact differently with batching. It belongs in a workload-specific sweep alongside the other serving parameters.

Goodput identifies the operating point

Throughput counts completed work. Goodput counts work that meets the service’s latency and quality requirements. As offered load increases, throughput can continue rising after deadline attainment has begun to fall. The inference SLO guide develops this distinction in more detail.

Consider an illustrative comparison at a fixed arrival rate with a 700 ms TTFT limit:

B has the highest throughput. C delivers the most requests within the stated limits. The objective therefore selects C, subject to the same quality and cost requirements applied to the other configurations.

Client-side timestamps also expose buffering and streaming stalls. Mean TPOT can be acceptable while a response contains a long pause, so the distribution of token gaps complements request-level latency.

Capacity and arrival-rate experiments

A closed-loop generator maintains a fixed number of outstanding requests, replacing each as it completes. It measures throughput and latency at that concurrency. An open-loop generator schedules arrivals independently of completions, revealing how a queue grows when demand continues during a slowdown.

Both experiments are useful. A concurrency sweep locates capacity and saturation; an arrival-rate sweep establishes deadline attainment under production-shaped demand. Cold caches, repeated prefixes, bursts, and mixed prompt lengths exercise different parts of the system.

The request record contains arrival time, first-token time, completion time, token counts, cache status, and errors. Failed and rejected requests remain part of the offered workload. This keeps apparent latency gains from being confused with dropping difficult work.

Communication in a distributed replica

Splitting a model across GPUs reduces local matrix work while adding transfers. Tensor parallelism introduces collectives around partitioned layers; expert parallelism introduces token dispatch and combination. The exposed part of that communication determines the gain from another device.

A larger parallel group that saves 20 ms of compute and adds 30 ms of communication increases latency. Placement, transfer size, and overlap therefore belong in the same experiment as batch size and cache allocation. The ParallelKittens article examines those boundaries at the kernel level.

An inference configuration is a balance among these resources. Phase-level measurements explain why a change works, while goodput identifies where that change becomes useful capacity for the application.

References

ParallelKittens approaches this as a kernel-design problem. It extends ThunderKittens with reusable primitives for combining computation and communication, so data movement can be scheduled alongside the operations that produce and consume it.¹ The useful target is exposed communication: the portion of transfer time that remains on the critical path after overlap.

Communication follows the partition

The parallelism strategy determines what moves between devices.

Tensor parallelism partitions operations within a layer. Devices compute partial results and use collectives to combine or redistribute them. These boundaries can occur repeatedly during every generated token.

Expert parallelism places different experts on different devices. Tokens travel to the selected experts, then their outputs return for combination. The traffic depends on routing decisions as well as batch size.

Pipeline parallelism assigns consecutive stages to different devices. Activations move between stages, and the schedule determines whether a stage has useful work while it waits for the next microbatch.

Distributed attention partitions sequence or attention state. The kernel exchanges the shards needed to form the output, with communication shaped by the chosen attention algorithm.

These patterns create different opportunities. A regular reduction has a different schedule from a variable-sized exchange of expert tokens. The relevant network workload is the sequence of these operations, including their dependencies and sizes.

Collective operations

An all-reduce combines values across participants and returns the reduced result to each. An all-gather assembles distributed shards into a complete result on every participant. Reduce-scatter combines reduction with partitioned output. NCCL specifies these semantics independently of the algorithms used to execute them.²

The distinction is useful when reading a model trace:

The runtime selects a particular implementation for each boundary. That selection establishes the actual number of stages, temporary buffers, and synchronization points. The same high-level model can therefore produce different communication behavior under different serving engines.

Latency and bandwidth regimes

A first-order transfer model separates startup latency from transmission time:

transfer time ≈ startup latency + message bytes / effective bandwidth

Effective bandwidth is the rate achieved on the path being used. Collective algorithms add stages, and topology changes which links carry the traffic, but the model already explains why small and large transfers favor different optimizations.

For an illustrative 4 microsecond startup and 100 GB/s effective bandwidth, transmitting 4 KiB takes about 0.041 microseconds. Nearly all the elapsed time is startup. A 64 MiB transfer takes about 671 microseconds for transmission, so bandwidth dominates instead.

Doubling bandwidth barely changes the small-message case. Reducing launch overhead or combining messages can improve it substantially. Large transfers benefit more directly from higher sustained bandwidth and avoiding redundant copies.

Message fusion introduces a scheduling tradeoff. Combining several small transfers amortizes startup, but the combined transfer waits until its inputs are ready. If one result is available much earlier than the others, fusion can delay its consumer. The useful grouping follows readiness and dependencies as well as byte count.

The physical path

Within a server, communication may use PCIe or a dedicated GPU interconnect such as NVLink. Across servers, the path includes network adapters and a fabric such as InfiniBand or Ethernet with RDMA. Placement determines how often the execution crosses each boundary.

A frequently executed collective benefits from keeping its participants on a fast local path. A larger model may require crossing a slower boundary to fit, in which case the partition plan determines how much traffic pays that cost. Capacity and communication are coupled decisions.

RDMA can remove host-side copies from the transfer path. It does not remove queueing in the fabric, oversubscribed links, or uneven traffic among destinations. Those effects appear in the tail of distributed execution, especially when every participant waits for the slowest result.

Compute-communication overlap

For a serial stage, elapsed time is compute time plus communication time. With independent work and sufficient resources, the two can overlap:

serial stage:        T = compute + communication
ideal overlap:       T = max(compute, communication)
exposed communication = time remaining on the critical path

A stage with 6 ms of compute and 4 ms of communication takes 10 ms serially and 6 ms under ideal overlap, a 1.67x stage speedup. The bound assumes the transfer does not slow the computation through shared resource contention.

Its application-level effect depends on the fraction of total time in that stage. If it occupies 20 percent of request time, the idealized normalized total becomes approximately 0.8 + 0.2/1.67 = 0.92. That is about a 1.09x request speedup.

Tiling creates finer dependencies. A consumer may begin once the first tile arrives rather than waiting for the entire tensor. The producer, transfer, and consumer can then form a pipeline. Tile size controls reuse, synchronization frequency, and the amount of work exposed for overlap.

The pipeline also needs explicit ownership. A buffer cannot be overwritten while another device is still reading it, and a consumer must observe the producer’s completed writes before using the tile. Synchronization is part of the algorithm, with both a correctness cost and a scheduling cost.

The ParallelKittens template

ParallelKittens organizes kernels around loader, storer, consumer, and communicator roles. Loaders and storers move tiles, consumers perform computation, and communicators handle inter-GPU work. Its primitives and template encode recurring scheduling patterns across multi-GPU kernels.¹

This makes transfer mechanism and resource assignment visible design choices. Copy-engine transfers and thread-level peer operations have different overheads. Dedicated communication resources can make progress independently, while using those resources also changes what remains available to computation.

The paper evaluates Hopper and Blackwell workloads and reports maxima of 2.33x for data- and tensor-parallel workloads, 4.08x for sequence-parallel workloads, and 1.22x for expert-parallel workloads.¹ These results describe the tested kernels and baselines. Their significance is that a reusable design can capture gains across several communication patterns rather than requiring an unrelated implementation for every operator.

Reading a distributed trace

Nsight Systems separates CPU overhead, launch latency, and GPU execution time.³ Across multiple devices, those timelines explain whether a gap comes from delayed submission, a dependency, or data movement.

A collective that appears slow on most ranks can be waiting for one late participant. If seven GPUs arrive at the boundary early and the eighth finishes its preceding work late, the apparent collective duration includes that skew. The cause may be expert imbalance, input preparation, or a competing workload on the late device.

A trace therefore connects three intervals: production of the input, execution of the transfer, and the point where the consumer resumes. Communication that overlaps successfully may occupy a large interval without extending the critical path. A short transfer immediately before a dependent operation may matter more.

The shape sweep includes small and large messages, prefill and decode batches, and representative sequence lengths. Packing, unpacking, barriers, and launch overhead belong in the measured operation because they are part of moving a usable tensor to its consumer.

Kernel and system validation

A reference implementation establishes the expected output, with numerical tolerances appropriate to the operation. Partial tiles, changing rank counts, irregular expert assignments, and repeated execution exercise the boundaries most likely to expose ordering errors.

The performance comparison has two levels. A kernel benchmark measures whether the transfer and computation schedule improved. A serving benchmark measures whether that improvement reduces request latency, increases capacity, or lowers cost at the same output quality.

Custom fused kernels are most useful when the operation repeats often, accounts for a substantial share of runtime, and has a manageable shape space. A mature collective implementation remains a valuable baseline and fallback as model layouts and hardware change.

The connection between networking and kernel design is direct: the partition decides which data moves, the topology decides its path, and the schedule decides how much of the movement is visible to the next operation. Improving any of those can turn idle accelerator time into useful computation.

References

Paul Erdős asked how fast $u(n)$ grows in 1946.¹ The question needs no background to state and no notation beyond a ruler. It has been open ever since.

On 20 May 2026 OpenAI published a proof, produced by an internal reasoning model, that Erdős’s own answer to the question was wrong.² The result is real and the mathematics is now checked several ways over, including by a nine-person panel of specialists within a day of the announcement.

The problem is easy to state and hard for a specific reason

Distance is a rigid constraint. Fix two points at distance 1; the set of points at distance 1 from both is at most two points. So unit distances cannot pile up locally the way, say, collinearity can. Any configuration with many unit distances has to distribute the coincidences globally, across the whole point set, and that is where the difficulty lives.

Erdős’s own construction is the $\sqrt{n}\times \sqrt{n}$ integer grid, rescaled so that many integer pairs $(a,b)$ share the same value of $a^2+b^2$. The number of such representations grows, but only barely, and the resulting count is

for a constant $c>0$.¹ The exponent exceeds 1 but tends to 1 as $n$ grows. In eighty years nobody improved on it.

Two bounds moving toward each other, slowly

There are two separate questions, and conflating them is the most common error in coverage of this result.

The upper bound question asks what a proof forbids. Erdős gave $O(n^{3\mathrm{/}2})$. Spencer, Szemerédi and Trotter brought it to $O(n^{4\mathrm{/}3})$ in 1984, and that has stood for forty-two years.³

The lower bound question asks what a construction achieves. That is the grid bound above.

Erdős conjectured that the truth was at the bottom: that $u(n)=n^{1+o(1)}$, that the grid was essentially optimal, and that the $O(n^{4\mathrm{/}3})$ upper bound was the artefact. Nearly all subsequent effort went into pushing the upper bound down toward the grid, because that is where the answer was assumed to be.

The May 2026 result moved the lower bound. It exhibits an infinite family of point sets with

for an absolute constant $\delta >0$ and infinitely many $n$.² Since $\delta$ is fixed rather than shrinking with $n$, this contradicts $n^{1+o(1)}$ directly. The conjecture is false. The upper bound was not improved, and the gap between the two bounds is now wider than it was before, in the sense that the plausible location of the answer has expanded rather than contracted.

Reporting that described this as “solving” the unit distance problem inverted what happened. The problem is more open than it was on 19 May.

What the model produced

The construction does not come from discrete geometry. It comes from algebraic number theory.

The route, as reconstructed by the mathematicians who read it, is to build number fields of large degree with small discriminant and many primes of small norm, and to extract a point configuration from the resulting lattice. The tool for producing such fields is the Golod–Shafarevich criterion, which guarantees that certain class field towers are infinite. The nine-author companion note attributes the essential ideas, in retrospect, to Golod–Shafarevich, to Hajir–Maire–Ramakrishna, and to Ellenberg–Venkatesh.⁴

This is the interesting part of the story. Golod–Shafarevich towers were developed in the 1960s to answer a question about class field towers that has nothing to do with points in a plane. Using them to build unit-distance configurations requires knowing both bodies of work well enough to see that one supplies what the other needs, and then being willing to grind through a long calculation whose payoff is uncertain.

Jacob Tsimerman, one of the verifiers, has said publicly that he had considered a strategy of this shape and abandoned it, because such techniques consume a great deal of time and frequently do not work.⁵ That is a precise description of where the model had an advantage: not insight, but breadth of recall plus indifference to sunk cost.

Scott Aaronson, who reported the account of the run from Lijie Chen, described it as essentially one-shot: the problem was handed over, the model thought, and it emitted a several-page argument that held up under expert analysis.⁶ Separately, OpenAI has indicated the model solved the problem roughly half the time at maximum token budget, which means the single successful run was drawn from a distribution that also contains failures.⁵

How it was checked

The verification chain is unusually well documented, and worth walking through because it is the part that generalises.

Four things happened, in order.

The nine-author note by Alon, Bloom, Gowers, Litt, Sawin, Shankar, Tsimerman, Wang and Matchett Wood appeared the same day, presenting “a short, digested, human-verified version” of the argument along with reflections on it.⁴ That is a nine-person panel of specialists assembled in under a day.

Will Sawin, independently and also on 20 May, posted a preprint making the exponent explicit: there are point sets with more than $n^{1.014}$ unit distances, via the same Golod–Shafarevich route.⁷ The frequently quoted figure of $\delta \approx 0.014$ is Sawin’s, not the model’s. The model’s $\delta$ was inexplicit.

Explicit certificate optimisation followed. Work in June searching over prime sets pushed the achievable $\delta$ past $0.015$ and then above $0.03$, with contemporaneous MathOverflow discussion reporting better still.⁸ These are engineering improvements on a fixed method, not new ideas.

Formalisation came last. On 26 June, Logical Intelligence reported a Lean 4 proof produced by their Aleph Prover system: roughly 33,000 lines across 252 Mathlib modules, re-checked with two independent Lean kernels.⁹ It is conditional. The Golod–Shafarevich inequality and Shafarevich’s rank-relation bound are not in Mathlib and were taken as axioms, with mathematicians confirming the statements matched textbook references. The process involved a human review pass between two prover iterations. So the answer to “was it formalised” is yes, a month later, by a different group, modulo two classical inputs.

Separating this from adjacent episodes

Three distinct things have been called “AI solves an Erdős problem” in the past year, and they are not the same kind of event.

Erdős Problem #728, resolved in January 2026, is the cleanest formal case: GPT-5.2 Pro generated an argument, Harmonic’s Aristotle formalised it in Lean, and the Lean proof was translated back into readable mathematics for arXiv.¹⁰ The result concerns a logarithmic-gap phenomenon in factorial divisibility. It is new, fully machine-checked, and far less famous than the unit distance problem.

The Erdős problems database episodes of late 2025 were something else again. Models were credited with resolving open problems when what they had actually done was locate an existing proof in the literature that the database’s maintainers had not indexed. That is a useful capability and not a mathematical discovery.

The unit distance result is a third category: a new construction in a famous problem, produced informally, refereed by humans first and formalised later. It has the highest mathematical stakes and the weakest a-priori verification guarantee of the three.

Questions worth keeping in view

Several critiques were raised in May and June. Some hold up.

Selection effects are unmeasured. OpenAI has not published failure rates, attempt counts, or compute. A model that produces one correct famous-problem proof out of some unreported number of attempts across some unreported number of problems is a different object from one that produces correct proofs reliably, and the public record does not distinguish them.¹¹ Aaronson makes the same point about problem selection: human effort concentrated on proving Erdős right, leaving the counterexample direction comparatively unexplored.⁶

Verification capacity is the bottleneck, not generation. Thomas Bloom’s formulation is the sharp one: “It could be right. It could be nonsense. Who’s going to be able to check this?”¹¹ The unit distance proof got nine of the world’s relevant experts within a day because it was a famous problem announced by a major lab. That does not scale. A hundred such claims a month would exhaust the referee pool for exactly the problems where refereeing matters most.

Attribution has no mechanism. Melanie Matchett Wood’s observation is that a model has read every paper, and there is no principled way for it to credit the prior work it is drawing on.¹¹ The nine-author note had to reconstruct the intellectual ancestry after the fact.

The institutional response was immediate. The Leiden Declaration, published 2 June 2026, called for oversight of AI in mathematical research and had gathered around 1,590 signatures within three days.¹¹ A July essay by Jun-Yong Park argues the deeper risk is that human capacity to verify, interpret and challenge research-level mathematics is itself eroding, and proposes that AI systems be required to present decision-critical claims in machine-checkable form.¹² Whatever one makes of the framing, the proposal is concrete: formalisation converts the verification bottleneck from a scarce-expert problem into a compute problem.

The critiques that do not hold up are the ones asserting the mathematics is wrong or trivial. Gowers said that if a human had submitted this to the Annals, he would have recommended acceptance without hesitation.¹³ Litt called it the first autonomously produced AI result he found interesting in itself.¹³ Matchett Wood, one of the sceptics on the broader questions, called it a beautiful piece of mathematics.¹¹

What this does and does not predict

The honest reading is narrow and still significant.

The task had properties that favour a model: a crisply stated target, a verifiable output, a cross-field connection requiring recall across two literatures that few individuals hold simultaneously, and a long unpleasant computation that a human would rationally decline to start. Not every open problem has this shape. Most do not.

But the shape is not rare either, and it was not previously thought to be reachable. Cross-domain technique transfer is a large fraction of what mathematical progress consists of, and it is exactly the part that scales with breadth of reading rather than depth of a single specialism.

Three things follow for anyone building or evaluating these systems.

Reported successes without denominators are not evidence about capability. Publish attempt counts and failure modes, or expect the result to be discounted.

Formalisation is the only verification method that scales with output volume. It arrived a month late here, incomplete, from a third party. Treating it as the default deliverable rather than a follow-up changes the economics of the whole pipeline.

And the useful unit of analysis is not “the model solved it” but the full chain: generation, human digestion, independent refinement, formalisation. Every stage in that chain did work that the others could not have done. The construction came from a model. The explicit exponent came from Sawin. The confidence came from nine people reading carefully. The audit trail came from Lean. Reporting that collapses this into a single claim about autonomy describes something that did not occur.

References

Both chapters answer questions that Erdős posed and, in two cases, attached prize money to. Neither answer is a small improvement to a constant. The Ramsey chapter closes a gap between an exponential lower bound and a factorial upper bound that had stood since the 1950s. The extremal chapter produces explicit graphs that falsify two conjectures about how extremal numbers should behave.

The multicolour Ramsey function

Write $R_k(3)$ for the least $N$ such that every colouring of the edges of the complete graph $K_N$ with $k$ colours contains a monochromatic triangle. For $k=2$ the answer is 6: the edges of $K_5$ split into an outer pentagon and an inner pentagram, each a five-cycle and therefore triangle-free, while no two-colouring of $K_6$ escapes.

The pigeonhole argument behind $K_6$ generalises. Pick a vertex, look at its $N-1$ edges, and note that some colour appears on at least $(N-1)\mathrm{/}k$ of them. If that neighbourhood contains an edge of the same colour you have a triangle; otherwise you have reduced to a $(k-1)$-colour problem on a smaller vertex set. Iterating the recurrence gives the Erdős–Szekeres-style bound, which after successive refinements stands at

Factorial growth. Written in the form $R_k(3)=k^{\theta k}$, this says $\theta \to 1$.

Lower bounds worked from the other side, by exhibiting triangle-free colourings. The standard tool is a product construction: a triangle-free $k$-colouring on $N_1$ vertices and a triangle-free $\mathrm{\ell }$-colouring on $N_2$ vertices combine into a triangle-free $(k+\mathrm{\ell })$-colouring on $N_1{N}_2$ vertices, so

Tensoring a good small colouring with itself is efficient, but it is inherently exponential: the best you can extract is $c^k$ for whatever base $c$ your seed colouring supplies. Decades of work on sum-free partitions and hand-found colourings pushed that base up, ending at $R_k(3)\ge {380}^{k\mathrm{/}5}-O(1)$.

The gap was not a constant factor

An exponential lower bound against a factorial upper bound is a widening gap, not a stubborn constant. Fekete’s lemma applied to the product construction shows the limit

exists in $[1,\mathrm{\infty }]$, and the open question was whether it is finite at all. Erdős offered $250 for the value of $L$ and $100 for deciding whether it is finite. Graham, Rothschild and Spencer recorded the superexponential growth question in their textbook; Conlon, Fox and Sudakov flagged the exponential-versus-factorial gap again in their survey.²

Plotting the exponent $\theta$ makes the shape of the gap visible. The old lower bound’s exponent decays like $1\mathrm{/}\log k$, so it certified nothing at all in the limit.

Chapter 9 proves the following.

Combined with the factorial upper bound this gives

and in particular $L=+\mathrm{\infty }$. The growth rate is now pinned to within a constant factor in the exponent’s exponent, which is the coarse question that had been open. The exact constant, whether $\theta$ is $1\mathrm{/}3$, $1$, or something between, remains open.

How the colouring is built

The construction is recursive and its invariant is stronger than triangle-freeness: at stage $j$, each colour class is required to be properly $(j+1)$-colourable as a graph.

Vertices are grouped into blocks. Each block carries a palette $P$, a subset of the available colours, recording exactly which colours are missing from that block; the rest are active there. Inside a block sits a relabelled copy of the previous stage’s colouring, using only the active colours, so every active colour arrives with a proper vertex labelling.

The work is in colouring edges between two blocks. Because the palettes were chosen by a maximal packing, distinct palettes differ in many colours in each direction, so for blocks $P\ne Q$ there are colours $a_1,\dots ,a_s\in Q\setminus P$ and $b_1,\dots ,b_s\in P\setminus Q$. A vertex’s internal labels in those colours form a word in $[H{]}^s$. The choice of cross-edge colour is then made by a pair of fixed maps $f,g:[H{]}^s\to [H{]}^s$ with the property that for all words $x,y$ there is a coordinate $d$ with

Such maps come from a saturated matrix: a random $s\times H^m$ matrix over $H$ colours in which any $m+1$ columns contain a row displaying every colour, which a union bound supplies for $m\asymp H\log H$ and $s\asymp H^2{\log }^{2}H$. This ingredient is adapted from work of Alon, Ben-Eliezer, Shangguan and Tamo on zero-error list decoding; the chapter’s contribution is applying it to $R(3,\dots ,3)$.

Two consequences do the combinatorial work. Every cross-edge colour is active at exactly one endpoint’s block and missing at the other, and the proper label at the active endpoint is determined by the opposite endpoint. Triangles spanning two blocks die because two same-coloured edges from an outside vertex force equal internal labels, so the edge between their endpoints cannot carry that colour. Triangles spanning three blocks die by a parity argument on symmetric differences: a colour would have to lie in $P\mathrm{△}Q$, $Q\mathrm{△}R$ and $P\mathrm{△}R$ simultaneously, which is impossible.

Multiplying palette-family sizes over $H$ stages yields a triangle-free colouring with $k_H\asymp H^3{\log }^{3}H$ colours on at least $(c_{0}H{)}^{k_H}$ vertices. Since $H\gg k^{1\mathrm{/}3}\mathrm{/}\log k$, that is the theorem.

A corollary about Shannon capacity

The Ramsey–Shannon correspondence, implicit in Erdős, McEliece and Taylor and made explicit by Alon and Orlitsky, converts the bound into a statement about information theory.³ Given a triangle-free $k$-colouring of $K_N$, let $H_i$ be the graph of colour $i$ and take the complete join $G=H_1\vee \cdots \vee H_k$. Then $\alpha (G)=2$, while the $N$ diagonal words form an independent set in the $k$-fold strong power, so the Shannon capacity satisfies $\mathrm{\Theta }(G)\ge N^{1\mathrm{/}k}$.

Setting $N=R_k(3)-1$ and using ${\lim }_k{R}_k(3{)}^{1\mathrm{/}k}=\mathrm{\infty }$ produces graphs with independence number 2 and arbitrarily large Shannon capacity. Shannon capacity therefore cannot be bounded above by any function of the independence number.

Turán-type extremal numbers

Chapter 10 changes the question. For a family $\mathcal{F}$ of graphs, the extremal number is

where $\mathcal{F}$-free means containing no member of $\mathcal{F}$ as a subgraph. For a single graph one writes $\mathrm{ex}(n,H)$. When $H$ is bipartite the answer is a polynomial $n^{2-\gamma }$ for some exponent, and determining those exponents is the central open programme of the subject.

Compactness: does a family reduce to one member?

Forbidding more graphs can only lower the extremal number. Erdős and Simonovits conjectured that it cannot lower it by much.⁴ The original formulation has easy counterexamples. The family $\{K_{1,2},2K_2\}$ has $\mathrm{ex}(n,\mathcal{F})=1$ while its members have extremal numbers $\lfloor n\mathrm{/}2\rfloor$ and $n-1$, so the corrected statement restricts to families whose members all contain a cycle:

For every finite nonempty family $\mathcal{F}$ of graphs, each containing a cycle, do there exist $F\in \mathcal{F}$ and $C>0$ with $\mathrm{ex}(n,F)\le C\mathrm{ex}(n,\mathcal{F})$ for all large $n$?

The chapter answers no, and does so with a family whose members are all connected and bipartite.

The construction takes $\mathcal{F}=\{C_4,C_6\}\cup \mathcal{J}\cup \mathcal{K}$. The two extra pieces come from templates built out of subdivided complete bipartite graphs, where $S_k$ is $K_{3,k}$ with every edge replaced by a two-edge path, glued in the style of Bukh and Conlon’s rooted-power construction, then closed under admissible quotients: identifications of vertices that respect the proper two-colouring and stay injective on distinguished subgraphs. Closing under quotients is what makes the family finite and what makes it hard to avoid.

The two bounds come from opposite directions.

• Upper. Counting short paths in any $\mathcal{F}$-free host graph forces $\mathrm{ex}(n,\mathcal{F})=O(n^{21\mathrm{/}16})$, and $21\mathrm{/}16=4\mathrm{/}3-1\mathrm{/}48$.
• Lower. For each individual $F\in \mathcal{F}$, the incidence graph of a generalized quadrangle is $F$-free and has $\mathrm{\Omega }(n^{4\mathrm{/}3})$ edges. Crucially, the field characteristic is allowed to depend on which $F$ is being avoided, so a single host does not have to work for the whole family.

That asymmetry is the whole idea. Every member is individually easy to avoid at density $n^{4\mathrm{/}3}$, but no single algebraic host avoids all of them at once, and the gap is polynomial rather than a constant factor.

Degeneracy: does local sparsity fix the exponent?

A graph is $r$-degenerate if every nonempty subgraph has a vertex of degree at most $r$. Erdős conjectured in 1967 that this local sparsity determines the extremal exponent for bipartite graphs:

The conjecture is true in several restricted settings: when one bipartition class has maximum degree at most $r$, for $r$-degenerate blow-ups of trees, and for grids at $r=2$. Alon, Krivelevich and Sudakov proved the weaker general estimate $\mathrm{ex}(n,H)=O(n^{2-1\mathrm{/}(4r)})$.⁵ A companion conjecture of Erdős asserted that $H$ is 2-degenerate if and only if $\mathrm{ex}(n,H)=O(n^{3\mathrm{/}2})$; Janzer disproved the reverse implication in 2021 by building 3-regular bipartite graphs with extremal number $O(n^{4\mathrm{/}3+\eta })$, but the forward implication, the $r=2$ case above, stayed open.⁶

Chapter 10 kills it.

The counterexample $H$ is built in layers. Start with a layer $V_0$ of $L_0$ vertices; for each subsequent layer, add one new vertex for every pair of vertices in the previous layer, joined to exactly those two parents. Every new vertex has degree 2 at birth, so $H$ is 2-degenerate, connected and bipartite by construction, with $s$ layers as a tunable depth.

The lower bound comes from a random host. Take the two sides to be copies of $\{0,1{\}}^m$, join opposite vertices whose Hamming distance is at most $k=\lfloor \tau m\rfloor$, then independently retain each vertex with probability $p=2^{-\beta m}$. A second-moment computation shows the sampled graph still has $\mathrm{\Omega }(n^{3\mathrm{/}2+\epsilon })$ edges for suitable $\tau$ and $\beta$, and padding extends it to every large order.

Showing that $H$ does not embed is where the layered design pays off. Each candidate embedding is scored by an entropy potential: for a parent array $u$ and child array $z$, the quantity

measures how much conditional entropy a child bit carries given its two parent bits at a random coordinate. Low-entropy arrays are too numerous to survive sampling: a counting argument shows that arrays with $E(u,z)\le \beta -\delta$ are excluded with high probability, at every layer and on both sides. So any embedding must raise $E$ by a fixed amount per layer, and $E$ is bounded above by 1. After enough layers that is impossible, so $H$ has no copy in the host. Choosing the depth $s$ large enough to exhaust the potential is exactly the role of the parameter thresholds $A(\tau )<\beta <C(\tau )$.

The Erdős ledger

Both of these chapters land on problems from Erdős’s list, as does OpenAI’s separately reported May 2026 result on the unit-distance problem in discrete geometry.⁷ That is not incidental. Erdős problems are unusually good targets for a search process: each is a self-contained combinatorial statement with a crisp yes-or-no answer, a documented history of partial results to calibrate against, and, in the counterexample direction, a certificate that is a finite object one can check.

What the three results have in common on the mathematical side is that the winning move was construction rather than argument. A superexponential Ramsey lower bound is a colouring. A refutation of compactness is a family of graphs. A refutation of the degeneracy conjecture is one bipartite graph plus a random host. In each case the difficulty was in finding an object with several tightly coupled properties, not in reasoning about objects already in hand.

The upper bounds, meanwhile, have barely moved. $R_k(3)$ is still bracketed between $k^{(1\mathrm{/}3-o(1))k}$ and $k^{(1+o(1))k}$, and the value of ${\lim }_k{R}_k(3{)}^{1\mathrm{/}k}$, Erdős’s $250 question, is untouched. Deciding whether it is finite was the $100 question, and that one is now answered.

References

The three results share a shape. In each case a qualitative statement was already believed, a weaker quantitative version was already known, and the contribution is to close a specific, quantified part of the gap between them. All three land where the previous techniques had stalled.

Arithmetic circuits compute polynomials, not functions

An arithmetic circuit over $\mathbb{C}$ is a directed acyclic graph. Input gates carry variables or constants, internal gates are binary $+$, $-$, or $\times$, and one gate is the output. Size is the number of internal gates. A gate may feed its result to any number of later gates, so a subexpression computed once can be reused freely.

An arithmetic formula is the same object restricted to a tree. Fan-out is one. Two uses of the same intermediate polynomial require two separate subformulas, each paid for in full. The natural size measure is the number of leaves, and the sharper measure used here is $L_{\mathrm{v}\mathrm{a}\mathrm{r}}(\mathrm{\Phi })$, the number of leaves labeled by variables, counting repeated occurrences separately.

The polynomial under study is the permanent of an $n\times n$ matrix of algebraically independent variables:

Its monomials enumerate perfect matchings in the complete bipartite graph on rows and columns. The determinant differs only by the signs $\mathrm{sgn}(\sigma )$, and that difference is decisive: the determinant has polynomial-size arithmetic circuits, while the permanent is complete for Valiant’s class VNP.² Whether the permanent has polynomial-size circuits is the algebraic counterpart of P versus NP, and it is the central open problem of algebraic complexity theory.

Progress on it has been slow in a specific way. The permanent depends on all $N=n^2$ variables, and combining $n^2$ distinct inputs with binary gates needs at least $n^2-1$ of them. That elementary counting argument was, for general division-free circuits, essentially the best available. The classical formula lower bound was $\mathrm{\Omega }(n^3)$, due to Kalorkoti.³

Chapter 5 improves both.

so $C({\mathrm{per}}_n)=\mathrm{\Omega }(n^2\log \log n)$ and the ratio $C({\mathrm{per}}_n)\mathrm{/}{n}^2$ diverges. This is the first superquadratic bound for unrestricted division-free circuits computing the permanent. For formulas:

with the same asymptotic $\mathrm{\Omega }(n^4\mathrm{/}\log n)$ holding for formulas that use division, provided every denominator is a nonzero rational function; only the constants change.

In terms of the input count $N=n^2$, the circuit bound reads $\mathrm{\Omega }(N\log \log N)$ and the formula bounds read $\mathrm{\Omega }(N^2\mathrm{/}\log N)$. Both are still polynomially far from the superpolynomial separation that permanent-versus-determinant demands.

Why the two proofs are different arguments

The circuit bound is geometric. Reverse-mode differentiation computes the full gradient of a size-$L$ circuit using at most $3L$ multiplications, which is exactly the sharing that a formula cannot do. If the gradient map is a homogeneous degree-$(d-1)$ map ${\mathbb{C}}^k\to {\mathbb{C}}^k$ whose only zero is the origin, its generic fiber has $(d-1{)}^k$ points, while Bézout’s inequality bounds the isolated solutions of the gate equations by $2^{3L}$. Comparing the two gives

To use this one needs a specialization of the permanent whose critical locus has codimension $\mathrm{\Theta }(n^2)$ while its degree $d$ still grows with $n$. Chapter 5 builds one from sums of subpermanents, controlling the critical locus through shared power sums and elementary symmetric functions of the columns.

The formula bound is algebraic instead. It marks a matching of matrix entries, expands the permanent in those variables, and counts algebraically independent coefficients. For the permanent, a matching of only $O(\log n)$ entries already contributes $\mathrm{\Omega }(n^2)$ independent coefficients, and independent coefficients must be charged to distinct occurrences of the marked variables. Summing over entry-disjoint matchings gives the quartic bound.

Both arguments are explicitly permanent-specific, and the paper is direct about the obstruction. For the determinant, a Schur complement identity compresses the coefficients of a marked $k$-entry block into a field generated by $O(k^2)$ elements, so the transcendence degree obeys ${\mathrm{td}}_Y(\det X)\le n\mathrm{\mid }Y\mathrm{\mid }$ and the method tops out at a cubic bound. On the circuit side, every homogeneous affine specialization of ${\det }_n$ has $\mathrm{codim}\mathrm{Crit}(P)\le n-1$, which caps the certificate at $O(n\log n)$, below the trivial $n^2-1$ counting bound. The technique does not leak to the determinant.

A two-player game is a soundness question

A finite two-player one-round game is a tuple $G=(X,Y,A,B,\mu ,V)$. A referee samples $(x,y)\sim \mu$, sends $x$ to Alice and $y$ to Bob, receives answers $a\in A$ and $b\in B$, and accepts if $V(x,y,a,b)=1$. The players agree on a strategy in advance but cannot communicate after seeing their questions. The maximum acceptance probability is the classical value $\omega (G)$.

An entangled game keeps the same questions, answers, and predicate, but lets the players share a bipartite quantum state before the questions arrive. Each measures their half according to their own question. The supremum of winning probabilities over all finite-dimensional shared states and local measurements is the entangled value ${\omega }^{\ast }(G)$.

Parallel repetition is the standard way to amplify soundness. In $G^{\otimes n}$ the referee samples $n$ independent question pairs and accepts only if every coordinate is won. The subtlety is that although the referee’s coordinates are independent, the players’ are not: Alice’s answer in coordinate $i$ may depend on her entire question tuple. Playing coordinates independently only gives the lower bound ${\omega }^{\ast }(G^{\otimes n})\ge {\omega }^{\ast }(G{)}^n$; the work is in the matching upper bound.

Raz proved the classical case: every finite two-player game with $\omega (G)<1$ satisfies $\omega (G^{\otimes n})\le \exp (-c_{G}n)$.⁴ Holenstein later gave an information-theoretic proof based on correlated sampling and improved the dependence on the soundness gap.⁵

The entangled analogue was noted as open by 2004 and stayed open. Exponential decay was proved for structured families, namely XOR games, unique games, projection games, and free games, and Bavarian, Vidick, and Yuen obtained exponential decay by first transforming a game into an anchored one.⁶ That is enough for hardness amplification but is not a repetition theorem about the original game. For arbitrary games, the strongest general statement was Yuen’s, and it decayed only polynomially:⁷

Chapter 6 replaces that with exponential decay, for every finite game, unmodified.

for a universal constant $c_{\mathrm{q}\mathrm{s}}>0$. The exponent $13$ is not claimed to be optimal; it inherits the loss in a standard quantum correlated-sampling lemma. The claim being made is about the rate, not the constant.

The proof keeps Yuen’s conditioning-and-rounding template. Assume a repeated strategy beats the bound; a greedy conditioning lemma selects a small core $D⊊[n]$ with $\mathrm{\mid }D\mathrm{\mid }\le \log (1\mathrm{/}\vartheta )\mathrm{/}\delta$ such that, conditioned on winning every coordinate in $D$, an average remaining coordinate is won with probability at least $1-\delta$. The conditioned coordinate is then rounded back into a legal single-copy strategy that beats ${\omega }^{\ast }(G)$, a contradiction.

The obstacle in the quantum setting was always that step. Conditioning on winning all $n$ coordinates is conditioning on an event of exponentially small probability, and the available quantum sampleability estimates degraded inversely with that probability, which is why the classical argument yielded only polynomial decay when transplanted. The new ingredient is a postselection-stable sampleability lemma with no such inverse dependence.

Lattice hardness at a fixed polynomial factor

The closest vector problem takes a full-rank integer basis $B\in {\mathbb{Z}}^{n\times n}$ and a target $t$, and asks for the lattice point nearest to $t$:

The approximate promise version ${\mathrm{G}\mathrm{a}\mathrm{p}\mathrm{C}\mathrm{V}\mathrm{P}}_{\gamma }^{(2)}$ takes an additional radius $r$ and asks to distinguish ${\mathrm{dist}}_2(t,\mathcal{L}(B))\le r$ from ${\mathrm{dist}}_2(t,\mathcal{L}(B))>\gamma (n)r$, with either answer permitted in between. Larger $\gamma$ makes the problem easier, so hardness results get harder to prove as $\gamma$ grows.

Chapter 7 gives a deterministic polynomial-time many-one reduction from 3SAT:

so ${\mathrm{G}\mathrm{a}\mathrm{p}\mathrm{C}\mathrm{V}\mathrm{P}}_{n^{1\mathrm{/}400}}^{(2)}$ is NP-hard. The same construction yields factor $n^{1\mathrm{/}200}$ for binary nearest codeword and syndrome decoding, and $n^{1\mathrm{/}(200p)}$ for closest vector in every fixed rational ${\mathrm{\ell }}_p$ norm, $p\ge 1$.

The exponent looks small, and it is. What makes it interesting is that it is a constant. The previous best, from Dinur, Kindler, Raz, and Safra, was NP-hardness within $n^{a\mathrm{/}\log \log n}$ for some absolute $a>0$.⁸ That factor grows faster than any fixed power of $\log n$, but its exponent tends to zero, so it never certifies hardness within $n^c$ for any fixed $c>0$. Moving from a vanishing exponent to a fixed one is the actual content.

The reduction factors as

3SAT  ->  binary nearest codeword  ->  Euclidean CVP

The second arrow is the standard dimension-preserving reduction. The first is the new work: assignments are encoded as Reed–Solomon evaluation tables over a characteristic-two field, with power-sum and shifted-moment constraints forcing low degree, and the resulting binary affine system $Hx=b$ is lifted to an integer lattice by coordinatewise reduction modulo two. Soundness recovers a satisfying assignment from any low-weight solution by reconstructing separable root sets over a rational function field.

Notably, this uses no randomization, no PCP theorem, and no Projection Games Conjecture; earlier fixed-polynomial lattice inapproximability results were conditional on the latter. The price is size: the field satisfies $q=\mathrm{\Theta }(N^{200})$ and the lattice rank $n\le 40N^{401}$.

How far this is from cryptography

It is worth being precise about what this does and does not say for post-quantum cryptography.

Lattice problems became cryptographically load-bearing through Ajtai’s worst-case to average-case connection, the Goldreich–Goldwasser–Halevi constructions, and Regev’s learning with errors, and that line now underpins NIST’s standardized key encapsulation and signature schemes. But those schemes rest on structured or average-case assumptions at polynomial approximation factors. They do not rest on the worst-case NP-hardness of CVP, and a hardness result at $n^{1\mathrm{/}400}$ does not strengthen them.

There is also a ceiling. Aharonov and Regev showed that for some absolute $C>0$,

so NP-hardness at the square-root scale would imply $\mathrm{N}\mathrm{P}=\mathrm{c}\mathrm{o}\mathrm{N}\mathrm{P}$.⁹ The exponent therefore cannot pass $1\mathrm{/}2$ by these means. Determining the largest $c\in [1\mathrm{/}400,1\mathrm{/}2)$ for which ${\mathrm{G}\mathrm{a}\mathrm{p}\mathrm{C}\mathrm{V}\mathrm{P}}_{n^c}^{(2)}$ is NP-hard is left open.

So the honest summary is a narrow one: a barrier that used to sit at a vanishing exponent now sits at $1\mathrm{/}400$, unconditionally and deterministically, and the region between there and $1\mathrm{/}2$ is unexplored.

What the three have in common

Each result takes a statement everyone expected to be true and supplies a quantitative certificate for part of it.

Each result moves a bound that had held for years, and the exact constants in each theorem, $144$, $13$, and $400$, are worth reading as measurements: they say precisely how far the new technique reaches, which is what makes the next step easy to aim at.

References

Chapter 3 constructs an explicit group that admits no finite permutation approximations at all. Chapter 4 constructs infinitely many pairwise nonisomorphic rigid groups that are indistinguishable to the operator algebra built from them.

The two are worth reading together because they attack the same instinct from opposite sides: the belief that infinite groups can be pinned down by finite or analytic shadows.

Soficity is approximation by permutations

Let $H$ be a countable group. A sofic approximation of $H$ is a sequence of maps

into the symmetric groups of finite sets $Y_n$, with $\mathrm{\mid }{Y}_n\mathrm{\mid }\to \mathrm{\infty }$. These maps are not required to be homomorphisms. They are required only to look like homomorphisms in a statistical sense, measured by normalized Hamming distance:

This is the fraction of points on which two permutations disagree. The conditions are:

The second condition says multiplication holds at almost every point of $Y_n$. The third says every nonidentity element of $H$ moves almost every point: the approximation stays faithful, and does not quietly send distinct group elements to nearly the same permutation. A group is sofic if such a sequence exists.

Gromov introduced the property in work on symbolic dynamics,² and Weiss named sofic groups and asked whether a nonsofic one exists. The question hardened into the soficity conjecture: is every countable group sofic?³

Nobody could produce a counterexample, and the class kept absorbing everything thrown at it. Amenable groups are sofic. Residually finite groups, those where every nonidentity element survives in some finite quotient, are sofic. So is the wider LEF class: a group is locally embeddable into finite groups if for every finite subset $F$ there is a finite group $B$ and an injection $\phi :F\to B$ with

so each finite chunk of the multiplication table embeds exactly, with $B$ allowed to depend on $F$. Soficity is the approximate version of the same idea, and the class is closed under enough operations that the supply of candidate counterexamples was thin.

Why anyone cared

Soficity mattered because a long list of conjectures had been proved for sofic groups and remained open in general. That made “every group is sofic” the load-bearing assumption in a whole shelf of theorems.

Gottschalk’s surjunctivity conjecture is the original motivation. A group $H$ is surjunctive if for every finite alphabet $A$, every injective $H$-equivariant continuous map $A^H\to A^H$ is surjective, a cellular-automaton analogue of the fact that an injective self-map of a finite set is onto. Gromov and Weiss proved every sofic group is surjunctive.

Connes’s embedding conjecture for groups asks whether every discrete group is hyperlinear: approximable by finite-dimensional unitary matrices in normalized Hilbert–Schmidt distance. Permutation matrices satisfy

so every sofic group is hyperlinear. Kaplansky’s direct-finiteness conjecture, which asks whether $ab=1$ in a group algebra forces $ba=1$, together with Lück’s determinant conjecture, the algebraic eigenvalue conjecture, and the Kervaire–Laudenbach conjecture all have “true for sofic groups” theorems attached.

Earlier work had produced conditional routes to a nonsofic group: Bowen and Burton from flexible permutation stability of ${\mathrm{P}\mathrm{S}\mathrm{L}}_d(\mathbb{Z})$, Gohla and Thom from central extensions of $p$-adic lattices under a stability hypothesis. Every route needed an unproved stability assumption. Separately, the Aldous–Lyons conjecture, a broader statement about unimodular random rooted networks of which the soficity conjecture is the restriction to point masses on normal subgroups, was disproved by Bowen, Chapman, Lubotzky and Vidick using machinery descended from ${\mathrm{M}\mathrm{I}\mathrm{P}}^{\ast }=\mathrm{R}\mathrm{E}$. That did not settle soficity, because a non-co-sofic invariant random subgroup need not be supported on a normal subgroup.

The counterexample

Let ${\mathbb{F}}_2$ be the field with two elements. The binary Leavitt algebra is

The relations are the algebraic shadow of the Cuntz algebra ${\mathcal{O}}_2$. They say $R\cong R^2$ as right $R$-modules: the ring is isomorphic to two copies of itself. Note $t_0{s}_0=1$ while $s_0{t}_0$ is a proper idempotent, so the ring is one-sided in places. Write $R^{\times }$ for the group of invertible elements. Since $R$ is finitely generated over a finite field, $R^{\times }$ is countable.

Theorem 1.1 (Chapter 3).

The proof works inside a finitely generated subgroup, which suffices because soficity passes to subgroups. A complete prefix code is a finite set of pairwise prefix-incomparable binary words whose cylinders partition all infinite binary strings; once its $n$ words are ordered, it induces a unital ring isomorphism

Applying this to a specific nine-word code $D$ realizes the elementary matrix group ${\mathrm{E}\mathrm{L}}_9(R)$ inside $R^{\times }$ as $G:={\mathrm{E}\mathrm{L}}_D(R)$. By the Ershov–Jaikin-Zapirain theorem, elementary groups over a finitely generated ring have Kazhdan’s property $(T)$ once $n\ge 3$, so $G$ is a property-$(T)$ group.

Property $(T)$ is a spectral-gap condition: every unitary representation with almost invariant unit vectors has a genuine nonzero invariant vector. Its relevance here is geometric rather than analytic. Given permutations modeling a finite generating set, the generator graph joins each point of $Y_n$ to its image under each generator. Kun’s theorem says the generator graph of a sofic approximation to a property-$(T)$ group becomes a disjoint union of uniformly expanding graphs after changing $o(\mathrm{\mid }{Y}_n\mathrm{\mid })$ edges,⁴ where a component $C$ is a $\gamma$-expander when

The Kun–Thom centralizer theorem then says: if $K$ has property $(T)$, $J$ is finitely generated, and a sofic approximation of $K\times J$ has a single uniformly expanding $K$-generator graph on the whole of $Y_n$, then $J$ is LEF.

The gap between the two is the whole difficulty. Kun’s decomposition delivers many expanding components; Kun–Thom needs one. The gap is real, not technical: $\mathrm{\Lambda }={\mathrm{S}\mathrm{L}}_3(\mathbb{Z})$ has property $(T)$ and is residually finite, $B=\mathrm{B}\mathrm{S}(2,3)$ is sofic but not residually finite and hence not LEF, and $\mathrm{\Lambda }\times B$ is nonetheless sofic. Expanding $\mathrm{\Lambda }$-components alone cannot force a commuting factor to be LEF.

The chapter’s bridge is a group-theoretic criterion. Suppose $\mathrm{\Gamma }\le G$ are infinite finitely generated property-$(T)$ groups with

and a finitely generated $J\le G$ satisfies

Then soficity of $G$ implies $J$ is LEF. The extra nesting, in which conjugation by $t_1$ pushes both commuting factors inside $\mathrm{\Gamma }$, is exactly what the ${\mathrm{S}\mathrm{L}}_3(\mathbb{Z})\times \mathrm{B}\mathrm{S}(2,3)$ example lacks.

The argument applies Kun’s theorem separately to the $\mathrm{\Gamma }$- and $G$-generator graphs, giving two different partitions of $Y_n$. A median-normalized size function

on each $G$-component $A$ is almost nondecreasing along the permutations approximating the $t_i$ and almost preserved by $\mathrm{\Gamma }$-generators. Because permutations conserve total increase and decrease, expansion pins $f$ near $1\mathrm{/}2$ outside a negligible set, which forces each transported $\mathrm{\Gamma }$-component to have roughly the same size as its target, so it fills more than half of it and the matching is injective. That injectivity lets the argument descend to a single expanding component and invoke Kun–Thom.

Finally the Leavitt configuration supplies the pieces. Inside $G={\mathrm{E}\mathrm{L}}_D(R)$ the chapter builds a property-$(T)$ subgroup $\mathrm{\Gamma }$ acting inside the cylinder $[0]$, units $u,v$, and a subgroup $J\cong V$, Thompson’s group $V$, acting inside the disjoint cylinder $[1000]$, with conjugation by $u$ moving $J$ into $[0001]\subseteq [0]$. Thompson’s group $V$ is finitely presented, infinite and simple, and no such group is LEF. So $G$ cannot be sofic, and neither can $R^{\times }$.

What the counterexample does and does not break

The theorem removes an assumption; it does not by itself falsify the conjectures that relied on it.

The surjunctivity entry is the sharpest. Surjunctivity passes to subgroups, so if $R^{\times }$ is surjunctive, it is the first surjunctive nonsofic group; if it is not, Gottschalk’s conjecture is false. Either way the next result comes from the same object.

Group von Neumann algebras

Chapter 4 moves to operator algebras. For a countable discrete group $G$, the left regular representation is

and the group von Neumann algebra is the double commutant

Concretely, $L(G)$ is the weak closure of finite complex combinations ${\sum }_g{a}_g{\lambda }_G(g)$, with canonical trace ${\tau }_G(x)=a_1$. It is an analytic completion of the group algebra, and completion loses information: it is a coarse invariant by construction.

A group is ICC if it is infinite and every nonidentity conjugacy class is infinite. For infinite $G$, the classical criterion of Murray and von Neumann says $L(G)$ is a ${\mathrm{I}\mathrm{I}}_1$ factor, an infinite-dimensional factor with a faithful normal tracial state, precisely when $G$ is ICC.

How coarse is the invariant? Connes’s classification of injective factors gives the extreme case: every amenable ICC group has the same group factor, the hyperfinite ${\mathrm{I}\mathrm{I}}_1$ factor. All amenability collapses to one point.

Property $(T)$ is the opposite of amenability, and was expected to prevent the collapse entirely.

Conjecture (Connes). Let $G$ and $H$ be countable ICC groups with property $(T)$. If $L(G)\cong L(H)$, then $G\cong H$.

It appears as Problem 1 in the appendix to Chapter 5 of his 1994 monograph.⁵

The surrounding notion is W*-superrigidity: a countable group $G$ is W*-superrigid if $L(G)\cong L(H)$ implies $G\cong H$ for every countable $H$, so the group is fully recoverable from its factor. Such groups exist; the first examples came from Ioana, Popa and Vaes,⁶ and the first with property $(T)$ from Chifan, Ioana, Osin and Sun. The question was whether property $(T)$ alone forces it.

The fiber is infinite

Theorem (Chapter 4). There exist finitely generated ICC property-$(T)$ groups $\mathrm{\Lambda },{\mathrm{\Gamma }}_0,{\mathrm{\Gamma }}_1,{\mathrm{\Gamma }}_2,\dots$ that are pairwise nonisomorphic and satisfy

with ${\mathrm{\Gamma }}_n$ containing a copy of ${\mathrm{\Gamma }}_0$ of index $2^{4n}$, so the family is mutually commensurable.

The pair $\mathrm{\Lambda },{\mathrm{\Gamma }}_0$ already refutes Connes’s conjecture. The infinite family does more. In his Madrid ICM address, Popa proved the group-factor functor is at most countable-to-one on ICC property-$(T)$ groups,⁷ and later asked whether the fibers are in fact finite. They are not, and his countability bound is sharp.

The mechanism is a deliberate leak in the invariant. For a countable abelian $K$-module $A$, Fourier transform gives

The right-hand side depends on the Haar probability space of the dual $\widehat{A}$ and on the $K$-action, but not on the compact group law of $\widehat{A}$. Two different group structures on the same measured $K$-space give the same crossed product, and hence the same factor, while their discrete duals can be nonisomorphic groups.

The elementary model is the four-point space ${\mathbb{F}}_2^2$. Coordinatewise addition makes it the Klein four-group. The binary carry

makes the same four points into $\mathbb{Z}\mathrm{/}4\mathbb{Z}$. Same set, same uniform Haar measure, different group.

The construction globalizes this. The acting group is a torsion-free ICC property-$(T)$ group

which surjects onto ${\mathrm{S}\mathrm{L}}_4({\mathbb{F}}_2[t])$. With $V={\mathbb{F}}_2[t{]}^4$ and the divided-square module

the dual $\widehat{D}$ gives the common compact $K$-space. Carrying the binary rule to a compact group $C_0$ with the same measured $K$-action and setting

Fourier transform identifies $L({\mathrm{\Gamma }}_0)\cong L(\mathrm{\Lambda })$, while order-four torsion distinguishes the two groups as abstract groups.

Verifying that $\mathrm{\Lambda }$ is ICC and has property $(T)$ suffices for the pair, because both properties transfer across an isomorphism of group factors: by the Murray–von Neumann criterion the ICC property is detected by factoriality, and by the Connes–Jones characterization an ICC group has property $(T)$ if and only if its group factor does.

Shifting the carry by $n$ coefficient positions in each of the four directions produces compact groups $C_n$ with the same measured $K$-action, hence ${\mathrm{\Gamma }}_n=\widehat{C_n}⋊K$ with $L({\mathrm{\Gamma }}_n)\cong L(\mathrm{\Lambda })$. Pontryagin duality embeds ${\mathrm{\Gamma }}_0$ in ${\mathrm{\Gamma }}_n$ with index $2^{4n}$, and the finite-orbit part of the intrinsic quotient $E_n[2]\mathrm{/}2E_n$ has order $2^{4n}$, an invariant computed from the abstract group that recovers $n$, which is what proves the family pairwise nonisomorphic.

Infinite fibers were already known outside the property-$(T)$ world: for a nontrivial finite abelian $H_0$ and $n\ge 3$, infinitely many pairwise nonisomorphic $H$ satisfy $L(H)\cong L(H_0\wr {\mathrm{P}\mathrm{S}\mathrm{L}}_n(\mathbb{Z}))$, but that wreath product lacks property $(T)$. The new content is an infinite fiber sitting entirely inside the class where the countability bound applies.

Reading the two together

Both results are negative, and both are negative in the same way: a property that looked like it should transmit rigidity turns out not to.

Property $(T)$ appears in both chapters, in opposite roles. In Chapter 3 it is the tool: it forces sofic approximations to be expanders, and expansion is what lets the argument match components and isolate a single one. In Chapter 4 it is the hypothesis that fails to deliver: spectral rigidity of the group does not survive the passage to the weak closure, because the crossed product only remembers a measure space and an action.

Neither proof needs a stability hypothesis or a computational reduction. Both are ordinary mathematics, checkable line by line, and OpenAI published Lean 4 certificates alongside the paper.⁸ Both close questions that had resisted the standard machinery for decades. That the arguments were produced by a model rather than a person is a fact about provenance; the theorems stand on their statements.

References

Chapters 1, 2, and 8 improve three bounds that had stood for a long time. Two of them dated from 1977 and 1978. The third was a conjecture of Ehrhart from 1964. This post explains what each problem asks, what was previously known, and the shape of the arguments.

Sphere packing in high dimensions

Let ${\mathrm{\Delta }}_d$ be the largest density achievable by a packing of congruent balls in ${\mathbb{R}}^d$. Lower bounds are easy and weak: random constructions give roughly $2^{-d}$. Upper bounds are hard, and for fifty years the best general one came from Kabatianskii and Levenshtein, who proved ${\mathrm{\Delta }}_d\le 2^{-(0.59905576\dots +o(1))d}$.

The dominant tool for upper bounds is a linear program introduced by Gorbachev and, independently, Cohn and Elkies.² Fix the Fourier convention $\widehat{f}(\xi )=\int f(x)e^{-2\pi ix\cdot \xi }dx$ and let $v_d$ be the volume of the unit ball. Define the admissible class

and the resulting bound

Every admissible $f$ is a certificate. Poisson summation turns the two sign conditions into an inequality about any packing at all: the spatial condition kills contributions from distinct centers, and the Fourier condition makes the remaining sum nonnegative. This is the framework in which Viazovska settled dimension 8 and, with collaborators, dimension 24, by producing exactly optimal “magic” functions.

What nobody knew was how strong the program is in general. Cohn and Zhao showed it is at least as strong as the Kabatianskii-Levenshtein bound.³ Whether it is strictly stronger in the exponent was open, though Afkhami-Jeddi, Cohn, Hartman, de Laat, and Tajdini conjectured the answer while studying the modular bootstrap.

Chapter 1 proves that conjecture.

Written as an exponent, ${\mathrm{\Delta }}_d\le 2^{-({\alpha }_{\ast }+o(1))d}$ with ${\alpha }_{\ast }=\frac{1}{2}{\log }_2(2\pi \mathrm{/}e)=0.6044\dots$, against the classical $0.59905576\dots$. Intervening work had improved only lower-order factors, so this is the first change to the exponent since 1978.

The result is two-sided, and the second half matters as much as the first. The limit is an equality, so no Cohn-Elkies auxiliary function can ever do better. The linear program is now a closed question at the level of exponents, and further progress on sphere packing must come from somewhere else.

Sign uncertainty as the underlying obstruction

The lower bound on ${\mathrm{L}\mathrm{P}}_d$ runs through an uncertainty principle. For $g\in L^1({\mathbb{R}}^d;\mathbb{R})$ with $\widehat{g}=\varsigma g$, $\varsigma \in \{-1,+1\}$, let $r(g)$ be the smallest $R$ beyond which $g\ge 0$, and set

A self-dual function that vanishes at the origin cannot become nonnegative too soon. The $+1$ case is the Bourgain-Clozel-Kahane problem; the $-1$ case was introduced by Cohn and Gonçalves and tied to sphere packing.⁴ Chapter 1 settles both asymptotically.

The link to packing is a two-line construction. Given admissible $F$, rescale by $a=(\widehat{F}(0)\mathrm{/}F(0){)}^{1\mathrm{/}d}$ so that $h(x)=F(ax)$ satisfies $h(0)=\widehat{h}(0)$. Then $g=\widehat{h}-h$ is anti-self-Fourier, vanishes at the origin, and is nonnegative outside the ball of radius $1\mathrm{/}a$. Since $\int g=0$, half of its total mass is negative, and all of that negative mass sits inside that ball. A Mellin-transform estimate shows a radial eigenfunction with $g(0)=0$ has exponentially little $L^1$ mass inside radius $c\sqrt{d}$ for any $c<1\mathrm{/}\pi$, which forces $1\mathrm{/}a\ge (1\mathrm{/}\pi -o(1))\sqrt{d}$. The matching upper bound modifies the Mellin transform of a Gaussian to build a Fourier pair whose sign conditions begin at $(1\mathrm{/}\pi +o(1))\sqrt{d}$. Stirling’s formula converts radii into densities.

The two constants are asymptotically equal but not equal: the paper records $A_{+}(d)<A_{-}(d)$ in every dimension.

Binary and spherical codes

Chapter 2 attacks the discrete analogues and arrives at the same exponent by a different road.

A binary code $C\subseteq \{0,1{\}}^n$ with minimum Hamming distance $d$ has size at most $A_2(n,d)$; a spherical code $C\subseteq S^{n-1}$ with pairwise inner products at most $s$ has size at most $A(n,s)$. The asymptotic rates are

The standing records were the second McEliece-Rodemich-Rumsey-Welch bound $M_2(\delta )$ from 1977 and the Kabatianskii-Levenshtein bound $B_{\mathrm{K}\mathrm{L}}(s)$ from 1978. Both come from Delsarte’s two-point linear program: a polynomial $F={\sum }_j{f}_j{P}_j$ in the appropriate orthogonal basis, with $f_0>0$, $f_j\ge 0$, and $F\le 0$ at every permitted inner product, certifies $\mathrm{\mid }C\mathrm{\mid }\le F(1)\mathrm{/}{f}_0$.

The new idea is to change what sits at each code point. In the classical construction each retained harmonic space contributes one vector per code point. Here a $d_E$-dimensional subspace is attached to each point $x$ inside a common $D$-dimensional ambient space, moving with the point under the symmetry group, so that the overlap $\mathrm{tr}(P_x{P}_y)$ remains a scalar function of distance. Writing $\mathrm{\Lambda }$ for the largest eigenvalue of the associated weighted transition matrix, the projection bound reads

An exponentially large projection rank $d_E$ divides straight into the bound, provided $\mathrm{\Lambda }$ stays clear of the threshold. The transition matrices come from representation graphs: tridiagonal in the binary case, and in the spherical case weighted graphs whose vertices are indexed by Young diagrams, with $r$ rows for the subspace at each code point and one more row for the ambient representation. That hierarchy level $r$ is the new parameter.

For binary codes the improvement is stated as a strict inequality against the fully optimized classical exponent, using an explicit variational quantity ${\kappa }_{\mathrm{b}\mathrm{i}\mathrm{n}}$:

The classical bounds are boundary cases of the enlarged problem, obtained by setting the attached harmonic degrees to zero. For spherical codes the hierarchy is strictly monotone at every level:

Level $r=0$ is exactly the classical construction. Every subsequent level strictly improves it, for every fixed $s\in (0,1)$.

Because a packing bound follows from a spherical-code bound by hemisphere projection, the hierarchy also produces

which is the Chapter 1 exponent, recovered as the small-angle limit $s\uparrow 1$. Two independent methods, one Euclidean and Fourier-analytic, one spherical and representation-theoretic, meeting at the same constant is the strongest available evidence that the constant is the right one.

Ehrhart’s volume conjecture

Chapter 8 is a different kind of problem with the same flavour: a convexity bound forced by a lattice condition.

Ehrhart asked in 1964 how large a convex body can be if its barycenter is its only interior lattice point. The natural candidate is the dilated, shifted simplex $(n+1){\mathrm{\Delta }}_n-(1,\dots ,1)$, and the conjecture is that it is extremal.

Ehrhart proved it in the plane and for simplices in every dimension. For general centered bodies, Milman-Pajor symmetrization with Minkowski’s theorem gives $\mathrm{vol}(K)\le 4^n$, and a sequence of refinements shaved subexponential and then exponential factors off that, the last of them leaning on Klartag and Lehec’s resolution of Bourgain’s slicing problem.⁵ Since $(n+1{)}^n\mathrm{/}n!$ grows like $e^n$ up to polynomial factors, all of those bounds were exponentially far from sharp.

The proof is complex-analytic. A theorem of Berman and Berndtsson supplies a smooth convex potential $\phi$ whose gradient transports $e^{-\phi (x)}dx$ to Lebesgue measure on $K$.⁶ Pulled back to $X=({\mathbb{C}}^{\ast }{)}^n$ through logarithmic radii, the weighted holomorphic space ${\mathcal{H}}_k$ has Laurent monomial basis indexed by ${\mathbb{Z}}^n\cap \mathrm{int}(kK)$, so the hypothesis that $0$ is the only interior lattice point says precisely that ${\mathcal{H}}_1=\mathbb{C}$.