A failure mode occurring when two logical modules, theories, or components expose incompatible assumptions, signatures, or contracts at their interface so that they cannot be directly composed without adaptation.

Principle

Composition requires a compatible interface: matching signatures, shared assumptions about domain, and agreed semantics. Any divergence at the boundary prevents seamless composition unless reconciled.

Demonstration

Module A exports a function typed as total from integers to integers and requires input normalization; Module B provides a partial integer function that returns special error tokens for some inputs. Even if names and arities match, the differing totality and error semantics cause composition to fail at runtime or logical level.

Misapplication

Attempting to integrate modules by only aligning symbol names or arities while ignoring preconditions, implicit invariants, or semantic expectations — for example, wire-together two services expecting different normalization of identifiers.

Consequence

Correct identification of an interface mismatch leads to explicit adapters, interface contracts, or re-design of boundaries; failure to do so produces subtle bugs, logical inconsistency, or inability to reuse components.

Reversal

Interface alignment — designing or adapting interfaces so that assumptions, signatures, and semantics match and components compose directly.

Boundary

Concerns the exposed boundary between modules: signatures, pre/postconditions, and implicit semantic assumptions. It does not primarily address internal model contradictions (semantic incompatibility) or low-level protocol/frame mismatches outside the logical interface.

Semantic Tension

Tension between local interface-specific fixes (adapters, wrappers) and global semantic reconciliation (changing core models); competes with semantic incompatibility when mismatches reflect deeper model conflicts rather than surface signature differences.

Synthesis

Interface mismatch is the practical incompatibility at module boundaries where syntactic alignment without semantic agreement fails; resolving it requires making implicit assumptions explicit, adding adapters or contracts, or refactoring component boundaries.