Tick0 (snark_params.Snark

include module type of struct include Crypto_params.Tick end

module Full = Crypto_params.Tick.Full

module Run = Crypto_params.Tick.Run

val group_map_params : Pickles.Backend.Tock.Field.t Group_map.Params.t

include module type of struct include Full.Internal_Basic end

type field = Full.field

module R1CS_constraint_system = Crypto_params.Tick.R1CS_constraint_system

module Bigint = Crypto_params.Tick.Bigint

module Constraint = Crypto_params.Tick.Constraint

module Typ = Crypto_params.Tick.Typ

module Boolean = Crypto_params.Tick.Boolean

module Checked = Crypto_params.Tick.Checked

module Field = Crypto_params.Tick.Field

module As_prover = Crypto_params.Tick.As_prover

module Proof_inputs = Crypto_params.Tick.Proof_inputs

module Let_syntax = Crypto_params.Tick.Let_syntax

module Bitstring_checked = Crypto_params.Tick.Bitstring_checked

module Handle = Crypto_params.Tick.Handle

module Runner = Crypto_params.Tick.Runner

type response = Snarky_backendless.Request.response

val unhandled : response

type request = Snarky_backendless.Request.request =

| With : {

request : 'a Snarky_backendless.Request.t;

respond : 'a Snarky_backendless.Request.Response.t -> response;

} -> request

module Handler = Crypto_params.Tick.Handler

val assert_ : ?label:string -> Constraint.t -> unit Checked.t

val assert_all : ?label:string -> Constraint.t list -> unit Checked.t

val assert_r1cs : 
  ?label:string ->
  Field.Var.t ->
  Field.Var.t ->
  Field.Var.t ->
  unit Checked.t

val assert_square : 
  ?label:string ->
  Field.Var.t ->
  Field.Var.t ->
  unit Checked.t

val as_prover : unit As_prover.t -> unit Checked.t

val mk_lazy : ( unit -> 'a Checked.t ) -> 'a Core_kernel.Lazy.t Checked.t

val next_auxiliary : unit -> int Checked.t

val request_witness : 
  ( 'var, 'value ) Typ.t ->
  'value Snarky_backendless.Request.t As_prover.t ->
  'var Checked.t

val perform : unit Snarky_backendless.Request.t As_prover.t -> unit Checked.t

val request : 
  ?such_that:( 'var -> unit Checked.t ) ->
  ( 'var, 'value ) Typ.t ->
  'value Snarky_backendless.Request.t ->
  'var Checked.t

val exists : 
  ?request:'value Snarky_backendless.Request.t As_prover.t ->
  ?compute:'value As_prover.t ->
  ( 'var, 'value ) Typ.t ->
  'var Checked.t

val exists_handle : 
  ?request:'value Snarky_backendless.Request.t As_prover.t ->
  ?compute:'value As_prover.t ->
  ( 'var, 'value ) Typ.t ->
  ( 'var, 'value ) Handle.t Checked.t

val handle : ( unit -> 'a Checked.t ) -> Handler.t -> 'a Checked.t

val handle_as_prover : 
  ( unit -> 'a Checked.t ) ->
  Handler.t As_prover.t ->
  'a Checked.t

val if_ : 
  Boolean.var ->
  typ:( 'var, 'a ) Typ.t ->
  then_:'var ->
  else_:'var ->
  'var Checked.t

val with_label : string -> ( unit -> 'a Checked.t ) -> 'a Checked.t

val constraint_system : 
  input_typ:( 'input_var, 'input_value ) Typ.t ->
  return_typ:( 'a, 'b ) Typ.t ->
  ( 'input_var -> 'a Checked.t ) ->
  R1CS_constraint_system.t

val conv : 
  ( 'r_var -> 'r_value ) ->
  ( 'input_var, 'input_value ) Typ.t ->
  ( 'a, 'b ) Typ.t ->
  ( 'input_var -> 'r_var ) ->
  'input_value ->
  'r_value

val generate_public_input : 
  ( 'input_var, 'input_value ) Typ.t ->
  'input_value ->
  Field.Vector.t

val generate_witness : 
  input_typ:( 'input_var, 'input_value ) Typ.t ->
  return_typ:( 'r_var, 'a ) Typ.t ->
  ( 'input_var -> 'r_var Checked.t ) ->
  'input_value ->
  Proof_inputs.t

val generate_witness_conv : 
  f:( Proof_inputs.t -> 'r_value -> 'out ) ->
  input_typ:( 'input_var, 'input_value ) Typ.t ->
  return_typ:( 'r_var, 'r_value ) Typ.t ->
  ( 'input_var -> 'r_var Checked.t ) ->
  'input_value ->
  'out

val run_unchecked : 'a Checked.t -> 'a

val run_and_check : 'a As_prover.t Checked.t -> 'a Core_kernel.Or_error.t

val check : 'a Checked.t -> unit Core_kernel.Or_error.t

val generate_auxiliary_input : 
  input_typ:( 'input_var, 'input_value ) Typ.t ->
  return_typ:( 'a, 'b ) Typ.t ->
  ( 'input_var -> 'a Checked.t ) ->
  'input_value ->
  unit

val constraint_count : 
  ?weight:( Constraint.t -> int ) ->
  ?log:( ?start:bool -> string -> int -> unit ) ->
  ( unit -> 'a Checked.t ) ->
  int

val constant : ( 'var, 'value ) Typ.t -> 'value -> 'var

module Test = Crypto_params.Tick.Test

val set_constraint_logger : 
  ( ?at_label_boundary:([ `End | `Start ] * string) ->
    Constraint.t option ->
    unit ) ->
  unit

val clear_constraint_logger : unit -> unit

module Number = Crypto_params.Tick.Number

module Enumerable = Crypto_params.Tick.Enumerable

module Inner_curve = Crypto_params.Tick.Inner_curve

module Snarkable : sig ... end