RECOGNITION
PHYSICS INSTITUTE

An independent nonprofit research institute in Austin, Texas.

We are deriving reality.

Physics describes what happens. We ask why it has to happen that way. We start from three facts that every question already uses and prove what follows, each result under its stated conditions. One public list holds what reality has to account for. Each result is marked on it as it is derived.

The list today One square for each thing reality has to account for.

681

of 4,280 derived, in full or given a stated premise.Counted from the public record, 11 November 2026, 12:53 AM CT

  • 78 derived in full
  • 603 derived, given a premise
  • 725 partly derived
  • 28 open walls
  • 2,846 not yet derived

78 are derived in full and 603 given a stated premise.

The list runs outward in its own order, from its first domain at the centre to its last at the edge. Point at a square to see its name; select it to open it on the map.

Every square is placed and counted in your browser by 705 bytes of machine code. Read them

Our mission

Derive all of reality.

Every square is one thing the structure of reality has to account for, from counting and the golden ratio to proteins and minds. A square fills in when its result is derived from the foundation.

The institute’s objective is to derive reality and to use that understanding for the greatest human benefit.

One square for each thing reality has to account for, from counting to minds, in the order of the list. 15.9% are derived, in full or given a premise; grey squares are not yet derived.

A square counts as derived when it is derived in full or derived given a stated premise. Derived in full means proved in full from the foundation. Partly derived means part of the result is proved. An open wall is a question the foundation does not decide: two models agree on everything below it and differ there. The list grows as the work reaches new ground, so the share can fall when squares are added.

Open the map

Film

The idea, in a film.

Film · The Idea · 2 min 23 s

Where the derivation starts

Five answers, each the only one its conditions allow.

Recognition Science is the discovered architecture of reality. Reality has one forced shape. A recognition is one thing told from another: a comparison actually made. Recognition Science starts from three facts that every question already uses, adds the stated conditions of each part of that shape, and proves that under them only one answer is possible. We follow that shape into gravity, matter, morality and meaning.

The three facts

  1. Some things can be told apart.
  2. Comparing two readings needs both.
  3. Reading an old record is a new event.

Each fact, with an example

The first answers, computed in your browser. The five answers below are computed now by this page’s own machine code, 705 bytes in all. The ratio, the dimension and the eight come from one function that takes no input: there is nothing in it to set. The cost is computed at the ratios shown, and the count is of the public list.

Run 1

  1. 01 · Counting

    4,280

    squares on the list, counted one at a time.

    Counting has one arithmetic.

    Start empty, always add one more mark, reach every count in finitely many steps and never repeat one: every such system has the same arithmetic (Dedekind, 1888).

    On the list: Natural numbers from iterated distinction · Derived in full

    Its bytes

    20 01 2d 00 80 20 41 02 74 22 02 20 02 28 02 40 41 01 6a 36 02 40 20 01 41 01 6a 21 01 41 00 20 01 36 02 54 41 00 28 02 40 41 00 28 02 44 6a

    They walk the record of the list and add one for each square. Every count of the list on this page comes from them.

    See it work

  2. 02 · The cost

    0.25

    is J(2), and J(½) is 0.25: twice and half cost the same. J(1) is 0: only a match costs nothing.

    A comparison has one cost.

    J(x) = ½(x + 1/x) − 1

    J is the only cost of a positive ratio x that obeys both the rule for combining comparisons, J(xy) + J(x/y) = 2J(x)J(y) + 2J(x) + 2J(y), and the calibration at a match: near x = 1 the cost is ½(ln x)² to leading order. It follows that twice and half cost the same, the cost is never negative, and only a match costs nothing.

    On the list: Uniqueness of the cost function J · Derived in full

    Its bytes

    20 00 44 00 00 00 00 00 00 f0 3f 20 00 a3 a0 44 00 00 00 00 00 00 e0 3f a2 44 00 00 00 00 00 00 f0 3f a1

    They take a ratio x and return x plus its mirror 1/x, halved, less one.

    See it work

  3. 03 · The golden ratio

    1.6180339887

    is φ, reached in 52 halvings. One step of that ladder costs J(φ) = 0.1180339887.

    One ratio lets the levels join.

    λ² = λ + 1

    Positive levels that grow by one fixed ratio, with level 2 the sum of levels 0 and 1: the ratio solves λ² = λ + 1, whose one positive root is φ.

    On the list: Golden ratio forced by self-similar ladder · Derived in full

    Its bytes

    44 00 00 00 00 00 00 f0 3f 21 00 44 00 00 00 00 00 00 00 40 21 01 20 00 20 01 a0 44 00 00 00 00 00 00 e0 3f a2 22 02 20 03 41 01 6a 21 03 20 02 20 02 a2 44 00 00 00 00 00 00 f0 3f 20 02 a0 63 04 40 20 02 21 00 05 20 02 21 01 0b 41 00 20 01 39 03 00 41 00 20 03 36 02 1c

    They try the ratio halfway between 1 and 2 and compare level 2 with the join of levels 0 and 1. If level 2 falls short the ratio is larger, and if not it is no larger; they halve the interval that way until it cannot be halved again.

    See it work

  4. 04 · Space

    3

    dimensions.

    Two loops stay linked only in three dimensions.

    In a closed space without one-dimensional holes, a lasting pair of loops can wind through each other a nonzero number of times, a count no bending changes while the loops stay apart, only in three dimensions.

    On the list: Three dimensions forced by linking · Derived in full

    Its bytes

    03 40 20 04 41 01 6a 22 04 41 02 6b 41 01 47 0d 00 0b 41 00 20 04 36 02 10

    They count dimensions up from one. In D dimensions, what a loop can be linked with has D − 2 dimensions: a pair of points on a flat sheet, a closed surface in four dimensions. They stop where it is another loop.

    See it work

  5. 05 · Eight states

    8

    settings of 3 switches, each visited once, and home again in 8 ticks.

    Three switches, eight states, eight ticks.

    Give each of the three dimensions one on/off switch: 2 × 2 × 2 = 8 settings. Each tick flips one switch, so the shortest pass through all eight settings and home takes eight ticks.

    On the list: Eight-tick cycle from the 3-cube · Derived in full

    Its bytes

    03 40 20 05 41 01 6a 22 05 68 22 07 20 04 41 01 6b 22 08 20 07 20 08 49 1b 21 07 20 06 41 01 20 07 74 73 22 06 41 01 20 06 74 20 09 72 21 09 0d 00 0b 41 00 20 05 36 02 18 41 00 20 09 69 36 02 14

    They flip one switch at each tick, mark every setting they reach, and count the ticks until every switch is off again.

    See it work

Research

Peer-reviewed and published papers.

Each designed page shows one paper’s result working in your browser.

Open The Papers

Our Science

Feature pages.

Each of these pages states one part of the structure, shows it working live and names the conditions it rests on.

Our people

Different disciplines. A shared ambition.

Our work connects mathematical foundations with molecules, plasmas, light and computation. The team brings the expertise needed to move between a formal result and a physical experiment.

Collaborate with us

Bring a question worth solving.

Your message goes by email to Jonathan Washburn and Emma Tully.

Research together

Bring a mathematical idea or an experiment that could advance the work.

Discuss a research idea

Explore a partnership

Find where our work in medicine or quantum computing could connect with yours.

Start a conversation

Support the institute

Gifts from individuals and foundations fund the research.

Ways to give

The engine of this page

The first answers, in 705 bytes of machine code.

This page does not only describe the derivation. It computes its first five answers in front of you, each from the condition that fixes it. The 705 bytes below compute those answers, find the golden turn from the ratio, give every square of the list its place and count the list, status by status. Each answer’s value in “Where the derivation starts” and every count of the list on this page comes out of them. The proofs that each answer is the only one its conditions allow are in the worked examples on the overview.

They are written directly as WebAssembly bytes, the machine code of the virtual machine built into every modern browser, with no compiler and no library. Your browser runs exactly these bytes. The function that computes the ratio, the dimension and the eight takes no input: its signature, the three bytes on black below, says no parameters and no results.

The page is laid out by what the bytes return. On a wide screen the words and the list share the width in the ratio 1 to φ. On every screen each square of the list sits one golden turn, 1/φ² of a full turn, on from the square before it, at a distance that grows as the square root of its place in the list. Both φ and the turn are found by the bytes before the page is drawn.

00 61 73 6d 01 00 00 00 01 12 04 60 01 7c 01 7c 60 00 00no input 60 01 7f 01 7f 60 01 7f 00 03 05 04 00 01 02 03 05 03 01 00 04 07 27 05 03 6d 65 6d 02 00 04 63 6f 73 74 00 00 06 64 65 72 69 76 65 00 01 05 74 61 6c 6c 79 00 02 05 70 6c 61 63 65 00 03 0a ed 04 04 25 00 the cost20 00 44 00 00 00 00 00 00 f0 3f 20 00 a3 a0 44 00 00 00 00 00 00 e0 3f a2 44 00 00 00 00 00 00 f0 3f a1 0b eb 01 02 03 7c 07 7f the golden ratio44 00 00 00 00 00 00 f0 3f 21 00 44 00 00 00 00 00 00 00 40 21 01 02 40 03 40 20 00 20 01 a0 44 00 00 00 00 00 00 e0 3f a2 22 02 20 00 61 0d 01 20 02 20 01 61 0d 01 20 03 41 01 6a 21 03 20 02 20 02 a2 44 00 00 00 00 00 00 f0 3f 20 02 a0 63 04 40 20 02 21 00 05 20 02 21 01 0b 0c 00 0b 0b 41 00 20 01 39 03 00 41 00 20 03 36 02 1c the cost41 00 20 01 10 00 39 03 08 space03 40 20 04 41 01 6a 22 04 41 02 6b 41 01 47 0d 00 0b 41 00 20 04 36 02 10 eight states03 40 20 05 41 01 6a 22 05 68 22 07 20 04 41 01 6b 22 08 20 07 20 08 49 1b 21 07 20 06 41 01 20 07 74 73 22 06 41 01 20 06 74 20 09 72 21 09 0d 00 0b 41 00 20 05 36 02 18 41 00 20 09 69 36 02 14 the golden turn41 00 44 00 00 00 00 00 00 f0 3f 20 01 20 01 a2 a3 39 03 20 0b 57 01 02 7f 41 00 42 00 37 03 40 41 00 42 00 37 03 48 41 00 42 00 37 03 50 02 40 03 40 20 01 20 00 4f 0d 01 counting20 01 2d 00 80 20 41 02 74 22 02 20 02 28 02 40 41 01 6a 36 02 40 20 01 41 01 6a 21 01 0c 00 0b 0b 41 00 20 01 36 02 54 41 00 28 02 40 41 00 28 02 44 6a 0b ff 01 02 08 7c 03 7f the golden turn44 00 00 00 00 00 00 00 40 41 00 2b 03 20 a2 21 01 44 00 00 00 00 00 00 f0 3f 21 03 44 00 00 00 00 00 00 f0 3f 21 04 41 28 21 09 03 40 20 01 20 01 a0 22 01 44 00 00 00 00 00 00 f0 3f 66 04 40 20 01 44 00 00 00 00 00 00 f0 3f a1 21 01 20 04 20 02 a2 20 05 20 03 a2 a1 20 04 20 03 a2 20 05 20 02 a2 a0 21 05 21 04 0b 20 03 44 00 00 00 00 00 00 e0 3f a2 44 00 00 00 00 00 00 f0 3f 20 02 a0 44 00 00 00 00 00 00 e0 3f a2 9f 22 02 a3 21 03 20 09 41 01 6b 22 09 0d 00 0b a place for every square44 00 00 00 00 00 00 f0 3f 21 06 02 40 03 40 20 0a 20 00 4f 0d 01 20 0a b8 9f 21 08 20 0a 41 04 74 22 0b 20 06 20 08 a2 39 03 80 80 02 20 0b 20 07 20 08 a2 39 03 88 80 02 20 06 20 04 a2 20 07 20 05 a2 a1 20 06 20 05 a2 20 07 20 04 a2 a0 21 07 21 06 20 0a 41 01 6a 21 0a 0c 00 0b 0b 0b

Dark bytes do the step named in front of them. Grey bytes are the frame: the file’s header, the loops and the ends.

Counting

One is added for each square, and one for its status.

018c20 01local.get k
018e2d 00 80 20i32.load8_u offset=4096
the status of this square in the record
019241 02i32.const 2
019474i32.shl
019522 02local.tee p
019720 02local.get p
019928 02 40i32.load offset=64
019c41 01i32.const 1
019e6ai32.add
019f36 02 40i32.store offset=64
that status's count: one more
01a220 01local.get k
01a441 01i32.const 1
01a66ai32.add
01a721 01local.set k
the count of squares: one more
01a90c 00br 0
01ab0bend
01ac0bend
01ad41 00i32.const 0
01af20 01local.get k
01b136 02 54i32.store offset=84
keep the count of squares
01b441 00i32.const 0
01b628 02 40i32.load offset=64
01b941 00i32.const 0
01bb28 02 44i32.load offset=68
01be6ai32.add
derived in full plus derived given a premise

The cost

For any ratio; and once inside the first steps, at the golden ratio.

005720 00local.get x
005944 00 00 00 00 00 00 f0 3ff64.const 1
006220 00local.get x
0064a3f64.div
0065a0f64.add
x + 1/x: the ratio and its mirror together
006644 00 00 00 00 00 00 e0 3ff64.const 0.5
006fa2f64.mul
half of that
007044 00 00 00 00 00 00 f0 3ff64.const 1
0079a1f64.sub
less one: a match, x = 1, costs nothing
00f041 00i32.const 0
00f220 01local.get hi
00f410 00call cost
00f639 03 08f64.store offset=8
the cost of one step of the ladder: the cost above, at this ratio

The golden ratio

Halve the interval until level 2 meets the join of levels 0 and 1.

008244 00 00 00 00 00 00 f0 3ff64.const 1
008b21 00local.set lo
008d44 00 00 00 00 00 00 00 40f64.const 2
009621 01local.set hi
the ratio lies between 1 and 2
009802 40block
009a03 40loop
009c20 00local.get lo
009e20 01local.get hi
00a0a0f64.add
00a144 00 00 00 00 00 00 e0 3ff64.const 0.5
00aaa2f64.mul
00ab22 02local.tee mid
try the ratio halfway between
00ad20 00local.get lo
00af61f64.eq
00b00d 01br_if 1
00b220 02local.get mid
00b420 01local.get hi
00b661f64.eq
00b70d 01br_if 1
stop when the interval can no longer be halved
00b920 03local.get n
00bb41 01i32.const 1
00bd6ai32.add
00be21 03local.set n
one more halving
00c020 02local.get mid
00c220 02local.get mid
00c4a2f64.mul
level 2: two steps up from level 0
00c544 00 00 00 00 00 00 f0 3ff64.const 1
00ce20 02local.get mid
00d0a0f64.add
the join: level 0 plus level 1
00d163f64.lt
does level 2 fall short of the join?
00d204 40if
00d420 02local.get mid
00d621 00local.set lo
it falls short: the ratio is larger
00d805else
00d920 02local.get mid
00db21 01local.set hi
it does not: the ratio is no larger
00dd0bend
00de0c 00br 0
00e00bend
00e10bend
00e241 00i32.const 0
00e420 01local.get hi
00e639 03 00f64.store offset=0
keep the ratio
00e941 00i32.const 0
00eb20 03local.get n
00ed36 02 1ci32.store offset=28
keep the number of halvings

Space

Count dimensions up to the one in which a loop can be linked with a loop.

00f903 40loop
00fb20 04local.get d
00fd41 01i32.const 1
00ff6ai32.add
010022 04local.tee d
one more dimension
010241 02i32.const 2
01046bi32.sub
what a loop can be linked with there has d − 2 dimensions
010541 01i32.const 1
010747i32.ne
01080d 00br_if 0
go on until that is 1: another loop
010a0bend
010b41 00i32.const 0
010d20 04local.get d
010f36 02 10i32.store offset=16
keep the dimension

Eight states

Walk the settings of the switches, one flip per tick, and count the ticks home.

011203 40loop
011420 05local.get k
011641 01i32.const 1
01186ai32.add
011922 05local.tee k
one more tick
011b68i32.ctz
011c22 07local.tee j
the lowest place of the count that just changed
011e20 04local.get d
012041 01i32.const 1
01226bi32.sub
012322 08local.tee top
012520 07local.get j
012720 08local.get top
012949i32.lt_u
012a1bselect
012b21 07local.set j
that switch flips; past the last switch, the last one flips
012d20 06local.get s
012f41 01i32.const 1
013120 07local.get j
013374i32.shl
013473i32.xor
013522 06local.tee s
flip that one switch
013741 01i32.const 1
013920 06local.get s
013b74i32.shl
013c20 09local.get seen
013e72i32.or
013f21 09local.set seen
mark this setting as visited
01410d 00br_if 0
a switch is still on: not home yet
01430bend
014441 00i32.const 0
014620 05local.get k
014836 02 18i32.store offset=24
keep the ticks it took to come home
014b41 00i32.const 0
014d20 09local.get seen
014f69i32.popcnt
015036 02 14i32.store offset=20
keep the number of settings visited

The golden turn

1/φ² of a full turn, built out of halved quarter turns.

015341 00i32.const 0
015544 00 00 00 00 00 00 f0 3ff64.const 1
015e20 01local.get hi
016020 01local.get hi
0162a2f64.mul
0163a3f64.div
016439 03 20f64.store offset=32
the golden turn: 1 / ratio² of a full turn
01c744 00 00 00 00 00 00 00 40f64.const 2
01d041 00i32.const 0
01d22b 03 20f64.load offset=32
01d5a2f64.mul
01d621 01local.set g
the golden turn, written in half turns
01d844 00 00 00 00 00 00 f0 3ff64.const 1
01e121 03local.set hs
start with a quarter turn
01e344 00 00 00 00 00 00 f0 3ff64.const 1
01ec21 04local.set rc
and with no turn made yet
01ee41 28i32.const 40
01f021 09local.set i
01f203 40loop
01f420 01local.get g
01f620 01local.get g
01f8a0f64.add
01f922 01local.tee g
01fb44 00 00 00 00 00 00 f0 3ff64.const 1
020466f64.ge
does the golden turn contain this piece?
020504 40if
020720 01local.get g
020944 00 00 00 00 00 00 f0 3ff64.const 1
0212a1f64.sub
021321 01local.set g
021520 04local.get rc
021720 02local.get hc
0219a2f64.mul
021a20 05local.get rs
021c20 03local.get hs
021ea2f64.mul
021fa1f64.sub
022020 04local.get rc
022220 03local.get hs
0224a2f64.mul
022520 05local.get rs
022720 02local.get hc
0229a2f64.mul
022aa0f64.add
022b21 05local.set rs
022d21 04local.set rc
it does: add this piece to the turn
022f0bend
023020 03local.get hs
023244 00 00 00 00 00 00 e0 3ff64.const 0.5
023ba2f64.mul
023c44 00 00 00 00 00 00 f0 3ff64.const 1
024520 02local.get hc
0247a0f64.add
024844 00 00 00 00 00 00 e0 3ff64.const 0.5
0251a2f64.mul
02529ff64.sqrt
025322 02local.tee hc
0255a3f64.div
025621 03local.set hs
halve the piece: a square root, and no π

A place for every square

Square k sits the square root of k from the centre, one golden turn on from the last.

026244 00 00 00 00 00 00 f0 3ff64.const 1
026b21 06local.set px
the first direction
026d02 40block
026f03 40loop
027120 0alocal.get k
027320 00local.get n
02754fi32.ge_u
02760d 01br_if 1
until every square has a place
027820 0alocal.get k
027ab8f64.convert_i32_u
027b9ff64.sqrt
027c21 08local.set r
distance from the centre: the square root of the count
027e20 0alocal.get k
028041 04i32.const 4
028274i32.shl
028322 0blocal.tee a
028520 06local.get px
028720 08local.get r
0289a2f64.mul
028a39 03 80 80 02f64.store offset=32768
028f20 0blocal.get a
029120 07local.get py
029320 08local.get r
0295a2f64.mul
029639 03 88 80 02f64.store offset=32776
write this square's place
029b20 06local.get px
029d20 04local.get rc
029fa2f64.mul
02a020 07local.get py
02a220 05local.get rs
02a4a2f64.mul
02a5a1f64.sub
02a620 06local.get px
02a820 05local.get rs
02aaa2f64.mul
02ab20 07local.get py
02ad20 04local.get rc
02afa2f64.mul
02b0a0f64.add
02b121 07local.set py
02b321 06local.set px
turn by one golden turn for the next square