Proof (kimchi_backend.Kimchi_pasta.Pallas_based

module Backend : sig ... end

module Fq : sig ... end

module G : sig ... end

module Challenge_polynomial : sig ... end

type message = Challenge_polynomial.t list

val hash_fold_array : 
  ( Ppx_hash_lib.Std.Hash.state -> 'a -> Ppx_hash_lib.Std.Hash.state ) ->
  Ppx_hash_lib.Std.Hash.state ->
  'a Core_kernel.Array.t ->
  Ppx_hash_lib.Std.Hash.state

module Stable : sig ... end

type t = Stable.Latest.t

val _ : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or

val to_yojson : t -> Yojson.Safe.t

val of_yojson : Yojson.Safe.t -> t Ppx_deriving_yojson_runtime.error_or

val compare : t -> t -> int

val t_of_sexp : Sexplib0__.Sexp.t -> t

val sexp_of_t : t -> Sexplib0__.Sexp.t

val hash_fold_t : 
  Ppx_hash_lib.Std.Hash.state ->
  t ->
  Ppx_hash_lib.Std.Hash.state

val hash : t -> Ppx_hash_lib.Std.Hash.hash_value

val equal : t -> t -> bool

val bin_size_t : t Bin_prot.Size.sizer

val bin_write_t : t Bin_prot.Write.writer

val bin_read_t : t Bin_prot.Read.reader

val __bin_read_t__ : ( int -> t ) Bin_prot.Read.reader

val bin_shape_t : Bin_prot.Shape.t

val bin_writer_t : t Bin_prot.Type_class.writer

val bin_reader_t : t Bin_prot.Type_class.reader

val bin_t : t Bin_prot.Type_class.t

val g : 
  'a ->
  ( 'a -> G.Affine.Backend.t ) ->
  (Pasta_bindings.Fp.t * Pasta_bindings.Fp.t) Pickles_types.Or_infinity.t

val fq_array_to_vec : Fq.Vector.elt Core_kernel.Array.t -> Fq.Vector.t

val opening_proof_of_backend_exn : 
  ( Pallas_based_plonk.Curve.Affine.Backend.t, Pasta_bindings.Fq.t )
    Kimchi_types.opening_proof ->
  ( G.Affine.t, Pasta_bindings.Fq.t )
    Pickles_types.Plonk_types.Openings.Bulletproof.t

val lookup_eval_of_backend : 
  'f Kimchi_types.lookup_evaluations ->
  'f array Kimchi_types.point_evaluations
    Pickles_types.Plonk_types.Evals.Lookup.t

val eval_of_backend : 
  Pasta_bindings.Fq.t Kimchi_types.proof_evaluations ->
  Pasta_bindings.Fq.t array Kimchi_types.point_evaluations
    Pickles_types.Plonk_types.Evals.t

val of_backend : Backend.t -> t

val lookup_eval_to_backend : 
  'f array Kimchi_types.point_evaluations
    Pickles_types.Plonk_types.Evals.Lookup.t ->
  'f Kimchi_types.lookup_evaluations

val eval_to_backend : 
  Pasta_bindings.Fq.t array Kimchi_types.point_evaluations
    Pickles_types.Plonk_types.Evals.t ->
  Pasta_bindings.Fq.t Kimchi_types.proof_evaluations

val vec_to_array : 
  (module Snarky_intf.Vector.S with type elt = 'elt and type t = 't) ->
  't ->
  'elt Core_kernel.Array.t

val to_backend' : 
  Challenge_polynomial.t list ->
  Pasta_bindings.Fq.t array ->
  t ->
  Backend.t

val to_backend : 
  Challenge_polynomial.t list ->
  Pasta_bindings.Fq.t list ->
  t ->
  Backend.t

val create : 
  ?message:message ->
  Pallas_based_plonk.Keypair.t ->
  primary:Kimchi_bindings.FieldVectors.Fq.t ->
  auxiliary:Kimchi_bindings.FieldVectors.Fq.t ->
  t

val create_async : 
  ?message:message ->
  Pallas_based_plonk.Keypair.t ->
  primary:Kimchi_bindings.FieldVectors.Fq.t ->
  auxiliary:Kimchi_bindings.FieldVectors.Fq.t ->
  t Promise.t

val batch_verify' : 
  ( 'a -> Fq.t array ) ->
  (( Pasta_bindings.Fq.t,
     Kimchi_bindings.Protocol.SRS.Fq.t,
     Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm )
     Kimchi_types.VerifierIndex.verifier_index
   * t
   * 'a
   * message option)
    list ->
  bool Promise.t

val batch_verify : 
  (( Pasta_bindings.Fq.t,
     Kimchi_bindings.Protocol.SRS.Fq.t,
     Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm )
     Kimchi_types.VerifierIndex.verifier_index
   * t
   * Fq.t list
   * message option)
    list ->
  bool Promise.t

val verify : 
  ?message:Challenge_polynomial.t list ->
  t ->
  ( Pasta_bindings.Fq.t,
    Kimchi_bindings.Protocol.SRS.Fq.t,
    Pasta_bindings.Fp.t Kimchi_types.or_infinity Kimchi_types.poly_comm )
    Kimchi_types.VerifierIndex.verifier_index ->
  Kimchi_bindings.FieldVectors.Fq.t ->
  bool