Monday, October 13, 2025

How to perform medieval obligational disputations (obligationes)

These guides to performing medieval disputations were created by GPT-5-Thinking based on the (very brief) description of these kinds of disputations written by Sara L. Uckelman in The History of Philosophical and Formal Logic, edited by Malpass and Marfori. Prompts omitted since they contained copyrighted book text, and do not really add to the post.

Positio and depositio

A practical guide to running medieval obligational disputations

(focus: positio, depositio, petitio — treated as one family)

This is a hands-on “how to” you can use in class, a reading group, or a solo drill. It gives you just enough historical fidelity to match medieval practice, but packaged like a modern exercise.

1) Roles, materials, and set-up

Players

  • Opponent (O): proposes sentences (one per turn unless using a “batch” variant).
  • Respondent (R): must answer each sentence by Concede, Deny, or Doubt (some authors also allow Distinguish for genuine ambiguity).

Board/record

  • Keep a running log with three growing sets:

    • Conceded: C
    • Denied (negated): D¬ (record negations of all denied sentences)
    • Doubted: ? (for bookkeeping only)

House decisions (choose before you start)

  1. Type: positio (default), depositio (mirror image), or petitio (reduces to positio; see §6).

  2. Relevance regime:

    • Old response (responsio vetus, “dynamic”): a sentence σ is relevant iff σ or ¬σ follows from C ∪ D¬ so far (relevance can change mid-game).
    • New response (responsio nova, “static”): σ is relevant iff σ or ¬σ follows from the positum alone (relevance never changes).

  3. Positum class (for positio): possible (consistent/satisfiable) or impossible (inconsistent). Most practice uses possible.

  4. Shape: simple (single sentence) or complex (conjunction/disjunction).

  5. Stipulations: any extra constraints (for “dependent” positio), e.g., “Treat all arithmetic as standard,” “No metaphysical necessities invoked,” etc. Write stipulations at the top of the log.

2) One rulebook, two relevance tests

Core answering rules (used by everyone):

  1. If relevant and σ follows, Concede σ.

  2. If relevant and ¬σ follows, Deny σ.

  3. If irrelevant:

    • If (known) true, Concede σ.
    • If (known) false, Deny σ.
    • If unknown/undetermined, Doubt σ.

“Follows” = logical consequence under your background logic (usually standard propositional + quantificational reasoning) plus any written stipulations.

Relevance tests (decide once):

  • Dynamic (vetus): compute from the current context C ∪ D¬. Update after every response.
  • Static (nova): compute once from the positum. Do not update during play.

3) Turn structure (script)

Opening move (positio):

  • O1: States the positum ϕ.
  • R1: If the session is possible positio and ϕ is consistent, admit it (Concede). For impossible positio, deny or handle by agreed variant.

Subsequent rounds (k ≥ 2):

  • Ok: utters a sentence σ_k.

  • Rk:

    1. Test relevance (dynamic or static).
    2. Apply the core answering rules.
    3. Update log: add σ_k to C if conceded; add ¬σ_k to **D¬if denied; addσ_k` to ? if doubted.
    4. (Dynamic only) Recompute relevance for the next turn if needed.

Ending the disputation: Stop after N rounds (e.g., 8–12 for a seminar), or when O declares “finis”.

4) Quick decision tree for the Respondent

  1. Are we in positio/depositio/petitio?

    • Depositio with depositum ϕ ≈ Positio with positum ¬ϕ (mirror the whole game).
    • Petitio (Opponent asks you to take an initial stance) → treat as Positio on that stance (see §6).

  2. Relevance?

    • Dynamic: does σ (or ¬σ) follow from C ∪ D¬?
    • Static: does σ (or ¬σ) follow from ϕ (the positum)?

  3. Then answer:

    • Relevant & follows → Concede
    • Relevant & negation follows → Deny
    • Irrelevant & true → Concede
    • Irrelevant & false → Deny
    • Irrelevant & unknown → Doubt

(Use Distinguish only for genuine scope/ambiguity; write both readings and proceed with the intended one.)

5) Worked micro-sessions

A) Positio (possible), dynamic relevance

Let ϕ := “The capital of England is Paris.” (false but consistent) Let ψ := “It is raining.” (truth value depends on the actual situation)

Turn Opponent says Respondent reasoning (dynamic relevance) R answers Log after move
1 ϕ Possible positio; ϕ is consistent ⇒ admit Concede C = {ϕ}
2 ¬ϕ ∨ ψ Either it follows from ϕ (if ϕ→ψ), or it’s irrelevant. Even if irrelevant, ¬ϕ is true (since ϕ is actually false), so the disjunction is true. Concede C = {ϕ, (¬ϕ ∨ ψ)}
3 ψ Now, from what’s conceded: ϕ together with (¬ϕ ∨ ψ) forces ψ. Hence ψ is relevant and follows. Concede C = {ϕ, (¬ϕ ∨ ψ), ψ}

Lesson: With a false but consistent positum, O can often force unrelated consequents under the dynamic regime by packaging truths about ¬ϕ into disjunctions.

B) Depositio (mirror of positio)

Take depositum ϕ. This is equivalent to running positio with positum ¬ϕ.

  • Start by Denying ϕ.
  • Thereafter, treat every O-move exactly as in positio but with ¬ϕ as the fixed anchor (for static) or as part of the evolving C ∪ D¬ (for dynamic).

C) Positio (possible), static relevance

Same ϕ, ψ as (A), but static relevance (Swyneshed).

  • ψ is irrelevant unless ϕ ⊢ ψ or ϕ ⊢ ¬ψ.
  • (¬ϕ ∨ ψ) is also irrelevant (it does not follow from ϕ).
  • So R answers round 2 by Concede (because it’s actually true), but that does not change relevance.
  • Round 3: ψ remains irrelevant; answer by Concede/Deny/Doubt according to its actual truth value (not because of any dynamic forcing).

Lesson: Static relevance blocks the Opponent’s “force any ψ” trick.

6) Handling the three named formats

  • Positio: Opponent proposes a positum. You run the rules above.
  • Depositio: Opponent proposes a depositum you must reject. Treat as Positio on ¬depositum (mirror image).
  • Petitio: Opponent petitions you to take a stance (e.g., “Concede α”). Reduce to Positio with positum α (or with the requested stance recorded as the initial commitment) and proceed normally. Cosmetic differences aside, the answering behavior is the same.

7) Opponent’s playbook (constructive pressure)

  • With dynamic relevance:

    • Use true disjunctions like ¬ϕ ∨ χ to seed the log; once conceded, many χ turn relevant and follow.
    • Ask for conjunctions to accumulate more in C, expanding what follows.

  • With static relevance:

    • Aim to show that σ (or ¬σ) is a logical consequence of the positum itself—e.g., choose a positum that already encodes the pathway to your target σ.
    • Otherwise, probe actual truths to elicit Concede on irrelevant claims (useful for pedagogy, less for “wins”).

8) Common pitfalls (and how to audit)

  • Mixing regimes: Don’t compute relevance dynamically if you chose static (and vice-versa).
  • Forgetting denial bookkeeping: Always add the negation of what you denied to D¬.
  • Ambiguity drift: If a sentence is ambiguous, Distinguish once; write both readings; choose one and stick to it.
  • Inconsistency check (possible positio): Your C ∪ D¬ should stay consistent throughout. If you derive both σ and ¬σ, something went wrong in reasoning or relevance.

Quick audit at the end

  1. Every relevant sentence: did R answer per consequence?
  2. Every irrelevant sentence: did R answer by actual truth value or “Doubt”?
  3. Dynamic only: does each step’s relevance match C ∪ D¬ at that step?

9) Variants and options you can add

  • Conjoined positio: start with a bundle ϕ₁ ∧ … ∧ ϕ_n. Treat the whole as the positum (static) or as initial concessions (dynamic).
  • Indeterminate/disjunctive positio: begin with ϕ ∨ ψ. Under dynamic rules, Opponent can often steer later relevance by adding true disjuncts.
  • Dependent positio: write extra stipulations (e.g., “assume standard arithmetic,” “ignore metaphysical necessity claims”) and honor them as background constraints.

10) Ready-to-use template (print for the table)

Header:

  • Type: □ positio □ depositio □ petitio
  • Regime: □ dynamic (vetus) □ static (nova)
  • Positum / Depositum / Petition: __________
  • Stipulations: _____________________________

Log sheet

  • C (Conceded): __________________________________
  • D¬ (Negations of Denied): _______________________
  • ? (Doubted): ____________________________________

Per turn checklist for R

  1. Mark relevance (from C ∪ D¬ or from the positum).
  2. Apply core rule (Concede / Deny / Doubt).
  3. Update the log.
  4. (Dynamic) Recompute relevance horizon.

Use this guide as a drill: run a 10-turn positio twice, once dynamic, once static, with the same positum. Compare the two transcripts. You’ll feel exactly why later authors revised the relevance rule—and you’ll be doing obligational disputations like a medieval pro.

Dubitatio

A practical guide to running dubitatio (doubting) obligational disputations

Unlike positio and depositio, dubitatio is built to mix truth with knowledge and to give the Respondent real choices. That’s the point: even when the Respondent knows the dubitatum is true (or false), the rules can still require “I doubt it” or “prove!”—and there isn’t always a unique correct reply. Here’s how to run it smoothly.

1) What makes dubitatio different?

  • The Opponent proposes a sentence δ (the dubitatum).
  • The Respondent is obliged to doubt δ. In many thirteenth-century formulations this surfaces as the stock reply “Prove!” (Latin: proba!). Use either “I doubt it” or “Prove!” for δ; below we standardize on “Prove!” because the classic rule set uses it uniformly.
  • Replies are non-deterministic in key places: for some moves the Respondent may choose between two allowed answers and still be fully correct. That never happens in standard positio/depositio.

2) Roles, materials, and the one modeling choice you must fix

Players

  • Opponent (O): utters one sentence per turn.
  • Respondent (R): answers each sentence.

Permitted answers

  • True / Concede, False / Deny, Doubt, Prove! (request a demonstration), optionally Distinguish for genuine ambiguity.

Log you should keep

  • C (Conceded true), D¬ (negations of denied), ? (Doubted). “Prove!” does not add anything to the log.

Classification is always relative to the dubitatum δ (static):

  1. Convertible to δ (logically equivalent to δ)
  2. Opposite of δ and its convertibles (equivalent to ¬δ)
  3. Antecedent of δ (sentence α with α ⊢ δ)
  4. Consequent of δ (sentence β with δ ⊢ β)
  5. Irrelevant to δ (none of the above)

Treat this as an order of precedence: if a sentence is convertible to δ, handle it as convertible, not as a mere consequent, etc.

3) The dubitatio rulebook (Nicholas-style, streamlined)

Let δ be the dubitatum. Then:

  • For δ and anything convertible to δ: reply “Prove!”
  • For ¬δ and anything convertible to ¬δ: reply “Prove!”
  • For any antecedent of δ (something that implies δ): reply “False” or “Prove!” — never “True.”
  • For any consequent of δ (something entailed by δ): reply “True” or “Prove!” — never “False.”
  • For anything irrelevant to δ: reply by its quality (if you know it’s true → True; if you know it’s false → False; if you don’t know → Doubt).

Why this feels odd (and great!): you might know an antecedent is true, yet still must not answer “True.” Likewise you might know a consequent is false (because you know δ is false), yet you still must not answer “False.” That’s the higher-order tension dubitatio trains.

4) Turn structure

  1. Opening

    • O1: states δ (the dubitatum).
    • R1: “Prove!” (or “I doubt it.”)

  2. Each subsequent round

    • Ok: Opponent utters one sentence σ_k.
    • Classify σ_k against δ using the precedence list.
    • Answer according to the rulebook above.
    • Update the log if and only if you replied True/False/Doubt (not for “Prove!”).

  3. Finish after N rounds (e.g., 8–12), or when O says “finis.”

5) Respondent’s strategy (to “win” = never concede/deny δ)

Assume δ is neither a tautology nor a contradiction (the interesting cases).

  • Absolute blocks: If O states δ, ¬δ, or anything equivalent to either, say “Prove!”.

  • Safe defaults:

    • For antecedents, prefer “Prove!” unless there’s a compelling tactical reason to say “False.”
    • For consequents, prefer “Prove!” unless there’s a compelling reason to say “True.”

  • Irrelevants: Answer by quality, but be wary of disguised equivalences. If you suspect σ is actually equivalent to δ or ¬δ, you must treat it as such and say “Prove!”

  • Do not try to “be helpful.” In dubitatio, saying “True” to an antecedent is illegal, even if it happens to be true.

6) Opponent’s playbook (to pressure well)

  • Test vigilance with convertibles: ¬¬δ, biconditionals, or cleverly rephrased synonyms of δ/¬δ.
  • Tempt “illegal truth”: offer enticing antecedents like δ ∧ χ or χ → δ. R must resist answering “True.”
  • Nudge commitments via consequents: harmless on paper (R can say “True”), but good for teaching how consequences differ from equivalences.
  • Mix in irrelevants with clear truth values to force R to toggle between knowledge, doubt, and proof-demanding.

7) Worked micro-session

Let the dubitatum be:

δ: “The capital of England is London.” (assumed common knowledge: true)

Turn 1

  • O: δ
  • R: Prove! (obligatory)

Turn 2 (consequent)

  • O: δ ∨ “Paris is the capital of England”
  • Class: Consequent of δ (since δ ⊢ δ ∨ …)
  • R (allowed): True or Prove!
  • R (choose): True → add to C.

Turn 3 (antecedent)

  • O: δ ∧ “2+2=4”
  • Class: Antecedent of δ (since δ ∧ … ⊢ δ)
  • R (allowed): False or Prove!, never True
  • R (even though both conjuncts are true): Prove!

Turn 4 (convertible to δ)

  • O: ¬¬δ
  • Class: Convertible to δ
  • R: Prove!

Turn 5 (irrelevant, unknown)

  • O: “It is raining in Rome.”
  • Class: Irrelevant to δ
  • R: Doubt (if the table hasn’t fixed the weather facts)

Turn 6 (opposite)

  • O: ¬δ
  • Class: Opposite of δ
  • R: Prove!

Result: R never concedes nor denies δ, yet lawfully concedes true consequents and treats irrelevants by their actual truth. That’s a model “win.”

8) Common pitfalls & how to audit

  • Wrong precedence. Always check for convertible / opposite-convertible first.
  • Answering by quality on relevant claims. For antecedents/consequents, the special rules override “according to quality.”
  • Illicit helpfulness. Saying “True” to an antecedent—or “False” to a consequent—is not allowed, even if you know it.
  • Forgetting that “Prove!” is content-neutral. It never alters C/D¬/?.

End-of-session audit

  1. Every convertible/opposite-convertible got “Prove!”
  2. Every antecedent got “False” or “Prove!” (no “True”).
  3. Every consequent got “True” or “Prove!” (no “False”).
  4. Irrelevants answered by quality (True/False/Doubt).
  5. δ and ¬δ were never conceded or denied.

9) Quick table you can print

Kind (w.r.t. δ) How to recognize Allowed replies Forbidden
δ & convertibles σ ↔ δ valid Prove! True, False, Doubt
Opposite & convertibles σ ↔ ¬δ valid Prove! True, False, Doubt
Antecedent σ ⊢ δ False or Prove! True
Consequent δ ⊢ σ True or Prove! False
Irrelevant none of the above By quality (True/False/Doubt) —

10) Ready-to-use template

Header

  • Dubitatum (δ): __________________________
  • Stipulations / background facts: ___________

Log

  • C (Conceded): ____________________________
  • D¬ (Negations of denied): ________________
  • ? (Doubted): _____________________________

Per-turn checklist

  1. Classify vs. δ (use precedence).
  2. Choose an allowed reply (remember your options).
  3. Update the log only for True/False/Doubt.

Run the same dubitatio twice: once with a true δ, once with a false δ. In both, a disciplined Respondent can always avoid conceding or denying δ—that’s the distinctive skill dubitatio trains.

Impositio

A practical guide to running impositio (imposition / institutio / appellatio)

What’s new here? In impositio, the Opponent redefines meanings—of words or of whole propositions. After that, the disputation (which may be a positio, depositio, or dubitatio) proceeds under the new lexicon. So you’ll manage two layers every turn:

  1. Semantics layer: apply the imposition(s) to interpret what’s being said.
  2. Obligation layer: answer using the base game’s rules (positio/depositio/dubitatio) on the reinterpreted content.

This guide gives you a working protocol, safe “house rules,” and examples (including how to navigate the tricky truth-relative impositions that can blow up).

1) Roles, materials, and the two ledgers

Players

  • Opponent (O): may introduce impositions (semantic stipulations) and then utter sentences.
  • Respondent (R): must answer each utterance as required by the base game (positio / depositio / dubitatio), but only after interpreting it via the impositions.

Keep two ledgers

  • Lexicon (L): a running list of impositions (term- or proposition-level), with scope and priority (see §3).
  • Obligation log: as in your base game (Conceded/Denied/Doubted etc.). The lexicon does not go here; it lives separately.

2) What can be imposed?

A) Term-level imposition (word → new meaning/extension)

“I impose that man means donkey.”

  • Every occurrence of man now behaves as if it meant donkey.

B) Proposition-level imposition (quoted sentence-name → content)

“I impose that ‘God exists’ signifies precisely that man is donkey.”

  • When someone asserts God exists (unquoted), interpret it as the proposition man is donkey.

C) Truth-relative imposition (meaning depends on the truth-status of the containing sentence)

“I impose that ‘a’ signifies man in any false proposition containing it, donkey in any true one, and (man or non-man) in any doubtful one.”

  • These are advanced; they can create instability (no consistent reading). See §6.

Combining with base games

  • Impositio is a modifier: you can run Positio + Impositio, Depositio + Impositio, or Dubitatio + Impositio. The obligation rules come entirely from the base game; the interpretation comes from the lexicon.

3) House rules that keep play smooth

Adopt these before you start:

  1. Prospective scope: New impositions affect future utterances only (no retroactive reinterpretation of past moves).

  2. Specificity beats generality: If two impositions conflict, the more specific rule for the same expression wins (e.g., a proposition-level imposition outranks a general term-level one inside that proposition).

  3. Latest wins (tie-breaker): Among equally specific rules for the same expression, the later imposition overrides earlier ones.

  4. Quoted vs unquoted: Only quoted strings designate expressions; unquoted occurrences are used and thus reinterpreted.

  5. Well-formedness check: The Opponent may propose any imposition. If a proposed imposition makes some sentences uninterpretable or semantically unstable (see §6), you must either:

    • (Strict medieval flavor) Allow it and play out the contradiction; the result is a reductio of the imposition.
    • (Seminar-friendly) Rule it illicit and require O to restate a coherent imposition. State which policy you’re using.

Write these five lines at the top of the board; you’ll need them.

4) Turn structure (the two-layer “interpret-then-answer” loop)

Opening

  • O may (i) introduce one or more impositions (record in Lexicon L), then (ii) start the base game (e.g., announce a positum; depositum; or dubitatum).

Each subsequent turn

  1. O speaks a sentence σ.

  2. Interpretation pass: compute σ^L by applying the lexicon:

    • Replace term meanings per active term-impositions.
    • If σ matches a proposition-level imposition key, substitute the imposed content.
    • If truth-relative rules are in play, run the stability procedure (see §6).

  3. Obligation pass: treat σ^L as the actual content and respond by your base game’s rules (positio/depositio/dubitatio).

  4. Update the obligation log. (Never write impositions in this log—those stay in L.)

5) Worked basics

A) Simple term-level impositio + Positio

  • Imposition: “I impose that man means donkey.” (record in L)
  • Positum: ϕ: “All men are mortal.”

Interpretation: ϕ^L = “All donkeys are mortal.”

  • If your background facts treat that as true, R must Concede (under positio rules: relevant consequents conceded; irrelevants by quality, etc.).
  • Every later use of man = donkey until revoked.

B) Proposition-level impositio + Dubitatio

  • Imposition: “I impose that ‘God exists’ signifies that man is donkey.”
  • Dubitatum: δ: God exists.

Interpretation: δ^L = “man is donkey.”

  • Under dubitatio, R must reply “Prove!” to δ and to any convertibles of δ (now convertibles of man is donkey).
  • If O later utters God exists, treat it as “man is donkey” each time.

6) Handling truth-relative (switching) impositions

These are the notorious ones (e.g., Lavenham’s ‘a’). They can make a sentence’s own truth determine the meanings inside it, which in turn determine its truth—a loop.

Stability procedure (per sentence σ containing a switcher):

  1. Trial assignment: tentatively label σ as True, interpret terms accordingly, evaluate truth.
  2. Check: If evaluation returns True, you found a fixed point; use that reading.
  3. If not, try False; if it returns False, fixed point found.
  4. If neither True nor False stabilizes, try Doubtful/Unknown (for games that use a third option in the meta; some tables allow this).
  5. If no assignment yields a fixed point → UNSTABLE.

What to do if UNSTABLE? Choose a policy upfront:

  • P1 (Strict/reductive): Let O press the contradiction to refute the imposition. R answers by base rules on each step; when faced with the target unstable sentence, R may declare “No well-defined content under L” (or, in dubitatio, default to “Prove!” endlessly). Conclude: imposition illicit.
  • P2 (Seminar-safe): Your house rule says truth-relative impositions are illicit. R may immediately say: “The proposed imposition yields no stable interpretation; please reimpose.” Then continue with a coherent imposition.

Either way, keep the meta clear in your transcript: mark the sentence UNSTABLE and record which policy you used.

Example: the classic trap Impose: “In any true sentence containing ‘a’, it means donkey; in any false one, man; in any doubtful one, (man or non-man).” Consider σ: Man is a.

  • Assume True ⇒ a = donkey ⇒ “Man is donkey” ⇒ False (ordinary background), contradicts assumption.
  • Assume False ⇒ a = man ⇒ “Man is man” ⇒ True, contradicts assumption.
  • Assume Doubtful ⇒ a = (man or non-man) ⇒ “Man is (man or non-man)” ⇒ True, so not doubtful. → UNSTABLE. Apply policy P1 or P2 above.

7) Opponent’s playbook (how to pressure well)

  • Shallow remapping: Start with a simple term-imposition to make everyone practice clean reinterpretation.
  • Then escalate: Add a proposition-level imposition that collides with the term-level one (e.g., “God exists” → “man is donkey” while man → donkey) and see if R honors specificity and latest-wins.
  • Finally, test vigilance: Introduce a truth-relative imposition; aim a sentence that becomes UNSTABLE. If your table uses P1, push the reductio; if P2, force R to call it illicit crisply.

8) Respondent’s survival kit

  1. Interpret first, answer second. Never apply base-game rules to the unreinterpreted sentence.
  2. Check precedence: convertible/proposition-level rewrites beat generic term switches inside that sentence.
  3. Mark UNSTABLE quickly. Don’t flail; run the stability procedure once, then invoke P1/P2.
  4. Keep ledgers separate. The lexicon is not the commitment set; don’t pollute C / D¬ / ? with semantic rules.

9) Quick table you can print

Situation What you do
New imposition Record in L with time stamp; announce scope (prospective).
Sentence arrives Compute σ^L (apply term- and proposition-level rules; then stability test if needed).
σ^L well-defined Apply base-game rules and log the result.
σ^L UNSTABLE Follow policy P1 (press reductio) or P2 (declare illicit; ask for reimposition).
Conflicting impositions Use specificity, then latest-wins.
Quoted strings Treat as names of expressions (don’t reinterpret).

10) Ready-to-use template

Header

  • Base game: □ positio □ depositio □ dubitatio
  • House policies: scope = prospective; conflicts = specificity → latest-wins; unstable = □ P1 □ P2

Lexicon (L)

  • [t+0] man ↦ donkey (term)
  • [t+1] ‘God exists’ ↦ (man is donkey) (prop)
  • [t+2] ‘a’ ↦ donkey/ man / (man∨¬man) by truth-status (term, switching)

Obligation log (per base game)

  • C: ___ D¬: ___ ?: ___

Per turn checklist

  1. Re-interpret (σ^L).
  2. If switching, run stability test.
  3. Answer by base game.
  4. Update log (not L).

Use this once with only simple impositions, once with mixed (term + proposition), and once with a switching case. After three runs, your table will have the reflexes needed to handle impositio cleanly—interpret first, then oblige.

at
Labels:

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)