ATIP as an algorithm: design note

design · draft · NLP and argumentation · edited 2026-11-06

This note turns a published procedure for classifying arguments into a program. It labels arguments with their type, first against human labels in the note-lab annotation project, later in-game against the player’s own arguments.

1. Background: the PTA and ATIP

The Periodic Table of Arguments (PTA, version 3.1) classifies arguments into 50 types (Wagemans; see Section 11). In the PTA an argument consists of three statements:

• a conclusion, the claim being argued for;
• a premise, the reason given for it;
• a lever, the usually unstated statement that says how the premise makes the conclusion acceptable (“rising prices are a CAUSE of strikes”).

Each statement has a subject, what it is about, and a predicate, what it says of the subject. An argument’s type is the unique combination of three parameters:

• form: which elements the conclusion and premise share. There are four forms, written α, β, γ, δ (Section 5.4).
• substance: what kind of statements or terms are involved (Section 5.5).
• lever: the relation the lever statement asserts, named by a keyword in capitals such as CAUSE or ANALOGOUS (Section 5.6).

The Argument Type Identification Procedure (ATIP, version 6) determines these in six steps (Wagemans 2026): (1) label the textual elements, (2) reformulate the argument as “conclusion because premise”, (3) determine the form, (4) the substance, (5) the lever, and (6) name the type. This note follows the same six steps.

Each type has a name and a symbol: “argument from cause”, Cau. We write a classified argument as a code of form, substance and symbol: α FF Cau is an alpha argument whose conclusion and premise are both statements of fact, of the type argument from cause. Section 12 lists all 50 types.

2. Scope

In scope:

• Typing one argument, a single premise → conclusion pair, with a code, plus a confidence and the runner-up codes, and the canonical terms and transformations it was typed from. These fields are the output record; it has the same shape as the gold labels (Section 7).
• Measuring each part of the procedure against human labels.
• The shape of the output that the game consumes.

This automates the Initial Analysis of CAPNA, the Comprehensive Assessment Procedure for Natural Argumentation (Hinton and Wagemans 2023, Section 11): find an argument and type it with ATIP. Its later stages (process, reasoning, language) evaluate the typed argument, with questions that depend on the type (“is a SIMILAR to b?”).

Out of scope:

• Judging whether an argument is good. That is a later step that reads this one’s output: CAPNA’s process, reasoning and language stages.
• How the game uses the output: deciding which of its keys an argument unlocks (sketched in Section 8 only as an interface).
• Explication of missing premises in free text (see Section 9). In the lab, reconstructed premises come from the human labels.

3. Principle: a deductive program with statistical oracles

ATIP is mostly a decision table. Steps 3 and 6 are lookups; steps 4 and 5 pick from small closed sets. So the program is deterministic, and every judgement it can’t make by rule is an oracle: a named function from an argument $𝑎$ and its surrounding text $\text{ctx}$ (both defined in Section 4) to a probability distribution over a small closed set:¹

A rule is an oracle that returns a point mass.² Rules and models are therefore interchangeable per oracle, so each oracle has its own arms³ in the lab (rule baseline, embedding model, NLI model, …). Every statistical judgement is localised, named and testable on its own.

There are ten oracles, ${𝑂}_1$ to ${𝑂}_{10}$. Each is introduced at the step that uses it, and Section 6 summarises them. ${𝑂}_9$ is the exception to the closed-set rule: it generates candidate rewordings (Section 5.3). The whole pipeline, with deterministic steps as blue rectangles and oracles as yellow hexagons:

flowchart TD
  in(["argument a"]) --> s1["1 · elements"] --> s2["2 · canonical form"] --> s3["3 · form"]
  s3 --> s4["4 · substance"] --> s5["5 · lever"] --> s6["6 · name"] --> out(["code distribution"])
  O1{{"O1 spans"}} -.-> s1
  O2{{"O2 sameness<br/>(used again in 3)"}} -.-> s2
  O9{{"O9 · O10 rewrites"}} -.-> s2
  O5{{"O5 delta?"}} -.-> s3
  O3{{"O3 · O4 · O6 · O7"}} -.-> s4
  O8{{"O8 lever"}} -.-> s5
  classDef det fill:#dbeafe,stroke:#1d4ed8
  classDef oracle fill:#fde68a,stroke:#b45309
  classDef io fill:#e5e7eb,stroke:#374151
  class s1,s2,s3,s4,s5,s6 det
  class O1,O2,O9,O5,O3,O8 oracle
  class in,out io

4. Input

4.1. The argument graph

A text is a graph with two kinds of node:

• statements $𝑆$: anything that can be a conclusion, a premise or a lever;
• connectors $𝐾$: one per PTA argument (one triad).

A connector $𝑘\in 𝐾$ is defined by three role relations from statements to connectors:

$\left(𝑠,𝑘\right)\in 𝐶$ reads “$𝑠$ is the conclusion of $𝑘$”, and likewise $𝑃$ for premise and $𝐿$ for lever. Each connector has exactly one conclusion and exactly one premise, and at most one lever statement:

A statement has no role of its own: its roles are the edges it takes part in, and it can take part in any number of them. The same statement can be the premise of one connector and the conclusion of another, which is what lets arguments nest.

Formally, a connector stands for an entailment relation: what goes into it entails its conclusion. When a conclusion $𝐶$ rests on two premises $𝐴$ and $𝐵$ jointly, the fair reading is $𝐴\wedge 𝐵\vDash 𝐶$: one entailment, “$𝐶$ because $𝐴$ and $𝐵$”, by lever $𝐿$. It is not two entailments, $𝐴\vDash 𝐶$ and $𝐵\vDash 𝐶$, since neither premise does the work alone. The cardinality above, exactly one premise, can’t express this: two connectors would assert the two separate entailments, which is a different claim. How joint premises fit the graph is open.

flowchart BT
  p1["premise"] -- P --> k1((k₁)) -- C --> c1["conclusion"]
  l1["lever"] -- L --> k1
  p2["premise"] -- P --> k2((k₂)) -- C --> p1
  classDef stmt fill:#e5e7eb,stroke:#374151
  classDef conn fill:#fde68a,stroke:#b45309
  class p1,c1,l1,p2 stmt
  class k1,k2 conn

This is the shape of the Argument Interchange Format (AIF; see Section 11): statements are its information nodes and connectors its inference nodes. The PTA adds the lever as a third kind of input.

The lever is usually implicit. A connector then has no lever statement, and its lever is only the keyword chosen in step 5. A lever gets a statement node when the text states it or argues about it; an attack on an inference is then an attack on its lever statement.

An argument, the unit the pipeline types, is one connector read off the graph: $𝑎=\left(𝑐,𝜌,\text{ctx}\right)$ with $𝑐$ the conclusion of $𝑘$, $𝜌$ (rho, for “reason”) its premise and $\text{ctx}$ the surrounding text. $𝑐$ and $𝜌$ are spans of text.

4.2. Sources

• Lab: the graph is labelled in INCEpTION, the annotation tool, on two span layers. Statement spans are the statements. A Connector span is a connector, anchored on the coherence marker (“because”, “so”) where there is one; it has three link features, conclusion, premise and lever
statement, each pointing at Statement spans. A statement that is implicit in the text is a zero-width span with its wording in note. INCEpTION can’t enforce the cardinalities above, so the converter checks them.
• Game: $𝑐$ and $𝜌$ come from an extra oracle over the player’s line and the dialogue so far (Section 8).

5. Pipeline

Throughout, subscript $𝑐$ marks the conclusion and $𝜌$ the premise, and the conclusion always comes first.

Running example (made up, like all examples here):

“I’d say the minister did a great job, since she raised the university budget.”

Probabilities in the examples are illustrative, not measured.

5.1. Step 1: elements

Split each statement into subject and predicate, and mark the surrounding elements. O1 finds these spans.

$𝑠$ is a subject and $𝑝$ a predicate. Write $\text{Su}$ for the set of subject terms and $\text{Pr}$ for the set of predicate terms, so ${𝑠}_{𝑐},{𝑠}_{𝜌}\in \text{Su}$ and ${𝑝}_{𝑐},{𝑝}_{𝜌}\in \text{Pr}$. $𝑀$ is the set of surrounding elements, which ATIP sorts into four kinds of marker:

• coherence: marks which statement is premise and which conclusion (“because”, “since”, “so”);
• structure: relates the argument to others (“in addition”, “secondly”);
• illocutive: the arguer’s stance towards the claim (“I’d say”, “I don’t believe”);
• perlocutive: the effect the arguer intends (“you should accept that”).

Gold has no subject/predicate spans: the labeller writes the canonical subjects and predicates, step 2′s output, as text (Section 7). So this is automated even in the lab, and scored through step 2′s fields. Rule baseline: dependency parse,⁴ subject = the nsubj/nsubj:pass subtree, predicate = the rest of the clause; copulas⁵ kept with the predicate. Markers come from a lexicon of the four kinds.

Step 1 also records ${𝑞}_{𝜌}$: the whole proposition the premise speaks of, if any (“Eurostat said that the economy grew”). Step 3 uses it to detect delta arguments. Rule baseline: the clausal complement of a reporting verb (“Eurostat said that the economy grew”) or an anaphoric “so”/“that”/“this” (“Eurostat said so”), resolved to the clause it stands for. Otherwise ${𝑞}_{𝜌}$ is empty.

Example. The human-labelled (“gold”) spans give the conclusion “the minister did a great job” and the premise “she raised the university budget”. Their parses, with subject and predicate words coloured:

flowchart TD
  did["did"] -- nsubj --> minister["minister"]
  minister -- det --> the1["the"]
  did -- obj --> job["job"]
  job -- det --> a1["a"]
  job -- amod --> great["great"]
  raised["raised"] -- nsubj --> she["she"]
  raised -- obj --> budget["budget"]
  budget -- det --> the2["the"]
  budget -- compound --> uni["university"]
  classDef subj fill:#bbf7d0,stroke:#15803d
  classDef pred fill:#dbeafe,stroke:#1d4ed8
  class minister,the1,she subj
  class did,job,a1,great,raised,budget,the2,uni pred

conclusion: {s_c: "the minister", p_c: "did a great job"}
premise:    {s_ρ: "she",          p_ρ: "raised the university budget"}
markers:
  - {text: "I'd say", kind: illocutive}
  - {text: "since",   kind: coherence}

5.2. Step 2: canonical form

ATIP’s step 2 rewrites the argument into the canonical sentence “conclusion because premise”. Its transformations include moving the conclusion first, replacing the coherence marker by “because”, dropping the other markers, resolving anaphora (replacing “she” by “the minister”), making implicit content explicit and switching between active and passive voice. Their purpose is to make shared subjects and predicates literally shared, because step 3 decides the form from what is shared.

Here the canonical form $𝜅\left(𝑎\right)$ is not a rewritten string. It is the tuple from step 1 plus an equivalence relation $\equiv$ on terms:

${𝑡}_1\equiv {𝑡}_2$ means “${𝑡}_1$ and ${𝑡}_2$ are the same subject or predicate after anaphora resolution, passivization and paraphrase”; $\not\equiv$ is its negation. Oracle O2 judges it. Making $\equiv$ explicit means it doesn’t matter whether two terms happen to share their wording. The canonical sentence in the output record is flattened from the tuple, using one representative wording per equivalence class.

Example. O2 compares the subjects and the predicates pairwise:

flowchart LR
  sc["s_c: the minister"] === eq{{"O2: ≡ same<br/>(coreference)"}} === sr["s_ρ: she"]
  pc["p_c: did a great job"] -.- ne{{"O2: ≢ different"}} -.- pr["p_ρ: raised the university budget"]
  classDef subj fill:#bbf7d0,stroke:#15803d
  classDef pred fill:#dbeafe,stroke:#1d4ed8
  classDef oracle fill:#fde68a,stroke:#b45309
  class sc,sr subj
  class pc,pr pred
  class eq,ne oracle

Flattening writes the same fields gold has (Section 7): the four canonical terms, and the transformations that changed a term’s wording, each tagged with the statement it applied to. Each appears once, in any order. Transposition, the “because” substitution and omitted markers aren’t listed: the conclusion and premise roles and the markers already record them. An $\equiv$ judgement between two different wordings is tagged same term, so O2′s decisions show next to the rewrites. The canonical sentence “conclusion because premise” and the lever written out are rendered from these fields, not stored.

canonical:
  conclusion: {subject: "the minister", predicate: "did a great job"}
  premise:    {subject: "the minister", predicate: "raised the university budget"}
transformations: ["anaphora (premise)"]

Delta reading. Some arguments rest on who said something or what would follow from it, not on its content: “the economy has grown, because Eurostat said so”. For these the PTA splits both statements differently: the subject is the whole proposition. When ${𝑞}_{𝜌}$ is non-empty, $𝜅$ also produces this second split:

In the conclusion, $𝑐$ as a whole is the subject and its predicate $𝜁$ is $𝐴$ (acceptable) or $𝑈$ (unacceptable); $𝔸$ is the set of the two. In the premise, ${𝑞}_{𝜌}$ is the subject and $𝑍$ is what the premise says of it (“was said by Eurostat”). $𝜁$ is usually implicit, so flattening writes it in brackets, as ATIP does: “the economy has grown [is acceptable (A)] because that was said by Eurostat”. Step 3 decides which split is used.

Passivization works on the parse. In “the budget was raised by the minister”, the subject is nsubj:pass = “the budget”; when there is an agent (obl:agent = “the minister”), the rule baseline also tries the active reading (subject “the minister”), so a shared subject isn’t missed.

5.3. Rewriting: making shared terms visible

$\equiv$ can only judge terms that are already there. Some arguments share a term only after a rewording that creates new text. Kant writes “I need not think, if only I can pay: others will readily undertake the irksome work for me”. As written the subjects differ (“I”, “others”), which would make it γ. Reworded as “I will have others undertake the work for me”, the premise shares the subject “I”, and the argument is α. No judgement of sameness between the existing terms finds that: the shared term has to be produced.

ATIP’s transformations therefore come in two kinds:

Selective transformations only rearrange or compare what is in the text. Generative ones write new wording, so they need a proposer and a check.

O9: rewrite proposer. Given the argument and its context, a generative model proposes up to $𝑛$ candidate canonical pairs $\left({𝑐}^{\prime },{𝜌}^{\prime }\right)$. Each candidate lists the transformations it used, from ATIP’s list plus nominalisation, and the source span each new phrase rewrites. O9 is not an oracle in the sense of Section 6: its output is text, not a choice from a closed set. Its candidates become the closed set the rest of the pipeline chooses from.

O10: rewrite check. A candidate is valid if it says the same as the original in context. For a rewording, an NLI model⁶ checks entailment both ways; for explication, which adds content, only that the original and the context entail the rewrite:

Preference. ATIP switches voice “for highlighting a common subject or predicate”, which implies preferring the reading that shares a term. So among valid candidates, γ is reported only when no candidate with $𝑃\left(\text{valid}\right)\ge 𝜃$ shares a subject or predicate. Otherwise each candidate is one more branch of the composition (Section 5.8), weighted by $𝑃\left(\text{valid}\right)$.

Example. The Kant sentence, with illustrative numbers:

${𝑐}_1^{\prime }$ is valid and shares “I”, so γ isn’t reported; the code comes from the α branch (here α PF Pra). Compare “it is so easy to be immature … I need not exert myself”, where the predicates “is easy” and “need not exert myself” may already be the same: that is an $\equiv$ judgement (O2), not a rewrite.

Visibility. Every candidate goes into the output record with its text, transformations, source spans and $𝑃\left(\text{valid}\right)$, and the chosen one is marked:

rewrites:
  - premise: I will have others undertake the irksome work for me
    transformations: ["activization (premise)"]
    rewrites_span: "others will readily undertake the irksome work for me"
    p_valid: 0.83
    chosen: true

A reviewer can reject a rewrite and rerun from step 3. Gold records the labeller’s own rewording in the same fields (Section 7), so the lab can measure whether O9′s candidates include it.

Limits. A generated rewrite can tidy an argument into one the author didn’t make. That is why O9 is restricted to ATIP’s transformations, each tied to a source span, and why its candidates are kept and scored rather than taken as given. A generative model is also the most expensive part of the pipeline; in-game use may need a smaller model or no generative step.

Arms and cost. Estimates for a laptop CPU, to be measured in the lab:

O9 is the bottleneck, so it runs only when needed:

1. Run steps 1–3 with O2 alone. If a subject or predicate is already shared, or the argument is δ, skip O9.
2. Otherwise propose candidates with the rule arm and check them with O10.
3. Only if none passes, call a generative arm.

Cost then grows with the number of γ-leaning arguments, not with document length. Canonical forms are cached per statement, so a growing document or dialogue only pays for its new arguments.

5.4. Step 3: form

ATIP distinguishes four forms by what the conclusion and premise share. It writes them with schematic letters: $𝑎$ and $𝑏$ are subjects, $𝑋$ and $𝑌$ predicates ($𝑋$ the conclusion’s, $𝑌$ the premise’s), $𝑞$ a whole proposition and $𝑍$ the premise’s predicate in a delta argument. In our terms $𝑎={𝑠}_{𝑐}$, $𝑏={𝑠}_{𝜌}$, $𝑋={𝑝}_{𝑐}$, $𝑌={𝑝}_{𝜌}$.

Delta covers the source-based arguments: appeals to an expert, to popularity, threats, personal attacks. Delta is structural: it is the alpha pattern, a shared subject, where the shared subject is a whole proposition and the conclusion’s predicate is acceptability. Under the delta reading of step 2:

($\varnothing$: step 1 found no such proposition.) Two judgements decide it: O5, whether the premise really predicates something of ${𝑞}_{𝜌}$ as a whole, and with which $𝜁$ (values $𝐴$, $𝑈$, none); and O2, whether ${𝑞}_{𝜌}$ is the conclusion. Delta is checked first because its reading re-splits both statements; if it holds, the ordinary split isn’t used. The form function $𝑓$ maps an argument to its form:

$\perp$ (both shared) is a rephrase or begging the question; ATIP has no form for it, so we flag it and stop. As a decision tree, with oracles as hexagons and each form in its own colour:

flowchart TD
  start(["canonical a"]) --> d{{"O5: does the premise predicate<br/>something of a whole q_ρ (A/U)?"}}
  d -- none --> s{{"O2: s_c ≡ s_ρ ?"}}
  d -- "A / U" --> dq{{"O2: c ≡ q_ρ ?"}}
  dq -- yes --> D["δ"]
  dq -- no --> s
  s -- yes --> p1{{"O2: p_c ≡ p_ρ ?"}}
  s -- no --> p2{{"O2: p_c ≡ p_ρ ?"}}
  p1 -- no --> A["α"]
  p1 -- yes --> X["⊥ flag"]
  p2 -- yes --> B["β"]
  p2 -- no --> G["γ"]
  classDef oracle fill:#fde68a,stroke:#b45309
  classDef alpha fill:#bfdbfe,stroke:#1d4ed8
  classDef beta fill:#bbf7d0,stroke:#15803d
  classDef gamma fill:#e9d5ff,stroke:#7e22ce
  classDef delta fill:#fed7aa,stroke:#c2410c
  classDef bot fill:#e5e7eb,stroke:#4b5563
  class d,dq,s,p1,p2 oracle
  class A alpha
  class B beta
  class G gamma
  class D delta
  class X bot

The oracles return probabilities, so $\equiv$ holds with some probability rather than outright. Treating the sameness judgements as independent, each leaf’s probability is the product along its path. In the sketch, O2(t1, t2) is $𝑃\left({𝑡}_1\equiv {𝑡}_2\right)$:

def form(a):
    zeta = O5(a)              # distribution over {"A", "U", "none"}
    d  = (1 - zeta["none"]) * (O2(a.c, a.q_ρ) if a.q_ρ else 0)  # P(δ)
    ss = O2(a.s_c, a.s_ρ)     # P(subjects are the same)
    pp = O2(a.p_c, a.p_ρ)     # P(predicates are the same)
    return {
        "δ": d,
        "α": (1 - d) * ss       * (1 - pp),
        "β": (1 - d) * (1 - ss) * pp,
        "γ": (1 - d) * (1 - ss) * (1 - pp),
        "⊥": (1 - d) * ss       * pp,
    }

Examples, one per outcome:

Running example: $𝑃\left(𝛿\right)=0.03$, $𝑃\left(𝑠\equiv \right)=0.95$, $𝑃\left(𝑝\equiv \right)=0.04$, so $𝑃\left(𝛼\right)\approx 0.88$, $𝑃\left(\perp \right)\approx 0.04$, $𝑃\left(𝛾\right)\approx 0.05$.

5.5. Step 4: substance

The values the substance can take depend on the form:

• α: the type of each predicate. F (fact): a claim checkable by observation or evidence, whether or not it is true. V (value): a judgement against some standard (aesthetic, moral, legal, …). P (policy): a recommendation to act, often with “should”. Oracle O3.
• β: the quantity of each subject. s (singular): one individual. p (particular): some members of a group. u (universal): all of them. Oracle O4. (This $𝑝$ is unrelated to the predicates ${𝑝}_{𝑐}$, ${𝑝}_{𝜌}$.)
• γ: i (identical) if the subjects relate to each other as the predicates do, otherwise d (different). Oracle O7.
• δ: the perspective of the premise’s source. I: first person, the arguer. II: second person, the addressee (threats, rewards, their commitments). III: third person (an expert, a witness, the public). Oracle O6.

For α and β the substance is a pair, written conclusion first: VF is a value conclusion from a factual premise. The substance function $𝑆$:

For gamma, ${𝑅}_{𝑠}$ is the relation between the subjects (${𝑠}_{𝜌}$ to ${𝑠}_{𝑐}$) and ${𝑅}_{𝑝}$ the relation between the predicates (${𝑝}_{𝜌}$ to ${𝑝}_{𝑐}$); the substance is $𝑖$ iff ${𝑅}_{𝑠}={𝑅}_{𝑝}$. O7 judges that comparison, so its input is the pair of relations, not the whole argument. For delta, the perspective is read off the premise’s predicate $𝑍$ (who says, threatens, commits, …).

Rule baselines:

def O3(p):  # predicate type: F / V / P
    if p.modal in {"should", "ought", "must"} or p.is_imperative:
        return "P"
    if p.head in EVALUATIVE or any(m in EVALUATIVE for m in p.modifiers):
        return "V"
    return "F"

def O4(s):  # subject quantity: s / p / u
    if s.det in {"all", "every", "each"} or s.is_generic_plural:
        return "u"
    if s.det in {"some", "a few", "many", "most"}:
        return "p"
    return "s"  # proper noun, "the X", pronoun, activity

def O6(Z):  # perspective of the source in Z: I / II / III
    match Z.source.person:
        case 1: return "I"
        case 2: return "II"
        case _: return "III"

Examples:

Condensed gamma. A gamma argument with substance $𝑑$ is usually an argument with a missing middle step. ATIP says to try inserting it before concluding that the premise is irrelevant, which is the type non sequitur (Non). Build the middle statement $𝑚=\left({𝑠}_{𝑐},{𝑝}_{𝜌}\right)$ (“a is Y”), then type ${𝑎}_1=\left(𝑐,𝑚\right)$ as $𝛼$ and ${𝑎}_2=\left(𝑚,𝜌\right)$ as $𝛽$. Depth one; no further recursion. The open problem is scoring whether the insertion makes the premise relevant (Section 9). The result is two output records, linked.

Example: “Socrates will die because all humans are mortal”. Nothing is shared (Socrates ≠ all humans, will die ≠ are mortal), so γ, and the two relations aren’t the same, so ${𝑂}_7$ says d. Insert $𝑚$ = “Socrates is mortal”:

flowchart TD
  g["Socrates will die<br/>because all humans are mortal<br/><b>γ d</b>"] --> m(["insert m = (s_c, p_ρ)<br/>Socrates is mortal"])
  m --> a1["a₁: Socrates will die<br/>because Socrates is mortal<br/><b>α FF</b> → step 5"]
  m --> a2["a₂: Socrates is mortal<br/>because all humans are mortal<br/><b>β su</b> → step 5 (G)"]
  classDef alpha fill:#bfdbfe,stroke:#1d4ed8
  classDef beta fill:#bbf7d0,stroke:#15803d
  classDef gamma fill:#e9d5ff,stroke:#7e22ce
  classDef op fill:#fde68a,stroke:#b45309
  class g gamma
  class a1 alpha
  class a2 beta
  class m op

5.6. Step 5: lever

The lever is the argument’s third statement (Section 1), so step 5 chooses a statement, not just a keyword. Write $𝐹$ for the form and $𝑡$ for the substance. $𝐾\left(𝐹,𝑡\right)$ is the set of keywords the PTA lists for that form and substance (Section 12); for example $𝐾\left(𝛼,\text{VF}\right)=\left\{\text{CRITERION},\text{DEFINITION},\text{SUBSUMED}\right\}$. Each keyword $𝑘$ names a relation, and the candidate levers are its instances ${\ell }_{𝑘}$ on the argument’s own terms:

The terms a lever relates are fixed by the form:

The candidates are deductive. $𝐾\left(𝐹,𝑡\right)$ is empty for α FV/VP/FP. The PTA is open to new types, so a lever outside the table is reported as novel rather than forced into a listed type.

1. Cue override. If the context states a keyword (“is a SIGN of”, “is ANALOGOUS to”) between the argument’s own terms, return that keyword with probability 1.
2. Otherwise oracle O8. Write out each candidate lever statement ${\ell }_{𝑘}$ as a sentence, the hypothesis ${ℎ}_{𝑘}$ (“rising prices are a CAUSE of the strike”). Score each with an NLI model⁷ as entailment of ${ℎ}_{𝑘}$ by the context. Normalise over $𝐾\left(𝐹,𝑡\right)\cup \left\{\text{none}\right\}$ with a softmax;⁸ none above a threshold gives novel.

def lever(a, form, substance):
    K = LEVERS[form][substance]               # table lookup
    if not K:
        return {"novel": 1.0}
    for k in K:
        if cue(k).links(a.terms, a.ctx):      # e.g. "is a SIGN of"
            return {k: 1.0}
    h = {k: fill(TEMPLATE[k], a) for k in K}
    h["none"] = "none of these"
    return softmax({k: entail(a.ctx, h_k) for k, h_k in h.items()})

Running example, α VF. The candidates and their filled-in hypotheses (Y = “raising the university budget”, X = “doing a great job”):

With a cue instead: “raising the budget is the very definition of a great job” skips the model and returns DEFINITION with probability 1.

5.7. Step 6: name

$𝑁$ is the set of the PTA’s 50 type names. $𝑛$ is a pure lookup in Section 12, which reproduces ATIP’s Table 7. γ d has no keyword ($𝑘$ is empty) and maps to Non, which is a type, not a missing value. Within a form the keyword alone fixes the name, as the PTA names types after the lever’s KEYWORD; $𝑡$ is kept as a consistency check (a keyword outside $𝐾\left(𝐹,𝑡\right)$ is an error upstream).

NAMES[("α", "VF", "CRITERION")]  # "argument from criterion (Cr)" -> "α VF Cr"
NAMES[("β", "su", "GENUS")]      # "argument from genus (G)"      -> "β su G"
NAMES[("γ", "d",  None)]         # "non sequitur (Non)"           -> "γ d Non"
NAMES.get(("α", "FV", None))     # None                           -> "novel"

5.8. Composition

The tree is small: at most 4 forms × 9 substances × 10 levers. Enumerate every path and multiply its oracle probabilities to get an exact distribution over codes:

Here ${𝑣}_{𝑖}$ is the answer oracle ${𝑂}_{𝑖}$ gives on that path. The output record’s code is the most likely code, alternatives the runners-up, and confidence the top probability. The product assumes the oracles are independent; the lab checks whether the resulting confidences are calibrated.⁹ Paths whose probability falls below a threshold are pruned (not explored further).

def classify(a):
    dist = Counter()
    for F, pF in form(a).items():
        if F == "⊥":
            dist["⊥"] += pF
            continue
        for t, pt in substance(a, F).items():
            for k, pk in lever(a, F, t).items():
                p = pF * pt * pk
                if p >= PRUNE:
                    dist[code(F, t, k)] += p
    return dist

Running example as a tree. Probabilities multiply down each path; the winning path is bold.

flowchart LR
  a(["a"]) --> D["δ 0.03"]
  a --> X["⊥ 0.04<br/>flagged"]
  a --> G["γ 0.05"]
  a ==> A["α 0.88"]
  A --> FF["FF 0.10"]
  A ==> VF["VF 0.81"]
  VF ==> Cr["Cr 0.62<br/><b>α VF Cr ≈ 0.44</b>"]
  VF --> Su["Su 0.21<br/>α VF Su ≈ 0.15"]
  VF --> Def["Def 0.09<br/>α VF Def ≈ 0.06"]
  VF --> N["none 0.08<br/>novel ≈ 0.06"]
  classDef alpha fill:#bfdbfe,stroke:#1d4ed8
  classDef win fill:#1d4ed8,color:#ffffff,stroke:#1e3a8a
  classDef gamma fill:#e9d5ff,stroke:#7e22ce
  classDef delta fill:#fed7aa,stroke:#c2410c
  classDef bot fill:#e5e7eb,stroke:#4b5563
  class A,VF,FF,Su,Def,N alpha
  class Cr win
  class G gamma
  class D delta
  class X bot

Record: code: α VF Cr, confidence: 0.44, alternatives: [α VF Su, α VF Def]. A confidence that low says the label should be reviewed before it is trusted.

The lever and naming tables are data, not code: one file read by both the lab (Python) and the game (Rust).

6. Oracles

Each oracle has a rule baseline and at least one model arm. Several of the models are already in use in the reading-notes lab, a sibling project that maps passages of text to concepts.

Reuse: the reading-notes lab already runs embedding models (usable for O2) and GLiNER2 (O1, O3, O5). Two things are new:

• An NLI arm (O7, O8): small DeBERTa-v3 NLI models (xsmall to base) run on CPU and export to ONNX,¹⁵ so they fit that lab’s latency harness.
• A dependency parser for the rule baselines (spaCy en_core_web_sm in the lab). Most of the deductive work runs on it.

7. Gold labels and evaluation

The gold labels are features on each Connector (Section 4.1). The classifier’s output record has the same fields, so every gold value can be compared with what the pipeline produced:

Concept tags are references, not a theory of concepts: a tag names what an argument is about at the level of a glossary entry, and a sense records a writer’s own version where the passage depends on it. Whether two writers share a concept stays a labelling decision, made per passage. Tags are lowercase, because INCEpTION may compare tag names case-insensitively. The tagset is open, so tags are added while labelling; together they become the concept list the models later choose from. Constraints can’t relate a concept to its senses in a multi-valued feature, so the shared prefix does that job: typing being lists every being/… sense.

Substance tags carry their form because INCEpTION may compare tag names case-insensitively, which would merge pp with PP and i with I. INCEpTION constraints show the substances valid for the chosen form, and the levers valid for the chosen substance, first and in bold; they don’t forbid the others, so the converter rejects invalid combinations. The layers and constraints are generated from the type table (Section 12) by scripts/pta_schema.py in the lab.

The name is derived from the three, so it isn’t stored. The features map one-to-one onto pipeline stages (the canonical terms and transformations onto steps 1–2, the rest onto steps 3–5), which allows stage-wise evaluation: run the pipeline with gold values substituted for everything upstream of a stage, and that stage’s errors are its own. Canonical terms are compared by meaning, not string: span overlap for terms taken from the text, entailment both ways (as O10 checks rewrites) for reworded ones. Transformations are compared as sets. End to end, measure code top-1/top-3¹⁶ and calibration. Statistics: each arm is compared pairwise against one baseline, with confidence intervals from resampling by passage.

A second human pass on a sample gives the ceiling: ATIP is hard for people too, and no arm should be expected to beat human agreement.

Pilot corpus. The first corpus is one short argumentative excerpt from each of about 30 writers across traditions (ancient, Buddhist, patristic and scholastic, early modern, German idealist, phenomenological, analytic, critical, psychoanalytic, Kyoto School, and speeches), plus the ten single-argument examples from the PTA website, which test typing on their own. One writer’s style shouldn’t shape the whole corpus. The pilot finds where the pipeline breaks; it is too small to rank arms.

• Split by writer. Each writer in turn is the test set and the rest form the dev set, so every annotation is tested once and no example helps to classify its own writer.
• What the dev set is for. O9′s generative arm takes 3–8 dev cases as in-context examples (original pair, the labeller’s rewording, its transformations), chosen by similarity to the current argument. The other oracles are used zero-shot; the dev set sets their thresholds (O2, O10) and calibrates their confidences (O7, O8, GLiNER2). Rule baselines may be fixed against the dev set only.
• Rewordings as gold. The canonical terms and transformations hold the labeller’s rewording; note holds only remarks. O9′s examples and its evaluation read the rewording; the subject/predicate splits are gold for O1 and O2.
• First run. The classifier runs on the gold connectors, stage-wise and end to end. Finding the connectors automatically (the document-analysis procedure) has no oracles yet and comes later.

Records quote the lab’s source texts, which are excerpts of published books, so they are never committed.

8. In-game use (sketch)

The player argues with a non-player character (NPC); this pipeline types the player’s arguments. The result is one input to key extraction: the game’s step that decides which of the game’s keys an argument unlocks.

What changes from the lab:

• No gold spans. O1 must find the claim, the reason and which is which, from the player’s line and the dialogue: the conclusion is often the NPC’s last claim, which the player supports or attacks.
• Short, informal text. The rule baselines will do worse than on books; the lab should keep a set of player-style notes to measure this separately.
• Runtime. Rust with ort, on a throttled CPU. Every model arm must export to ONNX, and the rule baselines must be small enough to port. The tables are already shared data (Section 5.8).
• Rewriting in-game. O9′s LLM arm is too slow and too large ( 400 MB at 0.5B, 4-bit) for a reply that should feel immediate. In-game O9 uses the rule and seq2seq arms, gated as in Section 5.3, and may run after the player’s line rather than before the reply. NPC arguments are analysed offline. The LLM arm stays in the lab, where its reviewed outputs can train the seq2seq arm.

What key extraction gets, per argument:

• the code distribution;
• the bound terms: which spans filled $𝑎$, $𝑏$, $𝑋$, $𝑌$, $𝑞$, each run through the reading-notes lab’s interpreters, which map a span to a concept id.

With the bound terms, an argument becomes a structured claim about concepts: “the player argued that concept Y is a CAUSE of concept X”. That is the natural thing for a key to gate on, e.g. a key that needs concept X introduced and argued for by a lever of some type. The quality step slots in between: it reads the same record and can veto. How keys combine these is left open.

9. Risks and open questions

• Subject/predicate splits in philosophical prose. Nominalisations and long clauses will break the parse baseline. Expected to be the largest source of O1 error.
• Sameness is the pivot. O2 decides form, and form decides every later candidate set. Errors there cascade; stage-wise evaluation will show how much.
• Rewriting decides form. Allowed rewordings are loose enough that one argument can come out α, β or γ (Section 5.3). O9 and O10 make the choice explicit and reviewable, but their errors move arguments between forms; the lab should measure how often O9′s candidates include the labeller’s rewording.
• Condensed gamma. No good scorer for “the insertion makes the premise relevant” yet. First version: try it, report both readings, lower the confidence.
• Explication in free text. Players will leave the link implicit. The lever is always reconstructed anyway (O8), but a missing premise isn’t handled. Deferred until there is player-style data.
• Independence assumption in the composition. Checked by calibration; if it fails, recalibrate the composed score rather than modelling dependencies.
• A parser in Rust. The rule baselines assume a dependency parser. The game needs one that runs under ort or in pure Rust; not yet surveyed.
• Training data. No PTA 3.1 corpus exists that I know of; Visser et al. 2021 uses the old 36-type labels and would need remapping. Fine-tuning stays deferred, as in the reading-notes lab.

10. Suggested order

1. Tables as data; form, substance, lever and naming as pure functions over given oracle values; composition. Testable with hand-made values.
2. Gold features in INCEpTION; stage-wise evaluation with gold oracles.
3. Rule baselines (parser, lexicons).
4. Model arms: embeddings (O2), GLiNER2 (O1, O3, O5), NLI (O7, O8).
5. Player-style data and in-game O1.

11. References

• Wagemans, J.H.M. (2026). Argument Type Identification Procedure (ATIP) – Version 6. https://www.periodic-table-of-arguments.org/argument-type-identification-procedure
• Wagemans, J.H.M. Periodic Table of Arguments, version 3.1, with worked examples of every type. https://www.periodic-table-of-arguments.org/pta-3-1-clickable
• Hinton, M., Wagemans, J.H.M. (2023). “How persuasive is AI-generated argumentation? An analysis of the quality of an argumentative text produced by the GPT-3 AI text generator.” Argument & Computation 14(1), 59–74. https://doi.org/10.3233/AAC-210026 Local copy in .docs/reference/.
• Hinton, M., Wagemans, J.H.M. (2022). “Evaluating reasoning in natural arguments: A procedural approach.” Argumentation 36, 61–84. The type-specific lever questions.
• Visser, J., Lawrence, J., Reed, C., Wagemans, J., Walton, D. (2021). “Annotating Argument Schemes.” Argumentation 35, 101–139.
• Chesñevar, C., McGinnis, J., Modgil, S., Rahwan, I., Reed, C., Simari, G., South, M., Vreeswijk, G., Willmott, S. (2006). “Towards an Argument Interchange Format.” Knowledge Engineering Review 21(4), 293–316.

12. Appendix: the 50 PTA 3.1 types

From ATIP’s Table 7. The lever column is the lever statement’s pattern, with the keyword in capitals. For β, the substance is any one of those listed.

What links here: ATIP: original ontology and procedure, Document argument analysis: finding and connecting arguments, Argument maps, Periodic Table of Arguments, xAIF editor