In_circuit (pickles.Composition_types.Wrap.Statement.In

type ('challenge, 'scalar_challenge, 'fp, 'lookup_opt, 'messages_for_next_wrap_proof, 'digest, 'messages_for_next_step_proof, 'bp_chals, 'index)
  t =
  ( ( 'challenge, 'scalar_challenge, 'fp, 'lookup_opt )
      Proof_state.Deferred_values.Plonk.In_circuit.t,
    'scalar_challenge,
    'fp,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    Stable.Latest.t

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

val of_yojson : 
  ( Yojson.Safe.t -> 'challenge 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 -> 'lookup_opt 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 ->
    'messages_for_next_step_proof 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 ->
  ( 'challenge,
    'scalar_challenge,
    'fp,
    'lookup_opt,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t
    Ppx_deriving_yojson_runtime.error_or

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

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

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

val hash_fold_t : 
  ( Ppx_hash_lib.Std.Hash.state -> 'challenge -> 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 -> 'lookup_opt -> 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 ->
    'messages_for_next_step_proof ->
    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 ->
  ( 'challenge,
    'scalar_challenge,
    'fp,
    'lookup_opt,
    'messages_for_next_wrap_proof,
    'digest,
    'messages_for_next_step_proof,
    'bp_chals,
    'index )
    t ->
  Ppx_hash_lib.Std.Hash.state

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

type ('a, 'b, 'c, 'd, 'e, 'f, 'g) flat_repr :=
  (( 'a, Pickles_types.Nat.N9.n ) Pickles_types.Vector.t
   * (( 'b, Pickles_types.Nat.N2.n ) Pickles_types.Vector.t
      * (( 'c, Pickles_types.Nat.N3.n ) Pickles_types.Vector.t
         * (( 'd, Pickles_types.Nat.N3.n ) Pickles_types.Vector.t
            * ('e
               * (( 'f, Pickles_types.Nat.N1.n ) Pickles_types.Vector.t
                  * ('g * unit)))))))
    Pickles_types.Hlist.HlistId.t

val spec : 
  'a Spec.impl ->
  ( 'b, 'c, 'd Pickles_types.Hlist0.Id.t, 'e Pickles_types.Hlist0.Id.t )
    Lookup_parameters.t ->
  ( ( 'd,
      'b,
      'b Scalar_challenge.t,
      'f,
      ( 'g, Backend.Tick.Rounds.n ) Pickles_types.Vector.t,
      'h,
      ('b Scalar_challenge.t * ('d * unit)) Pickles_types.Hlist.HlistId.t
        option )
      flat_repr,
    (( 'e, Pickles_types.Nat.N9.n ) Pickles_types.Vector.t
     * (( 'c, Pickles_types.Nat.N2.n ) Pickles_types.Vector.t
        * (( 'c Scalar_challenge.t, Pickles_types.Nat.N3.n )
             Pickles_types.Vector.t
           * (( 'i, Pickles_types.Nat.N3.n ) Pickles_types.Vector.t
              * (( 'j, Backend.Tick.Rounds.n ) Pickles_types.Vector.t
                 * (( 'k, Pickles_types.Nat.N1.n ) Pickles_types.Vector.t
                    * (( ('c Scalar_challenge.t * ('e * unit))
                           Pickles_types.Hlist.HlistId.t,
                         'a Snarky_backendless.Cvar.t
                           Snarky_backendless.Boolean.t )
                         opt
                       * unit)))))))
      Pickles_types.Hlist.HlistId.t,
    < bool1 : bool
    ; bool2 : 'a Snarky_backendless.Cvar.t Snarky_backendless.Boolean.t
    ; branch_data1 : 'h
    ; branch_data2 : 'k
    ; bulletproof_challenge1 : 'g
    ; bulletproof_challenge2 : 'j
    ; challenge1 : 'b
    ; challenge2 : 'c
    ; digest1 : 'f
    ; digest2 : 'i
    ; field1 : 'd
    ; field2 : 'e.. > )
    Spec.T.t

A layout of the raw data in a statement, which is needed for representing it inside the circuit.

val to_data : 
  ( 'a, 'b, 'c, 'd, 'e, 'e, 'e, 'f Pickles_types.Hlist0.Id.t, 'g ) t ->
  option_map:
    ( 'd ->
      f:
        ( ( 'h Pickles_types.Hlist0.Id.t, 'i Pickles_types.Hlist0.Id.t )
            Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t ->
          ('h * ('i * unit)) Pickles_types.Hlist.HlistId.t ) ->
      'j Pickles_types.Hlist0.Id.t ) ->
  ( 'c, 'a, 'b, 'e, 'f, 'g, 'j ) flat_repr

Convert a statement (as structured data) into the flat data-based representation.

val of_data : 
  ( 'a, 'b, 'c, 'd, 'e, 'f, 'g ) flat_repr ->
  option_map:
    ( 'g Pickles_types.Hlist0.Id.t ->
      f:
        ( ('h * ('i * unit)) Pickles_types.Hlist.HlistId.t ->
          ( 'h Pickles_types.Hlist0.Id.t, 'i Pickles_types.Hlist0.Id.t )
            Proof_state.Deferred_values.Plonk.In_circuit.Lookup.t ) ->
      'j ) ->
  ( 'b, 'c, 'a, 'j, 'd, 'd, 'd, 'e Pickles_types.Hlist0.Id.t, 'f ) t

Construct a statement (as structured data) from the flat data-based representation.