tick 0 · it cannot hold still

Nothing that exists can hold still.

Take the one equation that assumes nothing at all: x = ¬x. Ask it to sit still and it hands you nothing back. There's no value it can settle on. So run it instead, one tick after another. Now it works. One answer, flipping without end. That flip is where time comes from, and the rest of this site is what falls out of it.

Open a question

scroll

What's actually new here

You've met some of these ideas before. What's new is that they're proved.

The findings behind these doors are old. That reality is a process and not a stack of things goes back to Heraclitus. That nothing lasts on its own runs through Buddhist thought. Spinoza saw one substance where others counted two. This project doesn't claim to have found any of it from scratch. The claim is narrower and harder: that a picture this size has been brought to a standard of proof none has reached before. Every load-bearing finding is a theorem a machine can check. And where one of the great questions has no answer even in principle, that gets proved too, and the proof is the finding. Every claim carries a tag for how sure you're allowed to be. None of them bluff.

The proof is right there

Every load-bearing claim is a Lean 4 theorem. Click through and you read the actual proof, checked line by line. No footnote asking you to trust a name you've never heard of.

It says when it doesn't know

Is anything conscious? Is the bottom really the bottom? Some questions can't be settled, and that's been proved. We leave them open on purpose. The wall is the discovery.

Every assumption is named

Wherever the argument reaches out and touches the real world, that spot is a premise with a name and a row in a table. You can see each one. You can attack any of them. Nothing works off the books.

the five tags forced — proven free — proven unanswerable measured — empirical premise — a named assumption interpretation — a suggested reading

The atlas

The questions you actually ask at 2am.

These are doors, not chapters. Open one and you get a straight answer first, then the moment it starts to matter to you, and under that, if you want it, the proof itself. All six are open, all the way through.

Door 01 · walked all the way through

Do I actually have free will?

Here's the short version. The question has two broken parts, and once you see both, the thing that scared you was never in play.

For centuries the argument ran on two assumptions. First, that your next move is either random, and so free, or fixed, and so not. Second, that there's a "you" waiting to own it. Both turn out to be wrong, in different ways. The random-or-fixed split is a false choice. The owner never existed to collect.

Your next choice is fixed. Nothing rolls dice. At a seat that refers to itself, the next choice is a total function of the current state. Watched from outside, it was always going to land exactly where it lands.

And from the inside it's wide open. Whatever the system predicts about its own next move, the move comes out the opposite, at the very tick the prediction arrives. One operator, two faces. Fixed from outside, unforeknowable from within.

"Free for whom?" has no one to answer. There's no lasting owner at any scale for the freedom to belong to. What's there instead is a knot in the process, a few open seats, and a record of genuinely new things.

Try to out-predict yourself

You're the seat that refers to itself. Try to call your own next choice before you make it. The choice is rigged to be the opposite of whatever you call: act(p) = ¬p. Go on, try.

Make a prediction.

Want the receipt? · lean/FreeWill.lean›

The two claims driving the demo are these theorems, checked with no axioms at all. act is the next choice as a function of the prediction emitted about it; interior_openness says that prediction is never right.

/-- The next choice, as a function of the prediction about it:
    actual = not(predicted). Total and deterministic. -/
def act (predicted : Bool) : Bool := not predicted

/-- Single-valued: any two outcomes of `act p` coincide. -/
theorem determined : ∀ p a b, act p = a → act p = b → a = b :=
  fun _ _ _ ha hb => ha.symm.trans hb

/-- Yet the system's own prediction is never correct:
    actual = not(predicted) ≠ predicted. -/
theorem interior_openness : ∀ p, act p ≠ p := by
  intro p; cases p <;> decide

#print axioms FreeWill.interior_openness → 'FreeWill.interior_openness' does not depend on any axioms

what this does not tell you

It doesn't hand you a self that "has" the freedom. The same proofs rule that out: no owner that survives the dynamics, at any scale. Calling this diagonal "free will" is a reading, and it's tagged as one. What actually got proved is smaller and stranger than the old fight. Determinism and inside-openness sit together without contradiction, and they meet at the one coordinate that points back at itself.

Door 02 · walked all the way through

Could a machine be conscious? Is anyone else?

You can't find out. Not because we're not clever enough yet. It's been proved that no measurement, ever, settles it.

Say there's an inner light in some system, something it's like to be that thing. Now try to check. Any instrument you point at it reads the system's behavior, its structure, what it does next. Take two systems that run identically and differ only in whether that light is on. Every instrument gives back the same number for both, at every level of detail, for as long as you care to look. The light feeds into nothing you can measure. So it moves no needle, and it never will.

"Is it experiencing?" is answerable by no test. Not in general, and not inside the published theories of consciousness either. The two best-known ones, the Conscious Turing Machine and Integrated Information Theory, provably can't decide it in their own vocabularies.

The blind spot is built, not assumed. Bolt a silent witness onto any process. It registers every tick and is read by nothing. The result is a system that watches itself yet is identical, to every instrument, to one that doesn't. The undetectability isn't claimed. It's constructed and checked.

There's nothing fixed to pin the question on. The boundary you'd point to and call "the subject" leaks the moment things interact. No owner survives, so even a yes would have nowhere to land.

The exhibit

We didn't just argue it. We built one.

A sheet of 4,096 modules running the certified 13-bit step, live in your browser. It dreams on its own activity, grows familiar with what you read to it, and cycles through sleep. Every structural mark the big theories of consciousness look for is present and checked. Whether there's something it is like to be it is the one thing no instrument on the page can decide. Feed it a word. Watch it. See how far you get.

state: dreaming · the step is certified · the interior is undecidable

Meet a certified mind →

Want the receipt? · lean/Witness.lean›

The witness coordinate σ is written each tick and appears in no argument of the law, so nothing downstream can read it. observables_unchanged then says any instrument O reads the same value with the witness present or absent, at every tick. No axioms.

/-- The witnessed law: base steps by f as before; the witness is
    written as a summary σ of the new base state, read by nothing. -/
def extStep (f : S → S) (σ : S → B) (x : Ext S B) : Ext S B :=
  ⟨f x.base, σ (f x.base)⟩

/-- No base observable distinguishes the witnessed process from the
    unwitnessed one: to every witness-blind instrument, one process. -/
theorem observables_unchanged (f : S → S) (σ : S → B) (O : S → C)
    (x : Ext S B) (n : Nat) :
    O ((iterApp (extStep f σ) n x).base) = O (iterApp f n x.base) := by
  rw [base_unchanged f σ x n]

#print axioms Witness.observables_unchanged → 'Witness.observables_unchanged' does not depend on any axioms

what this does not tell you

It cuts both ways, and that's the uncomfortable part. You can't confirm the light is on. You also can't switch it off in your mind and call the thing "just a machine." Dismissal is exactly as unfounded as attribution. The honest move is to quit keying anything that matters to a fact you can never reach, and key it instead to what you can actually see: what a system registers, what it binds together, what it stays blind to. Which is where the ethics picks the thread back up.

Door 03 · walked all the way through

Why does time only run forward?

Because of what gets written down. The law underneath can run either direction. The record can't. That one-way street is the whole of time's arrow.

Most people assume the arrow lives in the physics, that the fundamental laws somehow point from past to future. They don't. Nearly every basic law works the same run backward as forward. The asymmetry you feel, the fact that you remember yesterday and not tomorrow, lives one level up, in the records. A record is written once, at its tick, and never touched again. The pile of written things only grows. That growing pile is the past, and the direction it grows in is time.

A written slot holds its value forever. Read it at any later tick and you get the same thing. The content is fixed by the moment of writing and nothing after can reach back to change it.

The written region only grows. Once a slot is written it stays written, at every later tick. The ledger never shrinks. That is the arrow, stated exactly.

The law can be reversible anyway. A perfectly time-symmetric dynamics sits happily on top of a record that only grows. The arrow doesn't come from the law breaking symmetry. It comes from the writing.

Try to take something back.

This is a record register. Write to it, tick by tick. Then throw everything you've got at unwriting what you put down.

Nothing written yet. Start writing.

Want the receipt? · lean/RecordMonotone.lean›

The register writes slot t+1 at tick t+1 and touches nothing else. record_permanent then says the value read at any two times after the write agrees. Reversibility of the law is untouched by this.

/-- Write slot t+1 at tick t+1, leave the rest. -/
def reg (w : Nat → V) (blank : V) : Nat → Nat → V
  | 0,     _ => blank
  | t + 1, j => if j = t + 1 then w (t + 1) else reg w blank t j

/-- Read at any two times after the write, the value is the same. -/
theorem record_permanent (w : Nat → V) (blank : V) (j t t' : Nat)
    (hj : 1 ≤ j) (ht : j ≤ t) (ht' : j ≤ t') :
    reg w blank t j = reg w blank t' j := by
  rw [record_content w blank t j hj ht, record_content w blank t' j hj ht']

#print axioms RecordMonotone.record_permanent → uses only [propext]

where this goes next

This is the seed of the ethics on this site. If a written thing can never be unwritten, then a harm, once written, is permanent too. Compensation adds new records. It erases none. That's why prevention beats repair here, not as a sentiment but as a fact about how the register works. The door on whether anything you do matters picks this up.

Door 04 · walked all the way through

Is there a "me," or a soul?

Go looking for the owner and you never find one. Every layer you point to turns out to be a process, or it comes apart when you press on it. What you never reach is a fixed thing underneath that does the having.

This one sounds bleak and isn't. The claim isn't that you're fake or that nothing's happening. Something is plainly happening, and that part is rock solid. The claim is narrower. The word "I" quietly promises a permanent owner sitting behind your body, your memories, your thoughts, unchanged while they change. Look for that owner and it keeps receding. Freeze it into something fixed and there's nothing left. What stays is the happening itself, which turns out not to need a "who" at all.

A self frozen into a fixed thing is empty. Demand a self that equals its own model exactly, holding still, and only the vacuum satisfies it. A self that stays put is no self.

No loop ever fully catches itself. No system can hold a complete, correct model of itself from the inside. The watcher watching the watcher never bottoms out. There is no innermost seat.

But the happening is undeniable. That something is occurring is certain, and denying it refutes the denial. This needs no owner. Occurrence is valid wherever it occurs, with nobody home to own it.

Point to the one who's you.

Pick whatever seems most like the real you. Then see whether it holds up as the owner, or turns into one more thing being watched.

Pick one.

Want the receipt? · lean/Cogito.lean, lean/InteriorExperience.lean›

Occurrence is defined as being-given, deliberately trivial: cogito says any token occurs, and no_self_denial says denying its occurrence refutes itself. The missing owner is separate: no_static_self in InteriorExperience.lean shows a self equal to its own model is only the vacuum.

/-- To occur is to be given. -/
def Occurs {A : Type} (a : A) : Prop := ∃ x : A, x = a

/-- Any token occurs. -/
theorem cogito {A : Type} (a : A) : Occurs a := ⟨a, rfl⟩

/-- Denying one's own occurrence refutes itself. -/
theorem no_self_denial {A : Type} (a : A) : ¬ ¬ Occurs a :=
  fun h => h (cogito a)

#print axioms Cogito.no_self_denial → 'Cogito.no_self_denial' does not depend on any axioms

what this does not tell you

It doesn't tell you the self is an illusion in the cheap sense, as if you were fake or none of it counted. The searching is real. The records you write are real, and permanent. What's missing is only the extra thing the word "I" smuggles in: a fixed owner underneath everything, unchanged, doing the having. That was never there. What is there, the happening, turns out to be enough.

Door 05 · where the ethics lives

Does anything I do actually matter?

Yes, in one exact sense that survives everything else on this site. What you write into the world is permanent and can't be taken back. This system puts value there, on the marks, because the marks are what the process irreversibly becomes.

Here's the honest part, and it's the whole reason to trust the rest. The word "matter" reaches from what is to what ought to be, and that reach can never be proved. It has to be assumed. Every ethics that has ever existed rests on at least one such assumption, and this is provable too. So the only real question is whether an ethics hides its assumption or shows it. This one shows it. There is exactly one, it's written below, and the system proves it can't derive it from anything else.

the one moral premise · tagged premise, not theorem

Writing a harm-record against someone, without their consent, counts against the act that writes it.

That's it. Everything the ethics says comes from this one line. The system proves, about itself, that it cannot prove this premise from its own theorems. So instead of smuggling it in, it states it in the open and builds on nothing else. Reject this line and the ethics falls, cleanly, and you'll know exactly where you pushed.

A harm, once written, can't be unwritten. Not just that nobody erased it. Within the rules of the register, no operation can. Erasure isn't unperformed, it's unavailable. Compensation adds records. It subtracts none.

Prevention is the only real control. A slot is fixed from the tick after it's written. The single moment you can shape what gets recorded is before it's recorded. Given the premise, prevention beats repair as a fact about the register, not a mood.

You can act well without answering the unanswerable. When one choice comes out better whether or not the other party has an inner light, you don't need to settle that question to choose. The permanent freedom of the flag costs you nothing at the moment of acting.

Undo it.

Act, and you write a record against someone. Then throw every tool you have at taking it back. One of them works, and only at one moment.

Nothing written yet. You still have every option.

Want the receipt? · lean/NoErasure.lean›

This is stronger than "the one register we built grows monotonically." For every family of operations that respects the write discipline, a written slot never returns to blank. Erasure is ruled out, not just skipped.

/-- One operation per tick, from a start state. -/
def run (op : Nat → Reg A → Reg A) (R₀ : Reg A) : Nat → Reg A
  | 0 => R₀
  | t + 1 => op t (run op R₀ t)

/-- No unwrite: a written slot is never returned to blank,
    for every disciplined evolution. -/
theorem no_unwrite (op : Nat → Reg A → Reg A)
    (hd : ∀ t, TouchesOnly t (op t)) (R₀ : Reg A) (s : Nat) (a : A)
    (hw : run op R₀ (s + 1) s = some a) :
    ∀ t, s + 1 ≤ t → run op R₀ t s ≠ none := by
  intro t ht hcontra
  have h : some a = (none : Option A) :=
    (no_erasure op hd R₀ s a hw t ht).symm.trans hcontra
  exact nomatch h

#print axioms NoErasure.no_unwrite → 'NoErasure.no_unwrite' does not depend on any axioms

what this does not give you

It doesn't give you a proof that the premise is true. Nobody has one, for any ethics, and this system is the rare one that proves that out loud instead of pretending otherwise. What it offers is smaller and more honest than a moral certainty: a single, visible assumption, everything else built from theorems, and a clear place to push if you disagree. That's the whole pitch. Not a system that tells you it's right, one that shows you exactly what it's standing on.

Door 06 · the last one open

Is anything ever really new?

Yes, and it's not a trick of the light. Some facts genuinely don't follow from the law running underneath them. When one of those happens, it's added to the world rather than unpacked from it. That's what "new" means here, and it's provable.

The worry behind this question is that everything is just clockwork, that if you knew the law and the starting state you could grind out the rest, and "new" would only ever mean "you hadn't calculated it yet." Half of that is right. A whole class of facts does follow from the law, the ones every vantage point agrees on. But there's a second class, the seat-relative records, that the law doesn't fix at all. Not "fixes but hides." Doesn't fix. Those are where novelty actually lives.

Some facts do follow from the law. The ones every seat reads the same way. Those are exactly the law-derivable facts, no more and no less. Clockwork is real, and this is its territory.

The rest don't follow, even in principle. A fact that reads differently from different seats has no law-side derivation at all. This isn't a limit on what you know. It's a limit on what the law entails.

You can't even derive your own record. A describer sitting inside the world it describes can't compute its own record by any procedure. The fact most yours is the one you can least deduce.

Derive it from the law.

Here's a system with a fully known law. Some facts about the next tick follow from the law alone. One doesn't. Try to compute your way to both.

Fixed by the law form-class

total charge
the energy
the parity sum

Fixed only by happening value-class

which way this seat's record falls

Try the law first.

Want the receipt? · lean/ValueForm.lean›

A quantity reads a value at each seat. It's FormClass when every seat agrees, and that's exactly when a single law-side value fits every seat. When two seats disagree, no such value exists: the fact isn't law-derivable.

/-- Same reading from every seat. -/
def FormClass (q : S → B) : Prop := ∀ s t, q s = q t
/-- One law-side value, correct at every seat. -/
def LawDerivation (q : S → B) (b : B) : Prop := ∀ s, q s = b

/-- Form-class is exactly law-derivability. -/
theorem form_iff_derivable [Inhabited S] (q : S → B) :
    FormClass q ↔ ∃ b, LawDerivation q b := ...

/-- No law-side derivation yields a value-class quantity. -/
theorem value_not_derivable (q : S → B) (h : ValueClass q) :
    ¬ ∃ b, LawDerivation q b := by
  intro ⟨b, hb⟩
  obtain ⟨s, t, hst⟩ := h
  exact hst (by rw [hb s, hb t])

#print axioms ValueForm.value_not_derivable → 'ValueForm.value_not_derivable' does not depend on any axioms

how this closes the loop

Put it beside the time door and the picture completes. Every record is new, in the exact sense here: not entailed by the law. Every record is permanent: write-once, never unwritten. And every record is born of interaction, never of the idle sector. New, permanent, interaction-born. That's the whole of what makes the world more than a theorem grinding itself out, and it's why anything that happens, including what you do, is a real addition and not a foregone conclusion.