Three epistemological approaches to cyber threat categorization exist. Empirical: observe attacks and catalog what happened — this is MITRE ATT&CK. Heuristic: propose categories by intuition and professional experience — this is STRIDE. Analytical: derive categories from the structural properties of the thing being attacked — this is TLCTC.
The distinction matters. Empirical frameworks grow with every new observation but never reach structural closure. Heuristic frameworks are useful but unfalsifiable — you cannot test whether the categories are correct. Only an analytical framework can say why its categories are these and no others, because they are not collected but derived under a stated criterion — and only such a framework can say what would prove them wrong.
TLCTC does not invent new logic. It imports proven principles from safety engineering, systems theory, classical logic, and philosophy of science — and applies them to the one engineering discipline that somehow skipped the formalization step.
First written against v2.1. This revision brings every principle to TLCTC v2.7: axiom references follow the v2.7 numbering; the derivation names its criterion (one control lever, one owner); mutual exclusivity is credited to the precedence rule R-SPECIFIC rather than to disjoint descriptions; the partition carries its scope (R-SCOPE); the consequence side is the v2.7 chain SRE → DRE → BRE; the #10 test includes the v2.6 subversion condition; and the method is now stated on its own in Layered Event Modelling. Each principle now also opens with the concept from logic, mathematics or the sciences it rests on, with sources under Further Reading.
The Entry Point: Two Languages, One Framework
Every security organization already operates in two layers without knowing it. When a board member asks "What are our top threats?" and a SOC analyst asks "What triggered this alert?" — they are not asking the same question at different zoom levels. They are asking structurally different questions that require structurally different vocabularies.
TLCTC makes this explicit. The Strategic Layer (#1 through #10, plain language, management-facing) and the Operational Layer (TLCTC-XX.YY notation, machine-readable, engineering-facing) are two interfaces into the same framework. This is not a TLCTC invention — it is how every mature engineering discipline works. Medicine has "heart problem" and ICD-10 codes. Electrical engineering has circuit theory and Maxwell's equations. Cybersecurity is the one field that never made this separation. In TLCTC it is an axiom (Axiom VIII): every top-level cluster has sub-threats beneath it, and both layers keep one meaning, so a cluster named in the boardroom is the same cluster in the SOC ticket and in the developer's backlog.
That recognition is the entry door. What follows is why it holds up.
Ten Principles — One Descent
Each principle below opens with the concept it rests on — from logic, mathematics or the natural sciences — so the original is clear before it is applied. Then it shows what TLCTC does with it.
Principle I: Causal Separation
A cause brings an event about; a consequence follows from it. A necessary condition must be present for the event, a sufficient condition is enough on its own. Fault trees, first drawn at Bell Labs in the early 1960s for the Minuteman launch control system, write the causes of one unwanted top event in Boolean logic: an AND gate needs all of its inputs, an OR gate needs any one. Event trees branch the consequences that can follow. Joined at the event, the two form the bow-tie, commonly traced to course notes of the chemical company ICI around 1979 and made standard practice by Shell after the Piper Alpha disaster (1988).
The split pays off in the arithmetic of risk, likelihood × impact: barriers on the cause side lower the likelihood, barriers on the consequence side lower the impact. Put both kinds of barrier in one list, and you can no longer say which factor a control changes.
The Bow-Tie model — proven in aviation, petrochemical, and nuclear safety — separates causes from consequences with a central pivot event: Loss of Control. TLCTC applies this to cybersecurity. Threats live on the cause side. Data breaches, ransomware, downtime live on the consequence side. The pivot is System Compromise. The right side is not one box but a chain — system, data and business risk events, in that order (Principle VI). Without this boundary, you cannot distinguish prevention from damage limitation — and the entire control mapping becomes structurally ambiguous.
Principle II: Actor–Threat Separation
A classification takes an input and returns a class, and the same input must always return the same class. What it classifies is fixed by the inputs it reads. If the class changes when only the actor changes, the actor is an input — f(act, actor) instead of f(act) — and the scheme classifies people, not acts. Criminal law made the same choice long ago: an offence is defined by the act, whoever commits it.
The threat intelligence industry is organized around actors: APT28, Lazarus Group, FIN7. TLCTC says: irrelevant for classification. A phishing email exploits human psychology (#9) regardless of whether the sender is a nation-state or a teenager. The generic vulnerability does not change with the attacker's biography. Actors are metadata — operationally important, structurally irrelevant. If your classification changes depending on who is attacking, you are classifying actors, not threats. The same holds for insiders: an insider reaching past their grant is classified like any outsider. What decides is the action, never the actor’s identity (Principle IV).
Principle III: The Thought Experiment
A thought experiment tests a claim by reasoning alone. Galileo’s best-known one (Two New Sciences, 1638): if heavier bodies fall faster, a heavy and a light stone tied together must fall both slower, because the light stone holds the heavy one back, and faster, because the pair is heavier. A claim that implies a contradiction is false. Logicians call the pattern reductio ad absurdum.
Analytical decomposition is the second tool: divide a whole into parts by one stated criterion, the classical fundamentum divisionis. Descartes made it a rule of method (Discourse on the Method, 1637): divide each difficulty into as many parts as it takes to solve it. With one criterion applied the same way everywhere, anyone can redo the division and check it.
TLCTC does not catalog observed attacks. It imagines the entire IT landscape as a single object and asks: in how many fundamentally distinct ways can this object be exploited? It walks the landscape one attack surface at a time — its designed functionality, its code acting in the server role, its code acting in the client role, its identity mechanisms, its communication channels, its finite capacity, its code execution capability, its physical form, its human operators, its third-party dependencies — and names, for each generic vulnerability, the control lever that reduces it.
The criterion is stated, not implied: a cluster exists where a generic vulnerability has its own control lever and its own owner. Ten levers, ten generic vulnerabilities, ten clusters — derived under that criterion, not collected from incidents. The derivation does not pretend to follow one physical principle, and it says so: #2 and #3 are one weakness type split by the role of the flawed component, #4, #5 and #7 carve specific security functions out of designed functionality in general, and #6 names a resource property. What the ten share is the criterion. This is analytical decomposition in the engineering sense: a whole broken into parts by a rule that anyone can apply again and check.
Principle IV: Partition Logic
A partition divides a set into non-empty blocks so that every element lies in exactly one block: none left out, none in two. A basic theorem of set theory makes partitions and equivalence relations two views of one thing. Every partition defines the relation “lies in the same block as”, and every equivalence relation — reflexive (x ~ x), symmetric (x ~ y ⇒ y ~ x) and transitive (x ~ y, y ~ z ⇒ x ~ z) — cuts its set into exactly such blocks. The traditional rules of logical division say the same in words (exhaustive, exclusive); management consulting knows it as MECE, Barbara Minto’s “mutually exclusive, collectively exhaustive”.
The ten clusters are built to partition the attack side of cyber risk: every successful attack step maps to exactly one cluster, because every generic vulnerability belongs to exactly one cluster (Axiom VI). This is classical set-theoretic logic applied to a domain that has been operating without it. The practical consequence is decisive: if your categories overlap, your control mappings become ambiguous — you cannot determine which control addresses which threat. If they have gaps, threats fall through unaddressed.
Two qualifications make the claim exact rather than weaker. First, mutual exclusivity is produced by rule, not by disjoint descriptions. A missing certificate check can honestly be described both as a code defect and as weak control of the communication path. The precedence rule R-SPECIFIC decides: where one weakness fits a specific generic vulnerability and a residual one (#1, or #2/#3), the specific one wins — here #5 — because the specific cluster names the lever that actually reduces the exposure. A step that still seems to fit two clusters is two steps and is split. Second, completeness is not proven; it is a falsifiable hypothesis (Principle VIII).
And the partition has a scope. Before any cluster is assigned, three questions sort the cause side of a risk event into four rows: Is there an actor? Did the actor intend the outcome? Did an accountable grantor confer an entitlement covering this action? Only the Attack row — intended, not entitled — is classified by the ten clusters (R-SCOPE). Failure, Error in Use and Abuse of Rights are operational risk with no cluster. An administrator who exfiltrates with genuine root has exploited no generic vulnerability; the system behaved as authorised. That is Abuse of Rights, answered by segregation of duties and supervision, not by a cyber control — and it is why there is no cluster #11 for insiders.
Principle V: Attack Paths as Causal Sequences
In a causal chain each link enables the next; break any link and nothing after it happens. Heinrich drew industrial accidents as a row of dominoes (1931). Probability shows why chains reward layered defence: if independent barriers each fail with probability 1/10, three of them fail together with probability 1/10 × 1/10 × 1/10 = 1/1000, the product rule for independent events. James Reason’s Swiss cheese model (1990) pictures exactly this: an accident needs the holes in every barrier to line up. In 2011, Lockheed Martin’s kill chain brought the idea to intrusions: seven phases, from reconnaissance to actions on objectives, and breaking one stops the intrusion.
Attack paths and event chains are established concepts — Kill Chain, MITRE ATT&CK sequences, attack trees. But every existing implementation sequences outcomes or techniques, not causes. A Kill Chain says "Delivery → Exploitation → Installation" — phase labels, not causal categories. TLCTC sequences generic vulnerabilities, with the time between them: #9 →[Δt=24h] #7 →[Δt=5m] #4 →[Δt=15m] #1 — a phishing mail, the malware it delivers, the stolen credential used, the designed functions abused (Axiom IX). Each node identifies which structural weakness was exploited at that step, and only steps that succeeded are on the path: a cluster assignment asserts a compromise, so a blocked attempt is a near miss, not a step. That is what makes control selection deterministic — at each position in the chain, you know exactly which class of defense applies, and the Δt tells you how long it has to act. The logical properties of these sequences — transitivity, irreversibility, and the distinction between grammar and instance — are the subject of Principle X.
Principle VI: System Risk Event vs. Data Risk Event
Science describes one event on several levels — a state of the machine, a state of the data, a state of the business — each with its own vocabulary. For the data level, Saltzer and Schroeder named three kinds of loss in 1975: unauthorized information release, unauthorized information modification and unauthorized denial of use, known today as confidentiality, integrity and availability. Add causal precedence — a cause comes before its effect — and the levels become a chain: in an attack, the data is lost after a system is compromised, and the business loses after the data.
Two categorically different event types occur during an attack, and the industry conflates them constantly. A System Risk Event (SRE) is System Compromise — the Bow-Tie pivot, Loss of Control. A Data Risk Event (DRE) is a consequence recorded on the data: C, loss of confidentiality; I, loss of integrity, refined where it matters into Ii (the content is wrong) and If (the claimed origin is wrong); A, loss of availability, refined into Av (the data is gone) and Ac (the data is present but unusable — the ransomware case). "We had a breach" — is that system compromise or data loss? Which caused which? TLCTC enforces the distinction.
Every cluster step records an SRE, so a path of four steps records four compromises, and a DRE can follow any of them, not only the last. A credential phished at the first step is a compromise of the human (#9), and the stolen secret is [DRE: C] right there, long before the attacker touches a server.
Since v2.7 the right side of the bow-tie is an explicit chain: SRE → DRE → BRE. Business Risk Events — an outage declared, a notification filed, a fine imposed — follow the data. Only causal transitions carry a Δt, the causal interval that bounds the window for detection and response. A duty that arises (to notify, to report) is a normative edge with no Δt of its own; a 72-hour statutory deadline bounds a separate response process that starts at awareness, it is not the Δt of the chain.
The structural claim remains: within the attack row, a DRE is always downstream of an SRE — loss of C, I or A is never itself a root cause. What v2.7 adds is honesty about where chains begin without a cluster: System Failure at the system altitude, Abuse of Rights at the DRE (no SRE: the system behaved as authorised), Error in Use at any altitude, and a compliance event entered directly when a norm changes. Naming these entry points is what makes a bow-tie inventory causally complete: the ten clusters account for every consequence of the attack row, and the named entry points for everything else.
Principle VII: The Dual Nature of Credentials
Logic distinguishes using a word from mentioning it: “Paris” has five letters; Paris has about two million inhabitants. A password lives the same double life. Copied, printed or overheard, it is mentioned: handled as data. Typed into a login, it is used: turned as a key. The earliest documented password theft shows both acts: in the spring of 1962 a student at MIT had the CTSS time-sharing system print its password file, and the passwords were then used to log in, one of them as the lab’s director. In TLCTC terms, that print request is a designed function abused (#1); the logins are #4.
This is where most intuitions break — and where the partition proves itself under pressure. A password is always the same string. But its operational role flips. During acquisition, the credential is data — something stolen, intercepted, copied. The cluster is determined by the method: #9 for phishing, #7 for a keylogger, #2 for SQL injection. During application, the credential is a system element — a key being turned. That is always #4. Same object, different generic vulnerability, different cluster, different controls. The two steps also carry different consequences: the acquisition step records the disclosure, [DRE: C] on the credential; the #4 step records none — authenticating discloses nothing, alters nothing, denies nothing. It opens a door, and the data risk event belongs to the step that walks through it. If the framework survives this stress test — and it does — the partition holds.
Principle VIII: Falsifiability
Falsification has the logical form of modus tollens: if theory T is true, observation O follows; O does not occur; therefore T is false. Verification has no such form. No number of white swans proves that all swans are white, while one black swan, found by Dutch sailors in Australia in 1697, refutes it. Karl Popper (Logik der Forschung, 1934) made this asymmetry the mark of science: a scientific claim states what would prove it wrong.
This is the differentiator. No other cybersecurity framework specifies the conditions under which its own classifications would be wrong. TLCTC does. Every classification can be tested: "Is this really #10? Remove the third-party trust relationship — does the attack still work? If yes, it is not #10." Since v2.6 the test has a second half: the trust artifact, or the third party issuing it, must have been subverted before the target accepted it. A flaw in a legitimately supplied library is not #10; it is classified where it is exploited, as #2 or #3. This is Popperian demarcation applied to threat taxonomy — the boundary test is a counterfactual conditional. A framework that cannot be tested cannot be scientific. STRIDE is unfalsifiable. ATT&CK is extensible but has no built-in verification mechanism. TLCTC has both — and the falsification condition applies to the framework as a whole: find a weakness that none of the ten generic vulnerabilities answers to, one with its own control lever and its own owner, and you have found the eleventh cluster.
Principle IX: Technological Invariance
A property is invariant when it stays the same under a transformation: a rotated circle is still a circle, two points moved together keep their distance. Physics builds its laws on invariance. Galileo observed (Dialogue, 1632) that everything in a cabin below deck behaves the same whether the ship lies in port or sails smoothly. Emmy Noether proved in 1918 that every continuous symmetry of a physical system comes with a conserved quantity. A statement that holds under every change of frame is a law; one that holds in a single frame is a snapshot.
Every interaction — networked or within a single system, regardless of protocol, architecture, or technology stack — reduces to a requester-responder dyad (Axiom II). TLCTC calls this the Universal Interaction Model. It is an invariance claim in the formal sense: the structural relationship holds across all transformations of the underlying technology. Cloud, IoT, OT, AI-driven systems — the ten generic vulnerabilities do not change. The dyad also settles the hardest boundary in the framework: classify by the role the flawed component plays relative to the attacker (R-ROLE). The same kind of flaw is #2 in a component that handles the requests it receives and #3 in one that handles the content it fetches. This is what gives the framework longevity. A taxonomy that must be revised every time a new platform emerges was never a taxonomy — it was a snapshot.
Principle X: Causal Direction and Irreducibility
A function maps each input to one output. When several inputs share an output, the function is not injective and has no inverse: from the output alone, the input cannot be recovered. Reasoning from an effect back to its cause is such an inverse problem. In Hadamard’s terms (1902) a well-posed problem has a solution that exists, is unique and is stable; inverse problems often fail the second condition. Medicine knows the search as differential diagnosis — one fever, many possible causes — and Judea Pearl’s causal graphs (Causality, 2000) draw causation as arrows that point one way, without cycles.
Causal chains obey three logical properties that most cyber taxonomies handle inconsistently or not at all. First, transitivity with anti-collapse: in pure logic, if a → b and b → c, then a → c, and chains compose. But TLCTC deliberately refuses this reduction for attack paths. Intermediate nodes are not bookkeeping — they are where controls live. Collapsing #9 → #7 → #4 → #1 to "the phishing mail led to the data theft" destroys the information needed to map defenses to each transition — and the Δt of each one. What looks like notational redundancy is load-bearing structure. Second, irreversibility: transitivity runs only forward. Given a consequence, you cannot uniquely infer the cause cluster — the #7 execution that encrypts the files can follow #9, #4, #2, #3 or #10, and combinations thereof, and the consequence it leaves, [DRE: Ac], is the same each time. The causal structure is a DAG, not a bijection. This is the formal reason descriptive frameworks fail as risk management instruments: they reason from observed symptoms backward, which is precisely the direction in which causal inference is non-unique. Forensic reconstruction and preventive classification are different epistemic operations — TLCTC is built for the second. Third, grammar vs. instance: the axiomatic grammar of possible cluster transitions is deterministic, constrained by the ten generic vulnerabilities. Any real-world instantiation of an attack path is probabilistic, because each arrow carries a Δt and conditional probabilities of exploitability, detection, and control failure. Risk quantification attaches to arrows, not to the grammar. This separates the structural claim — what paths are possible — from the actuarial one — what paths are likely. Cybersecurity routinely blurs the two; every mature engineering discipline keeps them distinct.
Full Circle
Return to the opening image. The board member and the SOC analyst are asking different questions — but those questions now have a shared structural foundation. The two-layer architecture holds because underneath it, causal separation provides direction, the thought experiment provides derivation, the partition provides clarity, irreducibility protects against inverse-problem collapse, and falsifiability provides verification.
None of these principles are new. Bow-Tie logic is decades old. Set-theoretic partitioning is classical mathematics. Falsifiability is twentieth-century philosophy of science. Systems-theoretic invariance is standard engineering.
Since October 2026 the method has a paper of its own. Layered Event Modelling (LEM v1.0) states, without reference to cyber, how events stack in layers, which links between them are causal and carry a Δt, and which are normative or merely relate two descriptions of the same situation. TLCTC v2.7 is its worked instantiation: the principles above are what LEM looks like when the domain is cyber risk.
| Principle | Underlying concept | In TLCTC |
|---|---|---|
| I · Causal separation | Cause and consequence; necessary and sufficient conditions; Boolean AND/OR; risk = likelihood × impact | Cyber bow-tie; System Compromise as pivot |
| II · Actor–threat separation | A classification is a function of its inputs | f(act), never f(act, actor) (Axiom IV) |
| III · Thought experiment | Reductio ad absurdum; decomposition by one stated criterion | One lever, one owner, one cluster |
| IV · Partition logic | Partition ⇔ equivalence relation; MECE | One step, one cluster; R-SPECIFIC; R-SCOPE |
| V · Attack paths | Causal chains; product rule for independent barriers | Chains of causes with Δt on every arrow |
| VI · SRE vs. DRE | Levels of description; three kinds of loss; causal precedence | SRE → DRE → BRE |
| VII · Credentials | Use and mention | Acquisition by the enabling cluster; application always #4 |
| VIII · Falsifiability | Modus tollens; verification–falsification asymmetry | Boundary tests; the eleventh cluster as refutation |
| IX · Invariance | Invariance under transformation; Noether’s theorem | Requester and responder on every platform (Axiom II) |
| X · Causal direction | Non-injective functions; ill-posed inverse problems; causal graphs | Forward classification; no collapsing; no backward inference |
The question was never whether these principles could be applied to cybersecurity. The question is why it took this long for someone to do it.
Further Reading
The concepts above in their original sources (the bow-tie’s exact origin is disputed; the ICI attribution is the commonly cited one):
- H. A. Watson, Launch Control Safety Study, Bell Telephone Laboratories, 1961 — the first fault tree.
- H. W. Heinrich, Industrial Accident Prevention, McGraw-Hill, 1931.
- J. Reason, Human Error, Cambridge University Press, 1990.
- E. M. Hutchins, M. J. Cloppert, R. M. Amin, “Intelligence-Driven Computer Network Defense Informed by Analysis of Adversary Campaigns and Intrusion Kill Chains”, Lockheed Martin, 2011.
- J. H. Saltzer, M. D. Schroeder, “The Protection of Information in Computer Systems”, Proceedings of the IEEE 63(9), 1975.
- G. Galilei, Dialogue Concerning the Two Chief World Systems, 1632; Two New Sciences, 1638.
- R. Descartes, Discourse on the Method, 1637.
- B. Minto, The Pyramid Principle (MECE).
- K. Popper, Logik der Forschung, 1934 (English: The Logic of Scientific Discovery, 1959).
- E. Noether, “Invariante Variationsprobleme”, 1918.
- J. Hadamard, “Sur les problèmes aux dérivées partielles et leur signification physique”, 1902.
- J. Pearl, Causality, Cambridge University Press, 2000.