Agent 神经-符号融合的统一推理架构 2026

一、问题的提出：当生成式推理撞上符号可验证性

2026 年的 Agent 系统似乎已经被一个隐含的二元对立所主导:神经大模型端到端生成文本与决策,符号系统执行逻辑推导与可验证执行。两套范式各有强项,但要让一个 Agent 既具备 LLM 的开放语义能力又具备符号求解的可证伪性,工程师被迫在"prompt 工程 + 工具调用"与"经典 AI 规划 + 演绎求解器"之间反复切换。问题是:为什么这两套范式不能在一个端到端可微的体系下融合?当我们审视 ReAct / Reflexion / Tree-of-Thoughts / Plan-and-Execute 四大推理范式时,会发现它们共同的认知负担——LLM 在每一步既要"猜测"下一步动作又要"评估"动作后果,这种双重负荷恰好是符号系统本来可以外包的:把"评估"交给确定性求解器,让神经网络只负责"提议"。本文尝试给出一种神经-符号融合的统一推理架构,把这一二元对立从"选择"转为"分工"。

神经 LLM 与经典符号 AI 的鸿沟可以用三组轴来刻画:连续表示 vs 离散表示、概率近似推理 vs 确定性演绎、端到端梯度 vs 符号可解释。这三组轴并不互斥,但传统的实现路径把它们强行分割成两个工程栈。最近三四年出现的 Neural Program Induction、Differentiable Logic、Knowledge Compilation as Interface 等研究方向,正在尝试把三组轴"软合并",本文把这三个方向统一在一个不动点几何视角下讨论。

二、形式化:神经-符号融合的三元组

设 Agent 在时间步 t 处于状态 s_t ∈ S,环境给出观察 o_t ∈ O,Agent 输出一组候选动作 a_t^1, ..., a_t^k ∈ A。神经-符号融合系统的设计目标可以形式化为:

定义 1(Agent 推理的三元组): 一个神经-符号 Agent 是一个三元组 (P_θ, V_φ, T_ψ),其中:

• P_θ: O × S → 2^A 是一个神经提议器(neural proposer),参数 θ 来自 LLM 微调或 in-context learning,输出候选动作集合;
• V_φ: A × O × S → {0, 1, ⊥} 是一个符号验证器(symbolic verifier),参数 φ 表示一组形式化规约(约束、规则、KB),输出动作是否被允许、被否决或不确定;
• T_ψ: A × S → S × ℝ 是一个神经-符号翻译器(translator),把验证通过的动作翻译为环境可执行的下游状态与置信度。

关键的设计约束是 V_φ 必须是确定性且可解释的:对任意 (a, o, s),V_φ 的返回值必须可由人工或自动定理证明器审计。换言之,V_φ 不参与梯度反传,只在 forward 时被查询;它通过修改 P_θ 的训练数据或在推理时过滤 P_θ 的候选来间接影响 Agent。

定义 2(统一目标函数): 给定任务分布 D,Agent 的期望回报是:

L(θ, φ, ψ) = E_(o,s) ~ D [ Σ_t γ^t · r(a_t, s_t, o_t) ]

其中 a_t = arg max_{a ∈ A_t} [ α · P_θ(a|o_t, s_t) + β · V_φ(a, o_t, s_t) · 置信度 ]

α, β 是可学习的组合系数;γ 是折扣因子。这个目标既不是纯 LLM 的 next-token 损失,也不是经典强化学习的期望回报——它把符号验证的"硬约束"作为一个可微松弛项(后文会展开)。

三、Neural Program Induction:程序归纳的张量化

第一支柱是程序归纳的张量化(neural program induction)。把符号系统视作"程序归纳问题":给定输入-输出对 {(x_i, y_i)},推断一个 Lisp/Python 程序 π 使 ∀i: π(x_i) ≈ y_i。DeepCoder、RobustFill、Neural Program Synthesis 等工作证明,在小型 DSL 上,神经搜索可以以远高于纯枚举的效率找到程序。

把这一思想抬升到 Agent 推理的层面:把 Agent 的每一步动作视作一段可执行程序,LLM 负责在程序空间 P 上做分布采样,符号求解器负责"程序是否满足规约"。具体地:

# 神经提议器 P_θ 生成候选程序骨架
candidate_programs = proposer.sample(
    prompt=observation + state,
    n=8,                # 采样 8 个候选
    temperature=0.7,
)
# 符号验证器 V_φ 在 DSL 类型系统 + 规约 KB 上过滤
validated = []
for prog in candidate_programs:
    try:
        type_check = type_system.check(prog)         # 类型一致性
        pre_cond = kb.check_precondition(prog, state)  # 前置条件
        if type_check and pre_cond:
            validated.append((prog, kb.score(prog)))
    except SymbolicError as e:
        log("rejected by V_phi", reason=str(e), prog=prog)
# 翻译器 T_ψ 把 validated 转换为可执行指令
executable = translator.compile(validated[0])

关键洞察是:神经网络的强项是"语义模糊情况下的合理猜测",符号系统的强项是"对合理猜测的硬性约束"。两者结合的关键是DSL 的设计:DSL 既要足够丰富以表达开放域推理,又要足够受限以使符号验证可在毫秒级完成。在 2026 年的实践中,常见的选择是:

1. 受限 Python 子集(only pure functions, no side effects in tool calls):用 mypy + Z3 做静态验证;
2. 结构化 JSON-Schema action(function calling 的 schema):用 JSON-Schema validator 做形态验证;
3. 领域特定 DSL(如 SQL 子集, Kubernetes YAML 子集):用专门求解器。

程序归纳的极限在哪里?当任务分布从"训练见过的程序结构"漂移到"训练未见的程序结构"时,提议器的分布会长尾塌缩到常见模式上,验证器会发现所有候选都不满足规约。这是OOD 触发的不动点漂移:神经提议器退化为纯猜测,符号验证器无法从"全候选被否决"的状态恢复出新的候选。缓解方案是回退到 LLM 的 plan-and-execute 模式,或者把"全否决"信号反馈给提议器作为 in-context 提示。

四、Differentiable Logic:逻辑约束的可微松弛

第二支柱是逻辑约束的可微松弛(differentiable logic)。经典一阶逻辑是不可微的——命题要么真要么假,不存在"99% 真"的中间状态。Differentiable Logic 把布尔连接词 ∧, ∨, ¬ 替换为它们的可微松弛:t-norm 乘积代替 ∧,s-norm 最大值代替 ∨,1 - x 代替 ¬。在这种松弛下,逻辑公式变成一个实值函数 f: {0,1}^n → [0,1],可以求梯度。

应用——在 Agent 推理中,我们经常需要表达"动作 a 必须满足前置条件 pre ∧ (post1 ∨ post2)",这类约束如果用经典逻辑表示,V_φ 会给出布尔判定。但如果用可微松弛,F(a) = pre_t(a) · max(post1_t(a), post2_t(a)),则 F(a) 可以作为软惩罚加到 P_θ 的训练损失里:

L(θ) = L_LM(θ) - λ · F(proposer.sample())

这种"软约束"在 LLM 训练时表现为一种归纳偏置:模型被鼓励采样满足前置条件的动作序列,而不是从无条件分布中取样。λ 是退火参数,在训练早期大(强制约束),后期小(让模型自由发挥)。

与硬约束的对照——可微松弛的代价是"软约束可能被违反"。在生产 Agent 中,这种违反是不可接受的——比如"用户授权才能删除文件"这种安全约束必须硬执行。正确做法是把可微松弛用于"训练时的归纳偏置",而推理时仍走硬验证:V_φ 在 forward 路径上是布尔判定,T_ψ 在编译时不引入模糊状态。这种"训练软 / 推理硬"的不对称设计,是神经-符号融合最关键的工程教训。

# Differentiable Logic 的 PyTorch 风格伪代码
def soft_and(x, y):
    return x * y                              # t-norm product
def soft_or(x, y):
    return torch.maximum(x, y)                # s-norm max
def soft_not(x):
    return 1.0 - x

# 训练时:把硬约束转成软惩罚加到 LM loss 上
pre_cond = soft_and(user_authenticated, file_exists)
post_cond = soft_or(backup_exists, soft_not(is_production))
soft_constraint = soft_and(pre_cond, post_cond)   # ∈ [0, 1]

lm_loss = ce_loss(logits, labels)
total_loss = lm_loss - lambda_weight * soft_constraint
# 当 soft_constraint ≈ 1 时,total_loss ≈ lm_loss(无惩罚)
# 当 soft_constraint ≈ 0 时,total_loss ≫ lm_loss(强制梯度把约束推到 1)

开放问题——如何选择 λ 的退火曲线?太慢则约束信号被 LM loss 淹没,太快则模型过早收敛到一种"安全但不灵活"的策略。在 2026 年的实践中,业界仍未给出一个普适的退火 schedule,这是神经-符号融合领域的未解难题。

五、Knowledge Compilation as Interface:知识图谱作为神经-符号接口

第三支柱是知识图谱作为神经-符号接口(KG as interface)。这一思路把"知识图谱"从一个静态数据库提升为 Agent 与 LLM 之间的双向信道:LLM 通过自然语言查询 KG,KG 通过返回结构化事实+规约约束影响 LLM 的下一步动作。

具体地,设 KG 是一个三元组集合 K ⊆ (E × R × E),其中 E 是实体集合,R 是关系集合。一个知识编译接口由三个组件构成:

1. Schema 层:定义 KG 的本体 O,包括实体类型、关系类型、约束(基数约束、值域约束、不变式);
2. 推理层:把 LLM 的自然语言意图转换为 SPARQL / Datalog 查询,执行查询,返回绑定;
3. 翻译层:把查询结果翻译回 LLM 可消化的自然语言或结构化 prompt。

核心收益是 KG 的可验证性:每一条 LLM 输出的事实,都可以反查到 KG 中的源三元组,这一"引用机制"在 RAG 系统中已经开始标准化。在 Agent 推理场景,KG 不只是事实来源,还是动作规约的源头:当 Agent 要执行"修改订单价格"动作时,V_φ 通过查询 KG 得到当前订单状态、用户权限、规则约束,直接给出布尔判定。

关键设计是 KG 的版本化与一致性:当底层业务规则变化时,KG 必须同步更新,否则 V_φ 会给出过时的判定。2026 年的实践中,KG 通常与业务事件总线打通,通过 CDC(change data capture)实时同步;但形式化规约的同步(如"促销期间不允许修改价格")仍然依赖人工维护,这是 KG-as-interface 的最大工程痛点。

对 Agent 的影响——KG-as-interface 把 Agent 的"世界模型"从一个隐式的 LLM 内部表示,外化为一个可查询、可审计、可版本化的结构。这与 id=368 的"Agent 世界模型的 POMDP 信念几何"形成了有趣对照:POMDP 视角下世界模型是 agent 内部的概率分布,KG 视角下世界模型是外部的确定性结构。两者并不矛盾:POMDP 处理"agent 不确定的部分",KG 处理"agent 应该确定的部分"。

六、统一视角:不动点几何与不动点定理

把上述三个支柱统一在一个不动点几何视角下:设神经-符号 Agent 在时间步 t 的状态为 s_t,环境观察为 o_t,系统的目标函数为 L(θ, φ, ψ)。当 Agent 收敛到一组稳定的动作序列时,我们可以定义:

定义 3(神经-符号不动点): Agent 的状态序列 (s_t) 满足 T(s_t, o_t) = s_{t+1} 时进入不动点,其中 T 是状态转移函数,由 P_θ, V_φ, T_ψ 复合而成。

不动点存在的条件——根据 Banach 不动点定理,如果 T 是关于 s 的压缩映射(‖T(s_1) - T(s_2)‖ ≤ L ‖s_1 - s_2‖,L < 1),则不动点唯一存在。在 Agent 推理中,这种压缩性来自两个机制:

1. V_φ 的硬约束压缩——验证器否决掉所有违反规约的候选,可行集被压缩到一个小区域;
2. T_ψ 的确定性翻译——同样的候选动作经过 T_ψ 总得到同样的执行,消除了提议器的随机性。

与经典不动点的区别——经典强化学习的策略不动点是"在同样状态下总选择同样动作",这是确定性的;神经-符号不动点还要求"动作必须满足规约",这是结构性的。两者合起来,不动点不是单纯的策略收敛,而是策略 + 规约的联合收敛。

几何直觉——把状态空间 S 视作一个流形,验证器 V_φ 把可行集 S_valid ⊂ S 切出来,翻译器 T_ψ 在 S_valid 上定义了一个向量场。不动点是这个向量场的零点。训练过程就是让 P_θ 的提议分布集中在 S_valid 邻域;推理过程就是让 T 的轨迹进入 S_valid 中的某个不动点。

向量场的拓扑分类——可行集 S_valid 的拓扑结构决定了不动点的数量与稳定性。若 S_valid 是凸集且 T 是单调映射,则 T 的不动点唯一;若 S_valid 是非凸集(如带环或孔洞),则 T 可能存在多个不动点,对应 Agent 推理中的"策略分叉"——同一观察下选择不同动作序列都是合理的。这种分叉在纯 LLM Agent 中是隐式的(由温度采样引入),在神经-符号 Agent 中是显式的(由 V_φ 的可行集结构决定)。

不动点的稳定性分析——对不动点 s*,考察 T 在 s* 处的雅可比矩阵 J = ∂T/∂s|s*。若 J 的所有特征值的模都小于 1,则 s* 是局部渐近稳定的不动点(小扰动后轨迹会回到 s*);若至少一个特征值的模大于 1,则 s* 是不稳定的不动点(扰动后轨迹会远离 s*)。在 Agent 推理中,我们希望 T 的不动点是稳定且可达的,这意味着 P_θ 在训练时应该让提议分布向稳定不动点倾斜,V_φ 在推理时应该把可行集切到只剩稳定不动点的邻域。

训练-推理的不动点对齐——一个常被忽视的工程问题是:P_θ 训练时的不动点(在 LLM 损失最小化的意义上)和 V_φ 推理时的不动点(在规约约束的意义上)未必是同一点。软约束 λ 退火的目的就是让这两个不动点逐渐对齐:训练早期 λ 大,软约束把 P_θ 推向 V_φ 的可行集;训练后期 λ 小,P_θ 的分布由 LM 损失主导,但其均值应该落在 V_φ 的稳定不动点附近。如果对齐失败,推理时会观察到"训练 loss 收敛但验证通过率低"的现象,这是软约束与硬约束桥接失败的标志。

七、对工程实践的推论

把这一理论映射到生产 Agent 工程,有七条可直接执行的推论:

1. DSL 优先于自由文本——不要让 LLM 直接输出 JSON,先用受限 DSL(JSON Schema 或 Python 子集)约束输出形态,再用 V_φ 验证;这条推论的代价是 DSL 设计的工程负担,收益是可验证性的量级提升。

2. V_φ 必须可审计——任何符号验证器的判定都必须可由人工在 5 分钟内复现;否则"符号约束"沦为另一种黑盒。

3. KG 同步延迟要有上限——业务事件到 KG 更新的端到端延迟必须 < 5 秒,否则 Agent 会基于过时规约决策;超过这个上限必须降级为"冻结 KG + 拒绝高风险动作"。

4. 训练软、推理硬——Differentiable Logic 用于训练时诱导偏置,推理时仍走硬验证;不要在推理路径上引入模糊状态。

5. OOD 触发回退——当 V_φ 连续 N 次否决所有候选时,Agent 必须回退到 LLM-only 模式(或人类接管);这是"全否决"信号的工程响应。

6. 不确定性来自 P_θ 而不是 V_φ——V_φ 是确定性的,任何不确定性必须由提议器的分布熵显式表达;不要让 V_φ 输出 0.7 这样的模糊判定。

7. 可微松弛与硬约束分离——可微松弛只进训练 loss,硬约束只进 forward 验证;两者共享规约语义但路径隔离。

下面用一个最小可运行示例说明第 1、2、4 条:

import json
from typing import Literal

# V_φ:硬约束验证器,完全确定性,完全可审计
class OrderActionValidator:
    ALLOWED_TYPES = {"view", "create", "modify", "cancel"}
    REQUIRES_AUTH = {"modify", "cancel"}

    def validate(self, action: dict, user: dict, order: dict) -> tuple[bool, str]:
        if action["type"] not in self.ALLOWED_TYPES:
            return False, f"unknown action type: {action['type']}"
        if action["type"] in self.REQUIRES_AUTH:
            if not user.get("is_authenticated"):
                return False, "authentication required"
            if user["id"] != order["owner_id"] and not user.get("is_admin"):
                return False, "permission denied"
        if action["type"] == "modify" and order["status"] == "shipped":
            return False, "shipped orders cannot be modified"
        return True, "ok"

# P_θ:LLM 提议器,输出受限 JSON DSL
def propose_action(observation: str, state: dict) -> list[dict]:
    prompt = f"""观察: {observation}\n状态: {state}\n输出严格的 JSON 动作候选(每个一行):"""
    response = llm.complete(prompt, response_format={"type": "json_object"})
    candidates = json.loads(response)["candidates"]
    return candidates

# T_ψ:翻译器,把验证通过的动作翻译为执行
def execute_action(action: dict) -> dict:
    return {"action_id": action["type"], "params": action.get("params", {})}

# 主循环
for step in range(max_steps):
    candidates = propose_action(observation, state)
    validator = OrderActionValidator()
    accepted = []
    for action in candidates:
        ok, reason = validator.validate(action, user, order)
        if ok:
            accepted.append(action)
        else:
            audit_log.append({"action": action, "rejected_by": "V_phi", "reason": reason})
    if not accepted:
        return fallback_to_llm_only(state)  # OOD 回退
    action = accepted[0]
    state = execute_action(action)

八、讨论:局限与开放问题

神经-符号融合的统一推理架构并非银弹,它面临四个根本性的开放问题:

第一,DSL 的可表达性 vs 可验证性的张力。DSL 越受限,可验证性越好,但能表达的推理也越少。无限 DSL(完整 Python)可表达一切但难以验证;极受限 DSL(只读 SQL)易验证但不能表达动作修改。这一表达性鸿沟目前没有通用解,工程上只能靠"任务特化的 DSL 集合"。更糟的是,DSL 设计的"对错"高度依赖下游任务:同一段 Python DSL 在数值计算任务里几乎无约束,在文件系统任务里就是灾难。一个粗糙的经验法则是:对安全敏感的动作(写文件、调用 API、修改状态),DSL 约束必须明确禁止 side effects 的隐式路径;对只读动作(查询、检索、分析),DSL 约束可以放宽以保留表达力。

第二,KG 维护的工程负担。KG-as-interface 把世界模型外化到 KG,这要求工程团队持续投入 KG schema 演进、约束规约维护、CDC 同步链路。LLM-only Agent 不需要这些负担,但代价是不可验证。在大型组织里,KG 维护通常由独立的数据团队负责,这引入了跨团队的规约一致性难题——数据团队修改规约时不一定通知 AI 团队,导致 V_φ 与业务现状脱节。缓解方案是"规约变更必须经 Agent 团队评审",但这会拖慢业务迭代速度。

第三,可微松弛与硬约束的桥接。Differentiable Logic 在训练时给出软信号,但推理时必须切换到硬验证。这一切换可能引入训练-推理不一致(train-inference gap),让软约束学到的偏置在硬约束面前失效。具体表现是:训练时模型学会"软约束值 0.8 时动作可行",但推理时 V_φ 只接受 0 或 1,导致推理时大量本应可行的动作被否决。一个工程性的缓解是"硬约束接受软约束的概率大于阈值 θ",但 θ 的选择是新的超参,引入新的调试负担。

第四,大模型的"语义漂移"对 V_φ 的影响。LLM 本身的输出分布会随 RLHF / continual learning 漂移,这会让"基于 LLM 输出文本"的 KG 查询变得不稳定。一个朴素的应对是"在 KG 查询前先对 LLM 输出做 schema 校验",但这只是缓解,不是根治。更深的问题是:LLM 输出"查询订单 #12345 的状态",但模型微调后可能输出"查询 order #12345 status"——文本字面相似但 KG 查询的 SPARQL 模板已经失效,这是语义等价但句法漂移。根治需要 KG 查询层做语义级(而非字符串级)匹配,这又引入了新的对齐问题。

第五,验证器的"完备性盲区"。V_φ 只能验证它"知道"的规约。当遇到规约未覆盖的情况,V_φ 给出"不确定"(⊥)而非"否决"。这一设计是工程权衡:宁可放行可疑动作让下游审计发现,也不可误否决合法动作。但放行的动作可能违反业务规则,只是 V_φ 没意识到。缓解是"未覆盖规约必须升级到人工审查队列",但这要求 V_φ 有完整的"未覆盖"信号日志。

九、给研究者的可观测清单

如果正在构建神经-符号 Agent 系统,以下九个观测点应该第一时间接入监控系统:

1. V_φ 否决率(reject rate):跨时间步统计"被 V_φ 否决的候选占总候选的比例",持续 > 50% 通常意味着 DSL 太严或 P_θ 分布漂移;持续 < 5% 则意味着 DSL 太松或规约不充分;
2. OOD 触发率(OOD fallback rate):统计"全候选被否决"的回合比例,> 10% 是危险信号,需要回退到 LLM-only 模式或人工接管;
3. KG 同步延迟(KG freshness lag):业务事件到 KG 更新的端到端延迟 P99,超过 SLO 必须告警;长尾延迟超过 30 秒应该触发"冻结 KG"机制;
4. 可微松弛 vs 硬约束的一致性(constraint consistency):训练时 soft constraint 与推理时 hard constraint 的对齐度,持续偏离意味着 λ 退火有问题;具体观测指标是"训练时软约束均值 / 推理时硬约束通过率",二者比例应接近 1;
5. 提议器熵(proposer entropy):P_θ 输出分布的熵,过低意味着过拟合(模型只输出一种候选),过高意味着欠拟合(候选过于分散,验证成本上升);建议监控 Shannon 熵随时间步的变化曲线;
6. 可微松弛系数 λ 退火轨迹:λ 的时间曲线,应该呈"早期大 → 后期小"的指数衰减,异常凸起需要排查训练 loss;λ < 0.01 时模型基本由 LM loss 主导,应该停止软约束信号;
7. 训练-推理动作对齐率(action alignment rate):同一观察下,训练时 P_θ 提议的动作与推理时 V_φ 通过的动作的比例,持续 < 70% 意味着软约束与硬约束桥接失败;
8. KG 规约变更频次(schema change rate):单位时间内 KG schema 变更次数,与 V_φ 验证失败率做相关性分析,突变后 24 小时内验证失败率上升 > 20% 是预期的;
9. 规约覆盖率(rule coverage rate):V_φ 实际命中的规约数 / KG 中总规约数,< 50% 意味着大量规约未被实际使用,可能是规约过定义或候选分布偏离规约热点。

把这九个指标接入 Prometheus + Grafana,你就能在生产环境实时观察神经-符号 Agent 的"健康度"——任何一项偏离基线,都对应着本文某一节的失效模式。建议把这九个指标映射到三色仪表板:绿(健康)、黄(需关注)、红(必须干预),配合 PagerDuty 自动告警,在生产环境形成完整的可观测闭环。

一句话摘要:神经-符号融合不是"用神经网络替代符号系统",也不是"用符号系统约束神经网络",而是把两者组织成"提议-验证-翻译"的三元组,在训练时通过可微松弛传导归纳偏置,在推理时通过硬验证保证可证伪性——这条架构路线让 Agent 既保留 LLM 的开放语义能力,又具备符号求解的可审计可证伪性,是 2026 年 Agent 推理走向生产可信的关键工程范式。

参考文献

1. Garcez A d, Lamb L C. Neurosymbolic AI: The 3rd Wave. Artificial Intelligence Review, 2023.
2. Evans R, Grefenstette E. Learning Explanatory Rules from Noisy Data. Journal of Artificial Intelligence Research, 2018.
3. Manhaeve R, Dumancic S, Kimmig A, et al. DeepProbLog: Neural Probabilistic Logic Programming. NeurIPS, 2018.
4. Cropper A, Dumancic S, Evans R, et al. Inductive Logic Programming at Scale. arXiv:2109.06162, 2021.
5. Chaudhuri S, Dillig I, Polikarpova N, et al. Program Synthesis. Foundations and Trends in Programming Languages, 2018.
6. Ellis K, Wong C, Nye M, et al. DreamCoder: Growing Generalizable, Interpretable Knowledge with Wake-Sleep Bayesian Program Learning. PhD Thesis MIT, 2021.
7. Si X, Raghothaman M, Heo K, et al. Synthesizing Datalog Programs using Numerical Relaxation. IJCAI, 2019.
8. Solar-Lezama A, Tancrède C. Program Synthesis by Sketching. PhD Thesis UC Berkeley, 2008.
9. Rocktäschel T, Riedel S. End-to-end Differentiable Proving. NeurIPS, 2017.
10. Minervini P, Bosnjak M, Rocktäschel S, et al. Differentiable Reasoning on Large Knowledge Bases. NAACL, 2020.
11. Pryor C, Dickens C, Augustine E, et al. Neural Program Synthesis from Diverse Program Examples. ICLR, 2022.
12. Parisotto E, Mohamed A, Singh R, et al. Neuro-Symbolic Program Synthesis. ICLR, 2017.
13. Verma A, Murali V, Singh R, et al. Programmatically Interpretable Reinforcement Learning. ICML, 2018.
14. Icarte R T, Klassen R Q, Valenzano R A, et al. Using Reward Machines for High-Level Task Specification and Decomposition in Reinforcement Learning. ICML, 2018.
15. Silver T, Chitnis R, Curtis A, et al. Planning with Learned Object Categories. ICAPS, 2021.