形式语义学基础

文档概述

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

关键词速览

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

一、Tarski的真值条件语义学

1.1 真值条件语义学的起源

阿尔弗雷德·塔斯基（Alfred Tarski）在1930年代开创了现代形式语义学，其核心思想是：句子的意义由其真值条件决定。

语义学的首要任务是给出”真理”的恰当定义。

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

Tarski提出了著名的”T约定”（T-convention）来定义真：

一个语句S为真，当且仅当事情如S所描述的那样。

T-语句示例

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

形式化：
T("雪是白的") ↔ 雪是白的

T-约定的核心洞见是：真值条件必须用元语言表达。如果对象语言（英语）和元语言（英语）相同，就会产生悖论。

1.3 Tarski语义学的形式化框架

1.3.1 语言结构

形式语言 $L$ 由以下成分组成：

语言结构 L = <V, C, P, R>
其中：
├── V: 变量集合 {x, y, z, ...}
├── C: 常量集合 (个体常项)
├── P: 谓词集合 (关系符号)
└── R: 关系 arity (元数)

示例

class FormalLanguage:
    """
    形式语言结构
    
    定义形式语义学的基本语言成分
    """
    
    def __init__(self, name):
        self.name = name
        self.constants = set()      # 个体常项
        self.variables = set()      # 变量
        self.predicates = {}        # 谓词: name -> arity
        self.function_symbols = {} # 函数符号: name -> arity
    
    def add_constant(self, c):
        """添加常项"""
        self.constants.add(c)
    
    def add_predicate(self, p, arity):
        """添加谓词"""
        self.predicates[p] = arity
    
    def interpret(self, structure):
        """
        设定语言在结构中的解释
        """
        self.structure = structure
        self.domain = structure.domain  # 论域/个体域

1.3.2 结构与模型

语义结构（Structure）或模型（Model）提供了语言的指称：

M = ⟨ D, I ⟩

其中：

$D$ ：论域（Domain），非空集合
$I$ ：解释函数（Interpretation），将常项映射到 $D$ 中的元素，谓词映射到 $D^{n}$ 的子集

class SemanticStructure:
    """
    语义结构/模型
    
    M = <D, I> 其中:
    - D: 非空论域
    - I: 解释函数
    """
    
    def __init__(self, domain, interpretation):
        self.domain = domain  # 论域 D
        self.interpretation = interpretation  # 解释函数 I
    
    def interpret_constant(self, c):
        """解释常项"""
        return self.interpretation.get(c)
    
    def interpret_predicate(self, P):
        """解释谓词"""
        return self.interpretation.get(P)
    
    def interpret_term(self, term, assignment=None):
        """
        解释项（常项或变项）
        
        变项需要赋值函数 g: Var -> D
        """
        if term.is_constant():
            return self.interpret_constant(term)
        elif term.is_variable():
            return assignment(term)

1.4 真值条件的形式化

1.4.1 一阶逻辑的真值条件

原子公式

M, g ⊨ P (t_{1}, ..., t_{n}) ⟺ ⟨ M (t_{1}), ..., M (t_{n})⟩ \in M (P)

其中 $M (t_{i})$ 是项的解释， $g$ 是赋值函数。

复合公式

联结词	语义
$\neg ϕ$	$M, g ⊨ \neg ϕ ⟺ M, g \neq ⊨ ϕ$
$ϕ \land ψ$	$M, g ⊨ ϕ \land ψ ⟺ M, g ⊨ ϕ 且 M, g ⊨ ψ$
$ϕ \lor ψ$	$M, g ⊨ ϕ \lor ψ ⟺ M, g ⊨ ϕ 或 M, g ⊨ ψ$
$ϕ \to ψ$	$M, g ⊨ ϕ \to ψ ⟺ M, g \neq ⊨ ϕ 或 M, g ⊨ ψ$

量词

M, g ⊨ \forall x ϕ ⟺ 对所有 d \in D, M, g [x / d] ⊨ ϕ

M, g ⊨ \exists x ϕ ⟺ 存在 d \in D, M, g [x / d] ⊨ ϕ

1.4.2 真值条件的计算实现

def evaluate(formula, model, assignment):
    """
    计算公式的真值
    
    递归实现真值条件语义
    """
    if formula.is_atomic():
        # 原子公式
        pred = formula.predicate
        terms = [evaluate_term(t, model, assignment) for t in formula.terms]
        extension = model.interpret_predicate(pred)
        return tuple(terms) in extension
    
    elif formula.is_negation():
        return not evaluate(formula.operand, model, assignment)
    
    elif formula.is_conjunction():
        return (evaluate(formula.left, model, assignment) and 
                evaluate(formula.right, model, assignment))
    
    elif formula.is_universal():
        # ∀x φ: 检查论域中所有元素
        domain = model.domain
        for d in domain:
            new_assignment = assignment.update(formula.variable, d)
            if not evaluate(formula.scope, model, new_assignment):
                return False
        return True
    
    elif formula.is_existential():
        # ∃x φ: 检查论域中是否存在
        domain = model.domain
        for d in domain:
            new_assignment = assignment.update(formula.variable, d)
            if evaluate(formula.scope, model, new_assignment):
                return True
        return False

二、模型论语义学基础

2.1 外延语义

形式语义学的核心概念是外延（Extension）——表达式所指称的对象。

2.1.1 基本外延关系

表达式类型	外延	示例
个体词项	$D$ 中的元素	”Socrates” → Socrates
一元谓词	$D$ 的子集	”human” → {Socrates, Plato, …}
多元谓词	$D^{n}$ 的子集	”loves” → {⟨a,b⟩: a loves b}
语句	真值（{T, F}）	“Socrates is mortal” → True

2.1.2 外延原则

外延同一性原则 外延相同的表达式可以在所有语境中替换而不改变真值：

e_{1} =_{e x t} e_{2} \Rightarrow 两者在所有语境中可替换

违反外延原则的语境

“John believes that…”
“Mary knows that…”
模态语境：“necessarily…”
命令句、疑问句

2.2 内涵语义

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

2.2.1 内涵的定义

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

[[e]]^{w} = 表达式 e 在世界 w 中的外延

class IntensionalMeaning:
    """
    内涵语义表示
    
    内涵 = 可能世界 → 外延
    """
    
    def __init__(self, extension_function):
        """
        初始化内涵
        
        Args:
            extension_function: f(world) -> extension
        """
        self.extension_function = extension_function
    
    def at_world(self, world):
        """获取在某可能世界中的外延"""
        return self.extension_function(world)
    
    def apply_to(self, world):
        """在特定世界上应用内涵"""
        return self.at_world(world)
 
class PossibleWorldSemantics:
    """
    可能世界语义学
    
    内涵逻辑的基础框架
    """
    
    def __init__(self):
        self.worlds = set()  # 可能世界集合
        self.actual_world = None
    
    def set_actual_world(self, w):
        """设定现实世界"""
        self.actual_world = w
    
    def evaluate_intension(self, intension, world=None):
        """
        评估内涵表达式
        
        内涵语义 = 函数 (可能世界 → 外延)
        """
        if world is None:
            world = self.actual_world
        return intension.at_world(world)

2.2.2 内涵类型论

蒙太古语法使用类型论来系统化内涵：

基础类型

$e$ ：实体类型（entities）
$t$ ：真值类型（truth values）

函数类型

$⟨ a, b ⟩$ ：从类型 $a$ 到类型 $b$ 的函数

内涵类型

$⟨ s, α ⟩$ ：内涵类型，从世界到 $α$ 外延的函数

表达式	语义类型
John	$e$
runs	$⟨ e, t ⟩$
necessarily	$⟨⟨ s, t ⟩, t ⟩$

2.3 可能世界语义学

2.3.1 可能世界的引入

可能世界语义学将语义解释建立在可能世界的基础上：

可能世界集合 W:

        W = {w₀, w₁, w₂, w₃, ...}
                ↓
        ┌─────────────────────┐
        │  w₀: 现实世界       │
        │  w₁: 拿破仑赢了滑铁卢│
        │  w₂: 人类从未登月   │
        │  w₃: 外星人存在     │
        └─────────────────────┘

语句在每个世界上都有真值

2.3.2 模态逻辑的语义

必然性

⊨_{w} □ ϕ ⟺ 对所有 w^{'} \in W, ⊨_{w^{'}} ϕ

可能性

⊨_{w} ◊ ϕ ⟺ 存在 w^{'} \in W, ⊨_{w^{'}} ϕ

class ModalLogicSemantics:
    """
    模态逻辑语义学
    
    基于可能世界语义
    """
    
    def __init__(self, worlds, accessibility_relation):
        """
        Args:
            worlds: 可能世界集合
            accessibility_relation: 可达关系 R(w₁, w₂)
        """
        self.worlds = worlds
        self.R = accessibility_relation
    
    def evaluate_necessary(self, formula, world):
        """评估必然性 □φ"""
        for w_prime in self.worlds:
            if self.R(world, w_prime):
                if not self.evaluate(formula, w_prime):
                    return False
        return True
    
    def evaluate_possible(self, formula, world):
        """评估可能性 ◇φ"""
        for w_prime in self.worlds:
            if self.R(world, w_prime):
                if self.evaluate(formula, w_prime):
                    return True
        return False

三、组合性原则

3.1 组合性原则的定义

组合性原则（Principle of Compositionality）是形式语义学的核心假设：

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

Frege原则 由Gottlob Frege于19世纪末提出，被视为语义学的基石。

3.1.1 形式化表达

设 $[[e]]$ 表示表达式 $e$ 的语义解释， $G$ 表示语义组合函数：

[[复合表达式]] = G ([[成分 1]], [[成分 2]], ..., [[成分 n]])

组合性的数学表达

class CompositionalSemantics:
    """
    组合性语义
    
    整体意义 = 组合函数(部分意义, 组合方式)
    """
    
    def __init__(self):
        self.meaning_functions = {}  # 词项的语义
        self.combination_rules = {} # 组合规则
    
    def combine(self, constituents, syntactic_rule):
        """
        组合成分语义
        
        遵循组合性原则:
        Sem(composite) = G(Sem(constituent₁), Sem(constituent₂), ...)
        """
        # 获取各成分的语义
        constituent_meanings = [self.meaning_functions[c] for c in constituents]
        
        # 获取组合规则
        combine_fn = self.combination_rules[syntactic_rule]
        
        # 应用组合函数
        result = combine_fn(*constituent_meanings)
        
        return result

3.1.2 组合性的认知基础

组合性原则的合理性在于：

递归结构：语言具有递归的组合结构
系统性：类似的部分可以产生类似的整体
可学习性：有限的规则组合产生无限的意义

3.2 组合系统的设计

3.2.1 类型驱动的组合

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

类型规则:

    α: A    β: B
    ───────────────  (函数应用)
      β(α): B
    
    α: A    (λx.φ): ⟨A, B⟩
    ────────────────────  (λ抽象)
      [α/x]φ: B

class TypeDrivenComposition:
    """
    类型驱动的语义组合
    
    基于类型论的组合性实现
    """
    
    def __init__(self):
        self.type_system = TypeSystem()
    
    def apply_function(self, function, argument):
        """
        函数应用规则
        
        规则: 如果 f: <A, B> 且 a: A，则 fa: B
        
        对应语义: [[fa]] = [[f]]([[a]])
        """
        # 检查类型匹配
        assert function.type == Type('function', argument.type, 'result')
        
        # 计算语义
        result_meaning = function.meaning(argument.meaning)
        return Meaning(result_meaning, function.type.result_type)
    
    def lambda_abstraction(self, variable, body):
        """
        λ抽象规则
        
        规则: 如果 φ: B 且 x: A，则 λx.φ: <A, B>
        
        语义: [[λx.φ]] = λd∈D. [[φ]]⁽ᵍ⁾
        """
        # 创建函数语义
        function_meaning = lambda d: self.evaluate(body, {variable: d})
        
        return Meaning(function_meaning, Type('function', variable.type, body.type))

3.2.2 语法-语义接口

组合性要求语法结构与语义结构对应：

句法结构 → 语义解释
    ↓
NP(John) + VP[V(run)] → S(John runs)
  e       ⟨e,t⟩              t

类型匹配: e × ⟨e,t⟩ → t

class SyntaxSemanticInterface:
    """
    语法-语义接口
    
    实现组合性：句法组合对应语义组合
    """
    
    def compose(self, left_constituent, right_constituent, rule):
        """
        根据句法规则组合语义
        
        组合性要求:
        Sem(left + right) = G(Sem(left), Sem(right), rule)
        """
        left_sem = left_constituent.semantics
        right_sem = right_constituent.semantics
        
        # 根据规则选择组合方式
        if rule == 'NP_VP':
            # NP + VP → S (主语+谓语)
            # ⟨e, t⟩(e) 类型的组合
            return self.subject_predicate(left_sem, right_sem)
        elif rule == 'Det_N':
            # Det + N → NP (限定词+名词)
            # ⟨e,t⟩(e) → t 的组合
            return self.determiner_noun(left_sem, right_sem)
    
    def subject_predicate(self, subject, predicate):
        """
        主语-谓语组合
        
        语义: predicate(subject)
        
        如果 predicate = λx.P(x)，subject = a
        则组合结果 = P(a)
        """
        return predicate.apply(subject)
    
    def determiner_noun(self, det, noun):
        """
        限定词-名词组合
        
        Det: ⟨⟨e,t⟩, ⟨e,t⟩⟩
        N: ⟨e,t⟩
        组合结果: ⟨e,t⟩
        """
        return det.apply(noun)

四、λ演算与语义组合

4.1 λ演算基础

λ演算由Alonzo Church于1930年代提出，是形式语义学中语义组合的核心工具。

4.1.1 λ语法

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

变量： $x, y, z, ...$
抽象： $λ x . M$ （表示以 $x$ 为参数的函数）
应用： $MN$ （将 $M$ 作用于 $N$ ）

4.1.2 α-等价与β-归约

α-等价（重命名）

λ x . M \equiv_{α} λ y . [y / x] M

β-归约（函数应用）

(λ x . M) N \to_{β} [N / x] M

class LambdaCalculus:
    """
    λ演算实现
    
    支持:
    - λ抽象
    - β归约
    - α等价
    """
    
    def __init__(self):
        self.environment = {}
    
    def abstract(self, variable, body):
        """创建λ抽象: λvariable.body"""
        return LambdaAbstraction(variable, body)
    
    def apply(self, function, argument):
        """函数应用: (λx.M)N → [N/x]M"""
        if isinstance(function, LambdaAbstraction):
            # β归约
            return self.substitute(function.body, function.variable, argument)
        else:
            return Application(function, argument)
    
    def substitute(self, expression, variable, replacement):
        """
        代入操作: [replacement/variable]expression
        
        遵循替换规则:
        - [N/x]x = N
        - [N/x]y = y (如果 y ≠ x)
        - [N/x](M₁M₂) = ([N/x]M₁)([N/x]M₂)
        - [N/x](λx.M) = λx.M (避免捕获)
        - [N/x](λy.M) = λy.[N/x]M (如果 y ∉ FV(N) 且 y ≠ x)
        """
        if expression.is_variable():
            if expression == variable:
                return replacement
            else:
                return expression
        
        elif expression.is_application():
            left = self.substitute(expression.left, variable, replacement)
            right = self.substitute(expression.right, variable, replacement)
            return Application(left, right)
        
        elif expression.is_abstraction():
            # 检查是否避免捕获
            if expression.variable == variable:
                return expression
            elif replacement.free_variables().issect(expression.bound_variables()):
                # 需要α转换
                new_var = self.fresh_variable(expression.variable)
                inner = self.substitute(expression.body, expression.variable, Variable(new_var))
                return LambdaAbstraction(new_var, self.substitute(inner, variable, replacement))
            else:
                body = self.substitute(expression.body, variable, replacement)
                return LambdaAbstraction(expression.variable, body)
    
    def beta_reduce(self, expression):
        """执行β归约"""
        if expression.is_application() and expression.left.is_abstraction():
            func = expression.left
            arg = expression.right
            return self.substitute(func.body, func.variable, arg)
        return expression

4.2 λ演算在语义学中的应用

4.2.1 语义表示

λ演算用于构建组合性的语义表示：

句法分析:
    [S [NP John] [VP [V runs]]]

语义构造:
    [[John]] = j
    [[runs]] = λx.run(x)
    [[VP]] = [[V runs]] = λx.run(x)
    [[S]] = [[VP]]([[NP]])
           = (λx.run(x))(j)
           →β run(j)

class SemanticConstruction:
    """
    基于λ演算的语义构造
    
    实现组合性语义组装
    """
    
    def __init__(self):
        self.lexicon = {}
    
    def construct_semantics(self, parse_tree):
        """
        根据句法树构造语义
        
        组合性: 递归应用语义规则
        """
        if parse_tree.is_leaf():
            return self.lookup_lexicon(parse_tree.label)
        
        # 获取子节点的语义
        child_semantics = [self.construct_semantics(child) for child in parse_tree.children]
        
        # 根据句法规则组合
        return self.combine(child_semantics, parse_tree.rule)
    
    def combine(self, child_semantics, rule):
        """
        根据规则组合语义
        
        例如: NP + VP → S
        对应语义: VP(NP) = VP语义(λx. φ)(NP语义)
        """
        if rule == 'S → NP VP':
            np_sem, vp_sem = child_semantics
            # VP是〈e,t〉类型函数
            # 应用: vp_sem(np_sem)
            return vp_sem.apply(np_sem)
        
        elif rule == 'VP → V NP':
            v_sem, np_sem = child_semantics
            # 动词短语: 需要处理论元结构
            return self.combine_vp(v_sem, np_sem)
    
    def combine_vp(self, verb_sem, np_sem):
        """
        动词短语的语义组合
        
        及物动词: V = λy.λx.event(x, y)
        直接宾语: NP = d
        结果: λy.λx.event(x, y)(d) → λx.event(x, d)
        """
        # 这是一个简化版本
        return verb_sem.apply(np_sem)

4.2.2 量化句的处理

λ演算特别适合处理量化词的语义：

"Every student passed."
    
句法: [S [Det every] [N student] [VP passed]]
    
语义构造:
    [[every]] = λP.λQ.∀x(P(x) → Q(x))
    [[student]] = λx.student(x)
    [[passed]] = λx.passed(x)
    
    [[Det N]] = [[Det]]([[N]])
              = (λP.λQ.∀x(P(x)→Q(x)))(λx.student(x))
              →β λQ.∀x(student(x) → Q(x))
    
    [[S]] = [[Det N VP]]
           = (λQ.∀x(student(x) → Q(x)))(λx.passed(x))
           →β ∀x(student(x) → passed(x))

class QuantifierSemantics:
    """
    量化词的语义处理
    
    使用λ演算实现组合性语义
    """
    
    def __init__(self):
        # 量化词的语义定义
        self.quantifiers = {
            'every': lambda P: lambda Q: lambda x: (P(x) <= Q(x)),
            'some': lambda P: lambda Q: lambda x: (P(x) and Q(x)),
            'no': lambda P: lambda Q: lambda x: not (P(x) and Q(x)),
            'a': lambda P: lambda Q: lambda x: (P(x) and Q(x)),  # existential
        }
    
    def every_semantics(self):
        """every的内涵逻辑表示"""
        # every: ⟨〈e,t〉, 〈〈e,t〉, 〈s, t〉〉⟩
        # 即: 接收一个名词短语谓词，返回一个NP辖域的函数
        return lambda P: lambda Q: lambda w: all(
            P(x)(w) <= Q(x)(w) for x in self.domain
        )
    
    def some_semantics(self):
        """some的内涵逻辑表示"""
        return lambda P: lambda Q: lambda w: any(
            P(x)(w) and Q(x)(w) for x in self.domain
        )

五、Montague语法

5.1 Montague语法的核心理念

理查德·蒙太古（Richard Montague）在1970年代创立了Montague语法，其核心观点：

自然语言与形式语言在原则上是同构的。

5.1.1 三原则

形式语义学方法：为自然语言建立形式语义模型
组合性原则：语义由语法结构组合
内涵语义：使用内涵逻辑处理自然语言的歧义

5.2 Montague语法的组件

Montague语法框架:

┌─────────────────────────────────────────┐
│            语法组件 (Syn)                │
│  ├── 范畴语法 (Categorial Grammar)       │
│  └── 短语结构规则                        │
└─────────────────────────────────────────┘
                    ↓ 翻译
┌─────────────────────────────────────────┐
│            翻译规则 (TR)                 │
│  将句法结构映射到内涵逻辑表达式          │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│         内涵逻辑 (IL)                    │
│  ├── 一阶逻辑 + λ演算                    │
│  └── 内涵算子 (↑, ↓, □, ◇)             │
└─────────────────────────────────────────┘
                    ↓
┌─────────────────────────────────────────┐
│          模型论语义 (M)                   │
│  可能世界语义学                          │
└─────────────────────────────────────────┘

class MontagueGrammar:
    """
    Montague语法框架
    
    实现自然语言的形式语义处理
    """
    
    def __init__(self):
        self.syntax = SyntaxComponent()
        self.translation_rules = TranslationRules()
        self.intensional_logic = IntensionalLogic()
        self.model_theoretic_semantics = ModelTheoreticSemantics()
    
    def parse_and_interpret(self, sentence):
        """
        完整处理流程:
        1. 句法分析
        2. 翻译到内涵逻辑
        3. 模型论解释
        """
        # 1. 句法分析
        parse_tree = self.syntax.parse(sentence)
        
        # 2. 翻译到内涵逻辑
        il_expression = self.translate(parse_tree)
        
        # 3. 模型论解释
        truth_value = self.model_theoretic_semantics.evaluate(il_expression)
        
        return {
            'parse_tree': parse_tree,
            'il_expression': il_expression,
            'truth_value': truth_value
        }
    
    def translate(self, parse_tree):
        """
        翻译规则
        
        递归应用翻译规则:
        - 词汇翻译：从词典获取
        - 句法翻译：根据组合规则翻译
        """
        if parse_tree.is_leaf():
            return self.syntax.lexicon[parse_tree.label]
        
        # 根据句法结构应用翻译规则
        return self.translation_rules.apply(parse_tree)

5.3 Montague语法的词汇语义

class MontagueLexicon:
    """
    Montague语法的词典
    
    每个词项关联:
    - 句法范畴
    - 语义类型
    - 内涵逻辑翻译
    """
    
    def __init__(self):
        self.entries = {}
    
    def add_entry(self, word, category, translation):
        """
        添加词典条目
        
        Args:
            word: 词汇项
            category: 句法范畴 (e, t, CN, IV, TV, Det, ...)
            translation: 内涵逻辑翻译
        """
        self.entries[word] = {
            'category': category,
            'translation': translation,
            'semantic_type': self.category_to_type(category)
        }
    
    def lookup(self, word):
        """查询词典"""
        return self.entries.get(word)
    
    def category_to_type(self, category):
        """
        范畴到类型的映射
        
        蒙太古语法的标准映射:
        - e: 实体类型
        - t: 真值类型
        - CN: 〈e,t〉 (普通名词)
        - IV: 〈e,t〉 (不及物动词)
        - TV: 〈e,〈e,t〉〉 (及物动词)
        - Det: 〈〈e,t〉,〈e,t〉〉 (限定词)
        """
        type_mapping = {
            'e': 'entity',
            't': 'truth',
            'CN': ('function', 'entity', 'truth'),
            'IV': ('function', 'entity', 'truth'),
            'TV': ('function', 'entity', ('function', 'entity', 'truth')),
            'Det': ('function', ('function', 'entity', 'truth'), 
                    ('function', 'entity', 'truth'))
        }
        return type_mapping.get(category)
    
    def build_english_lexicon(self):
        """构建英语词典"""
        # 名词
        self.add_entry('man', 'CN', lambda x: man(x))
        self.add_entry('woman', 'CN', lambda x: woman(x))
        self.add_entry('fish', 'CN', lambda x: fish(x))
        
        # 动词
        self.add_entry('walks', 'IV', lambda x: walks(x))
        self.add_entry('loves', 'TV', lambda y: lambda x: loves(x, y))
        
        # 限定词
        self.add_entry('every', 'Det', 
                      lambda P: lambda Q: lambda x: (P(x) → Q(x)))
        self.add_entry('a', 'Det',
                      lambda P: lambda Q: lambda x: (P(x) ∧ Q(x)))
        
        # 专名
        self.add_entry('John', 'NP', 'j')
        self.add_entry('Mary', 'NP', 'm')

5.4 Montague语法的组合规则

class MontagueCombinationRules:
    """
    Montague语法的组合规则
    
    句法规则 ↔ 语义规则 (同构)
    """
    
    def __init__(self):
        self.rules = {}
    
    def add_rule(self, syntactic_rule, semantic_rule):
        """
        添加组合规则
        
        同构原则：句法规则与语义规则一一对应
        """
        self.rules[syntactic_rule] = semantic_rule
    
    def apply(self, syntactic_rule, constituents):
        """
        应用组合规则
        
        典型规则:
        - NP → Det N (名词短语由限定词和名词组成)
        - S → NP IV (句子由名词短语和不及物动词组成)
        - S → NP TV NP (句子由名词短语、及物动词和名词短语组成)
        """
        if syntactic_rule == 'NP → Det N':
            det, noun = constituents
            # 语义: Det(N) = λQ.∀x(N(x) → Q(x))
            return self.combine_det_noun(det, noun)
        
        elif syntactic_rule == 'S → NP IV':
            np, iv = constituents
            # 语义: IV(NP) = IV(NP)
            return self.combine_subject_predicate(np, iv)
    
    def combine_det_noun(self, det, noun):
        """
        限定词 + 名词 → 名词短语
        
        [[Det N]] = [[Det]]([[N]])
        """
        # det: λP.λQ.∀x(P(x)→Q(x))
        # noun: λx.N(x)
        # 组合: det(noun) = λQ.∀x(N(x)→Q(x))
        return det.apply(noun)
    
    def combine_subject_predicate(self, subject, predicate):
        """
        主语 + 谓语 → 句子
        
        [[NP IV]] = [[IV]]([[NP]])
        """
        # predicate: λx.P(x)
        # subject: d
        # 组合: predicate(subject) = P(d)
        return predicate.apply(subject)

六、形式语义学的前沿议题

6.1 动态语义学

传统的Tarski语义学是静态的，而自然语言理解需要动态处理：

6.1.1 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            │
│ (指代链)                │
└─────────────────────────┘

class DiscourseRepresentationTheory:
    """
    话语表现理论 (DRT)
    
    动态语义学的基础框架
    """
    
    def __init__(self):
        self.drs_stack = []
    
    def new_drs(self):
        """创建新的DRS"""
        return {
            'referents': set(),      # 指称集合
            'conditions': []         # 条件列表
        }
    
    def add_referent(self, drs, variable):
        """添加指称"""
        drs['referents'].add(variable)
    
    def add_condition(self, drs, condition):
        """添加条件"""
        drs['conditions'].append(condition)
    
    def merge_drs(self, drs1, drs2):
        """
        合并两个DRS
        
        用于处理并列句
        """
        merged = {
            'referents': drs1['referents'] | drs2['referents'],
            'conditions': drs1['conditions'] + drs2['conditions']
        }
        return merged
    
    def resolve_anaphora(self, drs, pronoun):
        """
        回指消解
        
        在指称集合中寻找最合适的先行语
        """
        # 简化版本：返回最近的兼容指称
        candidates = list(drs['referents'])
        return candidates[-1] if candidates else None

6.2 概率语义学

将概率引入形式语义学：

class ProbabilisticSemantics:
    """
    概率语义学
    
    结合概率论与形式语义学
    """
    
    def __init__(self, domain):
        self.domain = domain
        self.probability_space = self._build_probability_space()
    
    def probabilistic_interpretation(self, expression, world):
        """
        概率解释
        
        语句的意义不再是简单的真值，
        而是真值上的概率分布
        """
        # P(φ | context) = 0.8
        pass
    
    def bayesian_pragmatics(self, utterance, context):
        """
        贝叶斯语用学
        
        基于概率推理的语用解释模型
        """
        # 使用贝叶斯推断解释话语
        prior = self.prior_belief(context)       # 先验
        likelihood = self.utterance_likelihood(utterance)  # 似然
        posterior = self.bayesian_update(prior, likelihood)  # 后验
        return posterior

参考文献与推荐阅读

Tarski, A. (1944). The semantic conception of truth. Philosophy and Phenomenological Research, 4(3), 341-376.
Montague, R. (1970). Universal grammar. Synthese, 22, 371-398.
Montague, R. (1973). The proper treatment of quantification in ordinary English. Approaches to Natural Language.
Heim, I., & Kratzer, A. (1998). Semantics in Generative Grammar. Blackwell.
Gamut, L. T. F. (1991). Logic, Language, and Meaning (Vol. 2). University of Chicago Press.
Barker, C., & Jacobson, P. (Eds.). (2007). Direct Compositionality. Oxford University Press.

关联文档

计算语义学深度指南：语义学整体框架

词向量与分布式语义：分布语义方法

语用学与AI：语用推理应用

概念语义学详解：概念表示

分布式语义学详解：分布式语义理论

人工智能知识库

探索

形式语义学基础

形式语义学基础

关键词速览

一、Tarski的真值条件语义学

1.1 真值条件语义学的起源

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

1.3 Tarski语义学的形式化框架

1.3.1 语言结构

1.3.2 结构与模型

1.4 真值条件的形式化

1.4.1 一阶逻辑的真值条件

1.4.2 真值条件的计算实现

二、模型论语义学基础

2.1 外延语义

2.1.1 基本外延关系

2.1.2 外延原则

2.2 内涵语义

2.2.1 内涵的定义

2.2.2 内涵类型论

2.3 可能世界语义学

2.3.1 可能世界的引入

2.3.2 模态逻辑的语义

三、组合性原则

3.1 组合性原则的定义

3.1.1 形式化表达

3.1.2 组合性的认知基础

3.2 组合系统的设计

3.2.1 类型驱动的组合

3.2.2 语法-语义接口

四、λ演算与语义组合

4.1 λ演算基础

4.1.1 λ语法

4.1.2 α-等价与β-归约

4.2 λ演算在语义学中的应用

4.2.1 语义表示

4.2.2 量化句的处理

五、Montague语法

5.1 Montague语法的核心理念

5.1.1 三原则

5.2 Montague语法的组件

5.3 Montague语法的词汇语义

5.4 Montague语法的组合规则

六、形式语义学的前沿议题

6.1 动态语义学

6.1.1 DRT（话语表现理论）

6.2 概率语义学

参考文献与推荐阅读

关系图谱

目录

反向链接