Algebra of Contexts ​

Set Law Applied to Context ​.me thinks in spaces. Not schemas. Not tables. Not object classes. A space is a region of meaning (context) that can contain other spaces. Everything else follows from set laws.

Core Rule ​

A space can contain spaces.

space ⊇ subspace ⊇ subspace ⊇ subspace

Examples:

• profile is a space
• profile.contact is a subspace of profile
• wallet.hidden is a subspace of wallet
• friends[age > 18] is a selected subspace of friends

In .me, paths are how we navigate nested spaces:

me.profile.name("Abella");
me.profile.contact.email("abella@neurons.me");
me.wallet["_"]("vault-key");
me.wallet.hidden.note("private");

Namespace ​

A namespace is a named space.

Examples:

• self
• kernel
• ana
• family.photos

In protocol form:

me://self:read/profile
me://kernel:export/snapshot
me://family.photos:read/2026.vacation.cover

So:

• namespace names the space
• selector states the operation
• path identifies the subspace

Set View ​

We can describe a space by the sets that act on it:

• A = audience set
• T = topology set
• C = capability set
• P = path / subspace set

These are not different ontologies. They are different views of the same space.

Space Predicates ​

The common adjectives are just set statements:

• public space: the readable audience is broadly open
• private space: the audience is tightly bounded, often {self}
• shared space: the audience contains more than one principal
• encrypted space: readable membership is enforced cryptographically
• replicated space: the topology has multiple carriers

Examples:

• wallet may be a private encrypted space
• family.photos may be a shared replicated encrypted space
• profile.public may be a public space

No new noun is required beyond space.

Anchored vs. Derived Shared Spaces ​

A shared space (|A| > 1 — "group" in everyday language) can hold its identity two ways:

• anchored: P is chosen once and stays stable. A is a mutable set inside it — members join or leave without changing what the space is or where it lives.
• derived: P is a function of A itself, computed from the exact member set. Change the set, and the space's own identity changes with it.

anchored:  P is stable; A varies inside P
derived:   P = f(A)

Anchored is the model already running here and in cleaker's own groups.<key>.* convention (a claimed namespace holding members[], admins[], invites[]) — the same shape netget's owner/admin ledger uses. Derived has no namespace primitive in this kernel; it is what NRP's concrete syntax calls surface[a+b] — the space's own address is the hash of its sorted member seeds, so removing one seed leaves nothing to derive back to, no separate revoke needed. Both modes, spelled out in that grammar (group:name vs surface[a+b]) with their current implementation status, live in NRP Chemistry.

Refinement ​

More specific spaces are subsets of less specific spaces.

profile.contact.email ⊆ profile.contact ⊆ profile
wallet.hidden ⊆ wallet

This same law appears across the system:

• deeper path -> smaller semantic region
• tighter audience -> smaller readable set
• tighter context -> smaller resolution set
• tighter capability -> smaller action set

Plurality As Grammar ​

[] extends this same refinement law to members of a space, not just nested subspaces:

Whatever[1] ⊆ Whatever[] ⊆ Whatever

Whatever[] says a space has members — grammar, not a data type. What kind of plural it is (bounded, ordered, evicting) is described as algebraic constraints over that plural (|Whatever[]| <= 128, Whatever[n].slot = n mod 128), never as a named category like kind: "buffer" — the same discipline A/T/C already follow: .me describes the shape, something else (a GUI, a daemon) interprets it. Full treatment in Plurality Is Grammar.

Encryption As Membership ​

Encryption does not create a different universe. It creates a stricter readable membership over a space.

Examples:

• a private space may have A = {self}
• a shared encrypted space may have A = {me ∪ wife} The topology can be large while the readable audience stays small:

T = {home-daemon, office-daemon, phone}
A = {me, wife}

That means the same space may be replicated widely without becoming readable widely.

Why This Matters ​

This gives .me one ontology instead of many.

• .me declares, creates, and navigates spaces
• cleaker records, routes, and transports spaces
• monad.ai serves, resolves, and persists spaces The system stays unified because everything still reduces to:

space inside space inside space

And all of it follows set law.

Where This Runs Outside the Kernel ​

A (audience) is enforced cryptographically here, inside .me itself, via scope-secret key-wrapping. The first place that same A/C separation was extended to a real piece of infrastructure outside the kernel is netget's gateway — see Gateway Capability Model, which proves, with a live executable test suite, that a signed capability (C) is never inferred from audience or role membership (A), even for an authenticated admin identity. It does not yet use this kernel's real key-wrapped A — that adoption is still future work, tracked in that doc's own scope notes — but the capability-separation half of the model is already running against a live gateway, not just declared here.

For the theory this and the gateway work both trace back to, see The Algebra of Encrypted Audiences and Digital Space Algebra.