Creativistic Philosophy: Exploring the Limits of Formalization, #4–Extending Algorithms.
By Andreas Keller
***
You can also download and read or share a .pdf of the complete text of this essay by scrolling down to the bottom of this poast and clicking on the Download tab.
***
Creativistic Philosophy: Exploring the Limits of Formalization, #4 — Extending Algorithms [ii]
In this installment of the creativistic philosophy series, we will continue with our investigation of simple patterns and the algorithms that produce them. Actually, these ideas work just as well for complex patterns produced by complex algorithms, but our examples will be very simple. Like the previous one, the current installment is a bit technical. Both do not look very philosophical yet, but they provide us with some concepts we can use later, when things will be getting more interesting. The connection to philosophy, specifically the philosophy of creativity, will become clear later.
The example we looked at in the previous installment[iii] was a table in which each column represents a predicate on the natural numbers. In this example, each column marks the numbers divisible by the column number, e.g., column 2 marks the even numbers. We can view an algorithm generating such a table as one that enumerates algorithms for the single columns.[iv]
Now imagine you want to add another predicate to our table, e.g., one that tells us if a number is odd. We can easily add it to our table by shifting all table elements by one place and push in the new column as the new first column. The result looks like this:[v]
The predicates in each column remain the same as before, but we can no longer interpret them as “the number is divisible by the column number.” The numbers divisible by 2 are now in column 3, etc. However, this is not a problem. The columns represent the same predicates as before. We should just not refer to the column numbers in the definitions of the predicates.
The example shows that if we have an algorithm — let’s call it “A” — that enumerates predicates, i.e. produces a table like the one shown, and if we have another predicate — let’s call it “P” — then we can produce a new, extended algorithm — let’s call it “E” — that contains the same predicates as A, plus the new predicate.[vi]
If we want to insert several predicates into the table, then we can do so by shifting everything enough to make space for the new columns.[vii]
If we have two tables with an unlimited number of columns which are both generated by two algorithms — “A” and “B” — then we can merge the two into one algorithm — let’s call it “M” — by simply alternating the columns, so that in the first column of M, we would have the first column of A, in the second column of M we have the first column of B, in the third column of M the second column of A, and so on.[6] This can be compared to the way a layer cake is made, just in the vertical direction. We could do the merging in different ways (e.g., putting a B-columns after every two A-columns), but this simple layer cake method is the simplest.
To give an example, we can merge the table shown above with another one, for example this one:
We can interpret the predicate in each column here as “n is smaller than or equal to m”, where m is 1, 2, 3, etc. The merged table would then look like this:
As a result of such operations, a table might contain several columns that look the same, i.e. that are equivalent. The algorithms for these columns might be identical or different. Such cases are no problem, we do not require that each column in our table is unique. We can, therefore, also produce a table with an unlimited number of columns from a finite number of columns by simply repeating the columns.[ix]
Let us now sum up, and slightly extend, what we have learned in this installment:
- If we have an algorithm that enumerates predicates (or more generally: functions), then we can transform it into another algorithm that enumerates the functions/predicates in another order or shifts them to different columns. The patterns represented by the columns will remain the same, the table-pattern will change.
- A simple example is shifting the contents of the table to make space for another pattern/predicate/function.
- We could also rearrange the sequence of columns in any other way that can be expressed in our enumerating algorithm.
- It is advisable not to refer to column numbers when formulating the algorithms for single columns since the columns might be shifted around.
- The results of two enumeration algorithms, producing two tables, can be merged into one, e.g., by alternating their columns in the merged table, akin to the layers of a cake.
- If we have an algorithm enumerating algorithms for predicates (or other functions), and we have another computable predicate/function, we can always extend the original enumerating algorithm. The simplest way is by shifting all columns by one and inserting the new predicate as the new first column.
- Since algorithms and formal theories are equivalent, this means we can always extend formal theories with additional knowledge, so statements not derivable in the original theory (in the example, this would be statements like “3 is odd” and “6 is not odd”) can be derived in the extended theory.
- Note that the algorithm in our example does not yet “know” that “even” or “divisible by 2” means “not odd” and that “odd” means “not even.” As a general rule, always assume algorithms to be stupid, i.e., don’t assume they know something you know or something that for you goes without saying.
- We allow columns to have the same content. Our table producing algorithms, i.e. our enumeration of column algorithms, might produce algorithms for columns that are equal or that are equivalent in the sense that they produce the same outputs for the same inputs in all cases.
- We can refer to the algorithms producing single columns by the name of the algorithm producing the enumeration (table) with the column number as an index. This notation will make later discussions a bit more compact and easier to understand.
As announced in the previous installment, I will introduce a way to generate a new predicate for each enumeration/table of predicates. By “new” in this context, I mean that it is a predicate that is not contained in the given enumeration. We are going to see that this is always possible. We can then, of course, merge this new predicate into the old enumeration (by shifting all columns and inserting the new one), thus giving us a new, extended algorithm. However, we can repeat the operation to generate a new predicate not contained in that extended algorithm, producing another new predicate, and so on. This will be the topic of the next installment.
NOTES
[i] The layer cake in this picture was made by slicing a cake and alternating layers of cream between the slices. This can be seen as a model of how two tables can be merged by inserting the columns of the second table alternately between the columns of the first table.
[ii] © Andreas Keller 2025. All rights reserved, including the right to use this text or sections or translations thereof as training data or part of training data of AI systems or machine learning systems. Using this work or parts thereof as training data or part of training data of an AI system or machine learning system requires prior written permission by the author.
[iii] (Keller, 2025).
[iv] There is a saying that every equation halves the number of readers — or book sales: this is attributed to Stephen Hawking or his publisher, see (Hawking, 1988). This probably also holds to other lines of formalisms, not just equations. Therefore, I am trying to keep mathematics-like formalism to a minimum. In some cases, I will put it into the notes, so readers can more easily skip it. Having said that, let me introduce a notation here: If we have an algorithm that produces the whole table and we give that algorithm a name, e.g. “A”, then we name the algorithms for the single columns with the column number as an index: A1, A2, A3 etc., or in general, An, where n is the column number.
[v] Remember that in these examples, a black rectangle stands for “true” and a white one for “false.” So the first and third rectangle of the new first column are black because 1 and 3 are odd numbers, the second rectangle is white because 2 is not.
[vi] Using the index-notation introduced above, we can define E by:
E1 := P
En := An-1 if n > 1
“:=” means “is defined as.” So the first (i.e. n = 1) column is the new predicate P and the other (i.e. n > 1) columns are those of A, shifted by one place. The shifting is done here by the “n-1.” This pseudocode can easily be translated into corresponding formulations in real programming languages.
[vii] Instead of inserting the new predicates at the beginning of the table, we could also insert them at other locations (as a block) or intersperse them individually. The resulting algorithm would be somewhat more complex in such cases, but would generate the same predicates, only in a different order.
[viii] So we can define M by:
Mn := A(n+1)/2 if n is odd
Mn := Bn/2 if n is even
[ix] In a later installment, we are going to see that it is impossible in the general case, i.e., for two arbitrary algorithms, to decide whether they are equivalent, i.e., produce the same output for each input. We cannot write an algorithm that will be able to successfully make such a test in all instances. Since we cannot reliably detect the equivalence of column-generating algorithms in the general case, it would be unwise to disallow equivalent columns and to require the columns to be unique, so that no two columns may contain the same values.
REFERENCES
(Gatilao, 2015). Gatilao, A. “Seven Layer Coconut Cake: Our Favorite Dessert of the Night.” Wikimedia. Available online at URL = <https://commons.wikimedia.org/wiki/File:Seven_Layer_Coconut_Cake._Our_favorite_dessert_of_the_night._(16453164766).jpg>.
(Hawking, 1988). Hawking, S. A Brief History of Time. London: Bantam Books.
(Keller, 2025). Keller, A. “Creativistic Philosophy: Exploring the Limits of Formalization, #3. — Patterns and Algorithms” Against Professional Philosophy. 7 September. Available online at URL = <https://againstprofphil.org/2025/09/07/creativistic-philosophy-exploring-the-limits-of-formalization-3-patterns-and-algorithms/>.
***
AGAINST PROFESSIONAL PHILOSOPHY REDUX 1043
Mr Nemo, W, X, Y, & Z, Monday 29 September 2025
Against Professional Philosophy is a sub-project of the online mega-project Philosophy Without Borders, which is home-based on Patreon here.
Please consider becoming a patron!
