THE EQUATIONS

C = (T, A)

A context is the pair of topology (where it runs) and audience (who can read it). The root split everything else on this site is built from.

Source: whois.me

meaning(node) = f(A), never f(T)

Meaning is a function of who's allowed to read, never of where the bytes physically sit. Moving data never changes what it means.

Source: whois.me

T = topology, A = audience, C = capability, P = path

The four independent axes a context resolves against — where, who, what's permitted, and where meaning is addressed.

Source: trust.me

replicate(T) ↛ change(A)

Copying ciphertext to a new host, backup, or device never expands who can read it. Replication and readability are independent operations.

Source: The Algebra of Encrypted Audiences, Centralize the Self, Distribute the Data

T ⊥ A

Topology and audience are orthogonal — a compact way of stating the replication invariant above as a structural relation, not just a rule.

Source: The Encrypted Island

Visual: T ⊥ A — infographic

I = (path, ciphertext, T, A, C)

The full identity of one encrypted island: where it's addressed, what it contains, where it runs, who can read it, what's permitted on it.

Source: The Encrypted Island, echoed in Digital Space Algebra

private   → A = {self}
shared    → |A| > 1
encrypted → A enforced cryptographically
replicated → |T| > 1

Four everyday words about data, restated as constraints on the same two variables — nothing about them requires new machinery beyond T and A.

Source: Digital Space Algebra

readable(state) = decrypt(state, A)
location(state) = replicate(state, T)
G' = G - noise(T_control, incentive, audit_gap, memory_loss)

Readability and location as two separate operations on the same state, plus the degradation formula: a reasoning gradient G erodes into G' when a single controlled channel injects noise along four named channels.

Source: 4ias

q ≤ p  ⟺  q is a descendant of p

The containment order every path in .me resolves under — position in the tree, not a foreign key, decides what's reachable from where.

Source: SpaceStructure, The Semantic Graph Engine

Let P_declared be the set of paths that were actually written.
Let P = PrefixClosure(P_declared).

The positions of a space are every written path plus every prefix of one — profile is a position even if only profile.contact.email was ever written. Under ≤, P is a rooted, tree-shaped poset.

Source: What Is the Mathematical Structure of a Space in .me? (Medium)

Γ = (o, m, a)

The resolution context: observer, mode, and authority — the three things a read depends on besides the path itself.

Source: SpaceStructure

R : P × Γ ⇀ M

Resolution is a partial function from (path, context) pairs to manifestations — partial, because not every path resolves under every context.

Source: SpaceStructure

M = Value + Pointer + Family + Children + History + {⊥}

Everything a resolved path can manifest as — including ⊥, structural absence, as a first-class outcome rather than an error.

Source: SpaceStructure

E_o(wallet) = ∅,   while   R_o(wallet.income, direct) = 100

Addressable but not discoverable: a secret-scoped root is absent from enumeration, yet its exact leaf still resolves. You can resolve what you cannot discover by browsing from its root.

Source: What Is the Mathematical Structure of a Space in .me? (Medium)

manifest(p | o, m, a) = x
— not —
value(p) = v

A path doesn't have one fixed value — what it manifests as depends on who's asking, under what mode, with what authority. The rejected right-hand form is the assumption this whole formalism replaces.

Source: SpaceStructure, The Ontology of Identity

R(p, o, direct) = Pointer(q)
R(p.s, o, traverse) = R(q.s, o, direct),  for s ≠ ε
π[p,q](p.s) = q.s

How a pointer resolves through composition: a suffix under a pointer resolves the same way as that suffix under the pointer's target — chains compose instead of needing to be special-cased.

Source: SpaceStructure

R*(p[φ], o) = ( i ↦ R(p.i, o, direct) )  for i ∈ I_φ
where I_φ = { i ∈ children(p) | φ(p.i, o) holds }

A bracket selector turns one position into an indexed family — every child satisfying a filter, resolved together.

Source: SpaceStructure, used throughout me.whatever(what)

T(Δp) = O(|Reach_D(p)| + C_eval)

The cost of a mutation at path p is bounded by how many dependents it actually reaches, plus evaluation cost — not by the size of the whole space.

Source: SpaceStructure

S = (P, ≤, Γ, M, R)
K = (S, π, Σ, H, D)

The full definitions: a space is its paths, containment order, contexts, manifestation domain, and resolution relation; a kernel adds pointers, a secret-scope algebra, a hash chain, and deterministic conflict resolution on top of a space.

Source: SpaceStructure

H_t  ──fold_LWW──▶  G_t  ──FreeCat──▶  C_t

The event history H_t folds (last write wins) into the active pointer graph G_t, which generates the free category of routes C_t.

Source: Is .me a Category? (Medium)

C_t = FreeCat(G_t)

Objects are positions, morphisms are formal paths of active pointer edges: every route the active graph permits, unconcerned with any particular execution.

Source: Is .me a Category? (Medium)

Trace^{(n)}_t : P̂ ⇀ Mor(C_t)
Mor(C_t) = ∐_{p, q ∈ P̂} Hom_{C_t}(p, q)

A fuel-bounded trace returns a morphism of C_t typed by source and target, not the category itself.

Source: Is .me a Category? (Medium)

Trace^{(n)}_t(x) = c : p → q,   c ∈ Hom_{C_t}(p, q),   x ∈ ↓p
Trace^{(n)}_t(x) = id_x : x → x        (no pointer involved)

The input lives in the source's cone (x = p.s), not necessarily at the source; with no pointer, the trace is the identity anchored at x itself.

Source: Is .me a Category? (Medium)

F_t(c) : ↓p → ↓q,   F_t(c)(x) ∈ ↓q
F_t(id_x) = id_{↓x}

The structural functor sends a route to its net relocation between principal cones; an identity route relocates nothing.

Source: Is .me a Category? (Medium)

Exec_{t,γ}(id_x, x) = R_{t,γ}(x)

Pointer-free resolution is the special case where the structural layer contributes nothing and contextual resolution acts directly on the input.

Source: Is .me a Category? (Medium)

RuntimeEval^{(n)}_{t,γ}(x) = R_{t,γ}( F_t(Trace^{(n)}_t(x))(x) ),   when the trace is defined

One read: trace the route, relocate the input along it, then resolve the relocated path under context. A4: profile.cards.primary.income ↦ wallet.income ↦ 1000.

Source: Is .me a Category? (Medium)

ConeSubst(P̂):   π_{p,q}(p.s) = q.s,   one morphism per ordered pair (p, q)

A deliberately restricted category: only the canonical prefix-replacement map between each pair of principal cones, so every hom-set is a singleton and every morphism invertible (chaotic).

Source: Is .me a Category? (Medium)

R_{t,γ} : P̂ ⇀ M      — semantic partiality
Trace^{(n)}_t           — operational partiality

Two partialities at two layers: a valid position may manifest nothing (⊥), and a fuel-bounded evaluation may not complete a finite trace.

Source: Is .me a Category? (Medium)

F_t injective on Hom_{C_t}(p, q)  ⟺  |Hom_{C_t}(p, q)| ≤ 1

Faithfulness is per hom-set: route information survives exactly for source–target pairs with at most one formal chain, and is lost wherever there are more.

Source: Is .me a Category? (Medium)

history → active graph → available routes → traversed route → canonical relocation → contextual manifestation

The six typed stages, H_t, G_t, C_t, Trace, F_t, R_{t,γ}: each carries exactly what the next one needs.

Source: Is .me a Category? (Medium)

identityHash(K) = keccak256("this.me/identity:v1::" + K.seed)

One deterministic function from a kernel's seed to its public fingerprint — identity as computation, not as an issued credential.

Source: Centralize the Self, Distribute the Data, Cryptographic Set-Chemistry on Audiences

wallet.hidden ⊆ wallet
⟹ A(wallet.hidden) satisfies A(wallet), not conversely

Nested secret scopes inherit their nearest ancestor's audience by default — the derivation walks ancestor prefixes, not a rule engine.

Source: The Algebra of Encrypted Audiences

cost(scoped_read)  ≈ 10¹–10² × cost(public_read)
tamper(ciphertext) ⟹ decrypt_failure, not corrupted_read

Reading a secret-scoped path costs one to two orders of magnitude more than a public read (real, measured), and tampering with ciphertext fails closed — you get a decrypt error, never silently corrupted data.

Source: The Algebra of Encrypted Audiences

A = A₁ ∪ A₂ ∪ ... ∪ Aₙ     (any member resolves independently)
A = A₁ ∩ A₂ ∩ ... ∩ Aₙ     (all members required, jointly)

An audience composes like a set: OR-audiences where any one key opens it, AND-audiences where every key is required together.

Source: The Encrypted Island

S₁, ..., Sₙ₋₁ ← random(32) each
Sₙ = S ⊕ S₁ ⊕ ... ⊕ Sₙ₋₁
∀ Kᵢ ∈ A:  Wᵢ = wrapSecretV1(P256_pub(Kᵢ), Sᵢ)

The AND-audience (joint-required) scheme: the real secret is XOR-split across every member's share, so decryption genuinely requires all of them — not just a policy check that could be bypassed.

Source: Cryptographic Set-Chemistry on Audiences

owner(p) = argmax_{n : prefix(n) ≤ p} |prefix(n)|

The owner of a path is the namespace whose prefix is the longest one containing it — a structural fact about the tree, never a name checked against a list.

Source: Surface Identity Claims (cleaker)

mode(p) = decl(q*)   if ∃ q* ≤ p, the deepest ancestor with a declaration
        = owner       otherwise

A path's write mode is whatever its deepest declaring ancestor says; what nobody declared defaults to owner — closed by default, not open by omission.

Source: Surface Identity Claims (cleaker)

K(p) = {pk(owner(p))} ∪ delegates(owner(p), p)

The keys allowed to write at p: the owner's own key, plus whatever delegates the owner has scoped to that path.

Source: Surface Identity Claims (cleaker)

write(p, v, σ, h, c) ⟺
  ∃k∈K(p): Verify(k, ⟨owner(p), p, v, h⟩, σ) ∧ h = head(owner(p))    if mode(p) = owner
  c = internal                                                        if mode(p) = internal
  ⊥                                                                    if mode(p) = api

A write is authorized only if some key in K(p) signs the path, value, and expected head together, against the current head — or, for a declared-internal branch, only the process itself. An api-mode branch never passes through this generic rule at all: it is written only through its own dedicated API.

Source: Surface Identity Claims (cleaker)

resolve(p, c, T) ∈ { v, closed, ∅ }

Reading has the same shape as writing — the same owner/mode structure decides whether a path answers with a value, answers closed, or doesn't exist at all.

Source: Surface Identity Claims (cleaker)

cost(mutation) = O(k), not O(n)
      k = |affected dependency frontier|   (a mutation's actual cost)
      n = |total graph size|               (irrelevant to that cost)

The core reactive-computation claim: a write's cost depends on how many nodes actually depend on it, never on the size of the whole graph. Measured, not assumed — see the benchmark numbers, including the ones that don't flatter it.

Source: Inverted Dependency Indexing, What is O(k)?

Visual: cost(mutation) = O(k) — infographic

Axiom 0 — Distinction: any system containing information requires ≥1 distinction
Axiom 1 — State: a distinction implies ≥2 mutually exclusive states
Axiom 2 — Transition: movement is the transition between states

The minimal formal precondition for any system to contain information at all — no substrate, no physics required, only the possibility of separation.

Source: The Axiom of Distinction

reach(0) = 1
reach(t) = reach(t-1) + new_nodes_connected_at_t

A structure that connects zero new nodes over all time never leaves its origin — reach is a structural precondition of persistence, stated as a trivial recurrence rather than asserted rhetorically.

Source: Connecting Dots

f(E, S) → 0                                    (neutralizing)
f(E, S) = E + f(E₁, S₁) + f(E₂, S₂) + …         (multiplying)

Whether directed energy — capital, attention, effort — compounds or dies on contact depends entirely on whether the receiving structure S has a mechanism to retain and re-propagate it, not on the size of the input.

Source: The Theorem of Non-Neutralized Energy

y_t = x_t + η_policy + η_memory + η_routing + η_incentive

The semantic state actually delivered through a controlled channel equals the intended state plus four named, independent noise terms — filtering, session loss, retrieval bias, and institutional pressure. The Centralized Noise Axiom.

Source: Bizantine, trust.me, byzantine-prompt

n = 1  ⟹  f ≤ 0

The degenerate case of the imported Byzantine bound applied to a single-controller channel: a centralized topology tolerates zero internal Byzantine faults, by construction — not by policy, by arithmetic.

Source: byzantine-prompt, Bizantine, trust.me, learn

Visual: n=1 ⟹ f≤0 — infographic