Tolerant, Classical, Strict (TCS) #
@cite{cobreros-etal-2012}
@cite{cobreros-etal-2012} "Tolerant, Classical, Strict", Journal of Philosophical Logic 41:347–385.
A similarity-based three-valued semantics for vague predicates that derives three notions of truth from a single model:
- Classical (c): standard satisfaction
M ⊨ᶜ P(a) iff a ∈ I(P)(Def 9) - Tolerant (t):
M ⊨ᵗ P(a) iff ∃d ~_P a, d ∈ I(P)(Def 9) - Strict (s):
M ⊨ˢ P(a) iff ∀d ~_P a, d ∈ I(P)(Def 9)
The indifference relation ~_P is reflexive and symmetric — but, crucially,
not necessarily transitive — capturing "looks the same for predicate P."
Paper-anchored mathematical foundation #
The paper formulates TCS in terms of indifference relations derived from
semi-orders (paper p. 350 fn 1, citing Luce 1956). The same atom-level
operators are equivalently described as the lower / upper approximation
operators of a tolerance approximation space in the rough-set tradition.
The paper flags this analogy in footnote 5 (p. 355), citing
@cite{pawlak-1982} (paper's reference [19]) for the equivalence-relation
case; borderline cases are exactly the boundary upper \ lower.
Re-reading TCS through a modal-logic lens (formaliser's framing) #
The paper itself does NOT use modal-logic vocabulary. The framing in this
section is the formaliser's lens, used to integrate with the existing
Core/Logic/Intensional/RestrictedModality.lean substrate; it is not
paper-anchored.
Structurally, TCS is a propositional modal logic in which each predicate
P carries its own reflexive-symmetric (KTB) Kripke accessibility
relation ~_P. The strict and tolerant satisfaction operators are
exactly the modal □ and ◇ over ~_P, applied to the classical
extension of P:
strict P at a≡boxR (~_P) I(P) a(Definition 9)tolerant P at a≡diamondR (~_P) I(P) a(Definition 9)
The s ⊆ c ⊆ t hierarchy is the T axiom instantiated at boxR
(Core.Logic.Intensional.boxR_T); the t/s duality is the standard
modal de Morgan boxR R ¬p ↔ ¬diamondR R p. T-models satisfy
frameConditions Logic.KTB by construction (Definition 4 of
@cite{cobreros-etal-2012}); see TModel.satisfies_KTB for the explicit
witness. The Brouwersche axiom B / symmetric-frame correspondence is
a standard Sahlqvist result; for systematic treatment see
@cite{blackburn-derijke-venema-2001} §3.5–3.6 and the model-theoretic
overview @cite{goranko-otto-2007}. The non-equivalence-relation
generalisation of Pawlak's rough sets to tolerance approximation spaces
(which the paper implicitly uses in footnote 5) is due to
@cite{skowron-stepaniuk-1996}; this attribution is supplied by the
formaliser, not the paper.
Key Results (paper-section-tagged) #
- Definition 9 (p. 353): t/s atomic clauses + their compositional lift
- Lemma 1 (p. 357): extension hierarchy s ⊆ c ⊆ t
- Facts 2-3 (p. 354): one-step + two-step tolerance principle
- Definition 10 (p. 355): borderline =
upper \ lower - Lemma 2 (p. 357): identity-model collapse of all three modes
- Definition 17 (p. 366): nine mixed consequence relations ⊨ᵐⁿ
- Lemma 7 (p. 368): strength ordering ⊨ᵗᵐ ⊆ ⊨ᶜᵐ ⊆ ⊨ˢᵐ
- Lemma 8 (p. 369): collapse cc = sc = ct = st on restricted vocabulary
- Remark 1 (p. 353), Lemma 10 (p. 371): t/s duality + self-duality of st and cc → deduction theorem
- Lemma 4 (p. 361) + Theorem 3 (p. 362): formula-level then
consequence-level correspondence with LP and K3. Note: paper Lemma 4 is
stated only for the restricted vocabulary (no
I_P); the formalisation in §15 extends it to handle similarity atoms by treating them as classical Bool-valued (always in{0, 1} ⊂ {0, 1/2, 1}), which is a faithful extension of the paper's construction.
Cross-framework comparators (paper p. 356, p. 359) #
The paper draws TWO distinct contrasts on the borderline-contradictions question, with two different opponents:
- Borderline-verdict contrast (p. 356) — TCS vs subvaluationism
(Hyde 1997). Both make
P ∧ ¬Ptrue at borderline cases; the contrast is over the underlying framework foundations (TCS via similarity-based modal semantics; subvaluationism via dual super-truth). Subvaluationism is not formalised in linglib; this is the closer comparator on the verdict but cannot be checked at the Lean level here. - Formal-validity contrast (p. 359) — TCS vs supervaluationism
(Fine 1975). Supervaluationism makes
P ∧ ¬Psuper-FALSE even at borderline cases (penumbral connection); this is the comparator formalised here, and it is realised as the §17 cross-framework theoremtcs_vs_supervaluation_borderline_contradiction. The Lean theorem combines the TCS half (IsBorderlinedefinition unfolding throughSatMode.dual) with the supervaluation half (nonContradiction_superFalsefromSupervaluation/Basic.lean).
Strict truth for an atomic predicate at individual a IS supervaluation
over the tolerance neighborhood of a: superTrue I(P) {d | d ~_P a}.
Tolerant truth is its existential dual. This makes TCS a localized
supervaluation — each individual gets its own specification space
determined by its similarity neighborhood.
Architecture #
This file provides the propositional restricted-vocabulary fragment
of TCS — atoms cover both predicate atoms P(a) and similarity atoms
a I_P b (paper Definition 8), but no quantifiers. All §2 (restricted
vocabulary) results apply; phenomena requiring first-order quantifiers
(paper §2.3) are out of scope.
The 4-element worked example from p. 354 of the paper (in the body text
immediately above footnote 4) lives in
Phenomena/Gradability/Studies/CobrerosEtAl2012.lean. The asymmetric
reciprocation point with LassiterGoodman2017PMF.lean::lg_literal_borderline_bounded
is addressed in that Studies file's §8-§9.
A T-model: a classical model equipped with per-predicate tolerance
relations. Each ~_P is reflexive and symmetric — but possibly
non-transitive — capturing "looks the same for predicate P."
Definition 4 of @cite{cobreros-etal-2012}. The non-transitivity of
~_P is what makes vagueness possible: a can look like b and b can
look like c, but a need not look like c.
Following the modal-logic tradition, the similarity relation is
Prop-valued so that it integrates directly with boxR/diamondR.
Decidability is added per-model where computation is needed.
- interp : Pred → D → Prop
Classical interpretation
I : Pred → D → Prop. Decidability of the interpretation (per predicate, per individual). Bundled so each
TModelinstance carries its own decision procedure.- sim : Pred → D → D → Prop
Tolerance (indifference) relation
~_Pper predicate. - sim_refl (P : Pred) : Core.Logic.Intensional.IsReflexive (self.sim P)
Reflexivity: every individual is similar to itself.
- sim_symm (P : Pred) : Core.Logic.Intensional.IsSymmetric (self.sim P)
Symmetry: similarity is undirected.
Instances For
Per-TModel decidability instance for the classical interpretation,
extracted from the bundled decInterp field.
Equations
- M.instDecidablePredInterp P = M.decInterp P
The similarity relation as an AccessRel — the Kripke frame
associated with each predicate. By construction this frame is
reflexive + symmetric, i.e., a KTB frame (Core.Logic.Intensional.Logic.KTB).
Instances For
T-models satisfy frameConditions Logic.KTB by construction.
The B axiom (Brouwersche, □p → □◇p from p) holds via boxR_B
T-models are KTB frames by construction: every per-predicate
similarity relation ~_P satisfies the frame conditions for the
normal modal logic KTB = K + T + B (reflexive + symmetric Kripke
frame). The four flag-fields beyond .M and .B are vacuously
satisfied because Logic.KTB doesn't require D, 4, or 5.
Atoms of the propositional restricted vocabulary of TCS. Two constructors per Definitions 8-9 of @cite{cobreros-etal-2012}:
pred P a≡P(a)— predicate application; t/c/s satisfaction clauses depend on the mode (Definition 9).sim P a b≡a I_P b— similarity predicate; classically interpreted in all modes (Definition 8, p. 353 + Remark 2, p. 354 reiterating the assumption for s/t modes).
- pred {Pred : Type u_1} {D : Type u_2} : Pred → D → TCSAtom Pred D
- sim {Pred : Type u_1} {D : Type u_2} : Pred → D → D → TCSAtom Pred D
Instances For
TCS formulas: propositional combinations (¬, ∧) of TCS atoms.
Reuses the canonical PropFormula from Core.Logic.ThreeValuedLogic
rather than introducing a duplicate inductive — mvEval and the
lpSat/k3Sat lemmas in that file apply directly.
Equations
Instances For
Strict atomic satisfaction: P holds at every ~_P-neighbour
of a. Definition 9, atomic clause for ⊨ˢ. Modal-logic-wise,
this is boxR (M.simAccess P) over the classical extension.
Equations
- Semantics.Supervaluation.TCS.StrictAt M P a = ∀ (d : D), M.sim P a d → M.interp P d
Instances For
Tolerant atomic satisfaction: P holds at some ~_P-neighbour
of a. Definition 9, atomic clause for ⊨ᵗ. Modal-logic-wise,
this is diamondR (M.simAccess P) over the classical extension.
Equations
- Semantics.Supervaluation.TCS.TolerantAt M P a = ∃ (d : D), M.sim P a d ∧ M.interp P d
Instances For
Strict atom = boxR over the similarity frame. This is
definitionally true; the lemma exists to expose the modal-logic
framing and to let downstream proofs invoke boxR_T/boxR_B
directly.
Tolerant atom = diamondR over the similarity frame. Definitional.
Strict ⟹ classical at the atomic level: if P holds for every
~_P-neighbour of a, it holds for a itself by reflexivity of
~_P. This is the T axiom instantiated.
Classical ⟹ tolerant at the atomic level: a itself
witnesses the existential by reflexivity of ~_P.
Strict ⟹ tolerant (transitive from above).
One-step tolerance (Fact 2 of @cite{cobreros-etal-2012}, p. 354):
if a is strictly P and a ~_P b, then b is tolerantly P.
The tolerance principle ∀x∀y(P(x) ∧ x~_Py → P(y)) is t-valid.
Proof structure: strict-at-a + sim(a,b) gives classical-at-b (via the strict clause); classical implies tolerant.
Two-step tolerance (Fact 3 of @cite{cobreros-etal-2012}, p. 354):
tolerance propagates across two similarity steps. The third step
can fail because ~_P is non-transitive — paper footnote 4
illustrates this on the 4-element model with Pa, a~b, b~c, c~d
where Pd is NOT tolerantly true.
Proof: strict(a) + sim(a,b) gives classical(b); then b witnesses tolerant(c) via sim(c,b) (by symmetry).
Borderline: in the tolerant extension but not the strict.
Definition 10 (p. 355): b(P)^M := ⟦P⟧ᵗ \ ⟦P⟧ˢ. We adopt this
set-difference form as canonical; the equivalent paraconsistent
characterisation tolerant P ∧ tolerant ¬P follows from Definition
9's negation clause (tolerant ¬P ↔ ¬strict P) and is recorded as
IsBorderline.iff_tolerant_pair below.
Equations
Instances For
Borderline iff witnesses on both sides of the classical extension in the similarity neighbourhood. This is the structural reading underlying paper p. 355's discussion of borderline-as-disagreement.
The tolerance neighborhood of a under P as a SpecSpace.
Reflexivity of ~_P ensures a is in its own neighbourhood, so the
admissible Finset is non-empty.
This makes TCS a localized supervaluation: each individual gets its own specification space (the rough-set / tolerance-approximation "granule" around it).
Equations
- Semantics.Supervaluation.TCS.toleranceSpace M P a = { admissible := Finset.filter (M.sim P a) Finset.univ, nonempty := ⋯ }
Instances For
Strict truth = super-truth over the tolerance neighborhood.
P is strict at a iff P is super-true (true at every spec point)
over a's tolerance space. The central architectural connection to
Supervaluation/Basic.lean.
¬Tolerant = super-false over the tolerance neighborhood.
Borderline = supervaluationally indeterminate over the tolerance
neighborhood. Connects TCS to @cite{fine-1975}: borderline cases are
exactly where the tolerance neighborhood disagrees on P.
Equations
- Semantics.Supervaluation.TCS.instDecidableEqSatMode x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯
Equations
- One or more equations did not get rendered due to their size.
Instances For
Equations
Equations
The dual operation on modes: tolerant ↔ strict, classical fixed.
Encodes the mutual recursion of Definition 9: M ⊨ᵗ ¬φ iff M ⊭ˢ φ.
Equations
Instances For
dual is an involution. Packaged as Function.Involutive so
downstream consumers can use mathlib's involution machinery.
Three-valued satisfaction (Definition 9 full). The propositional
fragment of Definition 9, dispatching on mode at atoms and threading
SatMode.dual through negation. Similarity atoms a I_P b are
classically interpreted regardless of mode (Definition 8 +
standing assumption above Definition 9).
Equations
- One or more equations did not get rendered due to their size.
- Semantics.Supervaluation.TCS.Sat M x✝ (Core.Logic.ThreeValuedLogic.PropFormula.atom (Semantics.Supervaluation.TCS.TCSAtom.sim P a b)) = M.sim P a b
- Semantics.Supervaluation.TCS.Sat M Semantics.Supervaluation.TCS.SatMode.classical (Core.Logic.ThreeValuedLogic.PropFormula.atom (Semantics.Supervaluation.TCS.TCSAtom.pred P a)) = M.interp P a
- Semantics.Supervaluation.TCS.Sat M x✝ φ.neg = ¬Semantics.Supervaluation.TCS.Sat M x✝.dual φ
- Semantics.Supervaluation.TCS.Sat M x✝ (φ.conj ψ) = (Semantics.Supervaluation.TCS.Sat M x✝ φ ∧ Semantics.Supervaluation.TCS.Sat M x✝ ψ)
Instances For
Lemma 1 (paper p. 357, formula level): for any TCS formula φ, strict satisfaction implies classical, and classical implies tolerant. Both directions must be proved together because the negation case for one direction needs the contrapositive of the other.
For predicate atoms this is the atomic Lemma 1 (StrictAt.imp_classical,
TolerantAt.of_classical). For similarity atoms all three modes
agree (similarity predicates are uniformly classical). The negation
case turns into a dual-swap; conjunction is pointwise.
An identity T-model: similarity is propositional equality. Paper Lemma 2 (p. 357): every C-model can be expanded to a T-model where t/c/s satisfaction coincide.
The construction is parameterised by an interp and produces the
T-model whose similarity relation is (· = ·).
Equations
- Semantics.Supervaluation.TCS.identityModel interp = { interp := interp, decInterp := inferInstance, sim := fun (x : Pred) (d₁ d₂ : D) => d₁ = d₂, sim_refl := ⋯, sim_symm := ⋯ }
Instances For
In an identity model, tolerant atomic = classical.
In an identity model, strict atomic = classical.
Lemma 2 (formula level): all three modes agree in an identity model, for every formula.
Mixed TCS-consequence (Definition 17 of @cite{cobreros-etal-2012}):
Γ ⊨ᵐⁿ φ iff every T-model that m-satisfies all premises also
n-satisfies the conclusion. The nine combinations (m, n ∈ {t, c, s})
yield the nine consequence relations.
Specialisation of Core.Logic.Consequence.MixedConsequence. As an
abbrev so the substrate API surface (mixed_monotone, etc.) is
reachable without unfold.
Equations
Instances For
The atomic-level SatImplies witnesses for the three pairwise
implications among satisfaction modes. These lift the formula-level
Lemma 1 (Sat.strict_imp_classical etc.) into the abstract
SatImplies shape that MixedConsequence's monotonicity API
consumes.
Lemma 7, premise-mode clause (p. 368): premise-mode strengthening
coarsens consequence: ⊨ᵗᵐ ⊆ ⊨ᶜᵐ ⊆ ⊨ˢᵐ for any conclusion mode m.
The "first/second part" decomposition is the formaliser's exposition;
the paper states both clauses as a single result.
Lemma 7, conclusion-mode clause (p. 368): conclusion-mode weakening
coarsens consequence: ⊨ᵐˢ ⊆ ⊨ᵐᶜ ⊆ ⊨ᵐᵗ for any premise mode m.
A TCS formula is restricted if it uses only predicate atoms.
Paper §2 (p. 356) defines the restricted vocabulary as formulas
free of BOTH I_P (similarity) atoms AND = (identity) atoms;
this Lean substrate has no = constructor on TCSAtom, so this
predicate captures only the no-I_P half of the paper's restriction.
For the propositional fragment under consideration here, the two
coincide.
On this fragment the Lemma 8 collapse holds (paper §3.3.1, p. 369,
states ⊨ˢᵗ ⇒ ⊨ᶜᶜ, and combined with Lemma 7 monotonicity gives
cc = sc = ct = st). With similarity (or identity) atoms in the
language, ALL NINE consequence relations of Definition 17 become
genuinely distinct (paper §3.4 full-vocabulary diagram, p. 371);
the four strongest (cc, sc, ct, st) are demonstrated distinct in
paper §3.4 via the one-step tolerance inference {Pa, aI_Pb} ⊨ Pb.
Equations
- Semantics.Supervaluation.TCS.IsRestricted (Core.Logic.ThreeValuedLogic.PropFormula.atom (Semantics.Supervaluation.TCS.TCSAtom.pred a a_1)) = True
- Semantics.Supervaluation.TCS.IsRestricted (Core.Logic.ThreeValuedLogic.PropFormula.atom (Semantics.Supervaluation.TCS.TCSAtom.sim a a_1 a_2)) = False
- Semantics.Supervaluation.TCS.IsRestricted φ.neg = Semantics.Supervaluation.TCS.IsRestricted φ
- Semantics.Supervaluation.TCS.IsRestricted (φ.conj ψ) = (Semantics.Supervaluation.TCS.IsRestricted φ ∧ Semantics.Supervaluation.TCS.IsRestricted ψ)
Instances For
Lemma 8, st ⟹ cc on restricted formulas (paper p. 369): the heart of the collapse. An st-counterexample to a cc-claim survives in the identity model where all modes agree.
The restriction to IsRestricted formulas is essential — paper §3.4
(p. 371) shows all nine consequence relations are distinct in the
full vocabulary.
cc ⟹ st by monotonicity (Lemma 7, twice). Holds unrestricted.
Lemma 8 cc ↔ st on restricted formulas: classical consequence collapses with strict-to-tolerant.
Lemma 8 cc ↔ sc on restricted formulas: sandwiching via Lemma 7.
Lemma 8 cc ↔ ct on restricted formulas: the dual sandwich.
Remark 1 (p. 353): satisfaction-level duality. Negation swaps
the satisfaction mode via dual: M ⊨ᵐ ¬φ ↔ ¬ M ⊨^{dual m} φ.
Definitionally true from Sat.neg_eq.
Note: the abstract Core.Logic.Bilateral.SatDuality structure
requires neg to be a syntactic involution (¬¬φ = φ). TCSFormula
negation is NOT syntactically involutive (we have .neg (.neg φ),
not φ), so the abstract structure does not literally apply. The
semantic-level swap is what's needed downstream and is proved here
directly.
Lemma 10 self-dual witnesses: the consequence relations satisfying
m = dual n (equivalently n = dual m) are exactly the self-dual ones,
and these are exactly the ones for which the deduction theorem holds.
For TCS this gives st, ts, and cc.
The MV-model construction of Lemma 4 (p. 361). Each TCS atom is
classified into Strong Kleene's {true, false, indet}:
pred P a→.trueifStrictAt M P a,.falseif¬TolerantAt M P a,.indetotherwise (borderline).sim P a b→ classical:.trueif similar,.falseotherwise.
Definition is noncomputable because strictness/tolerance are not
decidable in general (only when D is finite and sim is decidable).
The local Classical.propDecidable instance makes the if-then-else
well-typed; every theorem about toMV remains constructive.
Equations
- One or more equations did not get rendered due to their size.
- Semantics.Supervaluation.TCS.toMV M (Semantics.Supervaluation.TCS.TCSAtom.sim P a b) = if M.sim P a b then Core.Duality.Truth3.true else Core.Duality.Truth3.false
Instances For
Lemma 4 (p. 361, formula-level): for every T-model M and TCS
formula φ,
M ⊨ᵗ φ ↔ mvEval (toMV M) φis LP-designated (non-false)M ⊨ˢ φ ↔ mvEval (toMV M) φis K3-designated (= true)
The two halves are proved by mutual induction. The negation case
uses lpSat_neg_iff/k3Sat_neg_iff from the substrate; the
conjunction case uses lpSat_conj/k3Sat_conj.
Lemma 4, t-direction: tolerant satisfaction = LP-satisfaction
via toMV.
Lemma 4, s-direction: strict satisfaction = K3-satisfaction
via toMV.
Theorem 3 (paper p. 362, consequence-level): on the restricted
propositional vocabulary, t-consequence equals LP-consequence and
s-consequence equals K3-consequence (modulo the toMV translation
on premise/conclusion). The forward direction lifts Lemma 4
pointwise; the reverse direction uses the same toMV.
Schema theorems for the non-transitivity demonstration. With similarity atoms in the formula language, we can now state and prove the structural pattern of paper §3.4.1: each one-step / two-step sorites inference is individually valid in mixed consequence, but chaining past Fact 3's two-step limit fails.
Attribution caveat: the paper's §3.4.1 demonstration of
non-transitivity is for `⊨ᶜᵗ` (the corresponding chain `Pa, aI_Pb,
bI_Pc ⊭ᶜᵗ Pc`). The `⊨ˢᵗ` version of the sorites is stated separately
in paper §3.6 (Version 1 of the sorites, p. 376). The structural
pattern — each step valid in isolation, chain fails — is what §3.4.1
contributes; the `st`-instantiation here applies the same pattern to
the relation the paper ultimately advocates (paper p. 373: "st" is
the best-motivated choice).
Each one-step inference `[Pa, a I_P b] ⊨ˢᵗ Pb` is st-valid (Fact 2 of
the paper, p. 354). Two such inferences chain to give
`[Pa, a I_P b, b I_P c] ⊨ˢᵗ Pc` via Fact 3 (two-step tolerance,
p. 354). But three steps cannot be chained: on a model where `~_P`
exhausts at two steps, `[Pa, a I_P b, b I_P c, c I_P d] ⊭ˢᵗ Pd`. The
Studies file instantiates this on the 4-element model from p. 354.
Convenience: Pa, a I_P b ⊨ˢᵗ Pb is st-valid for every T-model
(one-step tolerance, schema form). Consumes paper Fact 2.
Two-step tolerance is st-valid in schema form. Consumes paper Fact 3.
Cross-framework divergence between TCS and Fine 1975 supervaluationism
on borderline contradictions: TCS makes P ∧ ¬P tolerantly true while
supervaluation makes it super-FALSE on the same neighbourhood. Both
ingredients exist in the substrate (TolerantAt,
nonContradiction_superFalse); this section combines them into a
Lean-checkable existential divergence claim.
Comparator caveat: the paper's headline borderline-contradiction
contrast (p. 356) is actually with **Hyde 1997 subvaluationism**, NOT
with Fine 1975 supervaluationism. Subvaluation and TCS *agree* that
`P ∧ ¬P` holds at borderline cases; they disagree on the underlying
framework. The contrast formalised here — TCS vs supervaluation —
is the *formal-validity-side* contrast (paper p. 359, where TCS's
*t*/*s*-validity diverge from supervaluationist validity in the
quantifier-pattern sense). Subvaluationism is not formalised in
linglib; if it were, a NEW divergence theorem on the
framework-foundations axis would be the right comparator on the
*verdict* question.
A concrete instantiation on the paper's 4-element model is provided
in `Phenomena/Gradability/Studies/CobrerosEtAl2012.lean`.
TCS-vs-Supervaluation borderline-contradiction divergence (schema
form): for any T-model M, predicate P, and individual a that
is borderline-P, the conjunction P(a) ∧ ¬P(a) is tolerantly
true at a in TCS while the supervaluation of the same conjunction
over the tolerance neighborhood is super-FALSE.
The two frameworks DISAGREE on the formal-validity-side verdict of
borderline contradictions: TCS at t mode says ✓, supervaluation
says ✗ everywhere. (Note: on the verdict question, the paper's
headline contrast is with subvaluationism; see the section docstring.)
Paracomplete dual (schema form): on the same borderline cases,
¬(P ∧ ¬P) (i.e., excluded middle in dual form) fails strictly.
Note that strict satisfaction is the paracomplete dual of
tolerant: in TCS, borderline cases satisfy P ∧ ¬P tolerantly
AND fail to satisfy classical principles strictly.