形式语义学基础

文档概述

本文档系统介绍形式语义学的核心理论框架与数学基础。从Tarski的真值条件语义学出发，阐述模型论语义学的基本概念、组合性原则的数学表达、λ演算在语义组合中的应用，以及Montague语法的形式化体系。

关键词速览

术语	英文	核心定义
真值条件	Truth Condition	语句为真的条件
模型论	Model Theory	形式语义学的数学基础
组合性原则	Compositionality	整体意义由部分意义组合
λ演算	Lambda Calculus	语义组合的形式工具
Montague语法	Montague Grammar	自然语言的形式语义框架
内涵逻辑	Intensional Logic	处理可能世界的逻辑
指称语义	Denotational Semantics	符号到对象的映射
递归定义	Recursive Definition	语义的归纳定义
外延	Extension	表达式的指称对象
内涵	Intension	表达式的意义函数

---

引言：形式语义学入门——语言和数学之间的桥梁

你有没有想过，当我们说”太阳从东边升起”这句话时，它到底”是”什么？

从形式语义学的视角来看，这句话之所以有意义，是因为它对应着现实世界中的一种状态——在所有我们能够观察到的世界里，太阳确实从东边升起。如果有一天太阳从西边出来了，那这句话就变成了假的。

这个例子听起来特别简单，甚至有点废话。但形式语义学做的事情，恰恰就是要把这种看似废话的道理，用严格的数学语言形式化地表达出来。它要回答的核心问题是：语言的表达式和它们所指涉的世界之间，到底是一种什么样的映射关系？

形式语义学在搞什么

形式语义学，简而言之，就是用数学方法来研究语言意义的一门学问。它的”形式”二字强调的是严密性——不像日常聊天那样模模糊糊地讨论”这句话什么意思”，形式语义学要用明确的规则和数学结构来定义意义。

你可能会问：为什么非得用数学？直接说不行吗？

还真不行。因为自然语言太狡猾了，同样一个字在不同语境下意思完全不同。比如”打”字：

• 打篮球（参与）
• 打毛衣（编织）
• 打报告（提交）
• 打哈哈（敷衍）
• 打比方（举例）

如果我们不引入形式化的工具，根本没法精确描述这些歧义到底是怎么产生的，又该怎么消解。

形式语义学做的事情，就是给语言装上一套”意义的几何学”——把每个表达式都映射到数学对象上，然后研究这些数学对象之间的关系。通过这套方法，我们可以：

1. 精确地定义什么是”真”
2. 解释歧义性如何产生
3. 揭示意义如何从部分组合成整体
4. 为自然语言处理提供理论支撑

和NLP的关系

如果你对人工智能感兴趣，可能会问：形式语义学在现代NLP中到底有没有用？

答案是：有用，但方式比较间接。

现代NLP主流用的是分布式语义学的方法——用词向量、神经网络来捕捉语义。ChatGPT之所以能理解和生成文本，靠的是大规模预训练学到的统计规律，而不是显式地”理解”语言。

但形式语义学提供了另一种思路：它试图用明确的规则来捕获语义，这让AI系统能够：

• 进行精确的推理（而不仅是统计相似）
• 解释自己的判断（可解释AI）
• 处理需要精确语义的场景（法律合同、医疗诊断等）

这两种路子不是互斥的，而是互补的。理解形式语义学，能让你对语言理解的本质有更深的认识。

---

一、Tarski的真值条件语义学

1.1 真值条件语义学的起源

阿尔弗雷德·塔斯基（Alfred Tarski）是20世纪最重要的逻辑学家之一。他在1930年代做了一件看似简单但革命性的事情：给”真”下一个严格的定义。

在Tarski之前，人们对”真理”的理解五花八门。有人说真理是主观的，有人说是客观的，有人说是相对的。Tarski不管这些哲学争论，他的做法非常技术性：如果我们能用元语言（meta-language）来描述对象语言（object language）的真值条件，就算定义了真。

用人话来说，就是：一个句子为真，当且仅当它所描述的情况确实发生了。

这句话听起来是不是像废话？“雪是白的”为真，当且仅当雪确实是白的。这不是明摆着的吗？

但问题在于，Tarski之前的哲学家和逻辑学家，没有一个人能把这个”明摆着”的道理用数学语言严格地表述出来。Tarski做到了，而且他发现这里面有很深的坑——如果元语言和对象语言是同一种语言，就会产生自指悖论（就像说谎者悖论”这句话是假的”一样）。

1.2 真的定义（Tarski的T约定）

Tarski提出的解决方案叫做”T约定”（T-convention）。他的核心洞见是：定义真不能在被定义的语言内部进行，必须在更高层次的语言（元语言）中进行。

来看看T-语句的例子：

"雪是白的"为真，当且仅当雪是白的。

形式化后写成：

T("雪是白的") ⟺ 雪是白的

左边的T()表示”为真”，右边的”雪是白的”是用元语言描述的事实。注意这里有一个微妙的地方：左边的引号里是句子本身，右边没有引号，是实际发生的事情。

Tarski的方案妙在什么地方呢？它把”真”这个概念拆成了两部分：

1. 句子的形式结构（我们可以用符号系统来处理）
2. 句子的真值条件（对应世界中需要满足的条件）

这样一来，我们就可以用数学方法来研究语言和世界的关系了。

1.3 Tarski语义学的形式化框架

1.3.1 语言结构

形式语言就像一套精心设计的积木系统，它的基本构件包括：

语言结构 L = <V, C, P, R>

其中：
├── V: 变量集合 {x, y, z, ...}
│   └── 就像代数里的未知数，可以指代任何对象
├── C: 常量集合
│   └── 具体的人事物，比如"Socrates"、"3"
├── P: 谓词集合
│   └── 表示性质或关系，比如"是人"、"爱"
└── R: 关系元数
    └── 说明谓词需要几个参数，比如"爱"是二元谓词

生活中的例子

想象你在做一个配对游戏：

• 常量就像写好名字的卡片（“小明”、“苹果”、“北京”）
• 变量就像空白的占位符，等着被填上具体的卡片
• 谓词就像游戏的匹配规则（“和…是朋友”、“比…大”）

当你把具体的卡片填进占位符，然后用规则去检验，就完成了一次”语义解释”。

1.3.2 结构与模型

语义结构（Structure）或模型（Model）是形式语义学的核心概念。它就像一个”世界的小模型”，告诉我们在某个论域里，各种符号对应什么对象。

用数学语言来说，模型M由两部分组成：

$$\mathcal{M}=⟨D,I⟩$$

• D（论域/Domain）：我们考虑的所有对象的集合。就像我们讨论”动物”这个话题时，论域里就是所有的动物。
• I（解释函数/Interpretation）：一个规则表，告诉我们每个常量对应D中的哪个元素，每个谓词对应D上的什么关系。

举个例子：

论域 D = {小明, 小红, 小刚, 猫1, 猫2}

解释 I：
├── 小明 → 小明
├── 小红 → 小红
├── 小刚 → 小刚
├── 是人 → {小明, 小红, 小刚}
├── 是猫 → {猫1, 猫2}
└── 爱 → {(小明, 小红), (小红, 小刚)}
    └── 解释：这是一个有序对的集合，表示谁爱谁

这样，“小明爱小红”这个句子在这个模型里就是真的，因为有序对(小明, 小红)在”爱”这个关系里。

1.4 真值条件的形式化

1.4.1 一阶逻辑的真值条件

现在我们来看看，在Tarski语义学框架下，基本的逻辑公式是怎么被赋予真值的。

原子公式

原子公式是最简单的公式，比如”x是人”或者”P(x)“。它的真值条件是：

$$\mathcal{M},g\models P(t_1,...,t_n)⟺⟨\mathcal{M}(t_1),...,\mathcal{M}(t_n)⟩\in \mathcal{M}(P)$$

这里有两个新符号：

• g是赋值函数（assignment），它告诉变量x对应论域里的哪个具体对象
• ⊨读作”满足”，表示”在某个模型和赋值下成立”

用人话来说，原子公式P(t₁, …, tₙ)在模型M下为真，当且仅当参数t₁到tₙ的解释组成的元组属于谓词P的指称。

复合公式

自然语言里我们可以用”并且”、“或者”、“如果…那么…”来组合句子，形式语言里也有对应的联结词：

联结词	符号	什么时候为真
否定	¬φ	φ为假时
合取	φ ∧ ψ	φ和ψ都为真时
析取	φ ∨ ψ	φ和ψ至少有一个为真时
蕴含	φ → ψ	φ为假 或者 ψ为真时

量词

量词是形式语言最强大的地方。它们允许我们表达”所有”和”存在”：

• 全称量词 ∀x：对于论域中的所有对象，某个性质都成立
• 存在量词 ∃x：论域中至少有一个对象满足某个性质

举例来说：

"所有人都爱某人" → ∀x (人(x) → ∃y 爱(x, y))

这句话在模型M下为真，要求：

1. 遍历论域D中的每一个对象d
2. 检查如果d是人
3. 那么一定存在某个对象e，使得d爱e这个关系成立

---

二、模型论语义学基础

2.1 外延语义

外延（Extension）是形式语义学最基础的概念之一。简单来说，外延就是表达式所指的那个东西。

生活中的类比：门牌号和住户

想象一个小区：

• 每户人家有一个门牌号（类似于”符号”）
• 门牌号对应的实际住户（类似于”外延”）

“门牌号301”这个符号，它的外延就是住在301室的那户人家。同理，“人”这个词语，它的外延就是所有具有人性特征的个体。

表达式类型	外延是什么	例子
个体词项	论域中的一个元素	”苏格拉底” → 苏格拉底本人
一元谓词	论域的一个子集	”是人” → {苏格拉底, 柏拉图, …}
二元谓词	有序对的集合	”爱” → {<小明,小红>, <小红,小刚>}

2.1.1 外延同一性原则

外延语义学有一个重要原则：外延相同的东西，在所有语境下可以相互替换而不改变真值。

这叫做** Leibniz法则**（或者替换同一性法则）：

如果 a = b，那么任何包含a的句子，把a换成b之后，真值不变。

举个例子：

"晨星是亮的"为真 ↔ "昏星是亮的"为真

因为”晨星”和”昏星”指的都是金星，所以可以互换。

但是，这个原则在某些语境下会失效！

有些语境不允许直接替换，这就是语言学家说的”外延语境”（extensional context）之外的情况。典型例子包括：

• 信念语境：“小明相信晨星是行星”不等于”小明相信昏星是行星”
• 知识语境：“小红知道奥巴马是美国总统”不等于”小红知道Obama是美国总统”（除非她懂英语）
• 模态语境：“必然的，晨星是行星”不等于”必然的，昏星是行星”

这些语境需要用内涵语义来处理。

2.2 内涵语义

当外延原则不适用的时候，我们就需要内涵（Intension）的概念。

2.2.1 内涵的定义

内涵是一个从可能世界到外延的函数。

这个定义有点抽象，让我们拆开来看：

可能世界是什么？可以理解为”一种可能的情况”。我们生活在一个现实世界里，但还有无数种可能的世界——如果拿破仑没有打过滑铁卢会怎样？如果人类从未登月会怎样？这些”如果”对应的世界，就是可能世界。

内涵做的事情，就是记录一个表达式在每个可能世界里分别指什么：

$$[[e]]=\lambda w.[[e]{]}^w$$

用人话来说：内涵就是”在不同世界里的指称”的集合。

例子：晨星的内涵

晨星的外延（在现实世界）= 金星
晨星的内涵 = {
    现实世界w₀: 金星,
    拿破仑没打过滑铁卢的世界w₁: 金星,
    人类没登月的世界w₂: 金星,
    ...其他所有可能世界...
}

因为晨星在所有可能世界里都指代金星，所以它是一个刚性指示词（rigid designator）。

而”当今法国国王”就不一样了：

• 在现实世界，它的指称是”马克龙”
• 但在另一个可能世界里，法国国王可能是另一个人

所以”当今法国国王”这个表达式的内涵是：

"当今法国国王"的内涵 = {
    w₀: 马克龙,
    w₁: 路易十八,
    w₂: 拿破仑七世,
    ...(不同世界里可能存在的法国国王)...
}

2.2.2 内涵类型论

蒙太古语法用类型论来系统地处理内涵。类型论给每个表达式都贴上一个”类型标签”，这样我们就能精确地知道它需要什么样的上下文才能组合。

基础类型

• e（entity）：实体类型，代表论域中的个体
• t（truth）：真值类型，只有真和假两个值

函数类型

• ⟨a, b⟩：从类型a到类型b的函数
• 比如⟨e, t⟩表示一个”接收一个个体，返回一个真值”的函数

内涵类型

• ⟨s, α⟩：内涵类型，其中s是可能世界类型，α是任意外延类型
• 内涵类型的外延是一个函数：可能世界 → α

表达式	语义类型	直观含义
John	e	一个具体的人
runs	⟨e, t⟩	一个函数：接收人返回真假
loves	⟨e, ⟨e, t⟩⟩	接收一个人，返回一个”接收另一个人返回真假”的函数
necessarily	⟨⟨s, t⟩, t⟩	接收一个命题，在所有可能世界里检查真假

2.3 可能世界语义学

可能世界语义学是内涵语义学的基石。它的核心思想是：理解一个句子的意义，就是知道在什么情况下它为真。

2.3.1 什么是可能世界

可能世界这个概念最早由哲学家莱布尼茨提出。他的想法是：现实世界只是众多可能世界中的一个，上帝在创造世界之前考虑过所有可能的选择。

现代逻辑学借用这个概念，但不需要上帝的设定。我们可以把可能世界理解为”一种完整的、关于世界是什么样子的描述”。就像：

可能世界集合 W:
    W = {w₀, w₁, w₂, w₃, ...}

    w₀: 现实世界，太阳从东边升起
    w₁: 拿破仑赢了滑铁卢，二战没有发生
    w₂: 人类从未发明计算机
    w₃: 外星人其实一直生活在地球上
    ...

每个可能世界都是自洽的——在那个世界里，一切逻辑和物理定律都是一致的。

2.3.2 模态逻辑的语义

模态逻辑处理”必然”和”可能”这样的概念。可能世界语义学给它们提供了精确的解释：

必然性 □φ

□φ在现实世界为真，当且仅当φ在所有可能世界都为真。

$${\models }_w\square \varphi ⟺\forall w^{\prime }\in W:{\models }_{w^{\prime }}\varphi$$

可能性 ◇φ

◇φ在现实世界为真，当且仅当至少有一个可能世界使得φ为真。

$${\models }_w◊\varphi ⟺\exists w^{\prime }\in W:{\models }_{w^{\prime }}\varphi$$

生活中的例子

“水必然是H₂O”这个命题：

• 如果在所有可能世界里，水都是H₂O，那么它就是必然真的
• 但如果我们考虑一个可能世界，在那里水的化学成分不同，那么”水必然是H₂O”就是假的

这就是为什么内涵语义很重要：它能区分”在现实世界为真”和”必然为真”。

---

三、形式语义学三大学派：各显神通

形式语义学发展至今，形成了三大主要流派。它们各有特点，服务于不同的目的：

流派	核心思想	代表人物	应用场景
指称语义	每个表达式对应一个数学对象	Scott, Strachey	程序语言理论
操作语义	理解意义 = 知道怎么执行	Plotkin, Kahn	程序验证
公理语义	意义由公理系统决定	Hoare, Dijkstra	形式化验证

下面我们逐一介绍。

3.1 指称语义：每个表达式对应一个”数学对象”

指称语义（Denotational Semantics）的核心思想非常直观：每个语言表达式都指称（denote）一个数学对象，这个数学对象就是表达式的意义。

生活类比：菜单和菜品

想象你去餐厅：

• 菜单上的菜名是指称
• 实际做出来的菜品是语义值（denotation）

“宫保鸡丁”这个菜名，指称的是一道具体的菜——由鸡肉、花生、辣椒等组成的菜肴。当你点了这道菜，服务员理解你的意思，厨房就会做出对应的菜品来。

指称语义就是这样一种映射：语言表达式 → 数学对象。

程序语言的例子

在指称语义里，一个程序的意义是什么？

# 伪代码的指称语义
[[x := 5]] = 一个从状态到状态的函数：把变量x的值设为5
[[while b do P]] = 不断执行P直到b为假

也就是说，程序的意义被定义为”状态转换函数”——给定一个初始状态，程序会把它变成什么终态。

指称语义的特点

优点：

• 语义是”静态的”数学对象，易于理论研究
• 不同实现只要行为等价，就有相同指称

缺点：

• 有些语言构造（如并发）难以用指称语义刻画
• 需要精心设计数学域来处理递归

3.2 操作语义：通过”执行”来理解意义

操作语义（Operational Semantics）的思路完全不一样：理解一个表达式的意义，就是知道如果”执行”它会发生什么。

生活类比：食谱

一本食谱告诉你”红烧肉怎么做”：

• 如果按照食谱的步骤一步步操作，你会得到一道红烧肉
• 理解食谱的意义，就是知道执行它会产生什么结果

这就是操作语义的核心：意义不在于静态的数学对象，而在于动态的执行过程。

小步语义 vs 大步语义

操作语义有两种主要方法：

1. 小步语义（Small-step / Structural Operational Semantics）

   • 描述每一步怎么转换
   • 适合研究程序执行细节
   • 形式：⟨S, σ⟩ → ⟨S', σ'⟩（给定语句S和状态σ，执行一步变成S’和σ’）

2. 大步语义（Big-step / Natural Semantics）

   • 直接描述最终结果
   • 适合理论分析
   • 形式：⟨S, σ⟩ ⇓ σ'（给定语句S和初始状态σ，最终得到状态σ’）

例子

考虑语句：x := 3; y := x + 1

小步语义的执行过程：

⟨x:=3; y:=x+1, {x:0, y:0}⟩ 
→ ⟨y:=x+1, {x:3, y:0}⟩      # 第一步：赋值x:=3
→ ⟨skip, {x:3, y:4}⟩         # 第二步：计算x+1=4并赋值给y

大步语义直接给出结果：

⟨x:=3; y:=x+1, {x:0, y:0}⟩ ⇓ {x:3, y:4}

3.3 公理语义：意义由规则决定

公理语义（Axiomatic Semantics）的想法是：不需要描述”程序做了什么”，只需要规定”什么样的事实是程序的真值条件”。

生活类比：法律条文

法律不是描述”法官会怎么判”，而是规定”满足什么条件就是合法/非法”。公理语义做的是类似的事情——用逻辑公式（公理和推理规则）来描述程序规范。

霍尔逻辑（Hoare Logic）

最著名的公理语义系统是Tony Hoare提出的霍尔三元组：

{P} S {Q}

意思是：如果你在执行程序S之前满足前置条件P，那么执行完之后一定会满足后置条件Q。

例子

# {x = 5}
y = x + 1
# {y = 6}

霍尔逻辑可以验证这个推理是否正确。赋值公理告诉我们：{P[E/x]} x := E {P}——也就是说，如果执行赋值前P用E替换x后成立，那么赋值后P就成立。

3.4 三种语义的关系与选择

三种语义方法不是互斥的，而是互补的：

• 指称语义适合理论研究，它给出语义的最”抽象”的描述
• 操作语义适合实现编译器解释器，它描述实际执行过程
• 公理语义适合验证程序正确性，它关注”规范”而非”实现”

在自然语言处理领域，指称语义和操作语义的影响最大。Montague的工作基本上是指称语义的路线，而近些年代码生成领域常用操作语义的思想来定义目标语言的语义。

---

四、组合性原则——为什么”理解了单词就能理解句子”？

4.1 组合性原则的定义

组合性原则（Principle of Compositionality）是形式语义学最重要的假设之一：

复合表达式的意义由其组成部分的意义及它们的组合方式决定。

这个原则由哲学家Frege在19世纪末提出，被称为Frege原则。它的另一种表述是：

一个表达式的意义完全由它的内部结构决定。

生活类比：积木搭建

想象你有一套积木：

• 每个积木块有自己的形状和颜色（类似词汇的意义）
• 积木块可以通过特定的方式拼接（类似语法规则）
• 拼接出来的结构有整体的意义（类似句子的意义）

组合性原则说的是：给定所有部件的含义和拼接规则，你就能确定整体结构的含义。

这意味着，如果你知道”狗”是什么意思，“咬”是什么意思，“那只”是什么意思，那么”那只狗咬人”这句话的意思基本上就能确定了——至少在理想情况下。

4.2 组合性原则的证据

为什么我们相信组合性原则？

证据1：语言的创造性

人类可以用有限的词汇创造出无限多的新句子。按照组合性原则，这是因为我们有有限的词汇（可以穷举）和一套组合规则（语法），这两者结合就能产生无限多的组合。

证据2：可学习性

小孩子是怎么学会语言的？他们听到有限的句子，却能推断出词汇的意义和语法规则。如果意义不是组合性的，这个推断任务几乎不可能完成——因为每个句子都是全新的，无法从过去的经验中类推。

证据3：翻译的可行性

我们能够把一种语言翻译成另一种语言，这在一定程度上依赖于组合性。如果意义不是组合性的，翻译就只能是查表式的，无法处理新句子。

4.3 组合性原则的形式化

设$[[e]]$表示表达式$e$的语义值，$\mathcal{G}$表示组合函数：

$$[[\text{复合表达式}]]=\mathcal{G}([[\text{成分1}]],[[\text{成分2}]],...,[[\text{成分n}]])$$

组合系统的设计

组合性要求我们在设计语义系统时考虑：

1. 每个词汇的语义是什么
2. 组合规则是什么
3. 如何保证类型匹配

类型驱动的组合

类型论为组合性提供了系统框架：

类型规则：
    
    表达式: 类型
    ─────────────
    α: A    β: B
    ────────────────  (函数应用)
      β(α): B
    
    表达式: 类型
    ─────────────
    φ: B    x: A
    ────────────────────  (λ抽象)
      λx.φ: ⟨A, B⟩

这个规则说的是：

• 如果我们有函数f: A → B，和参数a: A，那么f(a): B
• 如果我们有表达式φ: B，和变量x: A，那么λx.φ: A → B

4.4 组合性的局限性

组合性原则不是绝对的。在实际语言中，有些现象挑战了纯组合性的解释：

非组合性语义

1. 隐喻和习语：“踢桶”（发泄怒火）不能按字面意义组合理解
2. 回指：“小明打了小张，因为他心情不好”——“他”指谁，需要语境推理
3. 预设：“他又迟到了”预设他之前也迟到过，这个预设不是组合出来的
4. 语用推理：“能递我盐吗？“的意思不是问能力，而是请求

这些问题催生了动态语义学、语用学等研究方向，它们在形式语义学的基础上加入了语境、推理等因素。

---

五、λ演算与语义组合——形式语义学的瑞士军刀

5.1 λ演算入门：函数式语义的基础

λ演算（Lambda Calculus）由Alonzo Church在1930年代发明，是形式语义学中处理语义组合的核心工具。它被Alan Turing证明与图灵机等价，是计算理论的基石之一。

为什么要用λ演算？

想象你要表达”John loves Mary”这个句子的语义。按照组合性原则，我们需要把”loves”的语义和两个名词的语义组合起来。但问题是：

• “loves”是一个二元关系
• “John”和”Mary”分别是一个个体
• 我们需要一个机制来”应用”关系到它的参数上

λ演算提供了这个机制。

5.2 λ语法

λ表达式只有三种基本构件：

λ表达式 ::= 变量 | 抽象 | 应用

例子：
- x, y, z                    # 变量
- λx. M                      # 抽象：创建一个函数
- M N                        # 应用：把M作用于N

抽象（Lambda Abstraction）

λx. M表示一个函数：给定x，返回M（其中x被替换）。

例子：

• λx. x + 1 表示”加1”这个函数
• λf. f(3) 表示”把某个函数作用于3”的函数

应用（Application）

M N表示把函数M作用于参数N。

例子：

• (λx. x + 1) 5 → 计算结果是6

5.3 α等价与β归约

α-等价（Alpha Equivalence）

α-等价说的是：绑定变量只是”占位符”，叫什么名字不重要。

$$\lambda x.M{\equiv }_{\alpha }\lambda y.[y/x]M$$

只要y不在M中自由出现（不产生冲突），就可以把x换成y。

β-归约（Beta Reduction）

β-归约是λ演算的核心计算规则：

$$(\lambda x.M)N{\to }_{\beta }[N/x]M$$

用人话来说：把函数体里的x替换成N，然后扔掉λ。

例子：

(λx. x + 1) 5 
→ [5/x](x + 1)  # 用5替换x
→ 5 + 1         # 计算
→ 6

5.4 λ演算在语义组合中的应用

语义表示的例子

考虑句子：“John runs.”

按照Montague语法的处理：

[[John]] = j                    # 类型e：具体的人
[[runs]] = λx.runs(x)           # 类型⟨e, t⟩：一阶谓词

[[John runs]] = [[runs]]([[John]])
              = (λx.runs(x))(j) # β归约
              → runs(j)         # 句子的语义：一个命题

量化句的处理

λ演算特别擅长处理量化词。看一个更复杂的例子：

句子：“Every student passed.”

按照Montague语法的语义构造：

[[every]] = λP.λQ.∀x(P(x) → Q(x))
           # 语义：一个量词，接受两个谓词P和Q
           # 含义：所有满足P的x，也满足Q

[[student]] = λx.student(x)
[[passed]] = λx.passed(x)

[[every student]] = [[every]]([[student]])
                  = (λP.λQ.∀x(P(x)→Q(x)))(λx.student(x))
                  →β λQ.∀x(student(x) → Q(x))
                  # 语义：一个NP，意思是"对于所有x，如果x是学生，那么..."

[[S]] = [[every student]]([[passed]])
      = (λQ.∀x(student(x)→Q(x)))(λx.passed(x))
      →β ∀x(student(x) → passed(x))
      # 最终语义：对于所有x，如果x是学生，那么x通过了考试

这就是为什么λ演算在语义组合中如此重要——它允许我们”延迟填充”参数，实现组合性的语义组装。

---

六、一阶逻辑与语义——谓词、量词、个体域

6.1 一阶逻辑的基本构件

一阶逻辑（First-Order Logic, FOL）是形式语义学的主要表达工具。它的表达能力比命题逻辑强，但比二阶逻辑弱。

一阶逻辑的基本成分

1. 个体变量和常量：x, y, z, a, b, c…
2. 函数符号：f, g, h…（可以是多元的）
3. 谓词符号：P, Q, R…（可以是多元的）
4. 逻辑联结词：¬, ∧, ∨, →, ↔
5. 量词：∀, ∃
6. 等词：=（可选）

6.2 语义解释

一阶逻辑的语义由Tarski风格的真值定义给出。

项的解释

项（Term）是表示个体的表达式：

• 常量直接指派到论域中的元素
• 变量通过赋值函数指派
• 函数符号应用：f(t₁, …, tₙ)的解释是论域上的函数

原子公式的解释

原子公式P(t₁, …, tₙ)的真值由谓词P的解释和项的解释共同决定：

$$\mathcal{M},g\models P(t_1,...,t_n)⟺⟨\mathcal{M}(t_1),...,\mathcal{M}(t_n)⟩\in \mathcal{M}(P)$$

复合公式的解释

# 伪代码实现
def evaluate(phi, model, assignment):
    if phi == "¬ψ":
        return not evaluate(psi, model, assignment)
    elif phi == "ψ ∧ θ":
        return evaluate(psi, model, assignment) and evaluate(theta, model, assignment)
    elif phi == "∀x ψ":
        # 对于论域中所有对象，如果赋值让x对应该对象后ψ为真
        return all(evaluate(psi, model, assignment.with(x, d)) for d in model.domain)
    elif phi == "∃x ψ":
        # 论域中存在一个对象，使得...
        return any(evaluate(psi, model, assignment.with(x, d)) for d in model.domain)

6.3 量词的陷阱与技巧

量词在一阶逻辑里是新手最容易出错的地方。

注意量词的顺序

∀x ∃y "爱"(x, y)    # 每个人都能找到自己爱的人
∃y ∀x "爱"(x, y)    # 有一个人被所有人爱

这两个命题的意思完全不同！

注意变量的作用域

∀x (P(x) → ∃y Q(x, y))  # 对每个人x，如果P(x)成立，那么存在一个y与x有关系
(∀x P(x)) → ∃y Q(x, y)  # 如果对所有x都有P(x)，那么存在某个y...
                       # 注意这里的x是自由变量，可能导致歧义

生活中的量化

量词的陷阱在自然语言中很常见：

1. “每个人都有一个妈妈”

   • 正确理解：∀x ∃y mother-of(x) = y
   • 错误理解：∃y ∀x mother-of(x) = y（所有人的妈妈是同一个人）

2. “没有两片相同的雪花”

   • 形式化：¬∃x ∃y (x ≠ y ∧ same(x, y))
   • 不能写成：¬∀x ∀y (x = y ∨ same(x, y))（虽然逻辑等价，但直观上不同）

---

七、蒙塔古语法——用数学方法处理自然语言

7.1 Montague是谁，以及他做了什么

理查德·蒙太古（Richard Montague，1930-1971）是美国哲学家和逻辑学家，他在1970年代做了一件让语言学家和逻辑学家都震惊的事情：证明了自然语言和形式语言在原则上是同构的。

这句话的意思是：给形式语言写的那套严格的语义理论，可以原封不动地应用到自然语言上。

Montague在1970年发表了《Universal Grammar》，1973年发表了《The Proper Treatment of Quantification in Ordinary English》（简称PTQ）。这两篇论文开创了现代形式语义学。

7.2 PTQ系统的核心思想

PTQ系统（Proper Treatment of Quantification）是Montague语法的代表作。它的核心创新是：

1. 自然语言的形式化：用范畴语法（Categorial Grammar）分析英语语法
2. 组合性翻译：每个语法范畴对应一个语义类型
3. 内涵逻辑语义：用可能世界语义学解释量化等高级现象

Montague语法的框架

┌─────────────────────────────────────────┐
│            语法组件                       │
│  ├── 范畴语法（基于句法范畴）              │
│  └── 短语结构规则                         │
└─────────────────────────────────────────┘
                    ↓ 翻译规则
┌─────────────────────────────────────────┐
│            内涵逻辑表达式                  │
│  ├── 一阶逻辑 + λ演算                    │
│  └── 内涵算子（↑, ↓, □, ◇）            │
└─────────────────────────────────────────┘
                    ↓ 模型论解释
┌─────────────────────────────────────────┐
│          真值条件                         │
│  可能世界语义学                           │
└─────────────────────────────────────────┘

7.3 蒙塔古语法的词汇语义

Montague语法的核心是词典（Lexicon）。每个词典条目包含：

1. 词形
2. 句法范畴（决定怎么和其他词组合）
3. 语义翻译（翻译成内涵逻辑表达式）

英语词典示例

名词 (CN = Common Noun):
- man    → λx.man(x)
- woman  → λx.woman(x)
- fish   → λx.fish(x)

不及物动词 (IV = Intransitive Verb):
- runs   → λx.runs(x)
- sleeps → λx.sleeps(x)

及物动词 (TV = Transitive Verb):
- loves  → λy.λx.love(x, y)
          # 注意参数顺序：先接受宾语，返回一个需要主语的函数

限定词 (Det = Determiner):
- every  → λP.λQ.∀x(P(x) → Q(x))
- some   → λP.λQ.∃x(P(x) ∧ Q(x))
- no     → λP.λQ.¬∃x(P(x) ∧ Q(x))
- a      → λP.λQ.∃x(P(x) ∧ Q(x))

专名 (NP = Proper Noun):
- John   → j
- Mary   → m

7.4 Montague语法的组合规则

基本句法规则与语义对应

句法规则                      语义规则
─────────────────────────────────────────────
NP → Det N                     [[Det N]] = [[Det]]([[N]])

S → NP IV                      [[NP IV]] = [[IV]]([[NP]])

S → NP TV NP                   [[NP₁ TV NP₂]] = [[TV]]([[NP₂]])([[NP₁]])

完整推导示例

句子：“Every man loves a woman.”

1. 句法分析

[S [NP [Det every] [N man]]
    [S [TV loves] [NP [Det a] [N woman]]]]

2. 语义构造

[[man]] = λx.man(x)
[[woman]] = λx.woman(x)
[[loves]] = λy.λx.love(x, y)
[[every]] = λP.λQ.∀z(P(z) → Q(z))
[[a]] = λP.λQ.∃z(P(z) ∧ Q(z))

[[every man]] = [[every]]([[man]])
              = λQ.∀z(man(z) → Q(z))

[[a woman]] = [[a]]([[woman]])
             = λQ.∃z(woman(z) ∧ Q(z))

[[loves a woman]] = [[loves]]([[a woman]])
                   = (λy.λx.love(x, y))(λQ.∃z(woman(z)∧Q(z)))
                   →β λx.∃z(woman(z) ∧ love(x, z))

[[S]] = [[every man]]([[loves a woman]])
      = (λQ.∀z(man(z) → Q(z)))(λx.∃z(woman(z) ∧ love(x, z)))
      →β ∀z(man(z) → ∃z'(woman(z') ∧ love(z, z')))

这就是”每个男人都爱一个女人”的语义表示。

---

八、形式语义在NLP中的应用

8.1 语义解析

语义解析（Semantic Parsing）是把自然语言转换成形式语义表示的任务。

应用场景

1. 问答系统：把用户问题转换成逻辑查询
2. 数据库查询：自然语言到SQL的转换
3. 任务导向对话：把用户指令解析成可执行的动作

技术路线

现代语义解析主要有两种路线：

1. 传统组合范畴语法（CCG）：基于Montague语法的组合性规则
2. 神经语义解析：使用Seq2Seq模型端到端生成语义表示

CCCG解析示例

# 假设用CCG分析"What city does John live in?"
 
# 语法范畴：
# - John: NP
# - lives in: S\\NP / N  (需要名词短语，输出句子；接受名词后变成谓词)
# - what: (S\\NP)/N  (问号占位)
 
# 组合过程：
# 1. "what" + "city" → NP?  (需要填补的NP)
# 2. "John" + "lives in" → S\\NP
# 3. (S\\NP) + (NP?) → S?
# 最终生成：∃x.city(x) ∧ live(John, x)

8.2 知识图谱问答

知识图谱问答（KBQA）是形式语义的一个重要应用场景。

工作流程

1. 问题理解：把自然语言问题解析成逻辑形式
2. 逻辑查询：在知识图谱上执行查询
3. 答案生成：把查询结果转换回自然语言

例子

问题：“谁是特斯拉的CEO？”

1. 语义解析：∃x.CEO(x, Tesla)
2. 知识图谱查询：找到所有满足条件的x
3. 返回答案：“Elon Musk”

8.3 信息抽取

形式语义学的方法也应用于信息抽取（Information Extraction）。

事件抽取

# 句子："Apple在2024年发布了iPhone 16"
 
# 语义表示：
event = {
    "type": "发布",
    "agent": "Apple",
    "theme": "iPhone 16",
    "time": "2024年"
}
 
# 一阶逻辑表示：
∃e.发布(e) ∧ agent(e, Apple) ∧ theme(e, iPhone_16) ∧ time(e, 2024)

8.4 形式语义与神经网络的结合

现代NLP的趋势是把形式语义学的思想与神经网络结合：

1. 语义相似度：用向量表示语义，计算句子间的语义相似度
2. 语义推理：在嵌入空间中进行逻辑推理
3. 可解释推理：让神经网络能够”看到”推理过程

例子：逻辑张量网络（LTN）

Logic Tensor Networks (LTN)尝试在神经网络中融入逻辑约束：

# 定义逻辑公式作为神经网络的正则化项
def axiom_every_A_is_B(model, A, B):
    """∀x: A(x) → B(x)"""
    for x in domain:
        a_x = model.embedding(A, x)  # A(x)的真值
        b_x = model.embedding(B, x)  # B(x)的真值
        score = tf.reduce_mean(tf.nn.sigmoid(b_x) - tf.nn.sigmoid(a_x))
    return score  # 越小越好
 
# 训练目标：最小化逻辑违反 + 数据损失
loss = data_loss + λ * sum(axiom_violations)

---

九、类型论入门——名词是类型，动词是函数

9.1 类型论的基本思想

类型论（Type Theory）是继集合论之后数学基础的另一个重要选择。在形式语义学中，类型论比集合论更适合描述自然语言的语义结构。

核心思想

在类型论中，每个表达式都有一个类型（Type），它告诉我们这个表达式”是什么种类的东西”。

类比生活：

• “3”是一个数（类型：整数）
• “小于”是一个函数（类型：整数 → 整数 → 布尔）
• “是偶数”是一个谓词（类型：整数 → 布尔）

9.2 简单类型λ演算

简单类型λ演算是形式语义学最常用的类型系统：

基础类型

• ι (iota)：个体/实体类型
• o (omicron)：真值类型

函数类型

• σ → τ：从类型σ到类型τ的函数

类型规则

变量：Γ ⊢ x: σ  (如果x有类型σ)
抽象：Γ, x: σ ⊢ M: τ  ⇒  Γ ⊢ λx.M: σ → τ
应用：Γ ⊢ M: σ → τ    Γ ⊢ N: σ    ⇒    Γ ⊢ M N: τ

9.3 类型与语义的对应

在Montague语法的传统中，类型和语义有直接的对应关系：

语义类型	含义	自然语言对应
e	个体	专名（John, Paris）
t	真值	语句
⟨e, t⟩	个体→真值	不及物动词、名词
⟨e, ⟨e, t⟩⟩	个体→(个体→真值)	及物动词
⟨⟨e, t⟩, ⟨e, t⟩⟩	(个体→真值)→(个体→真值)	限定词

类型驱动的语义组合

当我们组合表达式时，类型决定了怎么组合：

John runs
  ↓         ↓
  e       ⟨e, t⟩
  └────┬────┘
       ↓ 函数应用
       t (真值)

every man runs
  ↓            ↓
⟨⟨e,t⟩,⟨e,t⟩⟩  ⟨e,t⟩
  └────┬────┘
       ↓ 函数应用
       ⟨e,t⟩ (谓词)
       │
       └─ 再与 "man" 组合 ─→ ⟨e,t⟩ ─→ 与 runs 组合 ─→ t

9.4 依存类型与精细类型论

基础类型论在处理某些语言现象时有局限，比如量化名词短语的语义。研究者在基础类型论上发展了更精细的系统。

依存类型

依存类型允许类型依赖于值：

Πx:A. B(x)    # 对于A中的每个x，有一个类型B(x)
Σx:A. B(x)    # 存在A中的x，使得类型B(x)

这让语义表示更加精细。

---

十、形式语义 vs 分布式语义——两种理解语言的方式

10.1 分布式语义：统计的视角

分布式语义学（Distributional Semantics）的核心思想是：一个词的意义由它所处的语境决定。

“观其伴知其义”（You shall know a word by the company it keeps）

这是J.R. Firth在1957年提出的名言。

词向量模型

现代分布式语义学的代表作是词向量（Word Embeddings）：

# 词向量的核心假设
# 相似语境中的词有相似的向量
 
word_vectors = {
    "king": [0.2, -0.3, 0.7, ...],
    "queen": [0.25, -0.28, 0.65, ...],
    "apple": [-0.4, 0.8, -0.1, ...],
}
 
# 语义相似度通过余弦相似度计算
similarity("king", "queen")  # 高（都和王室相关）
similarity("king", "apple")  # 低（不同领域）

10.2 形式语义：逻辑的视角

形式语义学追求的是精确、可解释、能够推理的语义表示。

形式语义的优势

1. 精确性：语义表示是明确定义的，没有歧义
2. 可组合性：语义可以像搭积木一样组合
3. 可推理：可以进行逻辑推理，得出新结论
4. 可验证：语义是否正确可以通过模型检验

分布式语义的优势

1. 覆盖面广：可以处理开放域的语义相似性
2. 端到端学习：不需要手工标注语义
3. 处理歧义：词向量可以同时编码多个意义
4. 计算效率：矩阵运算高度优化

10.3 两种方法的互补

形式语义和分布式语义不是对立的，而是互补的：

神经符号AI

当前AI研究的一个热点方向是神经符号AI（Neuro-symbolic AI），它试图结合两者的优势：

# 神经符号结合的思路
# 1. 用神经网络处理模糊的、开放域的语义
neural_output = transformer_encoder(natural_language)
 
# 2. 用符号系统进行精确推理
logical_form = parser(neural_output)  # 解析成逻辑形式
answer = reasoner(logical_form, knowledge_graph)  # 逻辑推理

例子：神经语义解析

现代语义解析模型可以：

• 输入自然语言
• 输出形式语义表示
• 通过可微分的方式端到端训练

class NeuralSemanticParser(nn.Module):
    def __init__(self, vocab_size, embedding_dim):
        self.encoder = nn.Embedding(vocab_size, embedding_dim)
        self.decoder = nn.LSTM(embedding_dim, hidden_dim)
        self.output_projection = nn.Linear(hidden_dim, num_logical_forms)
    
    def forward(self, tokens):
        embeddings = self.encoder(tokens)
        hidden = self.decoder(embeddings)
        logical_forms = self.output_projection(hidden)
        return logical_forms

10.4 实践中的选择

在具体的NLP应用中，该用哪种方法？

场景	推荐方法	原因
机器翻译（日常）	分布式语义（神经网络）	需要处理大量歧义
法律/医学文档分析	形式语义 + 知识图谱	需要精确推理
问答系统（常识）	神经符号混合	需要推理 + 覆盖面
情感分析	分布式语义	统计规律更有效
语义搜索	两者结合	精确匹配 + 语义相似

---

十一、动手实验：用Python实现简单的语义解析

11.1 环境准备

# requirements.txt
# lambdasem - 一个教学用的简单语义解析库
 
from dataclasses import dataclass
from typing import Dict, Set, Callable, Optional
from enum import Enum, auto
 
# 类型定义
class Type(Enum):
    ENTITY = auto()      # e - 个体
    TRUTH = auto()       # t - 真值
    FUNCTION = auto()    # 函数类型
    
@dataclass
class FunctionType:
    domain: 'Type'
    codomain: 'Type'
    
    def __str__(self):
        return f"({self.domain} → {self.codomain})"

11.2 定义语义域和模型

@dataclass
class Model:
    """
    语义模型 M = <D, I>
    - D: 论域（非空集合）
    - I: 解释函数
    """
    domain: Set
    interpretation: Dict[str, any]
    
    def interpret_constant(self, c: str):
        """解释常量"""
        return self.interpretation.get(c)
    
    def interpret_predicate(self, p: str):
        """解释谓词"""
        return self.interpretation.get(p)
    
    def interpret_function(self, f: str):
        """解释函数"""
        return self.interpretation.get(f)
 
# 创建示例模型
def create_example_model():
    """
    创建一个小型的语义模型
    
    论域：{john, mary, bob, fido, rex}
    谓词：human, dog, love
    """
    domain = {'john', 'mary', 'bob', 'fido', 'rex'}
    
    interpretation = {
        'john': 'john',
        'mary': 'mary',
        'bob': 'bob',
        'fido': 'fido',
        'rex': 'rex',
        
        'human': {'john', 'mary', 'bob'},
        'dog': {'fido', 'rex'},
        'mortal': {'john', 'mary', 'bob', 'fido', 'rex'},  # 所有都会死
        
        'love': {('john', 'mary'), ('mary', 'john'), ('bob', 'fido')},
        # 解释：john爱mary，mary爱john，bob爱fido
    }
    
    return Model(domain, interpretation)

11.3 实现语义类型和表达式

@dataclass
class SemanticExpression:
    """语义表达式的基类"""
    pass
 
@dataclass
class Constant(SemanticExpression):
    """常量表达式"""
    name: str
    value: any
 
@dataclass
class PredicateApplication(SemanticExpression):
    """谓词应用"""
    predicate: str
    arguments: list
 
@dataclass
class LambdaExpression(SemanticExpression):
    """λ抽象"""
    variable: str
    body: SemanticExpression
 
@dataclass
class Application(SemanticExpression):
    """函数应用"""
    function: SemanticExpression
    argument: SemanticExpression
 
@dataclass
class QuantifiedExpression(SemanticExpression):
    """量化表达式"""
    quantifier: str  # 'forall' 或 'exists'
    variable: str
    body: SemanticExpression

11.4 实现语义求值

class SemanticEvaluator:
    """语义求值器"""
    
    def __init__(self, model: Model):
        self.model = model
        self.assignment: Dict[str, any] = {}  # 变量赋值
    
    def evaluate(self, expr: SemanticExpression) -> any:
        """
        递归求值语义表达式
        """
        if isinstance(expr, Constant):
            return self.model.interpret_constant(expr.name)
        
        elif isinstance(expr, PredicateApplication):
            pred_ext = self.model.interpret_predicate(expr.predicate)
            args = [self.evaluate(arg) for arg in expr.arguments]
            return tuple(args) in pred_ext
        
        elif isinstance(expr, LambdaExpression):
            # 返回一个函数
            def lambda_func(val):
                self.assignment[expr.variable] = val
                return self.evaluate(expr.body)
            return lambda_func
        
        elif isinstance(expr, Application):
            func = self.evaluate(expr.function)
            arg = self.evaluate(expr.argument)
            if callable(func):
                return func(arg)
            else:
                return func(arg)
        
        elif isinstance(expr, QuantifiedExpression):
            return self.evaluate_quantifier(expr)
    
    def evaluate_quantifier(self, expr: QuantifiedExpression) -> bool:
        """求值量化表达式"""
        domain = self.model.domain
        
        if expr.quantifier == 'forall':
            # ∀x. φ: 对所有x，如果φ成立
            for d in domain:
                self.assignment[expr.variable] = d
                if not self.evaluate(expr.body):
                    return False
            return True
        
        elif expr.quantifier == 'exists':
            # ∃x. φ: 存在x使得φ成立
            for d in domain:
                self.assignment[expr.variable] = d
                if self.evaluate(expr.body):
                    return True
            return False

11.5 语义解析示例

def demo_semantic_parsing():
    """
    演示：解析和求值简单的英语句子
    """
    model = create_example_model()
    evaluator = SemanticEvaluator(model)
    
    # 例1: "John is human"
    # 语义表示: human(john)
    expr1 = PredicateApplication(
        predicate='human',
        arguments=[Constant('john')]
    )
    result1 = evaluator.evaluate(expr1)
    print(f"'John is human': {result1}")  # True
    
    # 例2: "John loves Mary"
    # 语义表示: love(john, mary)
    expr2 = PredicateApplication(
        predicate='love',
        arguments=[Constant('john'), Constant('mary')]
    )
    result2 = evaluator.evaluate(expr2)
    print(f"'John loves Mary': {result2}")  # True
    
    # 例3: "Someone loves everyone" (Naive的翻译)
    # 语义表示: ∃x.∀y. love(x, y)
    # 这在实际英语中需要更精细的分析
    expr3 = QuantifiedExpression(
        quantifier='exists',
        variable='x',
        body=QuantifiedExpression(
            quantifier='forall',
            variable='y',
            body=PredicateApplication(
                predicate='love',
                arguments=[Constant('x'), Constant('y')]
            )
        )
    )
    result3 = evaluator.evaluate(expr3)
    print(f"'Someone loves everyone': {result3}")  # False (在我们的模型中)
    
    # 例4: "Every human is mortal" - 使用λ表达式
    # 语义表示: ∀x. (human(x) → mortal(x))
    # 这里需要更复杂的表达式...
    print("\n模型信息:")
    print(f"论域: {model.domain}")
    print(f"人类: {model.interpretation['human']}")
    print(f"会死: {model.interpretation['mortal']}")
 
# 运行演示
demo_semantic_parsing()

11.6 词汇语义定义

class Lexicon:
    """
    词汇表：存储词汇的语义类型和翻译
    """
    
    def __init__(self):
        # 词汇条目: word -> (category, type, translation)
        self.entries = {}
        self._init_english_lexicon()
    
    def _init_english_lexicon(self):
        """
        初始化英语词汇表
        基于Montague语法的简化版本
        """
        # 专有名词 (类型: e)
        self.add('John', 'NP', 'e', lambda: 'john')
        self.add('Mary', 'NP', 'e', lambda: 'mary')
        self.add('Bob', 'NP', 'e', lambda: 'bob')
        
        # 普通名词 (类型: <e,t>)
        self.add('man', 'CN', '<e,t>', 
                 lambda x: x in {'john', 'mary', 'bob'})
        self.add('woman', 'CN', '<e,t>', 
                 lambda x: x in {'mary'})
        self.add('dog', 'CN', '<e,t>', 
                 lambda x: x in {'fido', 'rex'})
        
        # 不及物动词 (类型: <e,t>)
        self.add('runs', 'IV', '<e,t>', 
                 lambda x: x == 'john')  # 简化：只有john会跑
        self.add('sleeps', 'IV', '<e,t>', 
                 lambda x: x in {'john', 'mary', 'bob', 'fido', 'rex'})
        
        # 及物动词 (类型: <e,<e,t>>)
        # love = λy.λx.love(x,y) - 先宾语后主语
        self.add('loves', 'TV', '<e,<e,t>>', 
                 lambda y: lambda x: (x, y) in {
                     ('john', 'mary'), 
                     ('mary', 'john'),
                     ('bob', 'fido')
                 })
        
        # 限定词 (类型: <<e,t>,<e,t>>)
        self.add('every', 'Det', '<<e,t>,<e,t>>',
                 lambda P: lambda Q: lambda x: P(x) <= Q(x))
        self.add('some', 'Det', '<<e,t>,<e,t>>',
                 lambda P: lambda Q: lambda x: P(x) and Q(x))
        self.add('a', 'Det', '<<e,t>,<e,t>>',
                 lambda P: lambda Q: lambda x: P(x) and Q(x))
        self.add('no', 'Det', '<<e,t>,<e,t>>',
                 lambda P: lambda Q: lambda x: not (P(x) and Q(x)))
    
    def add(self, word, category, type_str, translation):
        """添加词汇条目"""
        self.entries[word] = {
            'category': category,
            'type': type_str,
            'translation': translation
        }
    
    def lookup(self, word):
        """查询词汇"""
        return self.entries.get(word)

---

十二、形式语义学的前沿议题

12.1 动态语义学

传统的Tarski语义学是静态的——每个句子独立地被赋予真值。但自然语言理解需要考虑语境和变化。

话语表现理论（DRT）

Hans Kamp提出的DRT引入话语表现结构来处理动态性：

句子序列: "A man walked in. He whistled."

DRS (话语表现结构):
┌─────────────────────────────┐
│ x [man(x)]                  │
│ y [walked-in(y)]            │
│ z [whistled(z)]             │
│                             │
│ x = y, y = z  (指代链)      │
└─────────────────────────────┘

"he"的解释：回指x/y/z中最合适的一个

DRT的核心思想是：语义表示不是静态的真值条件，而是随话语推进而更新的”信息状态”。

12.2 概率语义学

形式语义学面临的一个重要挑战是处理歧义和不确定性。概率语义学（Probabilistic Semantics）尝试把概率论引入形式语义框架。

基本思路

• 传统语义：句子要么为真，要么为假
• 概率语义：句子以某个概率为真

class ProbabilisticSemantics:
    """
    概率语义学
    
    语句的意义不是二元真值，而是[0,1]上的概率
    """
    
    def __init__(self, model, probability_space):
        self.model = model
        self.prob_space = probability_space
    
    def probability(self, formula):
        """
        计算公式的概率
        
        P(φ) = |{w ∈ W: M,w ⊨ φ}| / |W|
        """
        worlds = self.prob_space.worlds
        satisfying = [w for w in worlds if self.model.satisfies(formula, w)]
        return len(satisfying) / len(worlds)

12.3 语用学的形式化

语用学（Pragmatics）研究语言使用中的语境依赖性。近些年，形式语义学家尝试形式化语用推理。

格莱斯会话含义

Herbert Grice的会话含义理论认为，交流遵循某些原则：

1. 量的准则：提供恰好需要的信息，不多不少
2. 质的准则：说自己相信为真的事情
3. 相关准则：说话要相关
4. 方式准则：表达要清楚明白

违反这些准则会产生”含义”——字面意思之外的信息。

class GriceanPragmatics:
    """
    格莱斯语用推理
    
    基于理性agent的推理模型
    """
    
    def __init__(self):
        self.cooperative_principle = "在对话的适当阶段，"
        self.cooperative_principle += "说出恰好需要的话"
    
    def calculate_implicature(self, utterance, context):
        """
        计算会话含义
        
        使用博奕论框架：
        - Speaker选择说什么
        - Hearer推断Speaker的意图
        - 双方都假设对方是理性的
        """
        # 简化的理性inference模型
        possible_intentions = self.get_possible_intentions(context)
        utility = self.calculate_utility(utterance, possible_intentions)
        
        # 选择最有效的表达
        best_utterance = max(utility.items(), key=lambda x: x[1])
        return best_utterance

---

总结：形式语义学的核心洞见

形式语义学经过近百年的发展，形成了几个核心洞见：

1. 意义是组合的：句子的意义由词汇意义和组合规则决定
2. 意义是数学对象：可以用严格的数学结构来描述语义
3. 意义与世界对应：语义表示对应可能世界中的状态
4. 意义需要类型：不同类型的表达式需要不同的处理方式

这些洞见不仅在理论上有价值，也为自然语言处理、知识表示、智能推理等应用领域提供了基础。

形式语义学不是唯一的语义理论，但它提供了一套最严格的语义分析方法。理解形式语义学，能让你对语言的本质有更深的认识，也能为AI系统中语义建模提供指导。

---

参考文献与推荐阅读

1. Tarski, A. (1944). The semantic conception of truth. Philosophy and Phenomenological Research, 4(3), 341-376.

2. Montague, R. (1970). Universal grammar. Synthese, 22, 371-398.

3. Montague, R. (1973). The proper treatment of quantification in ordinary English. Approaches to Natural Language.

4. Heim, I., & Kratzer, A. (1998). Semantics in Generative Grammar. Blackwell.

5. Gamut, L. T. F. (1991). Logic, Language, and Meaning (Vol. 2). University of Chicago Press.

6. Barker, C., & Jacobson, P. (Eds.). (2007). Direct Compositionality. Oxford University Press.

7. van Benthem, J. (1986). Essays in Logical Semantics. D. Reidel.

8. Chierchia, G., & McConnell-Ginet, S. (2000). Meaning and Grammar (2nd ed.). MIT Press.

9. Dowty, D. R., Wall, R. E., & Peters, S. (1981). Introduction to Montague Semantics. Springer.

---

关联文档

• 计算语义学深度指南：语义学整体框架
• 词向量与分布式语义：分布语义方法
• 语用学与AI：语用推理应用
• 概念语义学详解：概念表示
• 分布式语义学详解：分布式语义理论