The Cohesive knowledge graph

overview

Cohesive has two linked goals:

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 domain semantics, system graph, operational concerns, 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

A fixed point is a value, structure, or behavior that a specified transformation leaves unchanged:

discipline

Functional programming describes computation primarily through values, functions, composition, and evaluation rather than through a distinguished sequence of commands that mutate shared state.

principle

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

principle

The glitch principle states that a non-trivial device making a discrete decision among finitely many outcomes from a continuous range of possible inputs cannot guarantee a uniform finite decision time for every input.

glossary

This glossary collects compact vocabulary used across the Cohesive system model. Terms that acquire their own distinctions, relations, and realization obligations are promoted into graph nodes rather than remaining glossary-only definitions.

principle

Happened-before is a strict partial order over occurrences that preserves potential causal influence without requiring one global clock or one total execution order.

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

Nondeterminism describes a model in which one context admits more than one possible continuation. Choice describes how, where, or by whom that multiplicity is resolved.

principle

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

principle

Process theories are modeling disciplines for work, interaction, change, and behavior that unfold over time.

reference

Programming paradigms are recurring ways of interpreting and organizing computation. They select which structures are primary, which composition laws matter, and which operational details are left to a language, compiler, runtime, or other realization.

discipline

Queueing theory is the mathematical and operational discipline for reasoning about work that arrives, waits, receives finite-capacity service, moves among resources, and completes.

principle

Recursion defines a value, structure, or behavior in terms of other instances of the same form. The recursive reference may point to a smaller component, a prior step, a nested process, or another derivation of the same relation.

principle

Reduction, evaluation, and confluence describe how a computation advances through possible intermediate expressions or states, how an execution strategy selects a path, and when divergent paths remain semantically coherent.

discipline

Relational and logic programming are approaches in which programs state which combinations of values, facts, or terms hold or are admissible, rather than prescribing only a function from distinguished inputs to distinguished outputs.

principle

Sheaves and gluing provide a local-to-global principle for 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.

reference

Cohesive aims to provide a standard language for describing systems and a family of compiler-like realizations that project that language into working infrastructure.

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

Authority is the boundary-relative standing by which an observer, role, protocol outcome, or source is accepted as able to make a claim, decision, transition, or effect count for a modeled subject.

semantic construct

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

semantic construct

Causality is a dependency relation between events, observations, transitions, decisions, or effects in which one occurrence may have influenced, enabled, required, constrained, or carried information into another.

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 invariant is a validity constraint that must hold for a modeled subject, transition, process, relation, or boundary.

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 policy is a decision rule that guides or constrains interpretation, authorization, routing, coordination, retention, recovery, or execution.

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 relation is a meaningful connection, dependency, association, correspondence, constraint, derivation, or causal link between semantic subjects.

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

Uncertainty is multiplicity in the states, histories, causes, outcomes, or interpretations that an observer cannot yet distinguish at a declared boundary.

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 concern

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

operational concern

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

operational concern

Arbitration resolves local contention among competing eligible occurrences when the system must select, admit, order, or grant one or more of them.

operational concern

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 concern

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

operational concern

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

operational concern

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

operational concern

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

operational concern

A consistent cut is a selected set of events, versions, observations, or process positions that is closed under the declared causal prerequisites.

operational concern

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

operational concern

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 concern

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

reference

Distributed failure scenarios are recurring hazard shapes that appear when effects, observations, commit boundaries, durability, isolation, coordination, and recovery cross independently governed boundaries.

operational concern

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 concern

Durability answers: which facts, histories, effects, decisions, or execution material survive which failures?

operational concern

Fairness constrains complete executions so that eligible participants, messages, or actions are not postponed forever under the stated assumptions.

operational concern

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

operational concern

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

operational concern

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

operational concern

A linearization point is the logical instant at which an operation takes effect in the abstract sequential history used to justify linearizability. It must lie between that operation's invocation and response.

operational concern

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

operational concern

Persistence answers: what is recorded as authoritative material?

operational concern

Progress Conditions classify liveness guarantees for concurrent or distributed operations.

operational concern

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

operational concern

Reconstitution answers: how is usable state recovered?

operational concern

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

operational concern

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

operational concern

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

operational concern

Scheduling determines which enabled work receives execution opportunity, in what order, on which resources, and under which priority, fairness, deadline, locality, and capacity rules.

operational concern

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

operational concern

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

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

Flow views describe movement through the system graph over time.

structural construct

An infrastructure graph is the system graph projection that relates modeled system structure to public realization substrate concepts.

structural construct

Invariant scopes describe where semantic invariants are attached in the system graph.

structural construct

Observer models describe how semantic observers are placed in the system graph.

structural construct

Policy scopes describe where semantic policies are attached in the system graph.

structural construct

Process graphs describe how semantic processes are arranged across time, observer models, entity models, relation models, boundaries, and external systems.

structural construct

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

structural construct

Relation models describe how semantic relations are represented in the system graph.

reference

The system graph is the realm that composes domain semantics into the cohesive system graph of a modeled system.

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 the durable execution architecture practice.

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 graph, operational concerns, and architecture practices 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

Asynchronous interaction design is the architecture practice of making independently progressing work explicit when one interaction is split across time, participants, and commit boundaries.

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.

pattern

Durable execution is an architecture practice for keeping a logical execution coherent across failure, restart, suspension, timeout, or delayed external work.

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

Orchestration and choreography are forms of coordination that differ by where process control, authority, and progress interpretation live in the realization.

pattern

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

pattern

Process managers are an orchestration pattern for coordinating a process across participants, time, effects, and failure boundaries.

pattern

Sagas are process managers specialized for domain process recovery across system boundaries where one atomic transaction is unavailable, too expensive, or misaligned with the domain process.

reference

This note connects the dedicated entries for sagas and process managers.

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.

architecture practice

Transactional outbox is the architecture practice of using an outbox to tie an accepted local state change to downstream publication responsibility without a distributed transaction between storage and consumer.

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. This is mostly about deciding which weaker guarantees become explicit parts of the domain protocol, entity model, process state, and recovery behavior.