The Cohesive knowledge graph

overview

Domains can be described as semantic system graphs composed of:

principle

Adjunctions describe paired constructions that translate between domains in the best available way, even when the translations are not inverses.

principle

Algebras and coalgebras provide complementary ways to model construction and behavior.

principle

The asynchronous computability theorem characterizes which distributed tasks can be solved wait-free in an asynchronous read/write system.

principle

The CALM theorem, "Consistency as Logical Monotonicity", states that a program has a consistent, coordination-free distributed implementation if and only if it can be expressed in monotonic logic.

reference

Categorical principles provide modeling discipline for the Cohesive System Model. They are not the entry point for ordinary readers, but they help keep distinctions precise when relating semantic dynamics, system structure, operational semantics, and realization substrate.

principle

Compositionality is the principle that complex systems should be understood from parts and the rules by which those parts compose.

principle

Database Sheaf Semantics views a database schema as a category, a database instance as a structure-preserving functor into sets, and local database views as sections that can be restricted, compared on overlaps, and sometimes glued into a coherent larger instance.

principle

Duality and symmetry are principles for recognizing paired concepts that explain one another through reversal, complementarity, or mirrored structure.

principle

Enrichment adds structure to relationships. Instead of merely asking whether a relationship exists, an enriched view asks what kind of value the relationship has: order, distance, cost, probability, time, authority, confidence, or information.

principle

Equivalence and equality should not be confused.

principle

Event-state duality is a modeling principle and an instance of duality and symmetry: the relationship between two views of behavior:

principle

Fibrations and indexed structure describe situations where each object in a base domain has a category of things lying over it.

principle

Fixed points and recursion describe self-referential definitions, repeated behavior, and systems whose outputs feed future inputs.

principle

Functoriality is the principle that a mapping between domains should preserve the structure that matters: identities, relationships, composition, and change.

principle

Monads, monoids, and their duals provide recurring patterns for sequencing, accumulation, context, observation, and composition.

principle

Naturality is the principle that a transformation should be independent of arbitrary representation choices. It should commute with the structure-preserving maps between representations.

principle

Optics are structured ways to focus on, observe, transform, or update part of a larger structure.

glossary

Sheaves and gluing provide local vocabulary for describing systems of observations: many observers, contexts, processors, time intervals, schemas, views, or execution cuts may each see part of a system, and the model needs to say when those partial views agree enough to form a coherent larger view.

principle

State machines are a modeling principle for behavior described by current state, admissible transitions, inputs, and outputs.

principle

Stuff, structure, and property are a modeling distinction for separating what a model contains, how it is organized, and what constraints it satisfies.

principle

Synchrony and Asynchrony describe whether events, observations, transitions, or participants are coupled into one boundary-relative unit.

principle

Systems Sheaf Semantics uses sheaf-theoretic local-to-global structure to model how observations, state, versions, histories, process state, and knowledge vary over contexts such as observers, boundaries, and causally valid cuts of execution.

principle

Trace and feedback describe systems where outputs are fed back as future inputs.

principle

Universal constructions are principles for naming "the" object determined by a diagram of related objects and morphisms.

principle

The Yoneda lemma says, roughly, that an object is determined by how it relates to all other objects through maps into or out of it.

semantic construct

Behavior is a time-varying value: a trajectory through state space:

semantic construct

A command is an observer-relative interpretation of an input event as an attempted transition.

semantic construct

An entity is an enduring, identifiable subject whose state evolves over time under controlled transitions.

semantic construct

An event is a time-bearing occurrence with a value. It marks, reports, or induces change depending on how it is interpreted by an observer relative to a boundary.

semantic construct

Identity is what allows a sequence of state observations to be understood as successive versions of the same thing.

semantic construct

An observable is a probe, projection, measurement, or field accessor that produces an observation from state.

semantic construct

An **observation** is a contextualized value produced by an observable acting on state. It is the form in which state becomes usable by an observer relative to a boundary.

semantic construct

An observer is a locus of interpretation. It is the participant, context, or execution locus relative to which values, observations, events, commands, queries, boundaries, and state acquire meaning.

semantic construct

A process is coherent work unfolding over time.

semantic construct

A query is an observer-relative interpretation of an input event as a request to observe, compute, or return information without requesting a modeled semantic state transition.

semantic construct

A shape is the logical structure expected of a value, observation, state view, event payload, command input, query result, or projection result within a model boundary.

semantic construct

A state is the condition or configuration of a subject within a model boundary, modeled as an assignment of values to the subject's relevant dimensions at a time, version, or point in behavior.

semantic construct

Time is the dimension in which occurrences, changes, histories, and behaviors are ordered or compared.

semantic construct

A transition is the semantic decision relation that determines whether an attempted change is accepted for a subject.

semantic construct

A **value** is pure structured data. It is the concrete information used to read, write, transmit, compare, validate, transform, or carry state.

semantic construct

A **version** identifies a point in an entity history at which a particular state became current.

operational semantics

ACID is a transaction contract: atomicity, consistency, isolation, and durability.

operational semantics

Acknowledgments answer: what does a participant or substrate claim has happened?

operational semantics

The CAP theorem describes an impossibility for distributed shared data under network partition: a system cannot simultaneously guarantee linearizable consistency, availability, and partition tolerance for all executions.

operational semantics

Commit Boundaries answer: what becomes accepted as one unit, and within which boundary?

operational semantics

Concurrency Control answers: How can multiple concurrent histories be reconciled into a single valid history?

operational semantics

Consensus answers: how do multiple observers agree on one decision, value, or ordered position despite concurrency, delay, partial failure, or independent local views?

operational semantics

Consistency Models constrain which observations are valid for a set of events, transitions, versions, sessions, replicas, and ordering relations.

operational semantics

Coordination answers: how is multi-step or multi-participant work made coherent across observers?

operational semantics

CRDTs, conflict-free replicated data types, are replicated data types designed so that independently updated replicas converge without requiring synchronous coordination for every update.

operational semantics

Delivery Semantics answers: what guarantees does an interaction edge provide?

operational semantics

The dual-write problem is the failure mode that appears when one operation tries to commit two or more effects across independent commit boundaries without one atomic commit protocol or durable recovery protocol connecting them.

operational semantics

Durable Execution is the operational semantics by which a process can continue coherently across failure, restart, suspension, timeout, or delayed external work.

operational semantics

Idempotency is the property that repeated handling of the same semantic input does not produce duplicate domain effects.

operational semantics

Interaction answers: how do observers address, observe, notify, or invoke one another?

operational semantics

Isolation describes what concurrent operations are allowed to observe of one another while they execute.

operational semantics

Ordering defines the scope within which events, commands, observations, or effects are sequenced.

operational semantics

Persistence answers: what is made durable and authoritative?

operational semantics

Progress Conditions classify liveness guarantees for concurrent or distributed operations.

operational semantics

Rate Limiting constrains how quickly work may be accepted, dispatched, delivered, or processed.

operational semantics

Reconstitution answers: how is usable state recovered?

operational semantics

Recovery defines how a system returns to coherent operation after failure, interruption, conflict, timeout, overload, or partial progress.

operational semantics

Retry is the controlled repetition of an operation after a transient failure, timeout, conflict, or unavailable dependency.

operational semantics

Safety and Liveness separate two kinds of operational property of a distributed system.

operational semantics

Two-Phase Commit is a coordination protocol for atomic commit across multiple participants.

operational semantics

Version Histories describe the shape of state evolution for a subject, entity, document, repository, projection, or replicated object.

operational semantics

Weak Isolation Patterns are design techniques used when one ACID transaction or two-phase commit boundary is unavailable, too expensive, or not aligned with the business process.

structural construct

Boundaries define the scope and context in which observation, interpretation, authority, failure, persistence, delivery, and coordination apply.

structural construct

Business Transactions describe domain-level units of work whose progress, acceptance, rejection, compensation, or completion matters to the business.

structural construct

Effects are modeled consequences of an accepted interpretation, transition, process step, or operational action.

structural construct

Entity models describe how the semantic entity role is arranged in the system graph.

structural construct

Flows describe movement through the system graph over time.

structural construct

Invariants describe where validity constraints are attached in the system graph.

structural construct

Observers describe how the semantic observer role is arranged in the system graph.

structural construct

Policies describe where decision rules are attached in the system graph.

structural construct

Processes describe how semantic processes are arranged across time, observers, entities, and external systems.

structural construct

Projections describe how derived observations or derived state views are arranged in the system graph.

structural construct

Relations describe how semantic roles are connected in the system graph.

realization substrate

Actor Systems are runtimes that organize execution around addressable actor identities, message delivery, placement, isolation, and serialized handling per actor.

realization substrate

Application Hosts are runtime containers for application code, request handling, background work, dependency management, and operational concerns.

realization substrate

Brokers are concrete messaging substrates that mediate delivery between producers and consumers.

realization substrate

Compute is the concrete capacity that executes work: CPU, memory, processes, containers, virtual machines, functions, tasks, nodes, clusters, and other execution resources.

realization substrate

Consensus Protocols are concrete protocol families that realize consensus under specified network, failure, timing, persistence, and membership assumptions.

pattern

CQRS, command query Responsibility Segregation, is a realization pattern that separates the write side that interprets commands and persists authoritative change from the read side that answers queries by reconstituting queryable observations.

realization substrate

Durable Execution Engines are concrete runtimes or substrate mechanisms that realize durable execution.

pattern

Event sourcing is a realization pattern in which an entity's durable history is represented by committed events rather than only by current-state records.

realization substrate

Infrastructure is the concrete operational environment that provides compute, networking, storage, deployment, security, observability, and platform services.

realization substrate

Network is the realization substrate for interaction across link, network, transport, and application protocol boundaries.

pattern

An outbox is a realization pattern that stores an outbound effect obligation in durable persistence, usually in the same local commit boundary as the state change that created the obligation.

realization substrate

Realization is the relation by which semantic roles, system structure, and operational semantics are made concrete in a substrate.

realization substrate

Runtimes are execution environments that host code and provide operational behavior.

realization substrate

Storage Systems are concrete mechanisms for durable or semi-durable data: databases, event stores, object stores, key-value stores, logs, file systems, caches, and actor state providers.

realization substrate

Workflow Engines are runtimes for defining, coordinating, and operating multi-step workflows across time.

pattern

Write-Ahead Logging, or WAL, is a storage recovery pattern in which durable recovery records are written before the corresponding state changes are allowed to become unrecoverable.

architecture practice

The actor model addresses the problem of organizing concurrent computation around isolated, addressable participants that communicate by message passing.

pattern

An anti-corruption layer addresses the problem of integrating with another model without letting that model's semantics leak into the local boundary.

reference

Architecture practices are named bundles of modeling choices, constraints, and implementation habits that address recurring system-engineering problems.

architecture practice

Clean Architecture addresses the problem of dependency direction: keeping high-value semantic rules from depending on volatile delivery, persistence, framework, and infrastructure choices.

architecture practice

CQRS is often described as an architectural pattern or style. In the Cohesive System Model, the technical mechanics are captured by CQRS as a realization substrate pattern.

architecture practice

CRDTs are a distributed-systems practice for designing replicated state that can accept concurrent updates and converge without synchronous coordination for every update.

architecture practice

Data Mesh addresses the problem of scaling analytical and operational data ownership across organizational and domain boundaries.

architecture practice

Domain-Driven Design, or DDD, addresses the problem of preserving domain meaning in software as systems grow in complexity.

architecture practice

Event sourcing is often described as an architecture practice. In the Cohesive System Model, the technical mechanics are captured by event sourcing as a realization substrate pattern.

architecture practice

Event-Driven Architecture addresses the problem of coordinating independent participants through event flow rather than direct synchronous control.

architecture practice

Microservices address the problem of independent ownership, deployment, scaling, and evolution across bounded capabilities.

architecture practice

The modular monolith addresses the problem of maintaining strong internal boundaries and cohesive change units without paying the operational cost of distributed deployment.

pattern

Ports and Adapters addresses the problem of keeping domain and application semantics independent from specific infrastructure, protocols, user interfaces, and external systems.

pattern

Sagas and process managers address the problem of coordinating long-running, multi-step work across boundaries where one atomic transaction is unavailable or inappropriate.

pattern

The transactional inbox addresses the consumer-side problem of processing a delivered input exactly once in domain meaning when the delivery substrate may redeliver it.

pattern

The transactional outbox addresses the problem of committing local state change and publishing a message without relying on a distributed transaction between the database and broker.

architecture practice

Weak isolation patterns are architecture practices for preserving useful correctness when one ACID transaction or two-phase commit boundary is unavailable, too expensive, or misaligned with the domain process.