Unified Manifestations of Software Systems: Full Chain Analysis

Status: Canonical reference. Full unified manifestation IDs for diverse software systems traced from physics through ecosystem. The structural ID of each system across ALL connected lattices.

1. What a unified manifestation IS

A unified manifestation = a specific system's position across ALL connected lattices in the arrangement. Every domain position specified. Every bridge level specified. The complete structural fingerprint.

U(system) = (
  Hardware position:     (Sw, Ic, St, Os, Pw, Pt)
  HW→Computing bridge:  (Ls, Mc, Id, Ct, Io, Sc)
  Computing position:    (Wd, Mm, In, Cy, Ch, Pr)
  Computing→Substrate:   (Enc, Hsh, Prt, Prs, Sch, Net)
  Substrate position:    (E, I, T, M, X, P)
  Substrate→Surface:     (extension activation profile)
  Surface position:      (D, Sh, Ac, Mt, Pg, Ch, Pc, Pn, Bn, Au, Hs, Ev)
  Surface→Eco bridge:    (mechanism activation profile)
  Ecosystem position:    (Vc, Ex, Ru, Dv, Ig, Gv, Tp, Eo, Io)
)

That's 6+6+6+6+6+12+12+10+9 = 73 dimensions. The full structural ID.

For this analysis: focus on the domain positions (6+6+6+12+9 = 39 dimensions) plus the most distinctive bridge levels. Omit physics-level (shared for all digital systems) and manufacturing (one-time, same for all silicon-based systems).

2. Unified Manifestations

2.1 Git

U(Git) = (
  Hardware:      (Sw4, Ic3, St3-4, Os3, Pw2, Pt3)     — standard desktop/server hardware
  HW→Comp:       (Ls3, Mc3, Id3, Ct3, Io3, Sc2)        — standard computing bridge
  Computing:     (Wd3, Mm4, In3, Cy3, Ch3, Pr2)         — standard computing
  Comp→Sub:      (Enc3-packfile, Hsh-Full-SHA, Prt2-pack protocol, Prs-Full-object store, Sch0-CLI, Net2-remotes)
  Substrate:     (E-Full, I-Full, T2, M0, X0, P0)
  Sub→Surf:      Tree=active, Type=0, Compute=0, Sub=0, Inbox=0, Sync=2, History=Full, others=0
  Surface:       (D-Full, Sh2, Ac2, Mt2-commit, Pg0, Ch2-merge, Pc1, Pn1, Bn1, Au1, Hs-Full, Ev0)
  Surf→Eco:      (Dp3, Ap0, Os-Full, Pd-Full, Pp0, Sa2, Ds2, Ua-Full, Cf-Full, Ve-Full)
  Ecosystem:     (Vc-Full, Ex2, Ru-Full, Dv3, Ig3, Gv2, Tp3, Eo3, Io3)
)

What the ID reveals:

Git's structural fingerprint is dominated by THREE peaks: Hsh-Full (bridge), Hs-Full (surface), and I-Full + E-Full (substrate). Content-addressed identity with perfect history. Everything else is low — no dispatch (X0), no emit (M0), no propagation (Pg0), no interactivity (Pc1/Pn1).

At the ecosystem level: Vc-Full and Ru-Full — Git produces enormous value AND is maximally reused (every developer uses it). Cf-Full (community) reflects the massive Git/GitHub ecosystem.

Structural summary: Git IS content-addressed immutable versioned storage. That's what the ID says. No computation, no reactivity, no interactivity — pure versioned data.

2.2 PostgreSQL

U(Postgres) = (
  Hardware:      (Sw4, Ic4, St4, Os4, Pw3, Pt4)         — server-grade hardware, SSD/NVMe
  HW→Comp:       (Ls3, Mc4, Id3, Ct4, Io3-DMA, Sc4-VT-x) — advanced computing bridge
  Computing:     (Wd3, Mm4-virtual, In3, Cy4, Ch4, Pr3)   — advanced computing
  Comp→Sub:      (Enc2-pg format, Hsh0-OID, Prt2-pg protocol, Prs4-WAL+replication, Sch2-process pool, Net2-client-server)
  Substrate:     (E3-typed rows, I0-OID, T2-schema.table, M2-WAL, X3-SQL eval, P1-client auth)
  Sub→Surf:      History=2(WAL), Sync=2(replication), Compute=3(materialized views), Type=3(constraints), others partial
  Surface:       (D-Full, Sh-Full, Ac-Full, Mt-Full, Pg2-triggers, Ch-Full-ACID, Pc1-batch, Pn0, Bn2, Au3-row level, Hs2-WAL, Ev3-views)
  Surf→Eco:      (Dp-Full, Ap3-libpq/JDBC, Os-Full, Pd3-packages, Pp2, Sa-Full-SQL standard, Ds3-pg_dump+logical repl, Ua-Full, Cf-Full, Ve-Full)
  Ecosystem:     (Vc-Full, Ex3, Ru3, Dv3, Ig-Full-SQL, Gv3-PostgreSQL Global Dev Group, Tp3, Eo-Full, Io3)
)

What the ID reveals:

Postgres's peaks: Prs4 (bridge — persistence is its core), Ch-Full and Ac-Full (surface — ACID consistency and SQL queries), and I0/Hsh0 (NO content addressing). The absence of content addressing (Hsh0, I0) IS the structural difference from the entity system — Postgres identifies data by location (OID, primary key), not by content.

Surface: D-Full, Sh-Full, Ac-Full, Mt-Full — the full CRUD stack at maximum. But Pc1/Pn0 — no interactivity, it's a backend.

Ecosystem: Ig-Full because SQL IS an integration standard. Sa-Full because SQL IS a standard. Postgres exists as ecosystem INFRASTRUCTURE — widely integrated, standardized.

Structural summary: Postgres IS a location-addressed transactional query engine. Maximum internal data management. Zero interactivity. Maximum ecosystem integration through SQL standard.

Contrast with Git: Both are data systems. Git: content-addressed + history-first + no query. Postgres: location-addressed + consistency-first + full query. Orthogonal in the same space.

2.3 Bitcoin

U(Bitcoin) = (
  Hardware:      Mining: (Sw4-ASIC, Ic3, St2, Os2, Pw4-optimized, Pt3)
                 Node:  (Sw4, Ic3, St3-4, Os3, Pw2, Pt4-network)
  HW→Comp:       Standard for nodes; ASIC-specific for miners
  Computing:     (Wd3, Mm3, In2-simple, Cy2, Ch4-network, Pr2)
  Comp→Sub:      (Enc2-canonical tx, Hsh-Full-SHA256d+Merkle, Prt-Full-Bitcoin P2P, Prs-Full-blockchain+UTXO, Sch1-event loop, Net-Full-gossip)
  Substrate:     (E3-transactions, I-Full-hash addressed, T2-block chain, M1-append only, X3-Script eval, P-Full-decentralized)
  Sub→Surf:      History=Full(blockchain IS history), Sync=Full(longest chain), Compute=3(Script), Network=Full, Role=3(miner/node/wallet)
  Surface:       (D3, Sh3, Ac2, Mt1-append only, Pg-Full, Ch-Full-consensus, Pc2, Pn0-1, Bn-Full, Au-Full-cryptographic, Hs-Full, Ev3-Script)
  Surf→Eco:      (Dp-Full, Ap3-RPC, Os-Full, Pd3, Pp0, Sa-Full-BIP standard, Ds-Full-public chain, Ua3, Cf-Full, Ve3)
  Ecosystem:     (Vc4, Ex3, Ru3, Dv3, Ig3, Gv2-BIP process, Tp-Full-global P2P, Eo3, Io2)
)

What the ID reveals:

Bitcoin's peaks: Hsh-Full + Prs-Full + Net-Full (bridge — maximum content addressing, persistence, and distribution), Ch-Full (surface — consensus IS coherence), Hs-Full (surface — blockchain IS history), Au-Full (surface — cryptographic authority), Mt1 (surface — append only, NO mutation).

The Mt1 is distinctive — Bitcoin is the MOST RESTRICTIVE on mutation of any major system. You can only append, never update or delete. This constraint IS the innovation — immutability provides the trust model.

Hardware split: MINERS have specialized hardware (ASIC, power-optimized). NODES have standard hardware. The unified manifestation has TWO hardware positions because different roles use different hardware. This connects to the ecosystem — the Role bridge primitive differentiates miner/node/wallet.

Structural summary: Bitcoin IS maximally content-addressed, maximally distributed, maximally immutable, maximally persistent, with cryptographic authority. Minimum mutation. The structural ID IS the value proposition.

2.4 Instagram

U(Instagram) = (
  Hardware:      Client: (Sw4-phone SoC, Ic3, St3, Os3, Pw3-battery, Pt-Full-camera+GPS+touch+WiFi+LTE)
                 Server: (Sw4, Ic4, St4, Os4, Pw3, Pt4)
  HW→Comp:       Client: standard mobile. Server: cloud infrastructure.
  Computing:     Client: (Wd3, Mm3, In3, Cy3, Ch4-WiFi/LTE, Pr3)
                 Server: (Wd3, Mm4, In3, Cy4, Ch-Full, Pr-Full-containers)
  Comp→Sub:      (Enc2-JSON/Protobuf, Hsh1-content IDs not content-addressed, Prt2-HTTP API, Prs3-distributed DB, Sch3-distributed, Net2-client-server)
  Substrate:     (E3-posts/stories/reels, I1-server-assigned IDs, T2-feed/profile/explore, M3-post/like/comment, X2-feed algorithm, P2-accounts+following)
  Sub→Surf:      Subscription=Full(real-time feed), Compute=Full(recommendation ML), Content=2(media types), Network=3(CDN), others moderate
  Surface:       (D-Full, Sh4, Ac-Full-algorithmic, Mt3, Pg-Full, Ch3-eventual, Pc-Full, Pn-Full, Bn-Full, Au3, Hs1, Ev-Full-recommendation)
  Surf→Eco:      (Dp-Full, Ap3-Graph API, Os0-closed, Pd0, Pp-Full-Meta platform, Sa2, Ds2, Ua-Full, Cf3, Ve-Full)
  Ecosystem:     (Vc-Full, Ex3, Ru1, Dv2, Ig3, Gv-Full-Meta policies, Tp-Full-global CDN, Eo3, Io1-walled garden)
)

What the ID reveals:

Instagram's peaks: Ac-Full + Ev-Full (surface — the recommendation algorithm IS the product), Pc-Full + Pn-Full (surface — full interactivity), Pg-Full (surface — real-time everything), Gv-Full (ecosystem — Meta controls everything), Io1 (ecosystem — walled garden, minimal interoperability).

Hardware SPLIT between client (phone with camera/GPS/touch — Pt-Full) and server (cloud — Pr-Full). The unified manifestation spans two hardware profiles simultaneously. The client is Perception-heavy (camera, touch, GPS). The server is Computation-heavy (ML recommendation).

I1 (substrate — server-assigned IDs, not content-addressed) means Instagram can DELETE content (unlike Bitcoin). Content isn't defined by its hash — it's defined by the server. This enables content moderation, takedowns, editing — all impossible with content-addressed identity.

Ev-Full (surface — evaluation) IS the recommendation algorithm. Instagram exists PRIMARILY as an evaluator — it derives the feed from user signals + content features + social graph. Without Ev, Instagram is just a photo hosting service.

Structural summary: Instagram IS an evaluation-dominated interactive platform with maximum perception, presentation, and propagation, operated within a governed walled garden. Location-addressed (not content-addressed) — enabling content control.

2.5 Linux Kernel

U(Linux) = (
  Hardware:      (varies — runs on Sw1-microcontroller through Sw4-server)
  HW→Comp:       (Ls3, Mc4, Id3, Ct4, Io3, Sc-Full)    — kernel IS the computing bridge
  Computing:     (Wd3, Mm4, In3, Cy4, Ch4, Pr-Full)     — kernel PROVIDES computing
  Comp→Sub:      (Enc1-various, Hsh1-inode, Prt2-syscall ABI, Prs3-VFS, Sch-Full-CFS, Net3-TCP/IP stack)
  Substrate:     (E2-files/processes, I1-inode/PID, T3-VFS tree, M3-signals/poll/inotify, X3-syscall dispatch, P3-users+namespaces)
  Sub→Surf:      All extensions at moderate levels — kernel provides PLATFORM for everything
  Surface:       (D3, Sh3, Ac3-VFS, Mt-Full-syscalls, Pg-Full-signals/epoll, Ch-Full-locks/atomics, Pc-Full-all input, Pn2-framebuffer, Bn-Full-namespaces, Au-Full-capabilities, Hs2-journaling, Ev3-BPF)
  Surf→Eco:      (Dp-Full, Ap2-syscall ABI, Os-Full, Pd-Full, Pp0, Sa-Full-POSIX, Ds3, Ua-Full, Cf-Full, Ve-Full)
  Ecosystem:     (Vc-Full, Ex3, Ru-Full, Dv-Full, Ig-Full-POSIX, Gv3-kernel.org, Tp-Full, Eo-Full, Io-Full)
)

What the ID reveals:

Linux is HIGH on nearly EVERYTHING — it's infrastructure. Sc-Full at the bridge (scheduling IS the kernel's core job). Pr-Full at computing (kernel provides process isolation). Bn-Full and Au-Full at surface (namespace isolation and capability-based security).

The distinctive feature: Linux's hardware position VARIES — it runs on everything from Sw1 (microcontrollers) to Sw4 (servers). The unified manifestation has a RANGE on hardware, not a single point. This is like a biological species with a wide habitat range — the same organism (Linux) occupies different hardware niches.

At substrate level: T3 (VFS tree — the filesystem hierarchy IS a tree namespace) and X3 (syscall dispatch — the kernel IS a dispatcher). These map directly to entity system concepts — Linux's VFS IS a tree, syscall dispatch IS typed execution.

Ecosystem: Full on nearly everything. Linux IS the digital ecosystem's infrastructure — like how photosynthesis is the biological ecosystem's energy foundation.

Structural summary: Linux IS the platform — maximum infrastructure across all levels, variable hardware, full ecosystem presence. It provides the computing substrate that everything else runs on.

2.6 Minecraft (Java Edition server)

U(Minecraft Server) = (
  Hardware:      Server: (Sw4, Ic3, St3, Os3, Pw2, Pt3-network)
                 Client: (Sw4-GPU, Ic3, St3, Os3, Pw2-3, Pt3-display+input)
  HW→Comp:       Standard computing
  Computing:     (Wd3, Mm4-JVM heap, In3-JVM bytecode, Cy3, Ch3, Pr3-JVM threads)
  Comp→Sub:      (Enc1-NBT format, Hsh0, Prt2-Minecraft protocol, Prs2-chunk files, Sch2-tick loop+workers, Net2-client-server)
  Substrate:     (E2-blocks/entities/items, I0-position-addressed, T2-chunk grid, M-Full-continuous world update, X2-game rules, P2-player accounts)
  Sub→Surf:      Subscription=3(player state sync), Compute=2(game rules), Network=2(server list), others low
  Surface:       (D-Full, Sh-Full, Ac3-spatial, Mt-Full-continuous, Pg-Full-tick broadcast, Ch3-server authoritative, Pc-Full-WASD+mouse+interact, Pn-Full-3D render+audio, Bn3-server+mods, Au2-ops/whitelist, Hs2-saves, Ev2-game rules)
  Surf→Eco:      (Dp3, Ap2-plugin API, Os0-Mojang proprietary, Pd3-mods+plugins, Pp3-Mojang/Microsoft, Sa1, Ds1, Ua-Full, Cf-Full, Ve-Full)
  Ecosystem:     (Vc4, Ex2, Ru2, Dv3-mods, Ig2, Gv3-Mojang+modding community, Tp3, Eo3, Io1)
)

What the ID reveals:

Minecraft's peaks: Mt-Full + Pg-Full (surface — continuous mutation with tick-based broadcast), Pc-Full + Pn-Full (surface — full interactive 3D), M-Full (substrate — the world changes CONSTANTLY at 20 ticks/second).

Hsh0 / I0 — NO content addressing. Blocks are identified by position (x,y,z), not by content hash. This is fundamentally different from the entity system's approach. Minecraft's world is LOCATION-addressed, like Postgres.

Hardware SPLIT: client needs GPU (Pn-Full requires 3D rendering), server doesn't (Pn0 for the server). The GPU requirement IS the Presentation primitive demanding specific hardware.

Ac3 (spatial queries — "what's at this position?" "what's near me?") — Minecraft access IS spatial, not relational or content-based. This is a different ACCESS modality than Postgres (SQL) or Git (path-based).

Structural summary: Minecraft IS a continuously mutating spatial world with full interactive 3D perception and presentation. Location-addressed, tick-driven, mod-extensible. The game loop (20 ticks/sec mutation + broadcast) IS the system's heartbeat.

2.7 curl

U(curl) = (
  Hardware:      (whatever the user's machine is — runs anywhere)
  Computing:     (standard)
  Comp→Sub:      (Enc0-1-passthrough, Hsh0, Prt3-speaks many protocols, Prs0, Sch0-single shot, Net2-client)
  Substrate:     (E0-1-opaque data, I0, T0, M0, X0-1-fixed commands, P0)
  Surface:       (D1, Sh0-1, Ac1, Mt0, Pg0, Ch0, Pc1-CLI args, Pn1-stdout, Bn2-network client, Au2-auth options, Hs0, Ev0)
  Ecosystem:     (Vc3-essential tool, Ex2, Ru-Full-everywhere, Dv1, Ig3-speaks everything, Gv2, Tp3, Eo3, Io-Full-protocol bridge)
)

What the ID reveals:

curl is near-ZERO on almost every domain but Prt3 (bridge — speaks many protocols) and Io-Full (ecosystem — maximum interoperability). curl IS a protocol bridge — its value is CONNECTING things, not processing data.

At the substrate level: almost nothing. E0-1 (opaque data passthrough), I0, T0, M0, X0-1. curl is NOT an information substrate. It's a PIPE — data goes through it without being structured, identified, organized, or processed.

At the ecosystem level: Vc3 + Ru-Full + Io-Full. High value (essential tool), maximum reuse (installed everywhere), maximum interoperability (the universal protocol client). curl's ecosystem presence is DISPROPORTIONATE to its internal complexity. Minimal internal structure, maximum external utility.

Structural summary: curl IS a minimal protocol bridge with maximum interoperability. The structural opposite of Bitcoin (maximum internal structure) or Instagram (maximum surface). curl proves that systems can have enormous ecosystem value with near-zero substrate/surface complexity.

2.8 TikTok Recommendation Algorithm (component)

U(TikTok Rec) = (
  Hardware:      (Sw4-GPU clusters, Ic4-NVLink, St3-HBM, Os3, Pw3, Pt4-datacenter networking)
  Computing:     (Wd3, Mm4, In4-CUDA/tensor ops, Cy3, Ch4, Pr4-distributed training)
  Comp→Sub:      (Enc2-feature vectors/Protobuf, Hsh1-feature IDs, Prt3-internal RPC, Prs3-feature store+model store, Sch3-distributed, Net3-internal mesh)
  Substrate:     (E3-features+embeddings, I1-feature IDs, T2-model architecture, M3-model updates, X-Full-inference, P2-service boundaries)
  Surface:       (D-Full, Sh4, Ac-Full-vector similarity, Mt3-model updates, Pg3-model deployment, Ch2, Pc-Full-every user signal, Pn0-feeds to app, Bn3, Au2, Hs3-model versions, Ev-Full-THIS IS THE SYSTEM)
  Ecosystem:     (Vc-Full, Ex3, Ru2, Dv2, Ig2, Gv1-minimal regulation, Tp3, Eo-Full, Io1)
)

What the ID reveals:

Ev-Full dominates EVERYTHING. The recommendation algorithm IS evaluation — it derives the ranked feed from user signals. Pc-Full (perceives every user interaction — swipe, watch time, share, pause) feeds directly into Ev-Full (computes ranked output). Pn0 (produces no presentation itself — feeds results to the app layer).

Hardware: GPU clusters with NVLink — Sw4 + In4 (tensor operations). The hardware is specialized FOR evaluation. The HW→Computing bridge has In4 (parallel instructions) specifically to support the evaluation workload.

X-Full at substrate (inference IS full execution — the model IS a dispatch system routing user signals through neural network layers). The model's forward pass IS typed dispatch — input features → layer transformations → output ranking.

Structural summary: TikTok's recommendation IS a perception-to-evaluation pipeline. Maximum perception (Pc-Full — every user signal), maximum evaluation (Ev-Full — ML inference), zero presentation (Pn0 — feeds to the app). The algorithm's unified manifestation is EVALUATION-DOMINATED from hardware through ecosystem.

2.9 Arduino Temperature Logger (embedded)

U(Arduino Temp Logger) = (
  Hardware:      (Sw3-ATmega, Ic2-SPI/I2C, St2-SRAM+Flash, Os1-fixed 16MHz, Pw1-5V regulated, Pt2-GPIO+sensor)
  HW→Comp:       (Ls2-standard cell, Mc1-flat RAM, Id1-AVR decode, Ct1-fixed clock, Io1-UART, Sc0-bare metal)
  Computing:     (Wd2-8bit, Mm2-flat, In2-AVR ISA, Cy1-fixed, Ch2-serial, Pr0-bare metal)
  Comp→Sub:      (Enc1-custom struct, Hsh0, Prt1-serial framing, Prs1-EEPROM, Sch0-main loop, Net0-local)
  Substrate:     (E1-sensor reading struct, I0, T0-flat, M1-overwrite, X1-fixed loop, P0)
  Surface:       (D1, Sh1-implicit, Ac1-direct address, Mt1-overwrite, Pg1-poll loop, Ch0, Pc3-continuous sensor, Pn2-serial+LED, Bn1, Au0, Hs0, Ev1-threshold check)
  Ecosystem:     (Vc1-personal project, Ex1, Ru1, Dv1, Ig1, Gv0, Tp1, Eo0, Io0)
)

What the ID reveals:

Almost everything at low levels EXCEPT Pc3 (continuous sensor input — this IS the device's purpose). The Arduino exists to PERCEIVE temperature and produce minimal output (Pn2 — serial print + LED).

Hardware: Sw3 (microcontroller — full CPU on chip but small), Wd2 (8-bit — minimal word size), Mm2 (flat RAM, no hierarchy). The hardware IS minimal, and this correctly shows up as low positions throughout the chain.

Ecosystem: near-zero on everything. A personal project doesn't participate in the digital ecosystem. This is the structural equivalent of a single bacterium — it exists but doesn't form community.

Structural summary: The Arduino logger IS a minimal perception device. Pc3 is the only above-average position. Everything else is at survival minimum. This is the E. coli of software — minimal but functional for its niche.

3. Comparative Analysis

3.1 The substrate fingerprint comparison

What the comparison reveals:

Identity (I) is the great divider. Systems split into content-addressed (Git, Bitcoin at I-Full) vs location-addressed (everything else at I0-I1). This IS the entity system's most distinctive feature — content addressing. Most software doesn't do it.

Mutation (M) divides interactive from static. Minecraft at M-Full (continuous), Instagram at M3, Linux at M3 vs Git at M0 (immutable), Bitcoin at M1 (append only). The mutation level IS the interactivity level.

Execution (X) divides evaluators from stores. TikTok rec at X-Full, Postgres/Linux/Bitcoin at X3 vs Git at X0. Systems WITH computation vs systems WITHOUT.

Peer (P) divides distributed from local. Bitcoin at P-Full, Linux at P3 vs Git/Arduino at P0. Distribution level.

3.2 The surface fingerprint comparison

(F = Full)

The Pc-Pn diagonal confirmed as system classifier:

• Interactive consumer: Instagram, Minecraft — Pc-Full + Pn-Full
• Backend service: Postgres, TikTok rec — Pc1/Pn0
• Embedded sensor: Arduino — Pc3/Pn2 (perceives more than it shows)
• Tool: curl, Git — Pc1/Pn1 (minimal I/O)

The Ev axis confirmed as computation classifier:

• Evaluation-dominated: TikTok rec (Ev-Full), Instagram (Ev-Full)
• Computation-capable: Postgres (Ev3), Bitcoin (Ev3), Linux (Ev3)
• No evaluation: Git (Ev0), curl (Ev0), Arduino (Ev1)

3.3 The ecosystem fingerprint comparison

Linux dominates the ecosystem — Full or near-Full on nearly everything. It IS the digital infrastructure, like photosynthesis in biology.

curl at Io-Full — maximum interoperability despite minimal internal complexity. The ecosystem values BRIDGE tools disproportionately to their internal structure.

Instagram at Io1 — walled garden. Minimum interoperability despite maximum internal capability. The ecosystem position DIVERGES from the surface capability — Instagram CAN interoperate but CHOOSES not to.

Arduino at near-zero — a personal project doesn't participate in the ecosystem. This correctly positions hobby embedded devices as non-ecosystem-participants.

4. What the unified manifestations reveal

4.1 The identity axis IS the fundamental architectural divide

Content-addressed (I-Full: Git, Bitcoin) vs location-addressed (I0-1: everything else). This single axis determines more structural properties than any other:

• Content-addressed systems have: perfect versioning (Hs-Full), natural deduplication, verifiable integrity, immutability (Mt0-1)
• Location-addressed systems have: mutable data (Mt3+), flexible identity, easier deletion, simpler implementation

4.2 The Pc-Pn-Ev triangle classifies application purpose

Every system's PURPOSE is captured by where it sits in the Perception-Presentation-Evaluation triangle:

• Data systems (Git, Postgres): low Pc, low Pn, moderate Ev — they STORE and QUERY
• Interactive platforms (Instagram, Minecraft): high Pc, high Pn, high Ev — they ENGAGE humans
• Evaluation engines (TikTok rec): high Pc, low Pn, maximum Ev — they COMPUTE
• Sensors (Arduino): high Pc, low Pn, low Ev — they PERCEIVE
• Bridges (curl): low everything — they CONNECT

4.3 Ecosystem presence decouples from internal complexity

curl (minimal internal) has Ru-Full and Io-Full at ecosystem. Instagram (maximum internal) has Io1 at ecosystem. Ecosystem position reflects UTILITY AND OPENNESS, not internal sophistication. Simple, open tools can dominate ecosystems. Complex, closed platforms can be ecosystem-isolated.

4.4 The hardware split is real and structural

Instagram (client GPU + server CPU), Bitcoin (ASIC miner + standard node), Minecraft (client GPU + server CPU). Many systems have MULTIPLE hardware manifestations. The unified manifestation should accommodate ranges/splits at the hardware level.

4.5 The 73-dimensional ID is structurally informative

Every tested system has a DISTINCTIVE fingerprint. No two systems share the same position. The fingerprint captures what the system IS, HOW it works, and WHERE it sits in the ecosystem — all from structural analysis, not from feature lists or marketing descriptions.

Summary

Nine systems analyzed with full unified manifestations across 39+ dimensions. The structural IDs correctly differentiate systems and reveal architectural patterns:

1. Identity (I) divides the software world — content-addressed vs location-addressed
2. Pc-Pn-Ev triangle classifies purpose — data/interactive/evaluator/sensor/bridge
3. Ecosystem position decouples from internal complexity — utility and openness matter more
4. Hardware splits are common — client/server, miner/node require range positions
5. Every system has a unique structural fingerprint — the methodology produces distinctive, informative IDs

Referenced by the model

Cited as a source by 6 model records (browse the model census):

• git — manifestation entity/sc3/git
• github — manifestation entity/sc3/github
• instagram-client — manifestation entity/sc3/instagram-client
• instagram — manifestation entity/sc3/instagram
• postgres — manifestation entity/sc3/postgres
• postgres-evolution — trajectory entity/sc3/postgres