About functions where function input describes inner working of the function

This paper argues an existence of a class of functions where function own input makes function description. That fact have impact to the wide spectrum of phenomena such as negative findings of Random Oracle Model in cryptography, complexity in some rules of cellular automata (Wolfram rule 30) and determinism in the true randomness to name just a few.

💡 Research Summary

The paper proposes a novel class of functions whose own input determines the internal workings of the function, thereby linking the notion of “conditional complexity” (McCabe’s cyclomatic complexity) with the description of a function. It begins by recalling that each conditional (if/else) statement doubles the number of independent execution paths, and that a program with many such conditionals can have an exponential number of possible paths. This observation is used to argue that an algorithm can be viewed as a composite function: the input not only selects an output but also selects a specific sequence of internal decisions.
The authors illustrate the idea with the Collatz (3n + 1) problem. For any starting integer n, the algorithm repeatedly applies “if odd then 3n + 1 else n/2”. Each step can be encoded as a left (L) or right (R) turn, producing a unique L/R string for that particular input. The collection of all such strings for all inputs up to the experimentally verified bound (≈10·2⁵⁸) constitutes a complete description of the function. Although the underlying code is only a few lines, the full description requires a string for each input, and the authors derive the inequality b ≤ r, where b is the bit‑length needed to describe the input set and r the bit‑length needed to describe the L/R strings. Thus the Kolmogorov‑Chaitin complexity of the function’s description cannot be lower than the entropy of its inputs.
A second example is Wolfram’s rule 30 cellular automaton. The rule is a simple conditional: “if both the cell and its right neighbor are white, copy the left neighbor; otherwise, invert the left neighbor”. Despite its simplicity, repeated application yields patterns that appear random regardless of the entropy of the initial configuration. The authors attribute this to the same conditional‑complexity mechanism: each iteration adds a new branching layer, and after many layers the pattern becomes statistically indistinguishable from true randomness.
The paper then revisits the Random Oracle Model (ROM) in cryptography, which assumes that any efficiently computable hash function cannot be distinguished from a true random oracle. By showing that a deterministic algorithm whose input‑complexity matches its description‑complexity can produce outputs that are statistically random, the authors argue that ROM’s negative results do not preclude the existence of practical hash functions that are deterministic yet indistinguishable from random. This suggests a new design principle: keep the elementary functions (f and g) simple, but compose them in a highly conditional, unpredictable way, thereby achieving the required complexity equivalence.
In the conclusion, the authors summarize three main points: (1) an algorithm can be regarded as a composite function; (2) providing an algorithmic description does not necessarily give a full description of the composite function, although the algorithm remains deterministic; (3) there exist cases where the complexity of the full function description coincides with the input complexity while the underlying algorithm is trivially simple. They reference the Böhm‑Jacopini theorem on structured programming, noting that when the selection (conditional) structure is used, traditional formalism may be insufficient to capture the emergent randomness. Overall, the paper challenges conventional views on function description, randomness, and complexity, offering a perspective that deterministic processes can exhibit true‑random behavior when the input itself encodes the execution path.