31、基于格的最小部分实现算法与线性递推快速跳转算法

基于格的最小部分实现算法与线性递推快速跳转算法

基于格的最小部分实现算法

在矩阵序列处理中，有一种基于格的最小部分实现算法。该算法的核心步骤如下：
1. 循环处理 ：对于 i 从 1 到 m 进行循环。
- 如果 δk+1(Mk, i(z), T ) = 0p ，则令 Mk+1, i(z) = Mk, i(z) 。
- 否则：
- 令 δi ←δk+1(Mk, i(z), T ) ， vi ←−k −1 + v(Mk, i(z)) 。
- 找到向量 (a1, · · ·, ap) 使得 δi = ∑p j=1 ajδ∗ j 。
- 找到整数 h 使得 v∗ h = max{v∗ j : 1 ≤j ≤p, aj ̸= 0} 。
- 如果 vi ≥v∗ h ，则令 Mk+1, i(z) = Mk, i(z) −∑p j=1 aj z−v∗ j +vic∗ j(z) 。
- 否则：
- 令 Mk+1, i(z) = z−vi+v∗ hMk, i(z) −∑p j=1 aj z−v∗ j +v∗ hc∗ j(z) 。
- 令 v∗ h ←vi ， c∗ h(z) ←Mk, i(z) ， δ∗ h ←δi 。
2. 终止判断 ：
- 如果 k + 1 = N ，则令 MN(z) ←(MN,i)1≤i≤m ，输出 pol(T (z)MN(z))M −1 N (z) 并终止算法。
- 否则，令 k ←k + 1 ，回到步骤 1。

下面通过一个具体的例子来说明该算法的应用。给定矩阵序列：

T (z) = 
[−1 1] z−1 + 
[0 0] 
[0 1] z−2 + 
[0 0] 
[ 1 1] z−3 + 
[−1 1] 
[1 2] z−4 + 
[0 1] 
[1 4] z−5 + 
[1 1] 
[2 7] z−6 + · · ·

目标是找到 T 的第 6 个最小部分实现。
- r = 0 ：初始基为 ω1 ←(−1, 0, 0, 0)t ， ω2 ←(0, −1, 0, 0)t ， ω3 ←(−z−1 + z−3 +z−4+z−5 +2z−6, −z−3 +z−5+z−6, z−7, 0)t ， ω4 ←(z−1 +z−2 +z−3+ 2z−4 + 4z−5 + 7z−6, z−3 + z−4 + z−5 + 2z−6, 0, z−7)t 。
- r = 1 ： I = {3, 4} 。
- 因为 θ(ω3) = θ(ω1) 且 v(ω3) < v(ω1) ，所以 ξ ←zω3 −ω1 = (z−2 +z−3 + z−4 + 2z−5, −z−2 + z−4 + z−5, z−6, 0)t ， ω1 ←ω3 ， ω3 ←ξ 。
- 因为 θ(ω4) = −θ(ω1) 且 v(ω4) = v(ω1) ，所以 ω4 ←ω4 + ω1 = (z−2 + 2z−3 + 3z−4 + 5z−5 + 9z−6, z−4 + 2z−5 + 3z−6, z−7, z−7)t ，其他不变。
- r = 2 ： I = {4} 。
- 因为 θ(ω4) = −θ(ω1) 且 v(ω4) ≤v(ω1) ，所以 ξ ←zω4 + ω1 = (2z−2 + 4z−3 + 6z−4 + 10z−5 + 2z−6, 2z−4 + 4z−5 + z−6, z−6 + z−7, z−6)t ， ω1 ←ω4 ， ω4 ←ξ ，其他不变。
- r = 3 ： I = {3, 4} 。
- 因为 θ(ω3) = θ(ω1) + θ(ω2) 且 v(ω3) ≤v(ω2) ，所以 ξ = −z2ω3 + z2ω1 + ω2 = (z−1 +2z−2+3z−3+9z−4, z−3+3z−4, −z−4+z−5, z−5)t ， ω2 ←ω3 ， ω3 ←ξ ，其他不变。
- 因为 θ(ω4) = 2θ(ω1) 且 v(ω4) = v(ω1) ，所以 ω4 ←ω4 −2ω1 = (−16z−6, −5z−6, z−6 −z−7, z−6 −2z−7)t ，其他不变。
- r = 4 ： I = {3} 。
- 因为 θ(ω3) = θ(ω1) 且 v(ω3) < v(ω1) ，所以 ω3 ←ω3 −zω1 = (4z−4 − 9z−5, z−4 −3z−5, −z−4 + z−5 −z−6, z−5 −z−6)t ， ω4 ←(−16z−6, −5z−6, z−6 − z−7, z−6 −2z−7)t ， ω2 ←(z−2 +z−3 +z−4 +2z−5, −z−2 +z−4 +z−5, z−6, 0)t ， ω1 ←(z−2 + 2z−3 + 3z−4 + 5z−5 + 9z−6, z−4 + 2z−5 + 3z−6, z−7, z−7)t 。
此时它们变为标准形式，得到 M6(z) 为：

[−z3 + z2 −z z −1]
[z2 −z]
[z −2]

这个算法通过寻找基元素的约化关系，使得它们的赋值越来越小，直到达到约化状态。不同的约化方式会导致不同的实现算法。该算法为最小部分实现问题提供了更深入的见解，并给出了一个统一的算法。

线性递推快速跳转算法

在许多科学领域，如模拟、统计和密码学中，伪随机数生成器（PRNGs）被广泛使用。在模拟应用中，通常需要多个不相交的伪随机数序列流，这些流通常通过在序列中跳转来获得相距较远的起始点。对于具有大状态空间的最大周期生成器，这种跳转在时间和内存使用上可能成本很高。

现有方法总结

许多实际的模拟生成器基于线性递推，因为可以通过线性代数技术轻松分析周期和高维分布等重要属性。假设基域是二元域 F2 ，考虑一个状态空间为 S := Fk 2 的 PRNG，状态转移函数 f : S →S 是 F2 上的线性函数，可由 k×k 的二进制矩阵 F 表示。对于给定的初始状态 s0 ，状态根据递推关系 sm+1 := f(sm) = Fsm 演化。

• 简单跳转方法 ：将递推关系表示为矩阵形式，预计算并存储相关矩阵的 J 次幂，然后通过简单的矩阵 - 向量乘法进行跳转。但对于大周期生成器，这种方法需要过多的内存且速度很慢。
• 滑动窗口算法 ：预计算并存储 g(t) := tJ mod ϕF (t) 的系数，然后使用 Horner 方法实现跳转。通过滑动窗口算法可以提高速度，但需要存储一个大的预计算表。

新的跳转方法

新方法基于线性递推在形式级数空间中的表示，跳转对应于级数与多项式的乘法。该方法需要的内存比之前的方法少得多，并且在速度上具有竞争力。在输出函数的特定条件下，对于 k 位状态空间，速度实际上为 O(klog3 2) ≈O(k1.59) ，而之前的方法为 O(k2) 。

具体步骤如下：
1. 假设条件 ：
- 线性输出函数 o 返回单个位，即 o : S →F2 。
- 映射 S →Fk 2 将生成器的状态映射到接下来的 k 位输出是一对一的，因此可以从 k 个连续的输出位中恢复状态。
2. 核心计算 ：
- 令 G(s, t) = ∑∞ i=1 o(si−1)t−i 为初始状态为 s0 = s 时输出序列的生成函数。
- 则 G(sJ, t) = tJG(s0, t) (mod F2[t]) = g(t)G(s0, t) (mod F2[t]) 。
- 为了恢复状态 sJ ，只需要 G(sJ, t) = g(t)G(s0, t) 中 t−1, . . . , t−k 的系数，即 G(sJ, t) 的前 k 项。
- 可以用 G(s0, t) 的前 2k 项截断来代替，得到多项式 h(s0, t) = ∑2k−1 i=0 o(si)t2k−1−i 。
- 计算多项式乘积 g(t)h(s0, t) ，其系数 t2k−1, . . . , tk 正是输出位 o(sJ), . . . , o(sJ+k−1) ，从而可以恢复状态 sJ 。
3. 多项式乘法选择 ：
- 经典方法需要 O(k2) 位运算来进行多项式乘法。
- 快速傅里叶变换可以用 O(k log k) 位运算完成多项式乘法，但隐藏常数较大，实现时速度较慢。
- 采用 Karatsuba 算法，需要 O(klog2 3) ≈O(k1.59) 位运算，该算法在中等 k 值时比经典方法更快。
4. 算法流程 ：

Algorithm 1. Jump ahead by polynomial multiplication
Input the state s = s0;
Compute the polynomial h(s0, t) by advancing the generator for 2k steps;
Compute the product g(t)h(s0, t) and extract the coefficients o(sJ), . . . , o(sJ+k−1);
Compute the state sJ from the bits o(sJ), . . . , o(sJ+k−1);
Return sJ.

以线性反馈移位寄存器（LFSR）为例，其状态空间是行向量空间 S := Fk 2 ，状态转移函数为 (x0, . . . , xk−1) →(x1, x2, . . . , xk−1, ∑k−1 i=0 aixi) 。如果选择 o : (x0, . . . , xk−1) →x0 ，则 o(k) : S →Fk 2 是恒等函数，可以跳过其逆运算的计算。使用 Karatsuba 多项式乘法，LFSR 的跳转可以在 O(k1.59) 时间内完成；使用快速傅里叶变换，则可以在 O(k log k) 时间内完成。

通过上述两种算法，我们可以在矩阵序列处理和伪随机数生成器跳转方面获得更高效的解决方案。

下面是线性递推快速跳转算法的流程图：

graph TD;
    A[输入状态 s = s0] --> B[推进生成器 2k 步计算 h(s0, t)];
    B --> C[计算 g(t)h(s0, t) 并提取系数 o(sJ), ..., o(sJ+k−1)];
    C --> D[从 o(sJ), ..., o(sJ+k−1) 计算状态 sJ];
    D --> E[返回 sJ];

综上所述，这两种算法在不同的应用场景中都具有重要的价值，为相关领域的计算提供了更高效的方法。

基于格的最小部分实现算法与线性递推快速跳转算法

算法对比分析

为了更清晰地了解基于格的最小部分实现算法和线性递推快速跳转算法的特点，我们对它们进行详细的对比分析。

算法名称	应用场景	核心思想	内存需求	时间复杂度	优势
基于格的最小部分实现算法	矩阵序列处理，寻找矩阵序列的最小部分实现	寻找基元素的约化关系，使基元素的赋值越来越小，直到达到约化状态	与矩阵序列的规模相关	未明确提及整体复杂度，主要通过迭代寻找约化关系	为最小部分实现问题提供统一算法，不同约化方式可衍生不同实现算法
线性递推快速跳转算法	伪随机数生成器中，实现多个不相交的伪随机数序列流的跳转	基于线性递推在形式级数空间中的表示，跳转对应于级数与多项式的乘法	比传统方法少得多	在特定条件下为 (O(k^{log_2 3})\approx O(k^{1.59}))	内存需求低，速度在特定条件下更优

从上述表格可以看出，两种算法针对不同的问题场景，采用了不同的核心思想。基于格的最小部分实现算法侧重于矩阵序列的处理，通过约化基元素来解决最小部分实现问题；而线性递推快速跳转算法则聚焦于伪随机数生成器的跳转问题，利用形式级数空间中的多项式乘法来提高跳转效率。

实际应用建议

在实际应用中，我们需要根据具体的问题场景和需求来选择合适的算法。以下是一些具体的建议：

基于格的最小部分实现算法

• 矩阵序列规模较小 ：当矩阵序列的规模相对较小时，该算法可以通过迭代寻找基元素的约化关系，逐步得到最小部分实现。在这种情况下，算法的复杂度相对较低，能够高效地解决问题。
• 需要统一算法框架 ：如果希望使用一个统一的算法框架来处理不同的最小部分实现问题，该算法是一个不错的选择。不同的约化方式可以衍生出不同的实现算法，具有较强的灵活性。

线性递推快速跳转算法

• 大状态空间的伪随机数生成器 ：对于具有大状态空间的伪随机数生成器，如 Mersenne twister 等，传统的跳转方法需要过多的内存且速度较慢。此时，新的跳转方法可以显著减少内存需求，并且在特定条件下具有更优的时间复杂度，能够实现快速跳转。
• 对内存敏感的应用场景 ：在一些对内存敏感的应用场景中，如嵌入式系统或资源受限的设备上，该算法的低内存需求使其成为首选。

未来发展趋势

随着科学技术的不断发展，这两种算法在未来可能会有以下发展趋势：

基于格的最小部分实现算法

• 算法优化 ：进一步研究基元素的约化关系，寻找更高效的约化方式，以降低算法的时间复杂度。
• 应用拓展 ：将该算法应用到更多领域，如信号处理、数据分析等，解决相关领域中的最小部分实现问题。

线性递推快速跳转算法

• 算法改进 ：继续探索形式级数空间中的多项式乘法算法，进一步提高跳转速度，降低时间复杂度。
• 与其他算法结合 ：将该算法与其他伪随机数生成算法相结合，提高伪随机数生成器的性能和安全性。

总结

本文介绍了基于格的最小部分实现算法和线性递推快速跳转算法。基于格的最小部分实现算法通过寻找基元素的约化关系，为矩阵序列的最小部分实现问题提供了统一的解决方案；线性递推快速跳转算法基于形式级数空间中的多项式乘法，为伪随机数生成器的跳转问题提供了一种内存需求低、速度快的解决方案。

在实际应用中，我们应根据具体的问题场景和需求选择合适的算法。同时，随着技术的不断发展，这两种算法也有望在算法优化、应用拓展等方面取得进一步的发展。

下面是选择算法的决策流程图：

graph TD;
    A[问题场景] --> B{是否为矩阵序列处理};
    B -- 是 --> C[考虑基于格的最小部分实现算法];
    B -- 否 --> D{是否为伪随机数生成器跳转问题};
    D -- 是 --> E[考虑线性递推快速跳转算法];
    D -- 否 --> F[寻找其他合适算法];
    C --> G{矩阵序列规模是否小};
    G -- 是 --> H[使用基于格的最小部分实现算法];
    G -- 否 --> I[评估其他算法];
    E --> J{状态空间是否大};
    J -- 是 --> K[使用线性递推快速跳转算法];
    J -- 否 --> L[评估其他算法];

希望本文的介绍能够帮助读者更好地理解这两种算法，并在实际应用中做出合适的选择。