Make (kimchi_backend.Kimchi_backend_common.Plonk_dlog

Parameters

module Inputs : Inputs_intf

Signature

module Backend = Inputs.Backend

module Fq = Inputs.Scalar_field

module G = Inputs.Curve

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 ->
  'b Core_kernel.Array.t ->
  Ppx_hash_lib.Std.Hash.state

module Stable : sig ... end

type t = Stable.Latest.t

val to_yojson : t -> Yojson.Safe.t

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

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

val compare : t -> t -> int

val t_of_sexp : Ppx_sexp_conv_lib.Sexp.t -> t

val sexp_of_t : t -> Ppx_sexp_conv_lib.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 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 ->
  ( 'b -> G.Affine.Backend.t ) ->
  (Inputs.Base_field.t * Inputs.Base_field.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 : 
  Inputs.Opening_proof_backend.t ->
  ( G.Affine.t, Inputs.Scalar_field.t )
    Pickles_types.Plonk_types.Openings.Bulletproof.t

Note that this function will panic if any of the points are points at infinity

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

val eval_of_backend : 
  Inputs.Evaluations_backend.t ->
  Inputs.Scalar_field.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 ->
  'f0 Kimchi_types.lookup_evaluations

val eval_to_backend : 
  Inputs.Scalar_field.t array Kimchi_types.point_evaluations
    Pickles_types.Plonk_types.Evals.t ->
  Inputs.Evaluations_backend.t

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

val to_backend' : 
  Challenge_polynomial.t list ->
  Inputs.Scalar_field.t array ->
  t ->
  Backend.t

val to_backend : 
  Challenge_polynomial.t list ->
  Inputs.Scalar_field.t list ->
  t ->
  Backend.t

val create : 
  ?message:message ->
  Inputs.Index.t ->
  primary:Inputs.Scalar_field.Vector.t ->
  auxiliary:Inputs.Scalar_field.Vector.t ->
  t

val create_async : 
  ?message:message ->
  Inputs.Index.t ->
  primary:Inputs.Scalar_field.Vector.t ->
  auxiliary:Inputs.Scalar_field.Vector.t ->
  t Promise.t

val batch_verify' : 
  ( 'a -> Fq.t array ) ->
  (Inputs.Verifier_index.t * t * 'a0 * message option) list ->
  bool Promise.t

val batch_verify : 
  (Inputs.Verifier_index.t * t * Fq.t list * message option) list ->
  bool Promise.t

val verify : 
  ?message:Challenge_polynomial.t list ->
  t ->
  Inputs.Verifier_index.t ->
  Inputs.Scalar_field.Vector.t ->
  bool