This page distinguishes four mechanisms that are often conflated when people talk about “sharing” in networked knowledge systems. The key diagnostic is what counts as “the same thing” and what happens under mutation.
**Structure sharing (identity semantics).** Multiple references point to **one structure**. “Same” means representational identity: one node/subnetwork, multiply referenced. Under mutation, the change propagates because there is only one thing to change. This is the enabling condition for *side roads that rejoin* in the strict sense: two walks can diverge and later traverse the **same node identity**, not merely similar text. **Synchronization (consistency semantics).** Multiple copies exist, but are kept consistent by a protocol. “Same” means equal state (for now), not shared identity. Under mutation, the system propagates *updates* to keep copies aligned; the copies remain copies. Synchronization can look like structure sharing in the UI, but it is logically different: identity is not shared; consistency is maintained. **Replication (copy semantics).** Multiple copies exist and are not automatically kept consistent. “Same” means “derived from the same source once.” Under mutation, copies diverge unless humans perform manual merge/sync. This is Bricken’s “replication is the source of complexity” in operational form: repeated structures drift, and maintenance cost scales with the number of copies. **Reenactment (causal/temporal identity).** Multiple local structures exist, but all participants share a **single causal history** (an ordered event stream) and deterministically derive the same state by running the same computation. “Same” means “produced by the same execution trace,” not “a shared object.” Under mutation, what propagates is the *event* that causes identical mutations everywhere. **Croquet** is the canonical reenactment case: it shares execution (event-causal identity) rather than a shared object store. This yields perfect “observable propagation” in experience, but it does not provide walk-level divergence by default; divergence must be designed as state/logic within the reenacted world. **Side-road relevance (one line).** Side roads require *divergent walks over shared structure*; therefore they are native to **structure sharing**, can be simulated (with tradeoffs) under **synchronization**, collapse into duplication under **replication**, and are orthogonal to **reenactment** unless you explicitly model per-user traversal inside the reenacted state.