1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
module S = Csir.Scalar
let alpha = Z.(shift_left one (Z.numbits S.order) - S.order)
let bitlist : ?le:bool -> bytes -> bool list =
fun ?(le = false) b ->
let l = Bytes.length b in
let start = if le then 0 else l - 1 in
let stop = if le then l else -1 in
let next a = if le then a + 1 else a - 1 in
let rec loop_byte acc n =
if n = stop then acc
else
let byte = Bytes.get_uint8 b n in
let rec loop_bit acc m =
if m = 8 then acc
else
let mask = 1 lsl m in
let bit = byte land mask in
let bit = if bit = 0 then false else true in
loop_bit (bit :: acc) (m + 1)
in
let acc = loop_bit acc 0 in
loop_byte acc (next n)
in
List.rev @@ loop_byte [] start
let bytes_of_hex hs =
let h = `Hex hs in
Hex.to_bytes h
let bool_list_to_scalar : bool list -> S.t =
fun b_list ->
let res, _ =
List.fold_left
(fun (acc_res, acc_p) b ->
let acc_res = if b then S.(acc_res + acc_p) else acc_res in
let acc_p = S.double acc_p in
(acc_res, acc_p))
(S.zero, S.one) b_list
in
res
let bool_list_to_z : bool list -> Z.t =
fun b_list ->
let res, _ =
List.fold_left
(fun (acc_res, acc_p) b ->
let acc_res = if b then Z.(acc_res + acc_p) else acc_res in
let acc_p = Z.(acc_p + acc_p) in
(acc_res, acc_p))
(Z.zero, Z.one) b_list
in
res
let bool_list_of_z : ?nb_bits:int -> Z.t -> bool list =
fun ?nb_bits z ->
let two = Z.of_int 2 in
let rec aux bits z = function
| 0 -> List.rev bits
| n ->
let b = Z.(equal (z mod two) one) in
aux (b :: bits) (Z.div z two) (n - 1)
in
aux [] z @@ Option.value ~default:(Z.numbits z) nb_bits
let rec transpose = function
| [] | [] :: _ -> []
| rows -> List.(map hd rows :: (transpose @@ map tl rows))
let tables_cs_encoding : (string list * Csir.CS.t) Data_encoding.t =
Data_encoding.(obj2 (req "tables" (list string)) (req "cs" Csir.CS.encoding))
let save_cs_to_file path tables cs =
let serialized_json =
Data_encoding.Json.construct tables_cs_encoding (tables, cs)
|> Data_encoding.Json.to_string
in
let outc = open_out path in
Printf.fprintf outc "%s" serialized_json;
close_out outc
let load_cs_from_file path =
if not (Sys.file_exists path) then
raise
@@ Invalid_argument
(Printf.sprintf "load_cs_from_file: %s does not exist." path);
let inc = open_in path in
let content = really_input_string inc (in_channel_length inc) in
close_in inc;
match Data_encoding.Json.from_string content with
| Error _ -> failwith ("Error loading file: " ^ path)
| Ok json -> Data_encoding.Json.destruct tables_cs_encoding json
let trace_info_encoding : Optimizer.trace_info Data_encoding.t =
let open Optimizer in
Data_encoding.(
conv
(fun { free_wires; assignments } -> (free_wires, assignments))
(fun (free_wires, assignments) -> { free_wires; assignments })
(obj2
(req "free_vars" (list int31))
(req "assignments"
(list (tup2 int31 (list (tup2 Csir.Scalar.encoding int31)))))))
let cs_ti_encoding = Data_encoding.tup2 Csir.CS.encoding trace_info_encoding
let get_circuit_id cs =
let serialized_bytes =
Data_encoding.Binary.to_bytes_exn Csir.CS.encoding cs
in
Hacl_star.Hacl.Blake2b_32.hash serialized_bytes 32 |> Hex.of_bytes |> Hex.show
let circuit_dir = "/tmp/plompiler"
let circuit_path s =
if not @@ Sys.file_exists circuit_dir then Sys.mkdir circuit_dir 0o755;
circuit_dir ^ "/" ^ s
let dump_label_traces path (cs : Csir.CS.t) =
let outc = open_out path in
List.iter
Csir.CS.(
Array.iter (fun c ->
Printf.fprintf outc "%s 1\n" @@ String.concat "; " (List.rev c.label)))
cs;
close_out outc