Mage of the East

RSS Available

Sun, 19 Apr 2026 22:46:09 +0200

RSS Available

This website has an RSS feed now!

https://mage-of-the-east.com/rss.xml

Blessed are the Misfits

Tue, 24 Mar 2026 00:38:12 +0100

Blessed are the Misfits

A review of Madeleine L'Engle's A Wrinkle in Time.

Personal rating: 5/5

Recommended if you like:

The Catcher in the Rye

The Neverending Story

The Little Prince

The Gray House by Mariam Petrosyan

His Dark Materials (with a caveat! See below.)

If you're a misfit, if you're different, if you stand out, if you are born with a strong stubbornness, with a brain that works differently, with a keen eye that most people lack, if you find it hard to control your anger, pain, joy, love, if you are constantly told that you're “too sensitive” or “too out-of-place” or “thinking too much” …

(If you're like me …)

… You would love this book.

Read more on mage-of-the-east.com

If Devotion had a Color

Sun, 15 Mar 2026 22:03:28 +0100

If Devotion had a Color

A review of Amal El-Mohtar and Max Gladstone's This Is How You Lose the Time War.

Personal rating: 4/5

May contain some lightweight spoilers. Think before you continue reading.

Read more on mage-of-the-east.com

Aronson's sequence visualized

Mon, 24 Nov 2025 08:53:32 +0100

Aronson's sequence visualized

A visualization of the Aronson's sequence: T is the first, fourth, eleventh, … letter in this sequence.

This is an interactive article. Read more on mage-of-the-east.com

Saphyra 2025 Spring Report

Tue, 1 Apr 2025 02:07:19 +0200

Saphyra 2025 Spring Report

On April 1, 2025, the following theorem was successfully formalized in Saphyra:

✅ √2 is irrational

Which brings the percentage of Prof. Wiedijk's 100 theorems formalized in Saphyra to:

This is an important milestone for Saphyra: I consider it to be the first nontrivial theorem, one that requires significantly more organization and care than basic theorems (such as the associativity of +). I have bumped the version to v0.3.0 after the addition of this proof.

The theorem and its proof can be viewed on Saphyra Web as the statement: ∀ n ↦ (r2denom:<OP> @ n) -> false which can be read as “no natural number can be a denominator of √2”.

Please allow a few seconds for the proof repository to load. The theorem can be found at the bottom of the page (on the left side). Click on a “open/close” button to see details of a part of the proof.

What's new

From v0.2.0 to v0.3.0, a lot of new features were added. All of them are crucial for a fully-featured proof assistant, and most of them are crucial for the proof of “√2 is irrational”.

Definitions.
- New definitions are made using defining statements, such as ∀ a ↦ ∀ b ↦ (a le:<OOP> b) = (∃ t ↦ a + t = b), which defines the le:<OOP> symbol, for the “less than or equal” relation (≤).
- Each definition node has an extra out-link, simply labelled like def @ le:<OOP>. This link is required when making a new definition dependent on the first one (such as defining lt:<OOP> using le:<OOP>), which prevents circular definitions.
Focusing.
- Instead of showing the entire proof repository, the user can now focus on a single part of the proof by clicking on the fish-eye button — ◉ — which hides the rest of the repository.
Speedups.
- Some caching is added to speed up the verification and saving processes.

All of this made the trip to the first nontrivial theorem much easier.

What's next

Although the first nontrivial theorem is now proven, a lot of things are still missing.

A node editor can be tremendously beneficial: it would allow better organization, easier understanding, and freer development.
The syntax can be updated to reduce visual noise.
More automation, such as a tactic for polynomials, will reduce a lot of manual work.
Modular structure: allow proof modules to depend on one another.
More lemmas: such as those regarding divisibility and primes.
More theorems: aim to keep growing.

This is the largest and most fun personal project I have made, and I'd love to see how far I can go.

Final Post of 2024

Tue, 31 Dec 2024 23:59:04 +0100

Final Post of 2024

A tiny puzzle for the end of 2024, for all readers of my website! Best viewed on desktop.

This is an interactive article. Read more on mage-of-the-east.com

Saphyra 2024 Fall Report

Sun, 10 Nov 2024 07:29:13 +0100

Saphyra 2024 Fall Report

This is a modified copy of the current README.md on Github.

Beautiful mathematics at your fingertips.

Overview

Saphyra /səˈfaɪ.ɹə/ is a proof assistant under active development, a personal project created and maintained entirely by @pennzht.

Saphyra aims to be simple and user-friendly. As of October 25, 2024, the proof repository has 67 tautologies and 17 natural number theorems verified. Tactics exist for each axiom, and also for rewriting equations based on proven statements.

Visit Saphyra Web to explore the current proof repository. Loading may take a few seconds.

Foundations

Currently Saphyra is built on a foundation of higher-order logic and Peano arithmetic, but it can be adjusted to use other rulesets, such as set theory. The axioms can be found in axioms.js.

Each proof or collection of proofs is a node. A node may have inputs, outputs, and subnodes, representing a conditional truth that if all inputs hold, and if all subnodes are valid, then all outputs hold. In a sense, a node is similar to a sequent, and subnodes are other sequents which the parent node depends on. Unlike a sequent, a node's outputs are conjunctive instead of disjunctive.

The verification process is defined in proof_module_2.js.

Interface

Saphyra uses a Web interface. Using the buttons “Export entire state” and “Import entire state”, one can import a proof repository, work on it, and save it. Clicking on goals (statements not yet proven) will show usable tactics on the right, where the user can provide parameters and apply them.

The menu “Step history” provides basic undo/redo support.

Nodes may be folded to unclutter the view.

Roadmap

Prof. Freek Wiedijk maintains a list of 100 theorems and their formalizations. This is a good measure of both the maturity of a proof assistant and the maturity of formal methods as a field.

By December 15, 2024, I aim to prove the following in Saphyra (2 of 100 theorems):

Irrationality of √2
Infinitude of primes

By March 31, 2025, I aim to prove the following (15 of 100 theorems, accumulated):

Divisibility by 3 rule
The Fundamental Theorem of Arithmetic
The Number of Subsets of a Set
Wilson’s Theorem
Euler’s Generalization of Fermat’s Little Theorem
The Denumerability of the Rational Numbers
The Binomial Theorem
Konigsberg Bridges Problem
Sum of a Geometric Series
The Cauchy-Schwarz Inequality
The Intermediate Value Theorem
Principle of Inclusion/Exclusion
Schroeder-Bernstein Theorem

The Uira text editor

Mon, 16 Sep 2024 19:39:13 +0200

The Uira text editor

Uira is a text editor I made as a fun project. I use it as a challenge to myself to make a simple, usable text editor within one month. It turned out quite suitable for my own writing needs.

Uira is written in Python, currently unoptimized. Most features are implemented in the most naïve way possible. Each text buffer is represented as an array of characters, and any edit simply creates a new array in the history. Whenever a buffer changes, the editor simply re-typesets the entire passage, and displays it on the screen. Syntax highlighting is only regex. Autocomplete just gets all word-like strings in the file and sorts them by decreasing frequency. This is surely slow for text files longer than 300 lines, but it turns out to be perfectly fine for small files.

Because I wrote Uira from scratch, I can add any feature to it in Python, without the need to look up the Emacs manual for Elisp or API usage. I haven't added any support for extensions (which may require a scripting language such as Lua), but now the editor is simply extensible by editing the code itself, taking advantage of the extensibility of the host language. I added two features, which I like a lot: The de Bruijn leap allows me to jump to any character on the screen, using three-letter coordinates based on de Bruijn sequences, and templates with holes let me insert a predefined template with “holes” and jump to each hole to insert some text (such as the function name, argument list, and function body of a function definition).

I don't expect Uira to be used by anyone other than me. But developing, using, and extending it has been very fun, and I might switch to it as my primary working editor instead of Emacs. I have already set my git editor to Uira, and now I write every commit message with it. I spent a few sleepless early mornings perfecting it, but the result is definitely worth the work. Due to my personal plans, I might not be able to work on it for the next few months, but I absolutely would like to continue improving it early 2025.

Joy in a Closed Box

Sat, 10 Aug 2024 19:09:33 +0200

Joy in a Closed Box

A review of Kenji Takemoto's Loss of Joy in a Closed Box.

Read more on mage-of-the-east.com

Building Odd-ordered Magic Squares

Mon, 8 Jul 2024 21:40:35 +0200

Building Odd-ordered Magic Squares

Build magic squares of odd order.

This is an interactive article. Read more on mage-of-the-east.com

In the Cold of Summer

Sun, 23 Jun 2024 08:45:07 +0200

In the Cold of Summer

After the downpour — an incessant drummer,
Flashing sky-fires and roaring rumblers —
The gentle chill of Zephyrus again rises,
And from the dark forest the genius reprises
Winged songs of old, in the cold of summer.

Music is a form of Reason

Tue, 18 Jun 2024 09:12:37 +0200

Music is a form of Reason

Disclaimer: I have not received any rigorous training in Arts (except some musical). Read this article as personal rambling instead of professional opinion.

Music is a form of Reason.

From the mathematical subdivision of bars and beats, to the frequency relations between harmonious note combinations, Music is filled with structure and similarity. The word “reason” comes from Latin “ratiō”, a callout and reminder to the olden days, when Pythagoreanists explored music using numbers.

Unlike Painting, which heavily owes its origin and inspiration to imitation of Nature, Music feels more like an abstract human construction. It's true that Music sometimes borrows from Nature (such as instruments mimicking the sound of birds or rivers), but musical beauty usually lies in repetition and coherence, the same reason why meter, rhyme, and alliteration are valued in poetry.

In this spirit, Music resembles Mathematics and Logic, and some Architecture: it is a kind of formalism, a celebration of Pattern itself, a masterpiece of the human mind.

Therefore, I consider Music a form of Reason.

Inevitable is Fate; unmissable is Destiny

Tue, 18 Jun 2024 09:12:37 +0200

Inevitable is Fate; unmissable is Destiny

A review of D-Pad Studio's video game Owlboy. Includes a few screenshots.

Personal rating: 5/5

Do you remember the feeling of emptiness after reaching the end of a book, a film, a game? A longing for a world behind the screen, between the pages? Some call it “post-fiction depression”; others call it “electronic heartbreak”. Those who experience this longing are doomed to return and relive the story, sometimes hoping to lose all memory of it in order to see everything as if it's the first time.

This is how I feel after playing Owlboy.

Read more on mage-of-the-east.com

Saphyra 2024 Spring Report

Tue, 2 Apr 2024 09:46:43 +0200

Saphyra 2024 Spring Report

Also published on GitHub

Saphyra is a proof assistant under development, with simplicity and user-friendliness as goals. As of April 1, 2024, it is able to verify some simple statements about natural numbers and automatically prove (propositional) tautologies with ≤ 6 atomic statements (the limit is artificially imposed to avoid long running loops). A Web user interface is also added, so you can prove propositions by clicking on suitable tactics.

This software is in its early stages and incomplete, but I have plans to continue developing it and improving it.

Click here to try the Web demo

Using the Web demo

Prove a given goal:

Click on the “incomplete” tab to enter this workspace.
The red block on the left is a goal not yet proven; click on it to see a list of tactics.
Apply the tactic impl-intro to create a subgoal: proving (B → (A and A) and B) using A.
Use impl-intro on the new goal again.
Use and-intro twice to destruct the goal into A, A, and B.
A is an exact match with the assumption A; use exact-match to resolve.
Similar for B.
Now the entire workspace is verified.

Prove a custom goal:

Click on the “empty” tab.
Click on “node #root” on the top-left.
On the right, enter a new goal, such as (-> (and _A _B) (-> _C _A)), then click “Apply”.
Click on the new goal on the left, and select the tauto tactic.
Now the entire workspace is verified.
Click on “open/close” under “node #0” to see the whole proof.

Foundation and Proof Structure

Currently, Saphyra uses Peano Arithmetic as the foundation, but it can be extended (in the future) to use alternate foundations.

Proofs are structured as nested nodes. Each node represents a conditional truth, similar to a sequent; the following node, for instance, represents that “from the statements (X → Y) and (Y → Z) and X, we can derive Z”. Unlike a sequent, a node's outputs are conjunctive instead of disjunctive.

The node contains subnodes (here hidden) that when combined, proves Z from the assumptions using built-in axioms. Each statement is suffixed with the justification: whether it is given, or derived from a rule.

In a large proof, nodes represent structure; in the interface, nodes may be expanded or collapsed, so the user can focus on important parts of the proof.

The entire workspace is also a node, usually named “#root”.

Below is the internal representation of a successful proof.

[node #root [] [[forall [: _x:O [= _x:O [+ _x:O O]]]]] [join] [ [comment This is a proof of the theorem: forall x, x = x + 0.] [node #2 [] [[forall [: _x:O [= _x:O [+ _x:O O]]]]] [forall-intro] [ [node #1 [] [[[: _x:O [= _x:O [+ _x:O O]]] _v0:O]] [join] [ [node #3 [] [[= [[: _x:O [= _x:O [+ _x:O O]]] _v0:O] [= _v0:O [+ _v0:O O]]]] [beta] []] [node #4 [[= [[: _x:O [= _x:O [+ _x:O O]]] _v0:O] [= _v0:O [+ _v0:O O]]]] [[= [= _v0:O [+ _v0:O O]] [[: _x:O [= _x:O [+ _x:O O]]] _v0:O]]] [=-sym] []] [node #5 [[= [= _v0:O [+ _v0:O O]] [[: _x:O [= _x:O [+ _x:O O]]] _v0:O]] [= _v0:O [+ _v0:O O]]] [[[: _x:O [= _x:O [+ _x:O O]]] _v0:O]] [equiv-elim] []] [link #3 #4 [= [[: _x:O [= _x:O [+ _x:O O]]] _v0:O] [= _v0:O [+ _v0:O O]]]] [link #4 #5 [= [= _v0:O [+ _v0:O O]] [[: _x:O [= _x:O [+ _x:O O]]] _v0:O]]] [link #5 ^c [[: _x:O [= _x:O [+ _x:O O]]] _v0:O]] [node #6 [[= [+ _v0:O O] _v0:O]] [[= _v0:O [+ _v0:O O]]] [=-sym] []] [link #6 #5 [= _v0:O [+ _v0:O O]]] [node #7 [] [[= [+ _v0:O O] _v0:O]] [+-O] []] [link #7 #6 [= [+ _v0:O O] _v0:O]] ]] ]] [link #2 ^c [forall [: _x:O [= _x:O [+ _x:O O]]]]] ]]

Statement Syntax

Statements are entered in a Lisp-like format, with variables (propositions or objects) beginning with an underscore (_).

Statement	Code
A	`_A`
(A and B) → C	`(-> (and _A _B) _C)`
not A (equivalently, A → false)	`(-> _A false)`
∀ x : Nat, x = x	`(forall (: _x:O (= _x:O _x:O)))`

Codebase Introduction

js/ contains the code for the Web demo.

The entry page is located at start.html, which provides the page layout and imports JS files.
run.js contains most functionality for the user-interface.
axioms.js contains axioms for first-order logic and Peano axioms that can be verified by simple pattern-matching. More complicated axioms, such as impl-intro, are given in proof_module_2.js
lisp.js contains an implementation of a minimal Lisp language. It is intended to be used for writing tactics, but is currently inactive.
toposort.js implements topological sorting for dependencies of nodes, which denies circular reasoning.
lambdas.js provides utilities necessary for lambda expression reasoning.
simple_typing.js offers a simple type system.
proof_module_2.js is the main verifier. It takes a node (usually the entire proof tree), points out any incorrect nodes, and annotates the nodes for user-friendly displaying.
nodeviz.js visualizes various objects. For example, dispStmt(obj) displays a statement in a user-readable way.
tree_derivs.js contains some example derivations.
tactics.js provides tactics.
- When the user selects a statement or a node, functions in tactics.js determine which rules or tactics are suitable for usage on that statement.
- When the user selects a tactic, functions in tactics.js apply that tactic on the proof tree, generating a new #root node.
- The tauto tactic breaks down the situation into 2^n cases, where n is the number of atomic statements in the goal, and uses suitable axioms to prove (evaluate) each case.

src/ contains a Python version, which is temporarily paused.

Future Plans

Complete Peano arithmetic and add tactics for natural numbers.
Add unification for statements and types.
Switch to ZFC / ETCS / Dependent Types as foundation, so that it may formalize most of modern mathematics.
Improve automatic reasoning.

Leap Day 2024

Thu, 29 Feb 2024 09:15:40 +0100

Leap Day 2024

It's Leap Day! Once every 4 years, or more accurately, 97 times every 400 years.

Daily routine is numbing, and time flies as we toil; but this not-so-rare calendar square reminds us to step out of our comfort zones and do the important things.

I've set up 29 goals for myself that I hope to achieve by the next Leap Day, 2028-02-29.

Read more on mage-of-the-east.com

Rites of Passage

Wed, 21 Feb 2024 21:06:15 +0100

Rites of Passage

I consider some programming projects to be rites of passage: completing any of these projects gives you …

hands-on experience on a hard problem;
deep understanding of a branch of computer science;
the right to boast.

Below are some examples. This list is not intended as a judging tool for a programmer's strength, nor do I think everyone should try these tasks. But I believe they can be fun challenges for those who aim above and beyond.

Foundations

Programming language
- Must have a non-trivial syntax using infixes; think Python or Java, not Lisp or Forth.
- Must be run in some way, whether interpreted, compiled, or transpiled.
- Must support at least stdin/stdout and file I/O.
- Must allow user-defined functions.
- Must be Turing-complete in ideal conditions.
- Bonus if it supports HTTP requests, GUI, or FFI.
- Should be reasonably fast: a typical O(n) algorithm should not become O(n²), but O(n log n) is acceptable.
Visual programming language
- Similar to: Scratch or Blender nodes.
Quine
- Bonus if it's a quine cycle
Version control
- Similar to: Git.
Operating system
Proof checker / Proof assistant
- Must be able to verify formal proofs in first-order logic.
- Milestone: verify formal proofs for the irrationality of √2 and the infinitude of primes

Sciences

Scientific calculator
- Infix or postfix (RPN) notation.
- Bonus if it displays mathematical notation (for example, fractions written vertically).
Graphing calculator
- Should support most mainstream graphs: lin-log, log-log, polar, 3D, cylindrical, spherical, contour, scalar/vector fields, parametric equations, and so on.
- Bonus if it supports showing 2D/3D slices of higher-dimensional objects.
- Harder than you think!
Physics engine
- “Physics” in a general sense. Support for any subset of physics suffices: rigid body, soft body, fluid, optics, electronics, and so on.

Data / Reasoning

Chess engine
- May use either traditional or modern approaches.
- Bonus if made into a bot on a chess platform.
Neural network
- Design and train a neural network to solve a non-trivial problem.
Compression software
- Any software that can compress and decompress a collection of files using a well-established or original compression algorithm.
Encoder and decoder
- For a common image/audio/video format.

User interfaces

Text editor
- May be CLI or GUI.
- Must support undo/redo.
- Bonus for good accessibility support.
Hex editor
Calendar
- Supports ICS files.
Map
- Similar to: Open Street Map.
Spreadsheet
GUI toolkit

Auditory / Visual

Digital audio workstation
Audio programming language
- Similar to: SuperCollider
Music player
3D renderer
Image processing / creation software
- May support either raster or vector images.
- Similar to: GIMP (raster), Inkscape (vector).
Font-rendering engine / Typesetting engine / Mathematical typesetting engine
Music engraving engine
- Converts MusicXML to SVG/PDF/PNG.
- Bonus if you can edit the source, WYSIWYG!

Network

Web browser
- Supports a small portion of the Web.
- Must at least be able to view text-only, JS-free sites.
Forum / Bulletin board
Instant messaging

Other

Game
- An original, creative, enjoyable, non-trivial game.
- See also: Ludum Dare
Generative art
Time zone converter
- Converts time (moments) between time zones.
- May depend on the tz database.
- Very hard to get correct!

Web Audio: First Impression

Mon, 29 Jan 2024 23:38:19 +0100

Web Audio: First Impression

Listen to Bach's “Prelude in C Major” implemented with the Web Audio API.

(For the first time, listen without headphones on to avoid any unexpected volume.)

This is an interactive article. Read more on mage-of-the-east.com

Ambigram Expressions (13.4 MiB)

Sat, 2 Dec 2023 22:01:37 +0100

Ambigram Expressions (13.4 MiB)

Enter two integers A and B, and receive an ambigram expression: one that evaluates to A right-side-up, and B upside-down.

This is an interactive article. Read more on mage-of-the-east.com

Game of Strife

Tue, 21 Nov 2023 06:20:40 +0100

Game of Strife

A multicolor version of the Game of Life.

This is an interactive article. Read more on mage-of-the-east.com

A simple Snake solver in 60 lines

Sun, 19 Nov 2023 22:16:46 +0100

A simple Snake solver in 60 lines

Watch the computer play Snake using 60 lines of code of automation.

This is an interactive article. Read more on mage-of-the-east.com

Why Chess is played in Squares but Go (Weiqi) on Intersections

Fri, 17 Nov 2023 22:13:45 +0100

Why Chess is played in Squares but Go (Weiqi) on Intersections

What caused the difference that Chess is played with pieces placed in squares, and Go (Weiqi) is played with stones placed on intersections, despite both games relying on a square grid?

The most reasonable explanation I can think of is practicality. Bishops (and queens may) move diagonally; mentally visualizing a diagonal on a plain colorless grid is difficult and error-prone. On a checkered grid, the square colors are a visual aid to help the player make moves correctly, a parity bit.

Parity is less of a concern for Go. When stones are placed on intersections, liberties (氣; breaths) are visualized by segments of the grid connected to the stone. Furthermore, when the board is filled with hundreds of stones, most of the grid is automatically hidden beneath the stones — whereas if stones had been played in the squares, the grid would have been visible all the time, which is distracting.

A Fever Dream

Thu, 21 Sep 2023 21:28:04 +0200

A Fever Dream

A review of Mariam Petrosyan's The Gray House.

Personal rating: 4/5

Recommended if you like:

One Hundred Years of Solitude

Never Let Me Go

Logic of God, Magic of Humans (神のロジック人間のマジック)

The Gray House is a truly bizarre book. After reading the ending of this 720-page doorstop, I became utterly conflicted whether it is a rare gem or a stack of nonsense. I believe that almost everyone who read it will either love it dearly or hate it bitterly; very few would be neutral towards it.

Read more on mage-of-the-east.com

Saphyra: the Beginning

Fri, 28 Apr 2023 21:55:08 +0200

Saphyra: the Beginning

A few years earlier I started developing Saphyra for fun (called Saphira then). My main goal was to build a simple proof assistant with a minimal kernel supporting multiple theories. I wanted to see how hard it was, both to build a proof assistant and to write proofs in it.

I restarted the project last year after a three-year hiatus, out of a desire to occupy myself with side projects on weekends. It's a “big clean problem” — one with a very clear goal, plenty of challenges, and an abundance of learning and experimenting opportunities.

Saphyra aims to be a proof assistant, similar to Mizar, HOL, and Coq. The program helps the user to write formal proofs of mathematical theorems that can be automatically verified, and the proof-writing process is also aided by some level of automation.

I aim to make Saphyra …

lean:
- The kernel — the program that checks the validity and rigor of proofs — should not exceed 1000 lines of code. The more code you have, the harder it is to verify its correctness.
extensible:
- The system should be easy to extend to support a wide range of logics: classical, intuitionistic, modal, linear; first-order, second-order, higher-order; set theories, type theories, category theories; and other user-defined systems of reasoning.
meta:
- The system should be able to prove relations between theories, such as that any EFA theorem is also a PRA theorem, and that ZFC proves the consistency of PA. To do this, we would use a relatively weak theory (such as EFA, PRA, PA, or ZF minus ∞) to show how proofs may be converted between theories.
easy to use:
- Usability may be improved many ways: using a familiar (Python- or Java-like) syntax; providing analysis tools; training AIs to observe common patterns in proofs; and many others.

Saphyra is hosted on GitHub; stay tuned!