关于haskell：是否有一种快速算法来确定上下文无关语言的术语的godel数？

Is there a fast algorithm to determine the godel number of a term of a context free language?

假设我们有一个简单的语法规范。有一种枚举该语法项的方法，该方法通过对角迭代来确保任何有限项都具有有限位置。例如，对于以下语法：

1
2
3
4
5
6

您可以列举如下术语：

1
2
3
4
5
6
7
8
9
10
11

0
1
0+0
0*0
0+1
(0)
1+0
0*1
0+0*0
00
... etc

我的问题是：有没有办法做相反的事情？也就是说，采用该语法的有效术语，例如0+0*0，并找到其在这种枚举中的位置-在这种情况下，为9？

相关讨论

枚举，直到您达到期限？但是，这显然并不快。不过，我本应该将其发布到CS，所以我认为这样的事情实际上不再是地方了。
我敢猜测CS也不适合。对于我来说，很难想象有人会在乎一种G？del编号算法的效率。
您是否要求枚举是"密集的"，以没有空白？使用结构递归向自然对象进行注入很容易，但是双射性似乎更困难。
这并不是真正的重复，但似乎很相关：stackoverflow.com/questions/17387686 / ...正如我在那个答案中说的那样，仅在语法明确的情况下，对角化的幼稚枚举才有效。
我不确定这是否有帮助，但是您可以使用[Chomsky-Schutzenberger定理]获取CFG的生成函数，并使用该函数快速确定有多少个短于您的字符串。给定的字符串。这样一来，虽然我不确定，但可以弄清楚它会出现在哪个索引上。 (en.wikipedia.org/wiki/…)
我认为这个职位是不唯一的。例如，您可以将0 0 0生成为{0 0} 0或0 {0 0}，它们是输出列表中的两个位置。当然，您只需指定左或右关联，此问题就会消失。
顺便说一句，问题似乎与解析密切相关。我敢打赌，您可以从语法分析树转到O(1)中的位置，而语法为O(1)...。但是我无法将其全神贯注于如何执行此操作的细节。
@jamshidh：给定的语法是明确的； 0 0 0只能最右派生为S->add->add+mul->add+term->add+0->add+mul+0->add+term+0->add??+0+0->mul+0+0->term+??0+0->0+0+0。为了枚举唯一的句子，对最右派生的限制显然是必要的。模棱两可的语法无法很好地发挥作用。
@ rici-我的错，你是对的。...语法中内置了左联想功能，我没有注意到。我现在更加坚决地认为，我的第二点意见是正确的。当我考虑仅用number:= 0|1, sum := number | sum + number的简单情况时，它的位置看起来是(类似)2^(#sum)+b，其中是#sum=<count of"+"s>和b=<binary number formed by the terminals in order>。我仍然不想在整个问题上全神贯注，我很高兴让自己相信这可能是正确的答案。 :)
@jamshidh：它不是那么简单，因为长度很重要。 0+0和0+0+0是不同的句子。如果您没有任何空的右侧(并且有一种简单的算法可以消除它们)，那么您确实可以按长度顺序枚举，因此可以从解析树中得出唯一的数字(如果您不需要编号紧凑)。
@ rici-任何消除算法都不会改变生成的表达式的顺序吗？无论如何，我是否假设我们没有空的右手边(即，存在O(1)算法)时就处于同一页面上，这是正确的吗？
@jamshidh：通过消除算法，我的意思是一种修改语法的算法，以使其不包含任何空白的RHS。您必须将修改后的语法用于生成和索引编制，是的。但是您不能解析O(1)中的任意句子；对于明确的LR可解析语法，句子长度为O(n)，通常为O(n^3)。
@ rici-我得到了消除算法的含义，当然我是在我的O中放入了指数(不是项)，只需在上面的各处读O(1)= O(n ^ 1)即可。某些算法(即Earley算法)可以保证达到最差的O(n ^ 3)，但我始终能够将上下文无关的语法重写为O(n)...。(虽然不确定是否总是可能的，但对于任何实用的语法来说似乎都是这样)。当然，现在我写了这篇文章，我意识到我的重写会像上面的重写一样更改生成的sencesence的顺序。 :)
这正是序列化库解决的问题：我们如何紧凑地将给定的ADT(您可以将其视为语法)表示为位，并从这些位中有效地恢复ADT？通常，我们不希望每个位串都对应某个值。这使问题变得更加困难。但是您可能对论文《每一位都很重要》感兴趣。
这与G？del数字有什么关系？

对于这个特定的问题，如果我们允许自己选择不同的枚举顺序，那么我们可以做一些相当简单的事情。这个想法基本上是"每一位计数"中的一个，我也在评论中提到了这一点。首先，进行一些准备：一些导入/扩展，表示语法的数据类型以及漂亮的打印机。为了简单起见，我的位数仅增加到2(足够大，不再可以使用二进制数，但是又足够小，不会磨损我的手指和眼睛)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

{-# LANGUAGE TypeSynonymInstances #-}
import Control.Applicative
import Data.Universe.Helpers

type S = Add
data Add = Mul Mul | Add :+ Mul deriving (Eq, Ord, Show, Read)
data Mul = Term Term | Mul :* Term deriving (Eq, Ord, Show, Read)
data Term = Number Number | Parentheses S deriving (Eq, Ord, Show, Read)
data Number = Digit Digit | Digit ::: Number deriving (Eq, Ord, Show, Read)
data Digit = D0 | D1 | D2 deriving (Eq, Ord, Show, Read, Bounded, Enum)

class PP a where pp :: a -> String
instance PP Add where
pp (Mul m) = pp m
pp (a :+ m) = pp a ++"+" ++ pp m
instance PP Mul where
pp (Term t) = pp t
pp (m :* t) = pp m ++"*" ++ pp t
instance PP Term where
pp (Number n) = pp n
pp (Parentheses s) ="(" ++ pp s ++")"
instance PP Number where
pp (Digit d) = pp d
pp (d ::: n) = pp d ++ pp n
instance PP Digit where pp = show . fromEnum

现在让我们定义枚举顺序。我们将使用两个基本的组合器，+++用于交织两个列表(助记符：中间字符是一个和，因此我们从第一个参数或第二个参数中获取元素)和+*+进行对角化(助记符：中间字符是一个产品，因此我们从第一个和第二个参数中获取元素)。有关这些信息的更多信息，请参见Universe文档。我们将保持不变的一个方面是，我们的列表(digits除外)始终是无限的。稍后将很重要。

1
2
3
4
5
6

ss = adds
adds = (Mul <$> muls ) +++ (uncurry (:+) <$> adds +*+ muls)
muls = (Term <$> terms ) +++ (uncurry (:*) <$> muls +*+ terms)
terms = (Number <$> numbers) +++ (Parentheses <$> ss)
numbers = (Digit <$> digits) ++ interleave [[d ::: n | n <- numbers] | d <- digits]
digits = [D0, D1, D2]

让我们看看一些术语：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

*Main> mapM_ (putStrLn . pp) (take 15 ss)
0
0+0
0*0
0+0*0
(0)
0+0+0
0*(0)
0+(0)
1
0+0+0*0
0*0*0
0*0+0
(0+0)
0+0*(0)
0*1

好的，现在让我们开始吧。假设我们有两个无限列表a和b。有两件事要注意。首先，在a +++ b中，所有偶数索引均来自a，所有奇数索引均来自b。因此，我们可以查看索引的最后一位以查看要查找的列表，并选择其余的位来选择该列表中的索引。其次，在a +*+ b中，我们可以使用数字对和单个数字之间的标准双射来在大列表中的索引与a和b列表中的索引对之间进行转换。好的！让我们开始吧。我们将为可哥德尔的事物定义一个类，该类可以在数字之间来回转换-索引到无限的居民列表中。稍后，我们将检查此翻译是否与我们上面定义的枚举匹配。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

type Nat = Integer -- bear with me here
class Godel a where
to :: a -> Nat
from :: Nat -> a

instance Godel Nat where to = id; from = id

instance (Godel a, Godel b) => Godel (a, b) where
to (m_, n_) = (m + n) * (m + n + 1) `quot` 2 + m where
m = to m_
n = to n_
from p = (from m, from n) where
isqrt = floor . sqrt . fromIntegral
base = (isqrt (1 + 8 * p) - 1) `quot` 2
triangle = base * (base + 1) `quot` 2
m = p - triangle
n = base - m

这里的对的实例是标准的Cantor对角线。只是一些代数：使用三角形数字来确定您要去哪里/从哪里来。现在为此类创建实例很容易。 Number仅以基数3表示：

1
2
3
4
5
6
7
8
9
10
11
12

-- this instance is a lie! there aren't infinitely many Digits
-- but we'll be careful about how we use it
instance Godel Digit where
to = fromIntegral . fromEnum
from = toEnum . fromIntegral

instance Godel Number where
to (Digit d) = to d
to (d ::: n) = 3 + to d + 3 * to n
from n
| n < 3 = Digit (from n)
| otherwise = let (q, r) = quotRem (n-3) 3 in from r ::: from q

对于其余的三种类型，我们将按照上面的建议检查标记位，以确定要发出的构造函数，并将其余的位用作对角线列表的索引。所有这三个实例看起来都非常相似。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

instance Godel Term where
to (Number n) = 2 * to n
to (Parentheses s) = 1 + 2 * to s
from n = case quotRem n 2 of
(q, 0) -> Number (from q)
(q, 1) -> Parentheses (from q)

instance Godel Mul where
to (Term t) = 2 * to t
to (m :* t) = 1 + 2 * to (m, t)
from n = case quotRem n 2 of
(q, 0) -> Term (from q)
(q, 1) -> uncurry (:*) (from q)

instance Godel Add where
to (Mul m) = 2 * to m
to (m :+ t) = 1 + 2 * to (m, t)
from n = case quotRem n 2 of
(q, 0) -> Mul (from q)
(q, 1) -> uncurry (:+) (from q)

就是这样！现在，我们可以在语法分析树及其Godel编号之间"高效"转换此语法。此外，此翻译与上面的枚举匹配，您可以验证：

1 2	*Main> map from [0..29] == take 30 ss True

我们确实滥用了该特定语法的许多不错的特性-非歧义性，几乎所有非终结词都有无限多个派生这一事实-但是这种技术的变化可以使您走得很远，尤其是如果您不太严格的话要求每个数字都必须与唯一的事物相关联。

另外，顺便说一句，您可能会注意到，除了(Nat, Nat)的实例外，这些Godel编号特别好，因为它们一次只看/产生一位(或三位)。因此，您可以想象进行一些流式传输。但是(Nat, Nat)太讨厌了：您必须提前知道整数才能计算sqrt。您实际上也可以将其变成流媒体家伙，而不会失去密集的特性(每个Nat与唯一的(Nat, Nat)相关联)，但这是另一个答案的主题...