TupperTransformer (A Novel Image Processing Algorithm)

Note: This project is in a very early, experimental stage.

Welcome to my repository. This project is my exploration of a new image processing technique based on my 2018 preprint, "Transformation of the pixels in Tupper's self-referential formula."

This algorithm operates directly on the high-precision integer (k-value) used to generate Tupper's self-referential bitmaps, rather than manipulating the pixels after they are rendered. This repository contains the interactive demo that serves as the proof-of-concept and implementation of that research.

Live Demonstration

Experience the algorithm in action with the new and improved interactive demo. The interface has been completely redesigned to be more intuitive and mobile-friendly.

Click here to open the live demo

About the New Demo

The interactive demo brings these concepts to life with a simple, unified interface designed for both desktop and mobile use.

The layout is organized into two main columns on larger screens:

Left Column (The Canvas & Workspace)

This is your main area for interaction.

• The Plot: The $106 \times 17$ grid where the formula is rendered, exactly as Tupper's inequality plots it for $k \le y < k+17$. You can draw on the plot by clicking and dragging: each pixel $p_i$ you add or remove changes k by $\pm 17 \times 2^{i-1}$. Hovering shows the pixel's index $p_i$. Untick "Draw on the plot" to scroll over it on a phone.
• Last operation: The line under the plot shows the paper's equation behind the last change, for example Move right: k′ = k × 2^17.
• Transform Controls: Move the entire pattern up ($k \times 2$), down ($k \div 2$), left ($k \div 2^{17}$), right ($k \times 2^{17}$), or diagonally. Click for one step or hold to repeat. Holding for more than half a second keeps it moving until you press Stop.
• K-Value: The high-precision integer k is always visible below the controls. It updates in real time as you draw or transform the image. You can also paste a k value directly into this box, and the plot will update automatically.

Right Column (Actions & Examples)

• Clear Canvas: Start over with $k = 0$.
• Examples: Load Tupper's self-referential plot or the UFO from the paper.
• Films from the paper: Both films are built with the framing formula (D), $k^\circ = f_1 k + f_2 k' + f_3 k'' + \dots$. Play, pause, or step one frame at a time.
  • Eg 3.1 (UFO): The same transformation, $k \times 2^{17}$, is applied to each frame to get the next, so the UFO flies right until it leaves the window.
  • Eg 3.2 (Tetris): $k = k_r + k_s$. Only the falling L piece $k_s$ is transformed, while the stack $k_r$ stays put. The 15 frames reproduce the k-values printed under the paper's frames.
• Library of Babel: Random k = 17 × (random 1802-bit number), so every one of the $2^{1802}$ possible images is equally likely.

Other Features

• Clickable Formula: Click the main Tupper's formula at the top of the page to instantly load the self-referential plot.

Notes on the Implementation

• Pixels follow the paper's equation (A): $p_1$ is the bottom-left pixel, $p_2$ the one above it, and $p_{18}$ the bottom of the next column.
• Pixels are stored column by column, so a pixel moved up past the top row reappears at the bottom of the next column (17 moves up equal one move right, as the paper derives). Pixels pushed out of the window are dropped, and every edit keeps k a multiple of 17.
• The k printed in the paper's introduction (and on Wikipedia) assumes reversed axes. In the paper's own layout it draws the formula rotated 180°, so "Load Tupper's" uses the same image encoded for this layout.

About the Paper (Algorithm Summary)

My research paper is based on Tupper's self-referential formula, which is popular due to its property of plotting itself. But that is not the only amazing thing about this formula: it doesn't only plot itself, but it plots every possible combination of the $106 \times 17$ pixels.

I.e. it plots all possible combinations of these 1802 pixels, and the value of k is used for sliding over the y-axis.

A copy of the paper is also available in this repository in the paper directory.

My research idea started with a question:

"If there is some graphical formation at a particular value of k, then what can be done to change the graphical formation or to change its position?"

This question leads to my research, which has two main ideas:

1. How to change any graphical formation into another graphical formation by applying some kind of operation to the value of the k.

2. How this different graphical formation can be used as a frame to create a film or motion picture.

What can my research do?

My research can do the following:

• Represent all possible graphical formations (within 1802 pixels) and all their possible variations.
• Create a formula for any film or motion picture.

In short, my research represents a mathematical form of the "Library of Babel" but for film and motion pictures.

Citation

If you use this work, please cite the original preprint.

Formatted Citation (APA Style)

Deshmukh, P. (2018). Transformation of the pixels in Tupper's self-referential formula. Figshare. https://doi.org/10.6084/m9.figshare.6373046

BibTeX Citation (Recommended)

@misc{Deshmukh2018,
  author    = "Prathamesh Deshmukh",
  title     = "{Transformation of the pixels in Tupper's self-referential formula}",
  publisher = "Figshare",
  year      = "2018",
  month     = "6",
  url       = "https://figshare.com/articles/preprint/Transformation_of_pixels_pdf/6373046",
  doi       = "10.6084/m9.figshare.6373046"
}

For a full list of publication details, indexing, and archive links, please see the CITATION.md file in this repository.

History & Related Materials

History

• 2018-06-08 - First online date, Posted date

Related Materials

• Tupper's Self-Referential Formula Explained
• Tupper's Formula Tools (defunct)
• Numberphile: The 'Everything' Formula
• Margaret Fortman: Tupper's Self-Referential Formula (Lake Forest College, 2015)
• Jeff Tupper: Reliable Two-Dimensional Graphing Methods (SIGGRAPH 2001, the original paper)

Technologies Used

The interactive demo is built with standard web technologies:

• HTML5: For the structure of the web page.
• CSS3: For styling the user interface.
• JavaScript (ES6+): For the core logic of the TupperTransformer algorithm and user interactions.
• BigInt: Natively handled in modern JavaScript for the high-precision integer arithmetic required for the k-value.

Project Structure

The repository is organized as follows:

.
├── paper/
├── CITATION.md
├── index.html
├── LICENSE
├── README.md

• paper/: Contains the original 2018 preprint that this project is based on.
• index.html: The core file for the interactive web demo, containing all HTML, CSS, and JavaScript.
• CITATION.md: Provides detailed citation information for academic use.
• LICENSE: The MIT license for the project.
• README.md: This documentation file.

Future Work

I will be creating some more advanced features as I get free time. This includes exploring more complex transformations and further optimizing the rendering process.

Contributing

I am open to suggestions and collaborations. If you have any ideas or would like to discuss implementing this research, please feel free to open an issue to start a conversation.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Categories & Keywords

(From Figshare)

Categories

• Theory of computation
• Applied computing
• Image processing
• Applied mathematics

Keywords

• tuppers-formula
• tuppers-self-referential-formula
• image-processing
• algorithm
• math
• theory-of-computation
• applied-computing
• applied-mathematics
• computation-theory
• applied-computer-science
• javascript
• interactive-demo
• preprint
• bigint