Wolfram mathematica 将特定规则应用于Mathematica中的保留（或未赋值）函数

我是Mathematica的新手，仍然无法理解Mathematica的评估控制、与之相关的所有可能构造（例如，

Hold

、

Unevaluated

，等等）以及它们的工作方式，尽管有详尽的文档以及讨论此主题的大量StackExchange和StackOverflow问题。因此，对于任何可能的重复，我深表歉意

我的用例如下：我有一个由数千条规则和模式（

DownValues

）定义的函数（比如

f

）。我想从

f[expr]

（对于某些

expr

）的展开表示开始，并获得将单个特定规则应用于

f[expr]

的结果。我希望结果也保持展开状态

作为一个特殊示例，假设我们有以下内容：

 In[1]: nat[0] := 0
 In[2]: nat[n_] := 1 + nat[n - 1]
 In[3]: DownValues[nat]
Out[3]: {HoldPattern[nat[0]] :> 0, HoldPattern[nat[n_]] :> 1 + nat[n - 1]}
 In[4]: nat[10]
Out[4]: 10

现在，我想从一个表示为

nat[10]

（未计算！）的表达式开始，并想具体应用第二条规则（

HoldPattern[n\u]]：>1+nat[n-1]

），以

1+nat[9]

的形式获得表达式。类似地，如果我希望应用第一条规则（

HoldPattern[nat[0]]：>0

），我希望结果保持其原始形式不变，即

nat[10]

---

谢谢你的帮助

这将有助于你理解Mathematica的运算方法

Wolfram参考：

也就是说，Mathematica“寻找形式为f[n]的表达式的值，它首先尝试特殊情况f[1]，只有当这不适用时，它才会尝试一般情况f[n]

因此，对于下面的函数，

nat[0]

总是首先尝试，但当然它只在参数为0时才计算。然后尝试

nat[n.]

nat[0] := 0
nat[n_] := 1 + nat[n - 1]

对于您关于获取

1+nat[9]

的问题，这里有一种方法

Clear[nat]

nat[0] := 0
nat[n_] := HoldForm[1 + nat[o]] /. o -> n - 1

ans = nat[10]

1+nat[9]

十,

或者（更好）

1+nat[9]

9+（1+nat[0]）

注意，这是10次迭代后的结果。最后的

ReleaseHold

结果是

nat[0]

计算为0

ReleaseHold[ans]

十,

如果您在上面的演示中使用

Hold

而不是

HoldForm

，您可能会发现更容易看到发生了什么。

正如Mathematica的StackExchange中作为a发布的一样，我发现了一种相对更直接的方法来处理这个问题：

 In[6] rules = DownValues[nat]                                                 
Out[6] {HoldPattern[nat[0]] :> 0, HoldPattern[nat[n_]] :> 1 + nat[n - 1]}

 In[7] DownValues[nat] = {}                                                    
Out[7] {}

 In[8] nat[10]                                                                 
Out[8] nat[10]

 In[9] nat[10] /. rules[[1]]                                                   
Out[9] nat[10]

 In[10] nat[10] /. rules[[2]]                                                  
Out[10] 1 + nat[9]

---

Mathematica的StackExchange中也提出了这个问题。

nat[10]/。规则[[1]]

实际上并没有对规则1执行任何操作。规则1仅在nat[0]上运行。您所看到的只是作为输出交付的输入，没有替换。此外，如果仍有

nat

的定义，则

nat[10]

在尝试任何替换之前计算为10。正如我在回答中提到的，Mathematica有一个计算阴影函数的系统。使用哪个规则的选择遵循此系统。

Do[ans = ReleaseHold[ans], 9]

ans

ReleaseHold[ans]

 In[6] rules = DownValues[nat]                                                 
Out[6] {HoldPattern[nat[0]] :> 0, HoldPattern[nat[n_]] :> 1 + nat[n - 1]}

 In[7] DownValues[nat] = {}                                                    
Out[7] {}

 In[8] nat[10]                                                                 
Out[8] nat[10]

 In[9] nat[10] /. rules[[1]]                                                   
Out[9] nat[10]

 In[10] nat[10] /. rules[[2]]                                                  
Out[10] 1 + nat[9]