Documentation

Linglib.Theories.Semantics.Supervaluation.TCS

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:

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:

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) #

Cross-framework comparators (paper p. 356, p. 359) #

The paper draws TWO distinct contrasts on the borderline-contradictions question, with two different opponents:

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.

structure Semantics.Supervaluation.TCS.TModel (D : Type u_1) (Pred : Type u_2) :
Type (max u_1 u_2)

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 : PredDProp

    Classical interpretation I : Pred → D → Prop.

  • decInterp (P : Pred) (d : D) : Decidable (self.interp P d)

    Decidability of the interpretation (per predicate, per individual). Bundled so each TModel instance carries its own decision procedure.

  • sim : PredDDProp

    Tolerance (indifference) relation ~_P per 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
    @[implicit_reducible]
    instance Semantics.Supervaluation.TCS.TModel.instDecidablePredInterp {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) :
    DecidablePred (M.interp P)

    Per-TModel decidability instance for the classical interpretation, extracted from the bundled decInterp field.

    Equations
    @[reducible]

    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).

    Equations
    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.

      inductive Semantics.Supervaluation.TCS.TCSAtom (Pred : Type u_1) (D : Type u_2) :
      Type (max u_1 u_2)

      Atoms of the propositional restricted vocabulary of TCS. Two constructors per Definitions 8-9 of @cite{cobreros-etal-2012}:

      • pred P aP(a) — predicate application; t/c/s satisfaction clauses depend on the mode (Definition 9).
      • sim P a ba 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).
      Instances For
        @[reducible, inline]
        abbrev Semantics.Supervaluation.TCS.TCSFormula (Pred : Type u_1) (D : Type u_2) :
        Type (max u_2 u_1)

        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
          def Semantics.Supervaluation.TCS.StrictAt {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :

          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
          Instances For
            def Semantics.Supervaluation.TCS.TolerantAt {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :

            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
            Instances For
              theorem Semantics.Supervaluation.TCS.strictAt_eq_boxR {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :
              StrictAt M P a = Core.Logic.Intensional.boxR (M.simAccess P) (fun (d : D) => M.interp P d) a

              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.

              theorem Semantics.Supervaluation.TCS.tolerantAt_eq_diamondR {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :
              TolerantAt M P a = Core.Logic.Intensional.diamondR (M.simAccess P) (fun (d : D) => M.interp P d) a

              Tolerant atom = diamondR over the similarity frame. Definitional.

              theorem Semantics.Supervaluation.TCS.StrictAt.imp_classical {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) (hs : StrictAt M P a) :
              M.interp P a

              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.

              theorem Semantics.Supervaluation.TCS.TolerantAt.of_classical {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) (hc : M.interp P a) :

              Classical ⟹ tolerant at the atomic level: a itself witnesses the existential by reflexivity of ~_P.

              theorem Semantics.Supervaluation.TCS.StrictAt.imp_tolerant {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) (hs : StrictAt M P a) :

              Strict ⟹ tolerant (transitive from above).

              theorem Semantics.Supervaluation.TCS.tolerance_one_step {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a b : D) (hs : StrictAt M P a) (hsim : M.sim P a b) :

              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.

              theorem Semantics.Supervaluation.TCS.tolerance_two_step {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a b c : D) (hs : StrictAt M P a) (hab : M.sim P a b) (hbc : M.sim P b c) :

              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).

              def Semantics.Supervaluation.TCS.IsBorderline {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :

              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
                theorem Semantics.Supervaluation.TCS.IsBorderline.iff_both_witnesses {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :
                IsBorderline M P a (∃ (d : D), M.sim P a d M.interp P d) ∃ (d : D), M.sim P a d ¬M.interp P d

                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.

                def Semantics.Supervaluation.TCS.toleranceSpace {D : Type u_1} {Pred : Type u_2} [Fintype D] (M : TModel D Pred) (P : Pred) (a : D) [DecidablePred (M.sim P a)] :

                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
                Instances For
                  theorem Semantics.Supervaluation.TCS.StrictAt.iff_superTrue {D : Type u_1} {Pred : Type u_2} [Fintype D] (M : TModel D Pred) (P : Pred) (a : D) [DecidablePred (M.sim P a)] :

                  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.

                  theorem Semantics.Supervaluation.TCS.TolerantAt.not_iff_superFalse {D : Type u_1} {Pred : Type u_2} [Fintype D] (M : TModel D Pred) (P : Pred) (a : D) [DecidablePred (M.sim P a)] :

                  ¬Tolerant = super-false over the tolerance neighborhood.

                  theorem Semantics.Supervaluation.TCS.IsBorderline.iff_superTrue_indet {D : Type u_1} {Pred : Type u_2} [Fintype D] (M : TModel D Pred) (P : Pred) (a : D) [DecidablePred (M.sim P a)] :

                  Borderline = supervaluationally indeterminate over the tolerance neighborhood. Connects TCS to @cite{fine-1975}: borderline cases are exactly where the tolerance neighborhood disagrees on P.

                  The three satisfaction modes of @cite{cobreros-etal-2012}.

                  Instances For
                    @[implicit_reducible]
                    Equations
                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For

                      dual is an involution. Packaged as Function.Involutive so downstream consumers can use mathlib's involution machinery.

                      def Semantics.Supervaluation.TCS.Sat {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) :
                      SatModeTCSFormula Pred DProp

                      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
                      Instances For
                        @[simp]
                        theorem Semantics.Supervaluation.TCS.Sat.atom_sim {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (m : SatMode) (P : Pred) (a b : D) :
                        @[simp]
                        theorem Semantics.Supervaluation.TCS.Sat.neg_eq {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (m : SatMode) (φ : TCSFormula Pred D) :
                        @[simp]
                        theorem Semantics.Supervaluation.TCS.Sat.conj_eq {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (m : SatMode) (φ ψ : TCSFormula Pred D) :
                        Sat M m (Core.Logic.ThreeValuedLogic.PropFormula.conj φ ψ) = (Sat M m φ Sat M m ψ)
                        theorem Semantics.Supervaluation.TCS.Sat.hierarchy {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (φ : TCSFormula Pred D) :

                        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.

                        theorem Semantics.Supervaluation.TCS.Sat.strict_imp_classical {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (φ : TCSFormula Pred D) :
                        theorem Semantics.Supervaluation.TCS.Sat.strict_imp_tolerant {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (φ : TCSFormula Pred D) :
                        def Semantics.Supervaluation.TCS.identityModel {D : Type u_1} {Pred : Type u_2} (interp : PredDProp) [(P : Pred) → (d : D) → Decidable (interp P d)] :
                        TModel D Pred

                        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
                        Instances For
                          theorem Semantics.Supervaluation.TCS.identityModel.tolerantAt_iff {D : Type u_1} {Pred : Type u_2} (interp : PredDProp) [(P : Pred) → (d : D) → Decidable (interp P d)] (P : Pred) (a : D) :
                          TolerantAt (identityModel interp) P a interp P a

                          In an identity model, tolerant atomic = classical.

                          theorem Semantics.Supervaluation.TCS.identityModel.strictAt_iff {D : Type u_1} {Pred : Type u_2} (interp : PredDProp) [(P : Pred) → (d : D) → Decidable (interp P d)] (P : Pred) (a : D) :
                          StrictAt (identityModel interp) P a interp P a

                          In an identity model, strict atomic = classical.

                          theorem Semantics.Supervaluation.TCS.identityModel.modes_agree {D : Type u_1} {Pred : Type u_2} (interp : PredDProp) [(P : Pred) → (d : D) → Decidable (interp P d)] (mode : SatMode) (φ : TCSFormula Pred D) :
                          Sat (identityModel interp) mode φ Sat (identityModel interp) SatMode.classical φ

                          Lemma 2 (formula level): all three modes agree in an identity model, for every formula.

                          @[reducible, inline]
                          abbrev Semantics.Supervaluation.TCS.tcsConsequence {D : Type u_1} {Pred : Type u_2} (m n : SatMode) (Γ : List (TCSFormula Pred D)) (φ : TCSFormula Pred D) :

                          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.

                            def Semantics.Supervaluation.TCS.IsRestricted {D : Type u_1} {Pred : Type u_2} :
                            TCSFormula Pred DProp

                            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
                            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.

                              theorem Semantics.Supervaluation.TCS.Sat.neg_swap {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (m : SatMode) (φ : TCSFormula Pred D) :

                              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.

                              noncomputable def Semantics.Supervaluation.TCS.toMV {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) :

                              The MV-model construction of Lemma 4 (p. 361). Each TCS atom is classified into Strong Kleene's {true, false, indet}:

                              • pred P a.true if StrictAt M P a, .false if ¬TolerantAt M P a, .indet otherwise (borderline).
                              • sim P a b → classical: .true if similar, .false otherwise.

                              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
                              Instances For
                                theorem Semantics.Supervaluation.TCS.toMV_pred_true_iff {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :
                                theorem Semantics.Supervaluation.TCS.toMV_pred_false_iff {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a : D) :
                                theorem Semantics.Supervaluation.TCS.toMV_sim_true_iff {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a b : D) :
                                theorem Semantics.Supervaluation.TCS.toMV_sim_false_iff {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (P : Pred) (a b : D) :
                                toMV M (TCSAtom.sim P a b) = Core.Duality.Truth3.false ¬M.sim P a b

                                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.

                                theorem Semantics.Supervaluation.TCS.strict_iff_k3Sat {D : Type u_1} {Pred : Type u_2} (M : TModel D Pred) (φ : TCSFormula Pred D) :

                                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.

                                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`. 
                                
                                theorem Semantics.Supervaluation.TCS.tcs_vs_supervaluation_borderline_contradiction {D : Type u_1} {Pred : Type u_2} [Fintype D] [DecidableEq D] (M : TModel D Pred) (P : Pred) (a : D) [DecidablePred (M.sim P a)] (hb : IsBorderline M P a) :

                                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.