Proof_state (pickles.Composition_types.Wrap.Proof

module Deferred_values : sig ... end

This module contains structures which contain the scalar-field elements that are required to finalize the verification of a proof that is partially verified inside a circuit.

module Stable : sig ... end

type ('plonk, 'scalar_challenge, 'fp, 'messages_for_next_wrap_proof, 'digest, 'bp_chals, 'index)
  t =
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    Stable.Latest.t =
  {

deferred_values : ( 'plonk, 'scalar_challenge, 'fp, 'bp_chals, 'index )
                    Deferred_values.t;

sponge_digest_before_evaluations : 'digest;

messages_for_next_wrap_proof : 'messages_for_next_wrap_proof;

}

val to_yojson : 
  ( 'plonk -> Yojson.Safe.t ) ->
  ( 'scalar_challenge -> Yojson.Safe.t ) ->
  ( 'fp -> Yojson.Safe.t ) ->
  ( 'messages_for_next_wrap_proof -> Yojson.Safe.t ) ->
  ( 'digest -> Yojson.Safe.t ) ->
  ( 'bp_chals -> Yojson.Safe.t ) ->
  ( 'index -> Yojson.Safe.t ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  Yojson.Safe.t

val of_yojson : 
  ( Yojson.Safe.t -> 'plonk Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'scalar_challenge Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'fp Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t ->
    'messages_for_next_wrap_proof Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'digest Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'bp_chals Ppx_deriving_yojson_runtime.error_or ) ->
  ( Yojson.Safe.t -> 'index Ppx_deriving_yojson_runtime.error_or ) ->
  Yojson.Safe.t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t
    Ppx_deriving_yojson_runtime.error_or

val sexp_of_t : 
  ( 'plonk -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'scalar_challenge -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'fp -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'messages_for_next_wrap_proof -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'digest -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'bp_chals -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'index -> Ppx_sexp_conv_lib.Sexp.t ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  Ppx_sexp_conv_lib.Sexp.t

val t_of_sexp : 
  ( Ppx_sexp_conv_lib.Sexp.t -> 'plonk ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'scalar_challenge ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'fp ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'messages_for_next_wrap_proof ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'digest ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'bp_chals ) ->
  ( Ppx_sexp_conv_lib.Sexp.t -> 'index ) ->
  Ppx_sexp_conv_lib.Sexp.t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t

val compare : 
  ( 'plonk -> 'plonk -> int ) ->
  ( 'scalar_challenge -> 'scalar_challenge -> int ) ->
  ( 'fp -> 'fp -> int ) ->
  ( 'messages_for_next_wrap_proof -> 'messages_for_next_wrap_proof -> int ) ->
  ( 'digest -> 'digest -> int ) ->
  ( 'bp_chals -> 'bp_chals -> int ) ->
  ( 'index -> 'index -> int ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  int

val to_hlist : 
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  ( unit,
    ( 'plonk, 'scalar_challenge, 'fp, 'bp_chals, 'index ) Deferred_values.t ->
    'digest ->
    'messages_for_next_wrap_proof ->
    unit )
    H_list.t

val of_hlist : 
  ( unit,
    ( 'plonk, 'scalar_challenge, 'fp, 'bp_chals, 'index ) Deferred_values.t ->
    'digest ->
    'messages_for_next_wrap_proof ->
    unit )
    H_list.t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t

val hash_fold_t : 
  ( Ppx_hash_lib.Std.Hash.state -> 'plonk -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'scalar_challenge ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'fp -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state ->
    'messages_for_next_wrap_proof ->
    Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'digest -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'bp_chals -> Ppx_hash_lib.Std.Hash.state ) ->
  ( Ppx_hash_lib.Std.Hash.state -> 'index -> Ppx_hash_lib.Std.Hash.state ) ->
  Ppx_hash_lib.Std.Hash.state ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  Ppx_hash_lib.Std.Hash.state

val equal : 
  ( 'plonk -> 'plonk -> bool ) ->
  ( 'scalar_challenge -> 'scalar_challenge -> bool ) ->
  ( 'fp -> 'fp -> bool ) ->
  ( 'messages_for_next_wrap_proof -> 'messages_for_next_wrap_proof -> bool ) ->
  ( 'digest -> 'digest -> bool ) ->
  ( 'bp_chals -> 'bp_chals -> bool ) ->
  ( 'index -> 'index -> bool ) ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  ( 'plonk,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'bp_chals,
    'index )
    t ->
  bool

module Messages_for_next_wrap_proof : sig ... end

The component of the proof accumulation state that is only computed on by the "wrapping" proof system, and that can be handled opaquely by any "step" circuits.

module Minimal : sig ... end

module In_circuit : sig ... end

val to_minimal : 
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h ) In_circuit.t ->
  to_option:
    ( 'd -> ( 'b, 'c ) Deferred_values.Plonk.In_circuit.Lookup.t option ) ->
  ( 'a, 'b, 'i, 'c, 'e, 'f, 'g, 'h ) Minimal.t