dependents-index-is-fragile-denormalization
OUT derived (depth 1)
The dependents set is a manually-maintained denormalized reverse index that is never persisted and must be rebuilt on every load, creating a consistency obligation on all mutation paths
Summary
The system tracks which beliefs depend on which others using a reverse index that exists only in memory, never saved to the database. Every time the system starts up it has to reconstruct this index from scratch, and every operation that changes relationships between beliefs is responsible for keeping it accurate — if any of those code paths forgets to update it, the index silently goes stale.
Justifications
SL — Three beliefs triangulate the same fragility: any mutation path that forgets to update dependents silently corrupts propagation
Antecedents (all must be IN):
- dependents-is-manual-reverse-index — `Node.dependents` is a denormalized reverse pointer set that must be kept in sync by external code (primarily `network.py`); nothing in the data model enforces consistency.
- dependents-index-derived-on-load — The `node.dependents` set is never persisted to SQLite; it is rebuilt by walking all justification antecedents and outlists during `load()`.
- dependents-bidirectional-index — Each node maintains a `dependents` set (reverse of antecedent/outlist edges), eagerly maintained by `add_node`, `add_justification`, `supersede`, `challenge`, and `convert_to_premise`.
Dependents
These beliefs depend on this one:
- architecture-has-no-hidden-fragility — The system's architectural safety is robust end-to-end: structural containment via clean layer boundaries and operational atomicity via context-managed mutations leave no hidden consistency hazards across the persistence boundary.
- complete-unified-system-is-production-ready — The fully unified minimal-dialectical-scalable system with end-to-end integrity is production-ready — all mutations produce correct state, all revision is reliable, all extensions compose safely — but only when every known fragility and bug is resolved.
- dedup-survivor-selection-is-topology-reliable — Deduplication reliably selects the structurally-optimal survivor in each duplicate cluster by choosing the node with the most dependents, and this selection is correct because the dependents index accurately reflects the justification graph.
- full-system-integrity-is-gap-free — The system achieves gap-free integrity — enforced across all architectural layers, lifecycle states, and mutation paths — only when the dependents reverse index is reliably maintained and propagation handles dangling references gracefully.
- mutation-pipeline-produces-consistent-state — Every mutation produces a fully consistent persisted network: atomic load/save ensures no partial writes, deterministic propagation ensures all truth values are correctly derived, and lifecycle-aware traversal prevents stale recomputations.
- operational-integrity-survives-all-graph-states — End-to-end operational integrity holds across all semantic edge cases — including vacuous premises, asymmetric absence, and empty antecedents — only when the dependents graph is consistent and propagation handles all node references safely.
- persistence-round-trip-is-lossless — The save/load round trip preserves all network state faithfully: snapshot persistence captures the full graph, stored truth values are trusted without re-propagation, justification insertion order is preserved via rowid, and outlist relationships survive serialization.
- unified-system-is-a-closed-self-maintaining-architecture — The system forms a closed self-maintaining belief architecture: end-to-end integrity ensures no operation corrupts consistency, while revision completeness ensures any valid belief configuration is reachable — together guaranteeing the system can evolve to any target state while preserving all invariants — only when all known defects and fragilities are resolved.