Creativistic Philosophy: Exploring the Limitations of Formalization, # 3– Patterns and Formulas.

By Andreas Keller

***

Creativistic Viewpoint: Checking Out the Limits of Formalization, # 3– Patterns and Formulas [ii]

1 Introduction

T he concept that mathematics can be utilized to explain components of fact originated in antiquity, [iii] yet it only took a main function during what is called the “scientific change” in the 17 th century, especially with Newton’s Principia Mathematica [iv] Following this example, all-natural philosophers, who later, in the 1830 s, began calling themselves “researchers,” discovered to produce mathematical concepts describing ever before majorities of physical fact.

This basic method allowed them to calculate numerous facets of the systems available. Frequently, at the center of such concepts there are systems of equations. Nonetheless, it is not always easy to do the computations, or “address” the formulas. Oftentimes, approaches to resolve the formulas are not understood or sometimes can also be shown not to exist. Researchers typically have to be material with simplified designs and approximate remedies. So, exist restricts to what can be computed and what can be defined?

The response is in fact “indeed.” Formalization and calculation have their limitations, and I will certainly recommend that the border between the “exact sciences” on the one hand and viewpoint and less specific (and much more thoughtful) academic subjects on the other basically runs along these borders of formalizability.

Yet checking out that topic will be the topic of a later installment. Before I check out the relationship between exact science and ideology, I want to explore the topic of computability with easy examples, to ensure that we can obtain a much more precise, however at the very same time instinctive, comprehending concerning what these limits are.

2 Restrictions of Formalization– Checking Out Easy Examples

In this and the adhering to instalments, we will certainly initially look at something simple: the collection of all-natural numbers. I will certainly first check out easy determinable residential or commercial properties, or predicates, of all-natural numbers, like “strange,” “also,” “prime,” etc. Subsequently, we will certainly increase this examination and look at determinable functions that map all-natural numbers to all-natural numbers. Later, we will certainly see how what we have discovered by doing this can be put on determinable functions that have arbitrary sorts of information as inputs and outcomes. To do so, we will check out what is called “Gödel numbers,” through which approximate information can be coded as all-natural numbers. This will enable us to use the insights acquired to points like discovering formulas, LLMs (“large language designs”) and various other AI systems.

Only very little mathematical knowledge is called for to comprehend these considerations. I am mosting likely to discuss points in little steps. For viewers that know with mathematics and experienced in it, the presentation might be also easy in places and as a result probably boring at times, yet I desire it to be understandable for as many prospective readers as feasible. Schoolchildren who are simply discovering mathematics ought to be able to adhere to the reasoning.

I am mosting likely to use the concepts of “formal theory” or “formula” mutually. You can think about an algorithm as a computer program, an app, written in some shows language.

The set of all-natural numbers shows up simple. We create these numbers by counting. We start with 1, and for every number, we can create its follower: from 1 we count to 2, from 2 to 3, and so-on.

We can designate residential properties to numbers. For example, we can say that a number is weird, that it is also, that it is smaller than another number, etc. It appears very easy to write a program that produces declarations regarding all-natural numbers. For instance, we might write a program that informs us whether a number provided to it as an input is even. For instance, if we represent the numbers in the typical decimal symbols, as a string of figures, we can simply check out the last number. If it is among the figures 0, 2, 4, 6, or 8, the number is even.

Such a formula can offer us either worths, “true,” if the input is an also number, and “false” if it is not. It can generate declarations like” 1 is not also,”” 2 is also,” etc. Another variation of such a formula could give us some even more compact symbols like 1 f, 2 t, 3 f, 4 t, etc (where the number represents the input, f the result “incorrect” and t the outcome “real”), or it might simply only generate the output worths f and t, producing an outcome series “ftftftft …” for the input series 1, 2, 3, 4, and so on. In a manner, the programs creating these various results are equivalent considering that one of them could quickly be turned into the other.

We can go one action additionally and create a program that fills up a table: In the first column, every number that can be divided (without rest) by 1 is marked with “true.” Well, that is every number. In the 2nd column, every number that is divisible by 2 is noted with “true” (this column explains the even numbers). In the third column, every number divisible by 3 is marked with real, and so on.

In the complying with visuals, the reality value “real” is stood for by black rectangular shapes, “false” by white ones. The dots show that the table proceeds, i.e. we can create as many additional lines and columns as we desire and as our resources, like time and storage room, allow.

Someone who has discovered to create programs can quickly write a program that will certainly fill up such a table. We can start in the upper left edge, with the” 1, 1-rectangle. After that we could fill the two nearby rectangular shapes” 2, 1 (that is the one below the initial one) and” 1, 2 (first line, 2nd column), then we proceed with” 3, 1,” 2, 2, and” 1, 3, and so-on. The following graphic shows in which sequence the areas will be loaded:

Using such a method we can load the table regarding we want. There are other possible ways to undergo all fields of such a table methodically, but regardless, this technique functions.

Each of the columns of this table represents a predicate on all-natural numbers. Much more particularly, a predicate with one variable: x is divisible by 1 (column 1, x is divisible by 2 (column 2, x is divisible by 3 (column 3, and so-on. We can likewise view the whole table as representing a predicate with two variables “x is divisible by y.”

We can think about an algorithm that can load this table as a formula that enumerates the predicates that are represented by the columns. Since it will one way or another fill up every field of the table, it can calculate all of these predicates, so these are not just bases on the all-natural numbers, they are additionally computable predicates. [v] We can, therefore, take the table algorithm and acquire formulas for computing each column from it. It can thus be considered as (or be turned into) an algorithm that mentions algorithms for each column. [vi]

What we can see in the table is that the algorithm produces a pattern. Each of the columns can also be considered as a pattern. If you understand how to configure in among the typical shows languages, you will most likely have the ability to compose a program creating this table with much less than a page of program code. The formula can be formulated as a finite text, i.e. a string of symbols (letters, numbers, unique characters) in a programs language. So, it contains a finite– and in this easy instance, tiny– quantity of information. We can think about the length of this program message as a step for the complexity of the pattern. I will come back to that idea in a later instalment.

It is feasible to stand for the whole table as a string of icons in some symbols as well. We could, for instance, compose the line- and column numbers in decimal notation, divided by a comma, and afterwards the letter “t” for true or “f” for false. So, for each and every field of the table, we can have something like” 1, 1, t”,” 2, 1, t”,” 1, 2, f”,” 3, 1, t”,” 2, 2, t”,” 1, 3, f” and so-on. If we presume a typical way to undergo all areas of the table, like the one defined above, we can create this equally as a string of letters standing for the fact worths designated to the areas of the table in the order we undergo them, like “ttfttftfff …” and so-on.

If we let the formula run for time and fill in the table more and more, the complete amount of data it creates will, at some time, come to be bigger than the formula’s very own size as a program message. We can after that see the formula creating this data as a pressed summary of this information.

Data compression requires that the data contains some regularity. It must be, in some basically complicated means, patterned or repeated. In the formula explaining this regularity, this monotone will certainly turn up in the form of loops [vii] that go through the same sequence of procedures consistently.

Allow us summarize a variety of insights we could leave this basic instance and mean some more concepts that will certainly be explored in later installments:

An algorithm describes a pattern.
An algorithm contains a limited amount of information. Considered as a text in a programs language, it has a limited length.
A short formula can produce an output that is a lot longer than itself (in fact, an arbitrarily long output) by means of loopholes or other shows language constructs that enable it to go through the exact same operations consistently. This causes the data created by it to reveal regularities, i.e. to be formed.
An algorithm can be deemed a pressed type of the data it generates or “explains” (if the quantity of data created is larger than the size of the algorithm).
We can think about the compression of the information into the algorithm as a process of folding or rolling up the data, resulting in the loop structure of the algorithm. Alternatively, we can picture the generation of information by the running program as an unfolding or presenting that leaves the outcome information as a track.
The formula can be viewed as a summary of the pattern or uniformity of the produced information. We can think about it as knowledge defining that data.
A formula generating a table like the one in the example can be deemed creating a list (i.e. a phoned number series) of algorithms for the functions defined by each column (in this instance, basic one-variable predicates).

In the following installation, we will certainly see that if we have such a table of predicates (or a formula producing such a table) and we are provided another predicate or set of predicates (e.g., explained by one more algorithm), we can combine such a predicate or collection of predicates right into the existing table, i.e. produce a (perhaps more complex) formula that creates a much more intricate pattern having all columns from both preliminary collections.

This causes the inquiry whether it is feasible to build a formula that is universal, i.e. which contains all feasible computable predicates merged right into one super-table or super-pattern. I will introduce a straightforward technique, called “diagonalization,” by which we can always create a brand-new predicate (column) not included in a provided table. Utilizing that, we will see that a global table or formula can not exist, i.e., it is not feasible to identify all the determinable predicates with a solitary algorithm. Considering that the fields of such a table stand for simple statements regarding natural numbers, like” 2 is also” or” 19 is divisible by 3,” this means it is not possible to acquire all computable true statements (and just these) concerning all-natural numbers by means of a single algorithm. We are going to see that every such algorithm is insufficient, i.e., there are constantly extra true and computable statements concerning the natural numbers than can be computed by any kind of single algorithm or can be acquired within any kind of single official theory.

As we will see later on, this result points towards the limits of formalizability and the limits of artificial intelligence.

REFERRALS

(Keller,2025 Keller, A. “Creativistic Viewpoint: Discovering the Restrictions of Formalization, # 2– From Astrology to ‘Artificial Intelligence'” Against Expert Philosophy 17 August. Readily available online at URL = < < https://againstprofphil.org/ 2025/ 08/ 17/ creativistic-philosophy-exploring-the-limits-of-formalization- 2 -from-astrology-to-artificial-intelligence/ >.

(Smith, 2024 Smith, G. “Newton’s Philosophiae Naturalis Principia Mathematica ” In E.N. Zalta and U. Nodelman (eds.), The Stanford Encyclopedia of Approach. Winter Version. Readily available online at URL = < < https://plato.stanford.edu/archives/win 2024/ entries/newton-principia/ >.

(Wikimedia, 2006 Wikimedia. “Various Spirograph Layouts.”Avaliable online at URL = < < https://commons.wikimedia.org/wiki/File:Various_Spirograph_Designs.jpg >.

NOTES

[i] The photo shows numerous patterns produced with a Spirograph, a toy from the age before personal computers became available. The Spirograph can be used as a metaphor for algorithms that create patterns– and can, naturally, be substitute by computer programs.

[ii] © Andreas Keller 2025 All rights scheduled, consisting of the right to use this text or sections or translations thereof as training information or part of training data of AI systems or artificial intelligence systems. Utilizing this job or parts thereof as training data or component of training information of an AI system or artificial intelligence system requires prior composed permission by the writer.

[iii] See also (Keller,2025

[iv] (Smith,2024

[v] In later installations, we will certainly see that predicates that are not computable can really be defined.

[vi] We can quickly generate a formula for the column with a specific column number n (e.g., n = 5 by wrapping a small program around the table formula that allows it run and that only result those results that have the column number 5, disposing of all various other outcomes. This would be an extremely ineffective remedy and there are smarter ways of doing this, however it would certainly constantly function.

[vii] Or some other equivalent concept, like “recursivity,” depending on the programs language, but these technological details do not require to issue us here.

Download and install