mplang-nightly 0.1.dev267__py3-none-any.whl → 0.1.dev269__py3-none-any.whl

mplang/py.typed

@@ -0,0 +1,13 @@
+# Copyright 2026 Ant Group Co., Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

mplang/v2/backends/simp_driver/http.py

@@ -32,7 +32,7 @@ if TYPE_CHECKING:
     from concurrent.futures import Future
 
     from mplang.v2.edsl.graph import Graph
-    from mplang.v2.edsl.spec import ClusterSpec
+    from mplang.v2.libs.device import ClusterSpec
 
 
 class SimpHttpDriver(SimpDriver):

mplang/v2/backends/simp_driver/mem.py

@@ -32,7 +32,7 @@ if TYPE_CHECKING:
     from concurrent.futures import Future
 
     from mplang.v2.edsl.graph import Graph
-    from mplang.v2.edsl.spec import ClusterSpec
+    from mplang.v2.libs.device import ClusterSpec
 
 
 class MemCluster:

mplang/v2/kernels/okvs_opt.cpp

@@ -36,6 +36,10 @@ extern "C" {
         uint64_t h1, h2, h3;
     };
 
+    // Declaration of the safe (robust) solver implemented in okvs.cpp
+    // Signature: solve_okvs(keys, values, output, n, m, seed_ptr)
+    void solve_okvs(uint64_t* keys, uint64_t* values, uint64_t* output, uint64_t n, uint64_t m, uint64_t* seed_ptr);
+
     // Stateless Bin Selection
     // Maps a key to a deterministic bin index [0, NUM_BINS).
     inline uint64_t get_bin_index(uint64_t key, __m128i seed) {
@@ -245,10 +249,21 @@ extern "C" {
             uint64_t valid_m = m_per_bin[b];
             
             if(!solve_bin(bin_keys[b], bin_vals[b], &P_vec[offset], valid_m, seed)) {
+                // On failure, log and fall back to the robust solver for this bin.
+                // The fallback is executed inside a critical section to avoid nested OpenMP
+                // regions and to serialize rare fallbacks.
                 #pragma omp critical
                 {
-                    fprintf(stderr, "[ERROR] Bin %lu failed OKVS peeling. Items: %lu / M: %lu (Ratio: %.2f). Try increasing expansion factor.\n", 
+                    fprintf(stderr, "[WARN] Bin %lu failed optimized peeling; falling back to safe solver. Items: %lu / M: %lu (Ratio: %.2f)\n",
                         b, bin_keys[b].size(), valid_m, (double)valid_m / bin_keys[b].size());
+
+                    // Prepare pointers for the safe solver
+                    uint64_t* keys_ptr = &bin_keys[b][0];
+                    uint64_t* vals_ptr = &bin_vals[b][0];
+                    uint64_t* out_ptr = output + (offset * 2ULL); // each 128-bit slot == 2 uint64_t
+
+                    // Call the safe solver implemented in okvs.cpp
+                    solve_okvs(keys_ptr, vals_ptr, out_ptr, bin_keys[b].size(), valid_m, seed_ptr);
                 }
             }
         }

mplang/v2/libs/mpc/psi/okvs_gct.py

@@ -40,12 +40,16 @@ def get_okvs_expansion(n: int) -> float:
     - For N → ∞: Theoretical minimum is ε ≈ 0.23 (M = 1.23N)
     - For finite N: Larger ε needed due to variance in random hash collisions
 
-    Empirical safe thresholds (failure probability < 0.01%):
-    - N < 1,000:    ε = 4.5  (M = 5.5N)  - very small sets need extra wide margin
-                                           to handle worst-case hash collisions
-    - N < 10,000:   ε = 0.4  (M = 1.4N)
-    - N < 100,000:  ε = 0.3  (M = 1.3N)
-    - N ≥ 100,000:  ε = 0.35 (M = 1.35N) - large sets converge near theory
+    Empirical safe thresholds (failure probability < 0.001%):
+    - N ≤ 200:      ε = 24.0 (M = 25.0N)  - extremely small sets need very wide margin
+    - N < 1,000:    ε = 11.0 (M = 12.0N)  - small sets need extra wide safety margin
+    - N < 10,000:   ε = 0.6  (M = 1.6N)
+    - N < 100,000:  ε = 0.4  (M = 1.4N)
+    - N ≥ 100,000:  ε = 0.35 (M = 1.35N)  - large sets converge near theory
+
+    Note: These expansion factors account for the 128-byte alignment requirement
+    in the OKVS implementation. The factors are intentionally conservative to
+    ensure high success rates (>99.9%) for the probabilistic peeling algorithm.
 
     Args:
         n: Number of key-value pairs to encode
@@ -53,12 +57,14 @@ def get_okvs_expansion(n: int) -> float:
     Returns:
         Expansion factor ε such that M = (1+ε)*N is safe for peeling
     """
-    if n < 1000:
-        return 5.5  # Small scale: need very wide safety margin for stability
+    if n <= 200:
+        return 25.0  # Extremely small scale: need very wide margin for stability
+    elif n < 1000:
+        return 12.0  # Small scale: need wide safety margin for stability
     elif n <= 10000:
-        return 1.4  # Medium scale
+        return 1.6  # Medium scale
     elif n <= 100000:
-        return 1.3  # Large scale
+        return 1.4  # Large scale
     else:
         # Mega-Binning requires ~1.35 for stability with 1024 bins
         return 1.35

mplang/v2/libs/mpc/psi/rr22.py

@@ -28,37 +28,36 @@ Phases:
 1.  **Correlated Randomness (VOLE)**:
     Sender and Receiver establish a shared correlation:
     W = V + U * Delta
-    - Sender holds U, V.
-    - Receiver holds W, Delta.
-    - U is random. Delta is a fixed secret scalar (Receiver's key).
+    - PSI Receiver holds `U` and `V` (these are generated by the OT "sender"
+      role in `silent_vole_random_u`).
+    - PSI Sender holds `W` and `Delta` (these are generated by the OT "receiver"
+      role).
+    - `U` is random; `Delta` is a fixed secret scalar held by the Sender.
 
 2.  **Encoding (OKVS)**:
-    Receiver encodes their input set Y into a structure P using OKVS, such that:
-    Decode(P, y) = H(y) for all y in Y.
-    Here H(y) is a Random Oracle (implemented via Davies-Meyer/AES).
+    The Receiver encodes its input set Y into an OKVS storage `P` such that
+    Decode(P, y) = H(y) for all y in Y. The function `H(y)` is implemented via
+    AES/Davies–Meyer expansion acting as a random oracle.
 
 3.  **Masking & Exchange**:
-    Receiver masks the structure P with their VOLE share W:
-    Q = P ^ W
-    Receiver sends Q to Sender.
-
-4.  **Decoding & Verification**:
-    Sender attempts to decode Q for each of their items x in X.
-    Since OKVS is linear:
-    Decode(Q, x) = Decode(P, x) ^ Decode(W, x)
-
-    Sender reconstructs the potential "Target" value T:
-    T = Decode(Q, x) ^ Decode(V, x) ^ H(x)
-
-    If x in Y (Intersection):
-       Decode(P, x) = H(x)
-       Decode(W, x) = Decode(V, x) ^ Decode(U, x) * Delta
-    Substitute into T:
-       T = H(x) ^ (Decode(V, x) ^ Decode(U, x) * Delta) ^ Decode(V, x) ^ H(x)
-       T = Decode(U, x) * Delta
-
-    Thus, verification becomes checking if T == U* * Delta, where U* = Decode(U, x).
-    This check is performed securely using hashes to prevent leakage.
+    The Receiver masks the OKVS storage `P` with its VOLE share `U`:
+    Q = P + U
+    The masked storage `Q` is sent to the Sender (so Sender sees a masked OKVS).
+
+4.  **Decoding & Tag Generation (Sender)**:
+    The Sender holds `W` and `Delta` and computes the linear combination:
+    K = Q * Delta + W
+    Using W = V + U * Delta and Q = P + U, this simplifies to
+    K = P * Delta + V.
+    The Sender decodes `K` for each of its items x to obtain P(x)*Delta + V(x),
+    then subtracts H(x)*Delta (computed locally) to recover `V(x)`. The value
+    `Tag = V(x)` serves as the sender-side tag for item x.
+
+5.  **Verification (Receiver)**:
+    The Sender hashes and truncates tags and sends the truncated hashes to the
+    Receiver. The Receiver locally decodes `V(y)` from its OKVS, hashes it with
+    the same domain separation and truncation, and compares to the received
+    truncated hashes to determine membership in the intersection.
 """
 
 from typing import Any, cast
@@ -77,17 +76,24 @@ def psi_intersect(
     sender_items: el.Object,
     receiver_items: el.Object,
 ) -> el.Object:
-    """Execute OKVS-based PSI Protocol.
+    """Execute OKVS-based PSI Protocol (Original RR22 Logic).
+
+    This implementation follows the RR22 paper's role assignment where:
+    - PSI Sender holds Delta (and W).
+    - PSI Receiver holds U and V.
+
+    This enables the "One Decode" optimization on the Sender side and prevents
+    offline brute-force attacks by the Receiver (though Sender could brute-force).
 
     Args:
         sender: Rank of Sender.
         receiver: Rank of Receiver.
-        n: Number of items (must be same for now).
-        sender_items: Object located at Sender containing (N,) u64 items.
-        receiver_items: Object located at Receiver containing (N,) u64 items.
+        n: Number of items.
+        sender_items: Object located at Sender.
+        receiver_items: Object located at Receiver.
 
     Returns:
-        Intersection verification tuple (T, U*, Delta).
+        Intersection mask (0/1) located at Receiver.
     """
 
     # Validation
@@ -95,52 +101,42 @@ def psi_intersect(
         raise ValueError(
             f"Sender ({sender}) and Receiver ({receiver}) must be different."
         )
-
     if n <= 0:
         raise ValueError(f"Input size n must be positive, got {n}.")
 
     # =========================================================================
-    # Phase 1. Parameter Setup & Topology
+    # Phase 1. Parameter Setup
     # =========================================================================
-    # OKVS Size M = expansion * N.
-    # The expansion factor is critical for the success probability of the "Peeling"
-    # algorithm used in OKVS encoding (Garbled Cuckoo Table).
-    # Larger N allows smaller expansion (closer to theoretical 1.23) while maintaining safety.
     import mplang.v2.libs.mpc.psi.okvs_gct as okvs_gct
 
     expansion = okvs_gct.get_okvs_expansion(n)
     M = int(n * expansion)
-
-    # Align M to 128 boundary for efficient batch processing in Silent VOLE (LPN)
     if M % 128 != 0:
         M = ((M // 128) + 1) * 128
 
     # =========================================================================
-    # Phase 2. Correlated Randomness Generation (VOLE)
+    # Phase 2. Correlated Randomness (VOLE)
     # =========================================================================
-    # Parties run Silent VOLE (based on LPN assumption) to generate:
-    #   Sender:   U, V  (Vectors of size M)
-    #   Receiver: W, Delta
-    # Correlation: W = V + U * Delta
+    # In the original paper logic (Fig 4), the PSI Sender holds Delta.
+    # Therefore, we swap the roles in the OT call.
+    #
+    # silent_vole_random_u(A, B) gives:
+    #   A (OT Sender):   U, V
+    #   B (OT Receiver): W, Delta
     #
-    # Note: U is uniformly random. It acts as a "One-Time Pad" key for the protocol.
+    # We want PSI Sender to be OT Receiver.
+    res_tuple = silent_ot.silent_vole_random_u(receiver, sender, M, base_k=1024)
 
-    # silent_vole_random_u returns (v, w, u, delta)
-    res_tuple = silent_ot.silent_vole_random_u(sender, receiver, M, base_k=1024)
-    v_sender, w_receiver, u_sender, delta_receiver = res_tuple[:4]
+    # PSI Receiver gets U, V
+    v_recv, w_sender, u_recv, delta_sender = res_tuple[:4]
 
     # =========================================================================
-    # Phase 3. Receiver Encoding & Masking (OKVS)
+    # Phase 3. Receiver Encoding & Masking
     # =========================================================================
-    # The Receiver encodes their input set Y into the OKVS structure P.
-    # Goal: Decode(P, y) = H(y)  forall y in Y.
-    #
-    # Then, Receiver masks P with the VOLE output W to get Q:
-    # Q = P ^ W
-    # This Q is sent to the Sender.
+    # Receiver computes P such that P(y) = H(y).
+    # Receiver masks P with U (Paper's A vector).
+    # Q = P ^ U
 
-    # 3.1 Generate OKVS Seed (Public/Session Randomness)
-    # Used for OKVS hashing distribution. Can be public, but generated at runtime for safety.
     from mplang.v2.dialects import crypto
     from mplang.v2.edsl import typing as elt
 
@@ -150,19 +146,11 @@ def psi_intersect(
     okvs_seed = simp.pcall_static((receiver,), _gen_seed)
     okvs_seed_sender = simp.shuffle_static(okvs_seed, {sender: receiver})
 
-    # Instantiate OKVS Data Structure
     okvs = okvs_gct.SparseOKVS(M)
 
-    def _recv_ops(y: Any, w: Any, delta: Any, seed: Any) -> Any:
-        # y: (N,) Inputs
-        # w: (M, 2) VOLE share
-
-        # 3.2 Compute H(y) - The Random Oracle Target
-        # We use Davies-Meyer construction: H(x) = E_x(0) ^ x
-        # This is a standard, efficient, and robust way to instantiate a RO from AES.
-
+    def _recv_ops(y: Any, u: Any, seed: Any) -> Any:
+        # 3.1 Compute H(y)
         def _reshape_seeds(items: Any) -> Any:
-            # Prepare items as AES keys (128-bit)
             lo = items
             hi = jnp.zeros_like(items)
             return jnp.stack([lo, hi], axis=1)  # (N, 2)
@@ -176,55 +164,59 @@ def psi_intersect(
 
         h_y = tensor.run_jax(_davies_meyer, res_exp, seeds)
 
-        # 3.3 Solve System of Linear Equations (OKVS Encode)
-        # We find P such that: P * M_okvs(y) = h_y
+        # 3.2 Encode P
         p_storage = okvs.encode(y, h_y, seed)
 
-        # 3.4 Mask with Vole Share
-        # Q = P ^ W
-        q_storage = field.add(p_storage, w)
+        # 3. Mask with U (instead of W)
+        # Q = P ^ U
+        q_storage = field.add(p_storage, u)
 
         return q_storage
 
-    # Execute on Receiver
+    # Receiver uses U to mask
     q_shared = simp.pcall_static(
-        (receiver,), _recv_ops, receiver_items, w_receiver, delta_receiver, okvs_seed
+        (receiver,), _recv_ops, receiver_items, u_recv, okvs_seed
     )
 
-    # 3.5 Send Q to Sender
     q_sender_view = simp.shuffle_static(q_shared, {sender: receiver})
 
     # =========================================================================
-    # Phase 4. Sender Decoding & Reconstruction
+    # Phase 4. Sender "One Decode" & Tag Generation
     # =========================================================================
-    # Sender uses Q and their local shares (U, V) to reconstruct T.
+    # Sender holds W, Delta. Receives Q.
+    # W = V + U * Delta
     #
     # Derivation:
-    # 1. S_decoded = Decode(Q, x) = Decode(P ^ W, x) = P(x) ^ W(x)
-    # 2. Recall W(x) = V(x) ^ U(x)*Delta (VOLE property)
-    # 3. So S_decoded = P(x) ^ V(x) ^ U(x)*Delta
-    #
-    # 4. Sender computes T = S_decoded ^ V(x) ^ H(x)
-    #    T = P(x) ^ V(x) ^ U(x)*Delta ^ V(x) ^ H(x)
-    #    T = P(x) ^ H(x) ^ U(x)*Delta
+    # K = Q * Delta + W
+    #   = (P + U) * Delta + (V + U * Delta)
+    #   = P * Delta + U * Delta + V + U * Delta
+    #   = P * Delta + V
     #
-    # 5. If x is in Intersection (Meanings x == y for some y):
-    #    Then P(x) == H(x) (by OKVS property)
-    #    So T = H(x) ^ H(x) ^ U(x)*Delta
-    #    T = U(x)*Delta
-    #
-    # This relation T == U* * Delta is what we verify in Phase 5.
+    # Sender computes Tag = Decode(K, x) - H(x) * Delta
+    # If x in Intersection: P(x) = H(x)
+    # Tag = (P(x) * Delta + V(x)) - P(x) * Delta
+    # Tag = V(x)
+
+    def _sender_ops(x: Any, q: Any, w: Any, delta: Any, seed: Any) -> Any:
+        # q, w: (M, 2)
+        # delta: (2,)
+
+        # Safe tiling assuming M is aligned
+        def _tile_m_simple(d: Any) -> Any:
+            return jnp.tile(d, (M, 1))
+
+        delta_expanded_m = tensor.run_jax(_tile_m_simple, delta)
 
-    def _sender_ops(x: Any, q: Any, u: Any, v: Any, seed: Any) -> tuple[Any, Any]:
-        # x: (N,) Sender Items
-        # q: (M, 2) Received OKVS
+        # 4.2. Compute Global K = Q * Delta + W
+        # This is the O(M) multiplication mentioned in the paper
+        q_times_delta = field.mul(q, delta_expanded_m)
+        k_storage = field.add(q_times_delta, w)
 
-        # 4.1 Decode Q and V at x
-        # OKVS Decode is a linear combination of storage positions.
-        s_decoded = okvs.decode(x, q, seed)
-        v_decoded = okvs.decode(x, v, seed)
+        # 4.3 One Decode
+        # decoded_val = P(x)*Delta + V(x)
+        decoded_k = okvs.decode(x, k_storage, seed)
 
-        # 4.2 Compute H(x)
+        # 4.4 Remove H(x)*Delta
         def _reshape_seeds(items: Any) -> Any:
             lo = items
             hi = jnp.zeros_like(items)
@@ -239,106 +231,73 @@ def psi_intersect(
 
         h_x = tensor.run_jax(_davies_meyer, res_exp_x, seeds_x)
 
-        # 4.3 Compute T candidate
-        # T = S ^ V ^ H(x)
-        # Note: s_decoded is (S^V^U*Delta) effectively
-        t_val = field.add(s_decoded, v_decoded)
-        t_val = field.add(t_val, h_x)
+        # Expand delta for batch N
+        def _tile_n(d: Any) -> Any:
+            return jnp.tile(d, (n, 1))
+
+        delta_expanded_n = tensor.run_jax(_tile_n, delta)
 
-        # 4.4 Compute U* = Decode(U, x)
-        # This is the sender's share of the randomness for item x.
-        s_u = field.decode_okvs(x, u, seed)
+        h_x_times_delta = field.mul(h_x, delta_expanded_n)
 
-        return t_val, s_u
+        # Final Tag = (P*Delta + V) + H*Delta = V(x)
+        tag = field.add(decoded_k, h_x_times_delta)
 
-    t_val_sender, u_star_sender = simp.pcall_static(
+        return tag
+
+    # Execute on Sender
+    sender_tags = simp.pcall_static(
         (sender,),
         _sender_ops,
         sender_items,
         q_sender_view,
-        u_sender,
-        v_sender,
+        w_sender,
+        delta_sender,
         okvs_seed_sender,
     )
-
     # =========================================================================
-    # Phase 5. Secure Verification
+    # Phase 5. Verification (Receiver Side)
     # =========================================================================
-    # The Protocol invariant is T == U* * Delta for intersection items.
-    #
-    # Security Risk:
-    # We must NOT reveal T or Delta to the other party.
-    # - If Receiver learns T, they can compute Diff = T - U*Delta = H(x) + ... and attack x.
-    # - If Sender learns Delta, VOLE security collapses.
-    #
-    # Secure Verification Method:
-    # 1. Sender sends U* (Random Mask share) to Receiver.
-    #    - U* is derived from U (random VOLE inputs) so it reveals nothing about X.
-    #
-    # 2. Receiver computes Target = U* * Delta.
-    #    - This allows Receiver to construct the expected value of T without knowing T's components.
-    #
-    # 3. Receiver Hashes the Target and sends H(Target) to Sender.
-    #    - Hashing prevents Sender from learning Delta algebraically.
-    #    - Hash function acts as a commitment.
-    #
-    # 4. Sender compares H(T) =? H(Target).
-    #    - Equality implies x is in Intersection.
-
-    # 5.1 Sender -> Receiver: U*
-    u_star_recv = simp.shuffle_static(u_star_sender, {receiver: sender})
-
-    # 5.2 Receiver: Compute Expected Target (U* * Delta)
-    def _recv_verify_ops(u_s: Any, delta: Any) -> Any:
-        # u_s: (N, 2), delta: (2,)
-
-        # Use tensor.run_jax to isolate JAX operations (tile is not an EDSL primitive)
-        def _tile(d: Any) -> Any:
-            return jnp.tile(d, (n, 1))
-
-        delta_expanded = tensor.run_jax(_tile, delta)
-
-        # Compute U* * Delta in GF(2^128)
-        target = field.mul(u_s, delta_expanded)
-        return target
-
-    target_val = simp.pcall_static(
-        (receiver,), _recv_verify_ops, u_star_recv, delta_receiver
-    )
+    # Sender sends Tags (which should be V(x)) to Receiver. To reduce
+    # communication we hash and truncate on the sender side and only send
+    # the truncated hash (first 16 bytes).
 
-    # 5.3 Hash Exchange
-    # Use robust hashing to prevent algebraic attacks or leakage
+    # 5.1 Compute hashed & truncated tags on Sender
     from mplang.v2.libs.mpc.ot import extension as ot_extension
 
-    def _hash_shares(share: el.Object, party: int) -> el.Object:
-        """Hash the shares using domain separator for security."""
-        return ot_extension.vec_hash(share, domain_sep=0xFEED, num_rows=n)
+    def _hash_and_trunc(tags: Any) -> Any:
+        # Compute batched hash on sender and truncate to 16 bytes
+        full_h = ot_extension.vec_hash(tags, domain_sep=0x1111, num_rows=n)
+        # Use tensor.slice_tensor to slice TraceObjects (start=(0,0), end=(n,16))
+        return tensor.slice_tensor(full_h, (0, 0), (n, 16))
 
-    # Hash(Target) on Receiver
-    h_target_recv = simp.pcall_static(
-        (receiver,), lambda x: _hash_shares(x, receiver), target_val
-    )
+    h_sender_trunc = simp.pcall_static((sender,), _hash_and_trunc, sender_tags)
 
-    # Hash(T) on Sender
-    h_t_sender = simp.pcall_static(
-        (sender,), lambda x: _hash_shares(x, sender), t_val_sender
-    )
+    # 5.2 Send truncated hashes to Receiver (much smaller payload)
+    tags_at_recv = simp.shuffle_static(h_sender_trunc, {receiver: sender})
+
+    # 5.3 Receiver computes local V(y) and compares
+    def _recv_verify(y: Any, v: Any, seed: Any, remote_tags: Any) -> Any:
+        # 1. Decode V locally: target = V(y)
+        local_v_y = okvs.decode(y, v, seed)
 
-    # Send Hash to Sender for comparison
-    h_target_at_sender = simp.shuffle_static(h_target_recv, {sender: receiver})
+        # 2. Hash local V(y) and compare with received truncated sender hashes
+        # Note: `remote_tags` here is already the truncated hash (16 bytes)
+        # sent from the Sender.
+        h_local = ot_extension.vec_hash(local_v_y, domain_sep=0x1111, num_rows=n)
 
-    # 5.4 Final Comparison on Sender
-    def _compare(h_t: Any, h_target: Any) -> Any:
-        # Compare 32-byte hashes (N, 32) row-by-row
+        def _core(h_r16: Any, h_l_full: Any) -> Any:
+            # h_r16: (n, 16) truncated bytes from sender
+            # h_l_full: (n, k) full hash bytes; truncate to 16
+            h_l16 = h_l_full[:, :16]
 
-        def _core(a: Any, b: Any) -> Any:
-            eq = jnp.all(a == b, axis=1)
-            return eq.astype(jnp.uint8)  # (N,) 0 or 1
+            eq_matrix = jnp.all(h_r16[:, None, :] == h_l16[None, :, :], axis=2)
+            membership = jnp.any(eq_matrix, axis=0)
+            return membership.astype(jnp.uint8)
 
-        return tensor.run_jax(_core, h_t, h_target)
+        return tensor.run_jax(_core, remote_tags, h_local)
 
     intersection_mask = simp.pcall_static(
-        (sender,), _compare, h_t_sender, h_target_at_sender
+        (receiver,), _recv_verify, receiver_items, v_recv, okvs_seed, tags_at_recv
     )
 
     return cast(el.Object, intersection_mask)

{mplang_nightly-0.1.dev267.dist-info → mplang_nightly-0.1.dev269.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mplang-nightly
-Version: 0.1.dev267
+Version: 0.1.dev269
 Summary: Multi-Party Programming Language
 Author-email: SecretFlow Team <secretflow-contact@service.alipay.com>
 License:                                  Apache License

{mplang_nightly-0.1.dev267.dist-info → mplang_nightly-0.1.dev269.dist-info}/RECORD

@@ -1,4 +1,5 @@
 mplang/__init__.py,sha256=CdfWOdeg-I1q6ULjdBxeLioVlplA4bgPTSn_2xSk5VY,1677
+mplang/py.typed,sha256=RyhZV7Yxo8BvEoBiFz5fH3IWVqQKTcBBE-bzjx_N5GQ,583
 mplang/v1/__init__.py,sha256=m7UQeAqYwQOzFt-lYqv9eKs9kdvutW025pxEG0h7eVs,3346
 mplang/v1/_device.py,sha256=MY4OO7TJr2oxDXbvv_pnBweALxP2wvV0cvq3DMLHFuE,22971
 mplang/v1/host.py,sha256=-daviW1W4HYFhBqMzkDkJoQap8HxNDFDop2FyI_mrak,4306
@@ -96,8 +97,8 @@ mplang/v2/backends/table_impl.py,sha256=Qmd-Z_PLjSbDngWkHz0wc6VykoGHfS2-rCOk1aWu
 mplang/v2/backends/tee_impl.py,sha256=Gp-vqqJPtEMNqP7y68tLhL3a-EW3BQwpo_qCJOSHqKs,7044
 mplang/v2/backends/tensor_impl.py,sha256=8f9f4-_e-m4JWGZSbXLmSSHcgPykRBc1sAYrA3OIxEg,18906
 mplang/v2/backends/simp_driver/__init__.py,sha256=ahOPYYvtFVwqxiFxkpSNP8BCTao_MfCXmtt5zsMaJxg,1258
-mplang/v2/backends/simp_driver/http.py,sha256=nl7ny7f8bzhy1ubNIDXhMgA5P_WA8dhhgFNHvcmfSKk,5548
-mplang/v2/backends/simp_driver/mem.py,sha256=nFA-KkYx5fDh6NseI8QOd5FkNErPDq4h_QjrWD7nMrE,9126
+mplang/v2/backends/simp_driver/http.py,sha256=Fm0M7BKf6Ddqec79btd-tJiuVaD92yghr1GJc84RXmg,5550
+mplang/v2/backends/simp_driver/mem.py,sha256=kx3jDAYx3QkJa1UZDhhY_JjJAdT8u-r6Hsw8fYwFPKY,9128
 mplang/v2/backends/simp_driver/ops.py,sha256=UeVC3eaCUwxrkN6OsJyMYj8qMDufMFQI0YogeSbhkjM,4515
 mplang/v2/backends/simp_driver/state.py,sha256=6tQyQg_PNzHOJkjCoNm51Wvknl3XiJZzpQXuRB4qRtM,1719
 mplang/v2/backends/simp_driver/values.py,sha256=OQ_7Kt6l7Pcfx5eB6GVbpunS6CG60Lj0AS6H9Wx9sKQ,1515
@@ -136,7 +137,7 @@ mplang/v2/kernels/__init__.py,sha256=J_rDl9lAXd7QL3Nt_P3YX6j9yge7ssguSaHuafPZNKE
 mplang/v2/kernels/gf128.cpp,sha256=WIvCr3MijzwJxMi1Wnfhm8aWT8oL0fia6FeyTmFJtPQ,5975
 mplang/v2/kernels/ldpc.cpp,sha256=_zE90ZHQvrweRkBB3CEu80cXKG0a-QNJ59ZQ452gml8,2654
 mplang/v2/kernels/okvs.cpp,sha256=Z_7oGHFAdLc5d5llUNujBO8HwDBh5yd3MpfmT8ZNf1o,10347
-mplang/v2/kernels/okvs_opt.cpp,sha256=d_HhvMdcebYsG2x7kYzjuFgmEsh9WKLH6SHee3375Bg,10932
+mplang/v2/kernels/okvs_opt.cpp,sha256=5MkI_rTfFxohIKqU5Uog0TpxokgXTjUVIJMUS0q5e2I,11870
 mplang/v2/kernels/py_kernels.py,sha256=FDsD86IHV-UBzxZLolhSOkrp24PuboHXeb1gBHLOfMo,12073
 mplang/v2/libs/collective.py,sha256=pfXq9tmFUNKjeHhWMTjtzOi-m2Fn1lLru1G6txZVyic,10683
 mplang/v2/libs/device/__init__.py,sha256=mXsSvXrWmlHu6Ch87Vcd85m4L_qdDkbSvJyHyuai2fc,1251
@@ -159,9 +160,9 @@ mplang/v2/libs/mpc/ot/silent.py,sha256=9J3sMsz3XzxPbIk91IpfAvvdGeZw-Tt0kElyPsNln
 mplang/v2/libs/mpc/psi/__init__.py,sha256=mpevlx3Z5_u9Q1McDZBBIGHApeO9julgiM09GToxxEA,1231
 mplang/v2/libs/mpc/psi/cuckoo.py,sha256=GQvLi7BtaPZyk96xwVCwpQPGlcGhOUX6kdsEn8P80l0,7752
 mplang/v2/libs/mpc/psi/okvs.py,sha256=a1Q4ILrsLII9K-BJRSX8iKkpkxJsMxFEj7cTId-XGCE,1576
-mplang/v2/libs/mpc/psi/okvs_gct.py,sha256=wRxBEZw-dnYXHWng-1eRsnnP6k6wKySSUxigN9eq08k,3023
+mplang/v2/libs/mpc/psi/okvs_gct.py,sha256=YcN5ms8StV4ogHR5gK4-SlbIjbcA0QjITagza2EyY70,3375
 mplang/v2/libs/mpc/psi/oprf.py,sha256=YXD-I9P3t1YuqHVxOD9JUpLTZUu-HjgvOaEOQ3hhxMM,13772
-mplang/v2/libs/mpc/psi/rr22.py,sha256=2mN1zbjrBUgaWCsF3Lj8ohtK6gcG95PtBb3EseS-Nsg,12614
+mplang/v2/libs/mpc/psi/rr22.py,sha256=fDXigUduBnHfG_8qoL4uS7EHaTmjUjJsZCgnA0-u8cQ,11209
 mplang/v2/libs/mpc/psi/unbalanced.py,sha256=hC84TVsgnlJDg6hpUrx8kbUbmFb27T9wrHG0zv3FXLc,7433
 mplang/v2/libs/mpc/vole/__init__.py,sha256=2dU4X6n73HoK-YCiCl4b36SkLRKR6rofe2xxLxBz6Rc,968
 mplang/v2/libs/mpc/vole/gilboa.py,sha256=apnKOYR4_dJ2wkzGq7PBlwauA-W5i5MPESdetCWTegU,9951
@@ -172,8 +173,8 @@ mplang/v2/runtime/dialect_state.py,sha256=HxO1i4kSOujS2tQzAF9-WmI3nChSaGgupf2_07
 mplang/v2/runtime/interpreter.py,sha256=UzrM5oepka6H0YKRZncNXhsuwKVm4pliG5J92fFRZMI,32300
 mplang/v2/runtime/object_store.py,sha256=yT6jtKG2GUEJVmpq3gnQ8mCMvUFYzgBciC5A-J5KRdk,5998
 mplang/v2/runtime/value.py,sha256=CMOxElJP78v7pjasPhEpbxWbSgB2KsLbpPmzz0mQX0E,4317
-mplang_nightly-0.1.dev267.dist-info/METADATA,sha256=fWTmQUUYcAYzXHVW7m_4CxvnQb7w4qbWn5vZ7yffuoU,16775
-mplang_nightly-0.1.dev267.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mplang_nightly-0.1.dev267.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev267.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev267.dist-info/RECORD,,
+mplang_nightly-0.1.dev269.dist-info/METADATA,sha256=54UZyxyPNQqxRpAXBoj_1ZQxHjf5a5Gi7sBKBsEYx78,16775
+mplang_nightly-0.1.dev269.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mplang_nightly-0.1.dev269.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev269.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev269.dist-info/RECORD,,