Coordinate System

The 256-bit interleaved coordinate system with X, Y, Z axes and plane bit

The Cyberspace Coordinate System

Cyberspace is a 256-bit coordinate system with three spatial axes (X, Y, Z) and a plane bit (P). Coordinates are not stored sequentially — they are interleaved at the bit level, creating a mathematical structure where spatial proximity corresponds to bit similarity.

What Is a Coordinate?

A Cyberspace coordinate (coord256) is a 256-bit integer with this structure:

X (85 bits) Spatial axis, bits at positions 3, 6, 9, ... (every 3rd bit starting at 3)
Y (85 bits) Spatial axis, bits at positions 2, 5, 8, ... (every 3rd bit starting at 2)
Z (85 bits) Spatial axis, bits at positions 1, 4, 7, ... (every 3rd bit starting at 1)
P (1 bit) Plane bit at position 0 (LSB): 0 = dataspace, 1 = ideaspace

The bit pattern is XYZXYZXYZ...P — the three axes are interleaved bit-by-bit, with the plane bit as the least significant bit. This interleaving ensures that spatially nearby coordinates share similar bit prefixes.

Key Insight

The interleaving is not arbitrary — it enables the Cantor pairing tree mechanism. Coordinates that are close in space have similar interleaved bit patterns, which makes computing traversal proofs efficient and mathematically verifiable.

Gibsons and Sectors

Each 85-bit axis value represents a position along that axis. The fundamental unit of distance is the Gibson (G) — one step in the 85-bit axis space.

Gibson

The smallest unit of coordinate distance. Moving 1 Gibson means changing an axis value by 1. Each axis spans 2⁸⁵ Gibsons (about 3.9 × 10²⁵ positions).

Sector

The high 55 bits of an 85-bit axis. Each sector contains 2³⁰ Gibsons (about 1 billion positions). Sectors are used for region-based operations like Hyperspace entry planes.

To extract a sector from an axis value, shift right by 30 bits:


def extract_sector(axis_value: int) -> int:
    """Extract 55-bit sector from 85-bit axis value.
    
    Sector = high 55 bits of the axis.
    Each sector contains 2^30 Gibsons.
    """
    return axis_value >> 30

# Example: Extract sector from X coordinate
x_axis = 123456789012345  # 85-bit value
sector = extract_sector(x_axis)
print(f"Sector: {sector}")
print(f"Gibson offset within sector: {x_axis & ((1 << 30) - 1)}")

Bit Interleaving

The coordinate encoding uses bit interleaving. Given X, Y, Z values (each 85 bits) and a plane bit P, the 256-bit coordinate is constructed by alternating bits:

coord = Z₀Y₀X₀ ... Z₈₄Y₈₄X₈₄P

Where subscript indicates bit position (₀ = LSB of each axis)

More precisely:

Bit 0: Plane bit P
Bit 1: Z₀ (bit 0 of Z)
Bit 2: Y₀ (bit 0 of Y)
Bit 3: X₀ (bit 0 of X)
Bit 4: Z₁ (bit 1 of Z)
Bit 5: Y₁ (bit 1 of Y)
Bit 6: X₁ (bit 1 of X)
...continuing for all 85 bits

Python Implementation


from typing import Tuple

AXIS_BITS = 85

def xyz_to_coord(x: int, y: int, z: int, plane: int = 0) -> int:
    """Convert X, Y, Z coordinates to interleaved 256-bit coordinate."""
    coord = plane & 1
    for i in range(AXIS_BITS):
        coord |= ((z >> i) & 1) << (1 + i * 3)
        coord |= ((y >> i) & 1) << (2 + i * 3)
        coord |= ((x >> i) & 1) << (3 + i * 3)
    return coord

def coord_to_xyz(coord: int) -> Tuple[int, int, int, int]:
    """De-interleave 256-bit coordinate to X, Y, Z, plane."""
    plane = coord & 1
    x = y = z = 0
    for i in range(AXIS_BITS):
        z |= ((coord >> (1 + i * 3)) & 1) << i
        y |= ((coord >> (2 + i * 3)) & 1) << i
        x |= ((coord >> (3 + i * 3)) & 1) << i
    return (x, y, z, plane)

# Example: Create a coordinate at (100, 200, 300) on plane 0
coord = xyz_to_coord(100, 200, 300, 0)
print(f"Coordinate: {hex(coord)}")

# Decode it back
x, y, z, p = coord_to_xyz(coord)
print(f"Decoded: ({x}, {y}, {z}, {p})")

The Two Planes

The plane bit creates two overlapping coordinate spaces:

Dataspace (P = 0)

Maps to physical reality via GPS coordinates. Coordinates in dataspace correspond to specific physical locations on and around Earth using ECEF (Earth-Centered, Earth-Fixed) conversion.

Use dataspace for location-based applications, AR content anchored to physical places, and geographic encryption zones.

Ideaspace (P = 1)

No physical mapping. Purely abstract coordinates for content that exists independently of physical location.

Use ideaspace for virtual spaces, abstract data structures, AI agent territories, and content that should not be tied to GPS.

Both planes share identical mathematical properties. Movement costs, encryption, and verification work the same way regardless of plane. The plane bit only determines whether coordinates have a physical-world interpretation.

Identity Is Location

In Cyberspace, your cryptographic identity determines your spawn coordinate. Your Nostr public key (a 256-bit number) is interpreted as a coordinate using the same interleaving scheme.

Your public key = your spawn location. When you first enter Cyberspace, you appear at the coordinate encoded by your identity. This is not metaphorical — it is a direct mathematical mapping.

This means:

You cannot choose your spawn point without choosing a different identity
Your location is public knowledge if your public key is known
Respawning returns you to your original spawn coordinate
Identity and location are mathematically inseparable

Movement and Proof-of-Work

Moving between coordinates requires computing a Cantor pairing tree proof. The computational cost scales with the distance crossed — farther jumps require more work.

Why Structured Work?

Standard proof-of-work (like Bitcoin mining) grinds random numbers until finding a hash below a target. The work is real but arbitrary — it doesn't encode spatial information.

Cyberspace uses structured work: computing the Cantor tree that mathematically connects two coordinates. The proof is not "I burned energy" but "I computed the fabric between these points." This is the difference between digging a hole and following a path.

Movement proofs are published as Nostr events:

kind: 3333, A: spawn — Initial entry at identity coordinate
kind: 3333, A: hop — Local movement (within a sector)
kind: 3333, A: sidestep — Boundary crossing (storage-infeasible distances, uses Merkle proof)
kind: 3333, A: enter-hyperspace — Board Hyperspace network via sector plane
kind: 3333, A: hyperjump — Traverse between Hyperjumps in Hyperspace

All Actions Use Kind 3333

Every Cyberspace movement action uses event kind 3333, differentiated by the A tag. This is a critical protocol pattern that ensures all movement is validated uniformly by relays.

Hyperjumps

A Bitcoin block's Merkle root can be interpreted as a 256-bit coordinate in Cyberspace. This coordinate is called a Hyperjump — a thermodynamically "paid for" location that punches holes through the vastness of cyberspace.

Hyperspace Network

Hyperspace is the 1-dimensional path formed by all Bitcoin blocks in height order. Each block is a Hyperjump (a coordinate where you can enter the network).

To enter Hyperspace, navigate to a Hyperjump's sector entry plane (all coordinates sharing the same 55-bit sector on X, Y, or Z axis), then publish an enter-hyperspace action with a Cantor proof (height ≈ 33, ~15 minutes on consumer hardware, ~$0.09 cloud cost).

Once in Hyperspace, travel between Hyperjumps uses a hyperjump action with an incremental Cantor tree proof computed over the path of block heights.

Next Steps

Now that you understand coordinates, explore the mechanisms that make movement possible: