Documentation

Linglib.Core.Logic.Modal.Dependence

Modal Dependence Logic (MDL) #

[Vaa08] [Vaa07]

MDL is the modal extension of dependence logic introduced in [Vaa08] ("Modal Dependence Logic", in Apt & van Rooij eds. New Perspectives on Games and Interaction, pp. 237-254). It adds a dependence atom =(p₁,...,pₙ; q) to classical modal logic, meaning "the value of q is functionally determined by the values of p₁,...,pₙ across the team."

The framework is grounded in Väänänen's foundational [Vaa07] (the Dependence Logic book, Cambridge University Press 2007), which develops the first-order team-semantic apparatus that MDL adapts to modal logic. Where the book's quantifiers range over assignments, MDL's modalities range over Kripke worlds — but the team-semantic skeleton (formulas as predicates of teams, downward closure, dependence atoms) transfers directly.

MDL is studied for its computational and model-theoretic properties (satisfiability complexity in [LV13] and Sevenster's earlier expressive-power work; bisimulation invariance), with applications in database theory, knowledge representation, and AI rather than primarily in linguistic semantics — hence the placement in Core/Logic/ rather than Semantics/, alongside the other team-semantic primitives (Core/Logic/Team/, Core/Logic/Bilateral/).

What changes from BSML #

MDL and BSML share a bilateral semantics (Player II = support, Player I = anti-support, negation flips polarity per [Vaa08] clause (T5)) and the same Kripke-model carrier. The structural differences:

Closure profile #

MDL's closure profile differs from BSML's, placing it in a different cell of the closure-property lattice:

PropertyBSML (NE-free)BSML (with NE)MDL
IsLowerSetbroken by NE✓ (Lemma 4.2)
SupClosedbroken by dep
∅ ∈ support

The dep atom is downward-closed (subteam of a functionally-dependent team is functionally dependent) but breaks union-closure (two functionally-dependent teams may have conflicting y values at worlds with matching x⃗).

Main declarations #

Implementation notes #

The MDL eval uses Väänänen's exact clauses, not BSML's. The disjunction clause is the under-DC simplified form X = Y ∪ Z (paper's (T6)' under Lemma 4.2 part 1) rather than the literal X ⊆ Y ∪ Z from (T6); under downward closure they are equivalent.

The KripkeModel carrier from Core/Logic/Modal/Kripke.lean is the shared substrate; BSML, QBSML, and the AAY-2024 extensions (BSMLOr/BSMLEmpty) alias BSMLModel := KripkeModel for literature compatibility.

Sibling logics in Core/Logic/Modal/ #

This directory houses modal-logic variants that share Kripke-model infrastructure but differ in atom flavor:

The bisimulation substrate currently lives at Core/Logic/Modal/BSML/Bisimulation.lean for historical reasons; a future refactor lifts it to Core/Logic/Modal/Bisimulation.lean.

Todo #

Syntax (Definition 1.1) #

inductive Core.Logic.Modal.Dependence.Formula (Atom : Type u_3) :
Type u_3

MDL syntax (Definition 1.1 of [Vaa08]): classical modal logic extended with the dependence atom =(p₁,...,pₙ; q).

and binary are abbreviations (the paper's □A := ¬◇¬A and A ∧ B := ¬(¬A ∨ ¬B)). We include conj as a primitive constructor here for ergonomic parallelism with BSML, with the semantic clauses matching what the abbreviations would yield.

  • atom {Atom : Type u_3} (p : Atom) : Formula Atom

    Atomic proposition.

  • dep {Atom : Type u_3} (xs : List Atom) (y : Atom) : Formula Atom

    Dependence atom =(x⃗; y): values of y in the team are functionally determined by values of x⃗.

  • neg {Atom : Type u_3} (φ : Formula Atom) : Formula Atom

    Bilateral negation: swap support/anti-support.

  • conj {Atom : Type u_3} (φ ψ : Formula Atom) : Formula Atom

    Conjunction.

  • disj {Atom : Type u_3} (φ ψ : Formula Atom) : Formula Atom

    Tensor disjunction (team-split form under downward closure).

  • poss {Atom : Type u_3} (φ : Formula Atom) : Formula Atom

    Possibility modal .

Instances For
    def Core.Logic.Modal.Dependence.instReprFormula.repr {Atom✝ : Type u_3} [Repr Atom✝] :
    Formula Atom✝Std.Format
    Equations
    • One or more equations did not get rendered due to their size.
    Instances For
      @[implicit_reducible]
      instance Core.Logic.Modal.Dependence.instReprFormula {Atom✝ : Type u_3} [Repr Atom✝] :
      Repr (Formula Atom✝)
      Equations

      Semantics (Definition 4.1) #

      def Core.Logic.Modal.Dependence.eval {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) :
      BoolFormula AtomFinset WProp

      Bilateral evaluation for MDL (Definition 4.1 of [Vaa08]). eval M true φ t is support (Player II); eval M false φ t is anti-support (Player I). Negation flips polarity (clause (T5)).

      The ◇ clauses (T8), (T9) use Väänänen's single-witness form, not BSML's per-world form; the two formulations diverge for non-union- closed logics like MDL.

      Equations
      Instances For
        @[reducible, inline]
        abbrev Core.Logic.Modal.Dependence.support {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) (t : Finset W) :

        Support: positive evaluation.

        Equations
        Instances For
          @[reducible, inline]
          abbrev Core.Logic.Modal.Dependence.antiSupport {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) (t : Finset W) :

          Anti-support: negative evaluation.

          Equations
          Instances For
            @[simp]
            theorem Core.Logic.Modal.Dependence.support_atom {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (p : Atom) (t : Finset W) :
            support M (Formula.atom p) t wt, M.val p w = true
            @[simp]
            theorem Core.Logic.Modal.Dependence.antiSupport_atom {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (p : Atom) (t : Finset W) :
            antiSupport M (Formula.atom p) t wt, M.val p w = false
            @[simp]
            theorem Core.Logic.Modal.Dependence.support_dep {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (xs : List Atom) (y : Atom) (t : Finset W) :
            support M (Formula.dep xs y) t w₁t, w₂t, (∀ xxs, M.val x w₁ = M.val x w₂)M.val y w₁ = M.val y w₂
            @[simp]
            theorem Core.Logic.Modal.Dependence.antiSupport_dep {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (xs : List Atom) (y : Atom) (t : Finset W) :
            antiSupport M (Formula.dep xs y) t t =
            @[simp]
            theorem Core.Logic.Modal.Dependence.support_neg {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) (t : Finset W) :
            support M φ.neg t antiSupport M φ t
            @[simp]
            theorem Core.Logic.Modal.Dependence.antiSupport_neg {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) (t : Finset W) :
            antiSupport M φ.neg t support M φ t
            @[simp]
            theorem Core.Logic.Modal.Dependence.support_conj {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ ψ : Formula Atom) (t : Finset W) :
            support M (φ.conj ψ) t support M φ t support M ψ t
            @[simp]
            theorem Core.Logic.Modal.Dependence.antiSupport_conj {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ ψ : Formula Atom) (t : Finset W) :
            antiSupport M (φ.conj ψ) t ∃ (t₁ : Finset W) (t₂ : Finset W), Team.splitsAs t t₁ t₂ antiSupport M φ t₁ antiSupport M ψ t₂
            @[simp]
            theorem Core.Logic.Modal.Dependence.support_disj {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ ψ : Formula Atom) (t : Finset W) :
            support M (φ.disj ψ) t ∃ (t₁ : Finset W) (t₂ : Finset W), Team.splitsAs t t₁ t₂ support M φ t₁ support M ψ t₂
            @[simp]
            theorem Core.Logic.Modal.Dependence.antiSupport_disj {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ ψ : Formula Atom) (t : Finset W) :
            antiSupport M (φ.disj ψ) t antiSupport M φ t antiSupport M ψ t
            @[simp]
            theorem Core.Logic.Modal.Dependence.support_poss {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) (t : Finset W) :
            support M φ.poss t ∃ (Y : Finset W), (∀ wt, yY, y M.access w) support M φ Y
            @[simp]
            theorem Core.Logic.Modal.Dependence.antiSupport_poss {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) (t : Finset W) :
            antiSupport M φ.poss t antiSupport M φ (t.biUnion M.access)
            theorem Core.Logic.Modal.Dependence.isBilateral {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) :

            MDL's support/antiSupport form a paraconsistent bilateral logic under Formula.neg.

            Modal depth of an MDL formula. Atoms and dep atoms are 0; neg preserves depth; conj and disj take max; poss increments.

            Equations
            Instances For

              Lemma 4.2: Downward closure #

              theorem Core.Logic.Modal.Dependence.isLowerSet_support {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) :
              IsLowerSet {t : Finset W | support M φ t}

              Lemma 4.2 of [Vaa08]: every MDL formula's support is downward-closed. The defining closure property of the dependence family — what BSML loses when it adds NE.

              Empty team property #

              theorem Core.Logic.Modal.Dependence.support_empty {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} (M : KripkeModel W Atom) (φ : Formula Atom) :
              support M φ

              Every MDL formula is supported on the empty team.

              Dep breaks union closure (the defining feature) #

              theorem Core.Logic.Modal.Dependence.not_supClosed_dep_of_witness {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} {p q : Atom} {w₁ w₂ : W} {M : KripkeModel W Atom} (_hp : M.val p w₁ = M.val p w₂) (hq : M.val q w₁ M.val q w₂) :
              ¬SupClosed {t : Finset W | support M (Formula.dep [p] q) t}

              The dep atom is not union-closed: a constructive counterexample. Take a model with at least two worlds w₁, w₂ where M.val p w₁ = M.val p w₂ but M.val q w₁ ≠ M.val q w₂. Then {w₁} and {w₂} each support =(p; q) vacuously (each is a singleton, so the functional-dependence condition is trivial), but {w₁, w₂} does not.

              Soundness for the closure cell (Definability bridge) #

              MDL is sound for its closure cell: every MDL-definable team property is downward-closed and has the empty-team property. The dependence family occupies the downward-closed, empty-team cell ([Vaa08]; [Ant25]) — dep breaks union closure (see not_supClosed_dep_of_witness) but preserves downward closure.

              Composes isLowerSet_support (Lemma 4.2) and support_empty through the Team/Definability.lean bridge. The converse (every such property is MDL-definable) is the open half.

              Bisimulation invariance (Väänänen-style ◇) #

              MDL's modality differs from BSML's: anti- uses the union of accessibility images (clause (T9)), and -support a single witness team (clause (T8)), rather than BSML's per-world sub-witnesses. The invariance proof therefore recurses through StateBisim.biUnionAccess and StateBisim.possWitness (the carrier-level Lemma 3.7 analogues in Core/Logic/Modal/Bisimulation.lean) at the modal step, where BSML uses StateBisim.accessImage / exists_image_subset. The dependence-atom case is depth-0 and turns on WorldBisim.val_eq: state bisim preserves the set of atom-valuation profiles realised in a team, and functional dependence is a property of that set.

              theorem Core.Logic.Modal.Dependence.bisim_invariant_eval {W : Type u_1} [DecidableEq W] [Fintype W] {Atom : Type u_2} {W' : Type u_3} [DecidableEq W'] [Fintype W'] (φ : Formula Atom) {k : } :
              φ.modalDepth k∀ {M : KripkeModel W Atom} {M' : KripkeModel W' Atom} {s : Finset W} {s' : Finset W'}, StateBisim k M s M' s'∀ (b : Bool), eval M b φ s eval M' b φ s'

              Bisimulation invariance for MDL (the [AAY24] Theorem 3.8 analogue for [Vaa08]'s modal dependence logic): if s ⇌_k s' and φ has modal depth ≤ k, then eval M b φ s ↔ eval M' b φ s' for both polarities.

              Second consumer of the carrier-level bisimulation substrate (after BSML), which is what licensed lifting it out of BSML/.