Documentation

Linglib.Phenomena.Quantification.Studies.Montague1973

Types of Intensional Logic (Definition 1)

The set of types is the smallest set Y such that:

We use the canonical Semantics.Montague.Ty which has:

def Montague1973.«term𝐞» :
Lean.ParserDescr
Equations
Instances For
    def Montague1973.«term𝐭» :
    Lean.ParserDescr
    Equations
    Instances For
      def Montague1973.«term⦃_,_⦄» :
      Lean.ParserDescr
      Equations
      • One or more equations did not get rendered due to their size.
      Instances For
        def Montague1973.«term⦃𝐬,_⦄» :
        Lean.ParserDescr
        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          @[reducible, inline]

          Common derived types

          Equations
          Instances For

            Syntactic Categories

            Basic categories: t (sentences), e (entity-denoting), CN (common nouns), IV (intransitive verbs) Derived categories: A/B and A//B (slash categories)

            The double slash // is for "intensional" arguments (take intensions).

            Instances For
              def Montague1973.instDecidableEqCat.decEq (x✝ x✝¹ : Cat) :
              Decidable (x✝ = x✝¹)
              Equations
              Instances For
                @[implicit_reducible]
                Equations
                def Montague1973.instReprCat.repr :
                CatStd.Format
                Equations
                Instances For
                  def Montague1973.«term_/'_» :
                  Lean.TrailingParserDescr
                  Equations
                  • Montague1973.«term_/'_» = Lean.ParserDescr.trailingNode `Montague1973.«term_/'_» 1022 0 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " /' ") (Lean.ParserDescr.cat `term 0))
                  Instances For
                    def Montague1973.«term_\'_» :
                    Lean.TrailingParserDescr
                    Equations
                    • Montague1973.«term_\'_» = Lean.ParserDescr.trailingNode `Montague1973.«term_\'_» 1022 0 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " \\' ") (Lean.ParserDescr.cat `term 0))
                    Instances For
                      def Montague1973.«term_//'_» :
                      Lean.TrailingParserDescr
                      Equations
                      • Montague1973.«term_//'_» = Lean.ParserDescr.trailingNode `Montague1973.«term_//'_» 1022 0 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " //' ") (Lean.ParserDescr.cat `term 0))
                      Instances For

                        The function f from categories to types.

                        This is the core of the syntax-semantics interface. Each syntactic category corresponds to a semantic type.

                        Key mappings:

                        • f(e) = e
                        • f(t) = t
                        • f(CN) = f(IV) = ⟨s, ⟨e, t⟩⟩ (intensions of properties)
                        • f(T) = ⟨⟨s, ⟨e, t⟩⟩, t⟩ (generalized quantifiers over property intensions)
                        • f(A/B) = ⟨⟨s, f(B)⟩, f(A)⟩ (functions from intensions of B to A)
                        Equations
                        Instances For

                          Term phrases (T) denote generalized quantifiers.

                          "Every man" doesn't denote an entity; it denotes a function that takes a property (intension) and returns true iff every man has that property.

                          @[reducible, inline]

                          Intensional Frame

                          A PTQ model uses the canonical Semantics.Montague.Frame which includes:

                          • Entity : domain of entities
                          • Index : possible worlds (indices)
                          Equations
                          Instances For
                            @[reducible, inline]

                            Denotation of a type in a frame (uses canonical Denot)

                            Equations
                            Instances For
                              @[reducible, inline]

                              Intension: function from indices to extensions

                              Equations
                              Instances For

                                Lexical Entry Structure

                                Each word has:

                                • Surface form
                                • Syntactic category
                                • Translation (semantic representation)
                                • form : String
                                • cat : Cat
                                Instances For

                                  Syntactic Rule

                                  A rule specifies:

                                  • Input categories
                                  • Output category
                                  • How to combine the strings (F function)
                                  Instances For
                                    def Montague1973.instDecidableEqSynRule.decEq (x✝ x✝¹ : SynRule) :
                                    Decidable (x✝ = x✝¹)
                                    Equations
                                    Instances For
                                      def Montague1973.instReprSynRule.repr :
                                      SynRuleStd.Format
                                      Equations
                                      Instances For

                                        Translation Rule

                                        Maps syntactic derivations to semantic representations. This is the homomorphism: h : Syntax → Semantics

                                        Instances For
                                          def Montague1973.instDecidableEqTransRule.decEq (x✝ x✝¹ : TransRule) :
                                          Decidable (x✝ = x✝¹)
                                          Equations
                                          Instances For
                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For

                                              Scope Reading

                                              Represents different scope orderings of quantifiers.

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

                                                  A toy model for demonstrating scope ambiguity.

                                                  Two men (m1, m2), two women (w1, w2).

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

                                                        Love relation for surface scope scenario.

                                                        m1 loves w1, m2 loves w2 (different women)

                                                        Equations
                                                        Instances For

                                                          Love relation for inverse scope scenario.

                                                          m1 loves w1, m2 loves w1 (same woman)

                                                          Equations
                                                          Instances For
                                                            def Montague1973.surfaceScopeTrue (love : ToyEntityToyEntityBool) :
                                                            Bool

                                                            Surface scope reading: ∀x[man(x) → ∃y[woman(y) ∧ love(x,y)]]

                                                            "For every man, there exists a woman that he loves."

                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            Instances For
                                                              def Montague1973.inverseScopeTrue (love : ToyEntityToyEntityBool) :
                                                              Bool

                                                              Inverse scope reading: ∃y[woman(y) ∧ ∀x[man(x) → love(x,y)]]

                                                              "There exists a woman such that every man loves her."

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

                                                                Surface scope is true in surface scenario.

                                                                When each man loves a different woman, surface scope is satisfied.

                                                                Inverse scope is false in surface scenario.

                                                                No single woman is loved by all men.

                                                                Both scopes are true in inverse scenario.

                                                                When all men love the same woman, both readings are true.

                                                                Scope ambiguity theorem.

                                                                The two readings are not equivalent - they differ in the surface scenario. This is why "Every man loves a woman" is ambiguous.

                                                                theorem Montague1973.inverse_entails_surface (love : ToyEntityToyEntityBool) :
                                                                inverseScopeTrue love = truesurfaceScopeTrue love = true

                                                                Inverse scope entails surface scope.

                                                                ∃y∀x.R(x,y) → ∀x∃y.R(x,y)

                                                                If there's one woman everyone loves, then certainly each man loves some woman.

                                                                Derivation Tree

                                                                Represents a syntactic derivation with rule applications.

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