exozy.me RSS Feed

Coupled meta-learning while learning homotopy theory

2026-08-12T12:00:00Z

Don’t you all have a body. For me, it is troublesome to think of a policy to control its actions. Even I don’t have a policy for it, it still does things anyway.

But first, to have a desired policy, I need to specify my policy desire. A policy is like a function that takes the environment as input and produces an action as output. A policy desire is the space (or type) of policies that I deemed acceptable.

Since the space of desired policies is not a point, there must be choice. Randomness works too.

Still, what I desire may drift from time to time based on what I experience.

This, seen from the outside, is a coupled meta-learning system: one loop learns a policy for whatever desire the system currently holds, and another loop picks the desire itself. The space of desires is not a point, so the outer loop must choose; randomness works. And since the policy the system acts with changes what it experiences, and what it experiences changes what it desires, the two loops keep feeding each other — nothing is fixed, everything drifts.

I think this system is enough to make continuous learning/self-improvement possible, although I don’t know how to control it well.

Homotopy theory is surprisingly useful for describing this kind of system in math.

The loop

Let \(\Theta\) be the space of systems — \(\theta_0\) is the current system, the current codebase — and \(\Phi\) the space of objectives — \(\phi_0\) is the desire, the scored registry. The inner loop adapts \(\theta_0\) toward an objective; the outer loop steers the desire itself. Since \(\Phi\) is not a point, steering has to choose; randomness works.

The deformation is a path, not a sequence of steps. Both move at once:

\[\theta : \mathbb{I} \to \Theta, \qquad \phi : \mathbb{I} \to \Phi\]

The interval \(\mathbb{I} = [0,1]\) is the deformation parameter, not a clock. A run is a path \(\theta : \mathbb{I} \to \Theta\), from the current system \(\theta(0) = \theta_0\) to the deformed \(\theta(1)\); the desire is a path \(\phi : \mathbb{I} \to \Phi\) too, and the two couple as a flow on \(\Theta \times \Phi\):

\[\frac{d\theta}{ds} = F(\theta(s), \phi(s)) \qquad \frac{d\phi}{ds} = G(\theta(s), \phi(s))\]

The policy path changes the environment, the environment drifts the desire path, the desire path redirects the policy path. Choice enters as a stochastic term: \(d\phi = G(\theta, \phi)\, ds + \sigma\, dW\).

The homotopy constraint: \(\Theta_0 \subseteq \Theta\) is the subspace of systems that keep the invariants — parity, fixpoint, conservation, crown jewels. The flow is projected onto the tangent space of \(\Theta_0\) at every instant: a trajectory that would leave \(\Theta_0\) is rejected, not repaired.

The interval is contractible, so every loop in it is null-homotopic: \(\pi_1(\mathbb{I}) = 0\).

The loop is small enough to write down in Lean:

/- The coupled self-improvement loop.
   θ : Θ — the base learner, the system itself.
   φ : Φ — the meta-learner, the objective space: a space, not a point.
   The deformation is continuous: a path, not a sequence of steps. -/

namespace SelfImprovement

/-- The space of systems Θ. -/
structure System where
  main : String
deriving Inhabited

/-- The space of objectives Φ — one point is one desire
    (a registry row: layer, jewel, score). -/
structure Objective where
  id : String
  score : Float
deriving Inhabited

/-- The invariant subspace Θ₀ ⊆ Θ — the systems the gate accepts
    (parity, fixpoint, conservation, crown jewels). -/
def Admissible (θ : System) : Prop :=
  -- the gate; a placeholder
  θ.main ≠ ""

/-- The interval 𝕀 = [0,1], where paths live.
    It is the deformation parameter, not a clock. -/
abbrev I := Float

/-- A path in A from a to b: a function out of the interval. -/
def Path (A : Type) (a b : A) : Type :=
  { γ : I → A // γ 0 = a ∧ γ 1 = b }

/-- A self-improvement run is a path in the space of systems. -/
def Improvement (θ₀ θ₁ : System) : Type := Path System θ₀ θ₁

/-- The coupled flow on Θ × Φ: at every instant F is the direction
    the system deforms toward the current desire, and G the direction
    the desire drifts with what the system experiences. -/
structure Flow where
  F : System → Objective → System
  G : System → Objective → Objective

/-- A deformation of the pair: one path in Θ and one in Φ, moving
    together. -/
structure Deformation (θ₀ θ₁ : System) (φ₀ φ₁ : Objective) where
  θ : Path System θ₀ θ₁
  φ : Path Objective φ₀ φ₁

/-- The homotopy constraint: a deformation is admissible iff every
    intermediate system keeps the invariants. The flow is projected
    onto the tangent of Θ₀ at every instant — a trajectory that
    would leave Θ₀ is rejected, not repaired. -/
def AdmissibleDeformation
    (θ₀ θ₁ : System) (φ₀ φ₁ : Objective) (d : Deformation θ₀ θ₁ φ₀ φ₁) : Prop :=
  ∀ s : I, Admissible (d.θ.1 s)

end SelfImprovement

Under some condition, we can prove that learning until the target objective is possible.

Prior art

The Internet suggested these for me.

Learning augmentation policies / domain randomization — the meta-learner is a distribution over data transforms (rotation, noise, brightness); the base learner takes fixed SGD steps on the transformed data (AutoAugment, domain randomization).
Generative Teaching Networks — the meta-learner generates synthetic training data; the reward is the student’s validation loss on held-out data.
Meta-RL with a learned task distribution — the meta-learner is a distribution over reward functions; the base learner is a policy trained with policy gradient (MAML-RL, VariBAD).
Topological regularization — any of the above, plus a penalty that keeps the data manifold’s persistent homology from collapsing during training

Use Case

For now, I’ll try to apply it to my life. My life objective isn’t describable by language alone. It is kind of like a feeling, yet it is not a feeling. It feels like part of myself.

I don’t know what computer project I will use it for. Any machine learning algorithm can use this framework, I think. I also made a programming/proof language as a side project called Interv.

This article will be edited when more progress is made.

Update(2026-08-13): In Interv, this idea framework isn’t too useful for making actual self-evolving systems. It’s too high level. The Path type remains a useful thinking tool when it comes to continuous deformation between two points.

Starting my Homelab Journey

2026-08-12T07:46:16Z

Finally got a machine that can somewhat be considered a homelab...

Hello, Hyades!

2026-08-01T06:13:47Z

For the past two years, this site has been hosted on SIPB’s amazing XVM service. Unfortunately, it’s not all sunshine and rainbows. XVM is nearly 20 years old and definitely showing its age, and yesterday’s MIT certpocalypse completely broke the XVM website.

Recently, I’ve been helping out with SIPB’s Hyades project, which aims to eventually replace both XVM and Scripts. Hyades isn’t quite ready yet, but I’ve already migrated this website from XVM to Hyades, and it seems to work pretty well so far! Hyades also builds my site in only 5 seconds compared to 15 on XVM, and I’m no longer limited to 512 MB of RAM.

Modi and the Cockroaches

2026-07-27T17:24:00Z

An open letter requesting an official open-source UPI client independent of proprietary platform attestation.

ADRs as assistance for agents and yourself

2026-07-25T00:00:00Z

Over the past months I’ve been writing a lot of code with a good colleague (claude code). There are a few constraints that I’ve noticed with him. His memory is not great and whenever he writes himself notes (.memory/ or AGENT.md files), on what he was employed to do, it becomes a bit of a mess because he is also subpar in outlining the steps and considerations that it takes for him to achieve the goal.

How to live in an era where machines can think

2026-07-17T12:00:00Z

Yesterday, Kimi K3 released.¹ Aside from the amazing capabilities of it, it made me wonder, how should I respond to it.

If we believe in how computation works from All you need is computation, all computation belongs in the same class: ~~turing complete~~. At this point in technology development, I feel that trying to compete in computation with carved stones as biological organism doesn’t make much sense anymore. We better do something else.

Being able to rest

With more than enough computation, I think people will be less busy in the future. Therefore, it’s important to learn about resting.

Here’s an except from The Miracle of Mindfulness.

When you breathe in, know that you are breathing in.
When you breathe out, know that you are breathing out.
When you breathe in short, know that.
When you breathe in long, know that.
Same for when you breathe out.
Bring the awareness to every present moment.

Resting is a skill. It is not the absence of things to do, but knowing what is happening as it happens.

Machines can compute for us, but they cannot breathe for us, nor be aware for us. When I notice that I am busy, I return to the breath. One mindful breath takes no thought process at all and relaxes the mind. Then I can return to work, being better.

The weights will be released 10 days after this.↩︎

Memory safety and type system

2026-07-12T12:00:00Z

You probably have heard of the recent Bun Rust rewrite debacle. Long story short, Bun’s recent Rust rewrite is not about Rust being better than Zig; it is about which kind of type system you need when a tracing garbage collector and a more manual allocator share a process. The boundary between JavaScriptCore’s tracing GC and Zig’s manual allocator is where ownership invariants have to be enforced by hand. With a linear type system, you can automatically enforce the invariance.

Example failure at programming

Bun calls into JavaScriptCore through the C API.

JSValueMakeString and JSObjectMake return a value with a +1 retain; you must release it or let it be collected.
JSValueProtect and JSValueUnprotect must be called in matched pairs; unprotecting too many times is undefined behavior.
The conservative stack scanner can find JSValueRefs on the stack during a JSC call, but it cannot see inside Zig heap allocations or globals, so anything stored there requires JSValueProtect.

Here’s an example bug that could have been caught with a more capable type system.

const NativeCache = struct {
    ctx: c.JSContextRef,
    cached_js_value: c.JSValueRef,

    pub fn init(ctx: c.JSContextRef, js_object: c.JSObjectRef, prop_name: []const u8) NativeCache {
        const name_str = c.JSStringCreateWithUTF8CString(prop_name.ptr);
        defer c.JSStringRelease(name_str);
        const val = c.JSObjectGetProperty(ctx, js_object, name_str, null);
        return .{ .ctx = ctx, .cached_js_value = val };
    }

    pub fn getCached(self: *NativeCache) c.JSValueRef {
        return self.cached_js_value;
    }
};

JSObjectGetProperty returns a borrowed reference. The NativeCache itself lives on the Zig heap, invisible to the JSC stack scanner. When the next GC cycle runs, the borrowed value may be collected, and getCached returns a dangling pointer. The compiler does not notice because the type JSValueRef carries no information about scope, protect count, or ownership.

The manual fix is to add JSValueProtect¹ in init and JSValueUnprotect in deinit. But the compiler still does not check that the calls are matched, that the destructor always runs, or that the value is not used after being unprotected. You are simply expected to get it right.

The languages

Rust:

Rust uses linear ownership plus borrow checking. You can’t prove arbitrary theorems in it, but it’s good enough for solving programming tasks with challenging memory safety.

I won’t explain how linear type works here. Look it up.

Lean:

Lean doesn’t have linear types, but it allows you to prove theorems.

Idris:

Idris 2 has a C backend that allows you to compile to C with GC. Having GC is bad though in Bun’s case, since TK.

Runtime engineering

It is different when you own a whole runtime. A Wren implementation, for example, has no foreign GC boundary; the Rust code can design the collector to cooperate with ownership from the start. safe_wren is a pure Rust implementation of Wren, and projects like piccolo and rust-gc explore the same direction for Lua and general GCs. In that world, the unsafe surface is the GC itself, and everything else sits in a safe, ownership-checked core. Bun cannot take that approach unless it replaces JavaScriptCore. Or maybe it can, since Anthropic’s model seems to have conscious thought about achieving AGI².

Closing thoughts

There are too few choices out there these days when it comes to programming languages. Yes, ATS does not count as an engineering choice to me. So choose the right one for your use case!

Apple docs ↩︎
not my advertisement↩︎

A stay on Plum Blossom Island

2026-06-04T12:00:00Z

We came for plum blossoms. The name promised. Only the name delivered.

The guesthouse was two stories — dining area and kitchen on the ground floor, rooms above. Quiet when we arrived. A few people eating downstairs. The owner handed us a key. The room was nicer than expected, like an actual hotel. We dropped our bags and set out.

The road to the monastery was rough in an ordinary way. One lane had coin-sized craters pocked into the surface. The other was smoother but stones pushed up through the concrete, just enough to notice.

A wooden gate stood at the entrance: 不二, torii-like. Through it, whitewashed walls and a front gate. Inside the courtyard, the ground was paved with sharp retail-style gravel and stone tablet panels running down the middle. Modern. Clean. Silent — not the silence of old stone, but the silence of minds holding still. People meditated all day. I don’t know what my mother finds there. Only know she stays. I didn’t.

The boat to the island crossed green, calm water. From a distance the island looked undeveloped — a few houses scattered across it, nothing more.

I had imagined a certain quiet. The quiet of a place removed, yes, but also the quiet of wanting nothing from the world because the world had stopped wanting anything from you. That’s not what I found.

The energy was wrong. Not wrong you can measure or explain — wrong you feel in the gut before the mind catches up. Stifling. Heavy with something I can’t name and don’t want to understand. Instinct said: leave. So I left, earlier than planned.

Before leaving, more Zen practice. It went badly. What happened there is not mine to tell.

They collect plums on the island. I couldn’t tell which trees were plum trees — without blossoms, they all look the same. An island named for something absent, and nobody seemed bothered. The plums came in buckets, practical, unromantic. A metaphor sits there if you want one.

Off the island. Into town. Three nights.

The town was the island’s opposite: loud, commercial, the most commercial part of the old city. Everything for sale, everything bright. After the stifling stillness of the island I thought I wanted this — noise, motion, the friction of other people. It wasn’t relief. Just a different kind of wrong. Mentally dusty. A commerce hangover. But I spent the three nights there, and in the spending, I wound down. Not because the place was right, but because time passed and I stopped expecting it to be.

My mother and I came together, aboard the same train. She meditated in the monastery while I fled the island. We met at meals, probably. We didn’t talk much about what each of us found. Some journeys run parallel without touching.

I never saw a plum blossom. Wrong season, or wrong island, or wrong me. You go somewhere because of its name, but the name is just a word someone chose long ago. The place owes you nothing.

Maybe Zen practice is good. I may visit another time. For now, rest.

Sorry about the article quality. It’s the best I can do without leaking sensitive information.

If you are interested in Dharma practice, look up Mindful Peace International or a sangha near you. I recommend the book The Miracle of Mindfulness for beginners.

MIT Athena: Somehow Still Not Dead Yet

2026-05-23T20:25:10Z

“MIT Athena: Not Dead Yet”, they said back in 2008. 18 years later and 42 years after the start of Project Athena, somehow Athena is still (barely) alive and kicking, thanks to Nixathena!

Nixathena is a new SIPB project to turn any computer into an Athena workstation running modern NixOS. It’s intended to replace Debathena, which hasn’t been updated since Ubuntu 18.04. You can find the features list, screenshots, and code on the MIT Forgejo.

5 - Website rewrite

2026-05-23T00:00:00Z

Hey, as you receive this rss-only notification I’ve published a new rewrite of the website.

I’d be happy about feedback and if any decisions in the design things stand out in a bad way.

To not just waste your time on an advertisement, let me also go about some things I’ve spent the last few months with that I haven’t posted:

Work got more demanding, but the research is going well and there are publications on the way on sparse BLAS routines on the Cerebras WSE3.
Got into lifting a few times a week and added a lot of cycling to the daily routine as well as longer rides.

==> all those lovely improvements in life resulted in me getting worse in uni the past months, so I’m currently trying to pick that aspect of life back up a bit more seriously :).

It feels so tedious and boring at times, but at the end it’s just the basics during my bachelor and I should have them down pretty well. Or at least finally complete it to get into cooler classes.

Have a good day! :)