Checkpoint the party/runtime stack before share-program and malicious-mode work.
Ship the TLS mesh, composer, Beaver/Yao/leaf MPC, prep/online paths, apps, and docs so the tree is pushable before elevating share_expr, security_mode, and prep resume. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
parent
695f8e84f7
commit
0d22946a0e
1835 changed files with 170291 additions and 2849 deletions
|
|
@ -44,25 +44,31 @@ inline auto eval_point_interior(const DpfKey & dpf, InputT && x, PathMemoizer &&
|
|||
|
||||
auto level_index = detail::path_resume_for_level(path, dpf, x, dpf.depth);
|
||||
|
||||
DPF_UNROLL_LOOP
|
||||
for (auto mask = dpf.msb_mask>>(level_index-1);
|
||||
level_index <= dpf.depth; ++level_index, mask>>=1)
|
||||
// Same guard as `ensure_level`: skip the `msb_mask` shift when already done.
|
||||
if (level_index <= dpf.depth)
|
||||
{
|
||||
bool bit = !!(mask & x);
|
||||
auto cw = dpf.correction_word(level_index-1, bit);
|
||||
const bool is_last = dpf_type::tree::is_last_level(level_index - 1,
|
||||
dpf.depth);
|
||||
path[level_index] = dpf_type::traverse_interior(path[level_index-1],
|
||||
cw, bit, is_last);
|
||||
if constexpr (dpf_type::is_verifiable)
|
||||
DPF_UNROLL_LOOP
|
||||
for (auto mask = dpf.msb_mask>>(level_index-1);
|
||||
level_index <= dpf.depth; ++level_index, mask>>=1)
|
||||
{
|
||||
if (pi != nullptr)
|
||||
bool bit = !!(mask & x);
|
||||
auto cw = dpf.correction_word(level_index-1, bit);
|
||||
const bool is_last = dpf_type::tree::is_last_level(level_index - 1,
|
||||
dpf.depth);
|
||||
path[level_index] = dpf_type::traverse_interior(path[level_index-1],
|
||||
cw, bit, is_last);
|
||||
if constexpr (dpf_type::is_verifiable)
|
||||
{
|
||||
const auto x_bits = static_cast<psnip_uint64_t>(
|
||||
utils::to_integral_type<std::decay_t<InputT>>{}(x)
|
||||
>> (utils::bitlength_of_v<std::decay_t<InputT>> - level_index));
|
||||
detail::vdpf::fold_node(*pi, level_index - 1, x_bits,
|
||||
path[level_index], dpf.correction_seeds()[level_index - 1]);
|
||||
if (pi != nullptr)
|
||||
{
|
||||
const auto x_bits = static_cast<psnip_uint64_t>(
|
||||
utils::to_integral_type<std::decay_t<InputT>>{}(x)
|
||||
>> (utils::bitlength_of_v<std::decay_t<InputT>>
|
||||
- level_index));
|
||||
detail::vdpf::fold_node(*pi, level_index - 1, x_bits,
|
||||
path[level_index],
|
||||
dpf.correction_seeds()[level_index - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -96,6 +102,7 @@ auto eval_point(const DpfKey & dpf, InputT && x, PathMemoizer && path,
|
|||
} // namespace internal
|
||||
|
||||
/// Evaluate output `I` at `x`.
|
||||
/// \complexity O(n) time. n is `depth`. One interior traversal per level from the memoizer resume index through the leaf. Extra space is the path memoizer (O(n) nodes, or one node if it does not memoize). A proof token adds one fold per level walked.
|
||||
template <std::size_t I = 0,
|
||||
typename DpfKey,
|
||||
typename InputT,
|
||||
|
|
@ -112,7 +119,33 @@ auto eval_point(const DpfKey & dpf, InputT && x, PathMemoizer && path = PathMemo
|
|||
internal::eval_point<I>(dpf, tx, path), tx);
|
||||
}
|
||||
|
||||
/// Evaluate at `x`, folding newly walked nodes into an existing proof token.
|
||||
/// @details Does not `init_proof`; used by bulk sequence evals that share a path.
|
||||
/// \complexity O(n) time. n is `depth`. One interior traversal per level from the memoizer resume index through the leaf. Extra space is the path memoizer (O(n) nodes, or one node if it does not memoize). A proof token adds one fold per level walked.
|
||||
template <std::size_t I = 0,
|
||||
typename DpfKey,
|
||||
typename InputT,
|
||||
typename PathMemoizer,
|
||||
std::enable_if_t<looks_like_dpf_key_v<DpfKey> && !is_multilevel_key_v<DpfKey>, bool> = true>
|
||||
HEDLEY_ALWAYS_INLINE
|
||||
auto eval_point(const DpfKey & dpf, InputT && x, PathMemoizer && path,
|
||||
proof_token * pi)
|
||||
{
|
||||
assert_not_wildcard_output<I>(dpf);
|
||||
using output_type = typename DpfKey::concrete_output_type<I>;
|
||||
|
||||
auto tx = dpf.offset_x(x);
|
||||
return make_eval_dpf_output<DpfKey, output_type>(
|
||||
internal::eval_point<I>(dpf, tx, path, pi), tx);
|
||||
}
|
||||
|
||||
/// Evaluate and fold a VDPF proof token for the walked path.
|
||||
/// @details A fresh token always folds every node on the path, including
|
||||
/// nodes already stored in a warm path memoizer (hash the cached
|
||||
/// seeds; do not re-expand the PRG). Callers that continue one
|
||||
/// accumulator across many points use the `proof_token *` overload
|
||||
/// without `init_proof`.
|
||||
/// \complexity O(n) time. n is `depth`. One interior traversal per level from the memoizer resume index through the leaf. Extra space is the path memoizer (O(n) nodes, or one node if it does not memoize). A proof token adds one fold per level walked.
|
||||
template <std::size_t I = 0,
|
||||
typename DpfKey,
|
||||
typename InputT,
|
||||
|
|
@ -124,16 +157,68 @@ auto eval_point(const DpfKey & dpf, InputT && x, prove_ref pr,
|
|||
{
|
||||
static_assert(DpfKey::is_verifiable,
|
||||
"eval_point(..., prove(π)): key must carry dpf::verifiable");
|
||||
assert_not_wildcard_output<I>(dpf);
|
||||
using output_type = typename DpfKey::concrete_output_type<I>;
|
||||
|
||||
detail::vdpf::init_proof(pr.token, dpf);
|
||||
auto tx = dpf.offset_x(x);
|
||||
return make_eval_dpf_output<DpfKey, output_type>(
|
||||
internal::eval_point<I>(dpf, tx, path, &pr.token), tx);
|
||||
auto walk_x = dpf.offset_x(x);
|
||||
utils::flip_msb_if_signed_integral(walk_x);
|
||||
if constexpr (DpfKey::is_verifiable)
|
||||
{
|
||||
const auto resume = detail::path_resume_for_level(
|
||||
path, dpf, walk_x, dpf.depth);
|
||||
for (std::size_t level_index = 1; level_index < resume; ++level_index)
|
||||
{
|
||||
const auto x_bits = static_cast<psnip_uint64_t>(
|
||||
utils::to_integral_type<std::decay_t<decltype(walk_x)>>{}(
|
||||
walk_x)
|
||||
>> (utils::bitlength_of_v<std::decay_t<decltype(walk_x)>>
|
||||
- level_index));
|
||||
detail::vdpf::fold_node(pr.token, level_index - 1, x_bits,
|
||||
path[level_index],
|
||||
dpf.correction_seeds()[level_index - 1]);
|
||||
}
|
||||
}
|
||||
auto out = eval_point<I>(dpf, std::forward<InputT>(x),
|
||||
std::forward<PathMemoizer>(path), &pr.token);
|
||||
detail::vdpf::fold_output_binding(pr.token, dpf);
|
||||
return out;
|
||||
}
|
||||
|
||||
/// Evaluate and fold the output into a weight-1 sketch.
|
||||
/// \complexity O(n) time. n is `depth`. One interior traversal per level from the memoizer resume index through the leaf. Extra space is the path memoizer (O(n) nodes, or one node if it does not memoize). A proof token adds one fold per level walked.
|
||||
template <std::size_t I = 0,
|
||||
typename DpfKey,
|
||||
typename InputT,
|
||||
typename PathMemoizer = dpf::nonmemoizing_path_memoizer<DpfKey>,
|
||||
std::enable_if_t<looks_like_dpf_key_v<DpfKey>, bool> = true>
|
||||
HEDLEY_ALWAYS_INLINE
|
||||
auto eval_point(const DpfKey & dpf, InputT && x, sketch_ref & sk,
|
||||
PathMemoizer && path = PathMemoizer{})
|
||||
{
|
||||
static_assert(DpfKey::is_extractable,
|
||||
"eval_point(..., sketch(σ)): key must carry dpf::extractable");
|
||||
auto out = eval_point<I>(dpf, std::forward<InputT>(x),
|
||||
std::forward<PathMemoizer>(path));
|
||||
if constexpr (DpfKey::is_extractable)
|
||||
sk.absorb((*out).raw());
|
||||
return out;
|
||||
}
|
||||
|
||||
/// @brief Rvalue convenience for a one-shot `sketch(local, rs)` temporary.
|
||||
/// \complexity O(n) time. n is `depth`. One interior traversal per level from the memoizer resume index through the leaf. Extra space is the path memoizer (O(n) nodes, or one node if it does not memoize). A proof token adds one fold per level walked.
|
||||
template <std::size_t I = 0,
|
||||
typename DpfKey,
|
||||
typename InputT,
|
||||
typename PathMemoizer = dpf::nonmemoizing_path_memoizer<DpfKey>,
|
||||
std::enable_if_t<looks_like_dpf_key_v<DpfKey>, bool> = true>
|
||||
HEDLEY_ALWAYS_INLINE
|
||||
auto eval_point(const DpfKey & dpf, InputT && x, sketch_ref && sk,
|
||||
PathMemoizer && path = PathMemoizer{})
|
||||
{
|
||||
return eval_point<I>(dpf, std::forward<InputT>(x), sk,
|
||||
std::forward<PathMemoizer>(path));
|
||||
}
|
||||
|
||||
/// Evaluate several outputs at `x`.
|
||||
/// \complexity O(n) time. n is `depth`. One interior traversal per level from the memoizer resume index through the leaf. Extra space is the path memoizer (O(n) nodes, or one node if it does not memoize). A proof token adds one fold per level walked.
|
||||
template <std::size_t I0,
|
||||
std::size_t I1,
|
||||
std::size_t ...Is,
|
||||
|
|
@ -150,37 +235,6 @@ auto eval_point(const DpfKey & dpf, InputT && x, PathMemoizer && path = PathMemo
|
|||
*eval_point<Is>(dpf, x, path)...);
|
||||
}
|
||||
|
||||
/// Fold every point in `[from, to]` into `pi` (caller must `init_proof` first,
|
||||
/// or pass a fresh token via `prove_interval` below).
|
||||
template <typename KeyT, typename InputT>
|
||||
void prove_fold_interval(const KeyT & key, InputT from, InputT to,
|
||||
proof_token & pi)
|
||||
{
|
||||
static_assert(KeyT::is_verifiable,
|
||||
"prove_fold_interval: key must carry dpf::verifiable");
|
||||
using input_type = typename KeyT::input_type;
|
||||
auto cur = static_cast<input_type>(from);
|
||||
const auto last = static_cast<input_type>(to);
|
||||
for (;;)
|
||||
{
|
||||
nonmemoizing_path_memoizer<KeyT> path{};
|
||||
auto tx = key.offset_x(cur);
|
||||
utils::flip_msb_if_signed_integral(tx);
|
||||
internal::eval_point_interior(key, tx, path, &pi);
|
||||
if (cur == last)
|
||||
break;
|
||||
++cur;
|
||||
}
|
||||
}
|
||||
|
||||
/// Initialise `pr.token` and fold `[from, to]`.
|
||||
template <typename KeyT, typename InputT>
|
||||
void prove_interval(const KeyT & key, InputT from, InputT to, prove_ref pr)
|
||||
{
|
||||
detail::vdpf::init_proof(pr.token, key);
|
||||
prove_fold_interval(key, from, to, pr.token);
|
||||
}
|
||||
|
||||
} // namespace dpf
|
||||
|
||||
#endif // LIBDPF_INCLUDE_DPF_EVAL_POINT_HPP__
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue