Reflexivity and the diagonal argument in proofs of limitative theorems

This paper discusses limitations of reflexive and diagonal arguments as methods of proof of limitative theorems (e.g. G"odel’s theorem on Entscheidungsproblem, Turing’s halting problem or Chaitin-G"odel’s theorem). The fact, that a formal system contains a sentence, which introduces reflexitivity, does not imply, that the same system does not contain a sentence or a proof procedure which solves this problem. Second basic method of proof - diagonal argument (i.e. showing non-eqiunumerosity of a program set with the set of real numbers) does not exclude existance of a single program, capable of computing all real numbers. In this work, we suggest an algorithm generating real numbers (arbitrary, infinite in the limit, binary strings), and we speculate it’s meaning for theoretical computer science.

💡 Research Summary

The paper revisits two classic proof techniques—self‑referential paradoxes and diagonal arguments—that underlie Gödel’s incompleteness theorem, Turing’s halting‑problem undecidability, and Chaitin‑Gödel information‑theoretic limits. The author argues that the mere presence of a self‑referential sentence in a formal system does not automatically preclude the existence of another sentence or algorithm that solves the same problem, and that diagonal non‑equinumerosity does not rule out a single program capable of generating every real number in the limit.

First, the author formalises reflexivity by introducing an axiom (AK) that evaluates any sentence as its conjunction with a “truth‑assertion” sentence ap. This construction yields a system where every formula is given a value, yet the classic Gödel sentence “this sentence is not provable” remains a paradoxical fixed point. The paper points out that even with AK the system cannot escape Gödelian self‑reference, because the Gödel sentence can be re‑expressed as a liar‑type statement.

Next, the halting‑problem proof is re‑examined. The standard diagonalisation (assume a universal tester T, construct a program S that loops when T says “halts”, feed S to T, obtain a contradiction) is reproduced, but the author then proposes a “large tester” consisting of a conventional tester T together with a complementary tester T₀ that runs in an infinite loop whenever T terminates, and returns 0 when T loops. By running T and T₀ in parallel, the author claims the contradiction disappears: T can now decide halting, albeit possibly after an infinite amount of time, because the failure to halt is transferred to T₀. The paper stresses that decidability in this sense does not guarantee finite‑time answers; the runtime may be unbounded, depending on the complexity of the input program.

The core of the paper concerns the diagonal argument that shows the set of computable reals is countable while the set of all reals is uncountable. The author observes that the argument only proves a cardinality gap, not the impossibility of a single algorithm that enumerates all reals with ever‑increasing precision. To illustrate this, a very simple algorithm (AS) is described: it builds a binary tree and, at stage n, outputs every binary string of length n. In the limit, the rows of this infinite matrix can be interpreted as approximations to every real number. The author claims the diagonal argument “does not apply because the matrices are rectangular and complete,” and that by taking a limit one obtains a countable‑by‑uncountable matrix that nevertheless contains every real as a limit of a column.

Further extensions are proposed. By adding a random path selector L, the algorithm can focus on a single infinite branch, producing a single real number with arbitrary precision. By adding a compressibility filter E that discards any string that can be encoded by a shorter program, the combined system (AS + L + E) is claimed to output only “m‑non‑compressible” strings, which the author equates with “non‑computable” reals. The paper also sketches a decision procedure (C) that, given a candidate string, checks whether it was removed by E, thereby “deciding” m‑non‑compressibility. From this the author concludes that Chaitin‑Gödel’s theorem is not universally valid.

In the final remarks, the author summarises several “facts”: every mathematically expressible problem can be encoded as a binary string; the number of such strings equals the number of possible solutions; a brute‑force generator can produce any binary string with arbitrary length; therefore any solvable problem can be solved to arbitrary precision, though not necessarily in finite time. The paper ends with a philosophical claim that proving theorems generates new information, and that systems equipped with AK‑type axioms and the proposed generators are not limited by Gödel, Turing, Church, or Chaitin.

Overall, the paper attempts to undermine the conventional interpretation of limitative theorems by presenting constructive, albeit highly idealised, algorithms that enumerate all binary strings and filter them for desired properties. While the ideas are intriguing, the work lacks rigorous complexity analysis, ignores practical constraints such as time and space resources, and conflates “existence in the limit” with effective computability. Consequently, the claims that classic limitative results are “not true in a general case” remain unsubstantiated within the standard framework of computability theory.