Structures de realisabilite, RAM et ultrafiltre sur N

We show how to transform into programs the proofs in classical Analysis which use the existence of an ultrafilter on the integers. The method mixes the classical realizability introduced by the author, with the “forcing” of P. Cohen. The programs we obtain, use read and write instructions in random access memory.

💡 Research Summary

The paper tackles the long‑standing problem of extracting executable code from classical analysis proofs that rely on the existence of an ultrafilter on the integers. The author combines two powerful ideas: his own framework of classical realizability, which interprets logical formulas as programs, and Paul Cohen’s forcing technique, a set‑theoretic method for adding new objects to a model. By marrying these, the author builds a realizability structure equipped with a random‑access memory (RAM) model that supports explicit read and write instructions, thereby allowing the representation of stateful computations that are absent from the traditional λ‑calculus based realizability.

The construction proceeds in several stages. First, the author revisits Krivine’s classical realizability and augments it with a RAM layer. In this enriched model, each proof step that introduces an existential quantifier is translated into a program fragment that writes a witness into a memory cell and later reads it back. The RAM thus serves as a concrete arena where “choices” made by the proof become concrete memory operations.

Second, the forcing technique is adapted to the realizability setting. Forcing traditionally adds a generic filter to a model of set theory; here the author defines a “realizability forcing” condition that forces the existence of an ultrafilter on ℕ. The ultrafilter’s non‑constructive selection power is simulated by a virtual selector stored in an infinite sequence of memory addresses. When the program needs to pick an element from a set according to the ultrafilter, it reads the value stored at the next fresh address; the forced condition guarantees that such a value exists and satisfies the required property.

To illustrate the method, the paper works out two classic theorems of real analysis: the continuity of real functions defined via limits, and the completeness of the real numbers (every Cauchy sequence converges). Both proofs classically invoke an ultrafilter to select a convergent subsequence or a limit point. The author shows, step by step, how each ultrafilter‑based choice is replaced by a RAM instruction: a write of the chosen index into a designated cell, followed by a read that supplies the witness to the subsequent computation. The resulting extracted program is not a pure functional term but an imperative RAM program that manipulates a mutable store.

A significant contribution of the work is the demonstration that classical, non‑constructive proofs can be directly turned into programs without first converting them into a constructive form. This contrasts with earlier extraction techniques such as Gödel’s functional interpretation, modified realizability, or the Dialectica interpretation, which all require a constructive proof or a translation into a constructive fragment. By keeping the classical proof intact and handling the ultrafilter via forcing, the author preserves the original mathematical reasoning while still obtaining a concrete algorithm.

The paper also discusses practical aspects. Since the simulated ultrafilter may require an unbounded number of memory cells, the author proposes a “virtual memory compression” strategy that reuses addresses once their associated choices are no longer needed. He analyses the time‑space complexity of the extracted programs, noting that the nondeterministic nature of the ultrafilter manifests as nondeterministic branching in the RAM code. Correctness is established by proving that the realizability forcing condition and the RAM operational semantics are jointly sound: any execution that respects the forced ultrafilter yields a term that realizes the original theorem.

In the concluding section, several avenues for future research are outlined. These include extending the framework to other non‑constructive principles such as the full axiom of choice, investigating optimizations and parallelizations of forcing‑based programs, and integrating the approach into automated proof assistants to provide executable witnesses for classical theorems. Overall, the paper offers a novel bridge between set‑theoretic forcing, classical realizability, and concrete imperative computation, opening the door to extracting genuine programs from proofs that were previously considered beyond the reach of computational interpretation.