混淆 OBDD

参考文献：

1. OBDD 旧版论文：Bryant R E. Graph-based algorithms for boolean function manipulation[J]. Computers, IEEE Transactions on, 1986, 100(8): 677-691.
2. OBDD 新版论文：Bryant R E. Graph-Based Algorithms for Boolean Function Manipulation 12[J].
3. 混淆 OBDD：Kruger L, Jha S, Goh E J, et al. Secure function evaluation with ordered binary decision diagrams[C]//Proceedings of the 13th ACM conference on Computer and communications security. 2006: 410-420.
4. 2PC 综述（含电路转换）：Kolesnikov V, Sadeghi A R, Schneider T. A systematic approach to practically efficient general two-party secure function evaluation protocols and their modular design[J]. Journal of Computer Security, 2013, 21(2): 283-315.

OBDD

1986年，Bryant 提出了布尔函数的表示方法 ordered binary decision diagrams (OBDDs)。相较于布尔电路，OBDD 更加紧凑，很多常见类型（除了整数乘法，指数级）的布尔函数对应的 OBDD 的节点数量更少。并且，OBDD 由于固定了变量顺序，因此它可以有效解决 布尔函数可满足性问题 和 图同构问题。

图结构

布尔函数$f(x_1,\cdots ,x_n)$的函数图（function graph）或者说 OBDD，它是一个有根节点的有向无环图（rooted, directed, acyclic graph）$G$，其节点集合$V$包含两类节点，

1. 非终端节点（nonterminal vertex）：包含属性 i n d e x ( v ) ∈ { 1 , ⋯   , n } index(v) \in \{1,\cdots,n\} index(v)∈{1,⋯,n}，还有两个指针指向子节点$low(v),high(v)\in V$，并且
   $$index(v)<index(low(v))，index(v)<index(high(v))$$
   从根节点到终端节点的路径上，index 是严格递增的。

2. 终端节点（terminal vertex）：包含属性 v a l u e ( v ) ∈ { 0 , 1 } value(v) \in \{0,1\} value(v)∈{0,1}，并设置$index(v)=n+1$

OBDD 的构建如下：

明显，

1. 任给一组参数 ( a 1 , ⋯   , a n ) ∈ { 0 , 1 } n (a_1,\cdots,a_n) \in \{0,1\}^n (a1​,⋯,an​)∈{0,1}n，在$G$中都存在唯一的路径，从根到达终端。
2. 图$G$的每个节点都至少落在一条路径上。

下面是 OBDD 的图示（右边是奇偶判定函数）：

OBDD 对变量的顺序十分敏感。下图显示了这一点：

实际上，对于$x_1{x}_2+\cdots ,x_{2n-1}{x}_{2n}$只要$2n+2$个点，但对于$x_1{x}_{n+1}+\cdots +x_n{x}_{2n}$需要$2^{n+1}$个点。因为 OBDD 中的计算中间值（intermediate information）并不是存储在内存中的，而是被编码为了所有可能的分支目标（this information is encoded in the set of possible branch destinations）。对于奇偶判定函数，中间值是$1$比特，每层$O(2)$个点；对于整数乘法，中间值是$n$比特，每层$O(2^n)$个点。

Traverse

节点类型为：

遍历 OBDD 的算法：

每个点都访问恰好一次，复杂度为$O(|G|)$

Reduction

给定布尔函数$f(x_1,\cdots ,x_n)$的 OBDD，那么 dependency set 定义为：
I f = { i : f ∣ x i = 0 ≠ f ∣ x i = 1 } I_f = \{ i: f|_{x_i=0} \neq f|_{x_i=1} \} If​={i:f∣xi​=0​=f∣xi​=1​}

否则，如果$f{|}_{x_i=0}=f{|}_{x_i=1}$，那么$f$就与$x_i$不相关。

给定两张 OBDD $G,G^{\prime }$，说它们是同构的（isomorphic），如果存在点击间的双射$\sigma$，使得：如果是终端，那么$value(v)=value(\sigma (v))$；如果是非终端，那么$index(v)=index(\sigma (v))$且$\sigma (low(v))=low(\sigma (v))$且$\sigma (high(v))=high(\sigma (v))$。明显的，如果图同构，那么任意子图同构。

约简图（reduce graph）：OBDD $G$ 不包含

1. 一个节点$v$，使得子节点$low(v)=high(v)$
2. 两个节点$v,v^{\prime }$，使得子图$G_v\cong G_{v^{\prime }}$

明显的，如果图是约简的，那么任意子图都是约简的。

canonical form：任意布尔函数都存在唯一的（同构意义下）最少节点的约简图。并且，有最少节点的图一定是约简的（否则，总可以删除一些点）。

约简算法：

上述算法的复杂度为$O(|G|\cdot log(|G|))$

Restriction

给定布尔函数$f(x_1,\cdots ,x_n)$的 OBDD，构造 a restriction of f：
$$f{|}_{x_i=b}(x_1,\cdots ,x_n)=f(x_1,\cdots ,x_{i-1},b,x_{i+1},\cdots ,x_n)$$

算法如下：

1. 输入函数$f$的OBDD $G$，根节点是$v$
2. 使用 Traverse 算法周游 OBDD，一旦遇到$index(v)=i$，那么
   1. 如果$b=0$，设置$high(v)\leftarrow low(v)$，$low(v)$不变
   2. 如果$b=1$，设置$low(v)\leftarrow high(v)$，$high(v)$不变
3. 运行 Reduction 算法，输出约简图的根$v$

上述算法的复杂度为$O(|G|\cdot log(|G|))$

Apply

给定布尔函数$f_1,f_2$的 OBDD，构造关于布尔运算$\odot$的函数的 OBDD：
$$(f_1\odot f_2)(x_1,\cdots ,x_n)=f_1(x_1,\cdots ,x_n)\odot f_2(x_1,\cdots ,x_n)$$

利用 Shannon expansion，写作
$$f_1\odot f_2={\bar{x}}_i\cdot (f_1{|}_{x_i=0}\odot f_2{|}_{x_i=0})+x_i\cdot (f_1{|}_{x_i=1}\odot f_2{|}_{x_i=1})$$
令$f_1\odot f_2$的 OBDD 的根为$u$，那么上式的右边就是
$$low(u)=OBDD(f_1{|}_{x_i=0}\odot f_2{|}_{x_i=0})$$

$$high(u)=OBDD(f_1{|}_{x_i=1}\odot f_2{|}_{x_i=1})$$

令$f_1$的 OBDD 的根为$v_1$，令$f_2$的 OBDD 的根为$v_2$，那么
$$low(v_1)=OBDD(f_1{|}_{x_i=0}),high(v_1)=OBDD(f_1{|}_{x_i=1})$$

$$low(v_2)=OBDD(f_2{|}_{x_i=0}),high(v_2)=OBDD(f_2{|}_{x_i=1})$$

考虑如下情形：

1. $v_1,v_2$都是终端，那么创建终端$index(u)=n+1$，且
   $$value(u)=value(v_1)\odot value(v_2)$$

2. $v_1,v_2$都不是终端，且$index(v_1)=index(v_2)=i$，那么创建非终端$index(u)=i$，再利用 Shannon expansion，

   1. 迭代计算两个子图$low(v_1)$和$low(v_2)$的$\odot$运算结果，它以$low(u)$为根
   2. 迭代计算两个子图$high(v_1)$和$high(v_2)$的$\odot$运算结果，它以$high(u)$为根

3. $v_1$不是终端，且$index(v_2)>index(v_1)$，那么明显$x_i\notin I_{f_2}$，
   $$f_2{|}_{x_i=0}=f_2{|}_{x_i=1}=f_2$$
   即$v_2=low(v_2)=high(v_2)$，因此执行

   1. 迭代计算两个子图$low(v_1)$和$v_2$的$\odot$运算结果，它以$low(u)$为根
   2. 迭代计算两个子图$high(v_1)$和$v_2$的$\odot$运算结果，它以$high(u)$为根

4. 反过来，$v_2$不是终端，且$index(v_1)>index(v_2)$，过程类似

然而，上述算法是指数级的，因为每遇到非终端节点都要迭代。其实这些迭代有大量的冗余，使用打表法，记录已经迭代过的点对$(v_1,v_2,u)$。每次迭代之前 check 表格，如果没有那么才继续执行迭代。这将复杂度降低到了$O(|G_1|\cdot |G_2|)$

另外，对于布尔运算，有时其中一个变量的值就可以完全确定最终结果。这个值叫做 “controlling” value，例如$0$之于$AND$，$1$之于$OR$

算法如下：

其中记录迭代信息的表格$T$是稀疏的，可以用Hash表来取代，减小空间开销。

Composition

给定布尔函数$f(x_1,\cdots ,x_n)$的 OBDD，构造 a composition of f and g：
$$f{|}_{x_i=g}(x_1,\cdots ,x_n)=f(x_1,\cdots ,x_{i-1},g(x_1,\cdots ,x_n),x_{i+1},\cdots ,x_n)$$

利用 Shannon expansion，写作
$$f{|}_{x_i=g}=g\cdot f{|}_{x_i=1}+\bar{g}\cdot f{|}_{x_i=0}$$
由于$\cdot$和$+$都是布尔运算，因此可以利用$2$次 Restriction 算法计算$f{|}_{x_i=0},f{|}_{x_i=1}$的 OBDD，然后将$g$的终端 value 翻转得到$\bar{g}$，再利用$3$次 Apply 算法分别计算$g\cdot f{|}_{x_i=1}$，$\bar{g}\cdot f{|}_{x_i=0}$和$(g\cdot f{|}_{x_i=1})+(\bar{g}\cdot f{|}_{x_i=0})$

然而，上述算法的复杂度为$O(|G_1{|}^2\cdot |G_2{|}^2)$。实际上，可以不再使用$3$次二元运算，而是使用$1$次三元运算 if-then-else：
$$ITE(a,b,c)=ab+\bar{a}c$$
那么可以将复杂度降低为$O(|G_1{|}^2\cdot |G_2|)$。在实际执行中，大多数函数组合在$O(|G_1|\cdot |G_2|)$时间内就可完成。

算法如下：

Satisfy

给定布尔函数$f(x_1,\cdots ,x_n)$的 OBDD，寻找 satisfying set：
$$S_f=\{(x_1,\cdots ,x_n):f(x_1,\cdots ,x_n)=1\}$$

为了找到一个$S_f$中元素，可以在 OBDD 中按照深度优先搜索来依次尝试每个 x ∈ { 0 , 1 } n x \in \{0,1\}^n x∈{0,1}n，非约简图中在最坏情况下需要$O(2^n)$次回溯。

但是在约简图中，第$n$层的节点$v$一定有$low(v)\ne high(v)$分别指向$0$终端和$1$终端。所以：约简图中的任意非终端，都一定可达$1$终端。那么只要从 OBDD 的根节点开始，按照深度优先遍历，然后至多回溯一次，就可以在$O(n)$时间内找到一个$S_f$中元素。算法如下：

另外，如果需要找到全部的$S_f$，那么对于$index(v)=i$的节点，计算如下集合：
$$S_{f_v}=\{(a_1,\cdots ,a_{i-1},x_i,\cdots ,x_n):f_v(a_1,\cdots ,a_{i-1},x_i,\cdots ,x_n)=1\}$$
迭代算法如下：

同样因为约简图的非终端都会到达$1$终端，因此至少有一半的迭代将会返回一些解。复杂度为$O(n\cdot |S_f|)$

改进

1. 自适应确定变量顺序：OBDD 的规模对变量的顺序很敏感。找到最优的顺序使得 OBDD 最小，这是 coNPC 问题。但是，如果某人熟悉组合设计，那么可以利用知识来确定一个合适的顺序。另外，除了某些类型的函数（包括整数乘法），大多数函数都存在一些很小的 OBDD 表示。可以用一系列的启发式算法有效地找到一组排列顺序，使得 OBDD 的规模合理的小。算法有： Rudell’s sifting algorithm, the window permutation algorithm, genetic algorithms（遗传算法）, or algorithms based on simulated annealing（模拟退火算法）.
2. 将布尔函数的值域从二元域扩展到任意域： f ( x 1 , ⋯   , x n ) : { 0 , 1 } n → S ⊂ N f(x_1,\cdots,x_n): \{0,1\}^n \to S \subset \mathbb N f(x1​,⋯,xn​):{0,1}n→S⊂N，其中$S$是有限集合。那么只需设置$|S|$个的终端节点。而$index(v)\le n$的非终端节点依然是只有两个子节点。

混淆OBDD

与 Yao’s GC 类似，不再是布尔电路的每个门计算$4$条目的混淆表，而是 OBDD 的每个非终端节点计算$2$个指针的混淆表。

为了防止约简的 OBDD 的跳级（skipping）使得路径的长度不同而泄露信息，我们需要对 OBDD 填充一些虚拟节点（dummy vertex），保证每条路径都一样长。另外，可以额外再添加若干，让 OBDD 的路径延长到随机长度，进一步消除路径长度的信息。

对于布尔函数$f(x_1,\cdots ,x_n)$对应的 OBDD $G$，我们为$G$的每个非终端节点$v$分配一个对称密钥$s_v$，同时利用 OT 协议为每个变量分配随机的密钥：

1. 如果$x_i=0$，那么混淆值为$s_i^0$
2. 如果$x_i=1$，那么混淆值为$s_i^1$

使用不可捉摸范围的对称加密，对于节点$v$，计算混淆表
$$Enc(s_v\oplus s_i^0,label(low(v))\Vert s_{low(v)})$$

$$Enc(s_v\oplus s_i^1,label(high(v))\Vert s_{high(v)})$$

其中 l a b e l ( ⋅ ) ∈ { 0 , 1 } label(\cdot) \in \{0,1\} label(⋅)∈{0,1}是随机位置。这可以用 P&P 技术来改进。

易知，仅当计算混淆 OBDD 时到达了节点$v$，才能够获得对应的密钥$s_v$

有序输入

Alice 和 Bob 要协同计算$f(x_1,\cdots ,x_n)$，其中 Alice 持有前$k$个输入$(a_1,\cdots ,a_k)$，Bob 持有后$n-k$个输入$(a_{k+1},\cdots ,a_n)$，其中$index(x_1)<\cdots <index(x_n)$

那么，Alice 构造 OBDD 时，可以执行 Restriction 算法，构造如下函数的 OBDD，
$$f{|}_{x_1=a_1,\cdots ,x_k=a_k}(x_{k+1},\cdots ,x_n)$$
相较于$f$对应的 OBDD，这大大降低了图的规模。因此，在很多常见布尔函数的计算上，OBDD 比 Yao’s GC 小得多。

算法如下：

注意，在计算$f{|}_{x_1=a_1,\cdots ,x_k=a_k}$时，要保留所有$index(v)=k+1$的节点！原因如下图所示：

对于 Alice 的$x_1$的不同取值，直接调用 Restriction 算法会产生不同的 OBDD，这会泄露$x_1$的信息。因此，我们应当保留全部的$index(v)=k+1$的节点，得到的 OBDD 拥有若干个 root 节点。

任意输入

然而，OBDD 的规模对变量顺序很敏感，Alice 可以找到合适的顺序，使得构造的 OBDD 尽可能小，并把这个顺序告知 Bob。Alice 和 Bob 协同计算$f(x_1,\cdots ,x_n)$，其中 Alice 持有其中的$k$个输入$X_A$，Bob 持有另外$n-k$个输入 X B = { x 1 , ⋯   , x n } − X A X_B = \{x_1,\cdots,x_n\} - X_A XB​={x1​,⋯,xn​}−XA​

Alice 执行 Restriction 算法，构造如下函数的 OBDD，
$$f{|}_{X_A}(X_B)$$
这进一步降低了 OBDD 的规模。

改进算法如下：

与 FairPlay 的电路规模（节点、门）比较如下：