Module Random_oracle_input.Chunked

type 'field t = {
field_elements : 'field array;
packeds : ('field * int) array;
}

The input for a random oracle, formed of full field elements and 'chunks' of fields that can be combined together into one or more field elements.

The chunks are represented as (field, length), where 0 <= field < 2^length. This allows us to efficiently combine values in a known range. For example,

{ field_elements= [||]; packeds= [|(x, 64); (y, 32); (z, 16)|] }

results in the chunks being combined as x * 2^(32+16) + y * 2^(64) + z. When the chunks do not fit within a single field element, they are greedily concatenated to form field elements, from left to right. This packing is performed by the pack_to_fields helper function.

val t_of_sexp : 'field. ( Ppx_sexp_conv_lib.Sexp.t -> 'field ) -> Ppx_sexp_conv_lib.Sexp.t -> 'field t
val sexp_of_t : 'field. ( 'field -> Ppx_sexp_conv_lib.Sexp.t ) -> 'field t -> Ppx_sexp_conv_lib.Sexp.t
val compare : 'field. ( 'field -> 'field -> Core_kernel__.Import.int ) -> 'field t -> 'field t -> Core_kernel__.Import.int
val append : 'a t -> 'b t -> 'c t
val field_elements : 'f array -> 'f0 t
val field : 'a -> 'b t
val packeds : ('a * int) array -> 'b t

An input [|(x_1, l_1); (x_2, l_2); ...|] includes the values [|x_1; x_2; ...|] in the input, assuming that `0 <= x_1 < 2^l_1`, `0 <= x_2 < 2^l_2`, etc. so that multiple x_is can be combined into a single field element when the sum of their l_is are less than the size of the field modulus (in bits).

val packed : ('a * int) -> 'b t

packed x = packeds [| x |]

module type Field_intf = sig ... end
val pack_to_fields : (module Field_intf with type t = 't) -> pow2:( int -> 't0 ) -> 't1 t -> 't1 Core_kernel.Array.t

Convert the input into a series of field elements, by concatenating any chunks of input that fit into a single field element. The concatenation is greedy, operating from left to right.