PROOF.bend
bend-osdev-gf@0.1.2.0 · 7,947 lines · 0 definitions
1# Generated by gen/proof.py; do not edit by hand.
2import Base
3import bend-osdev-bytes@0.1.1.1/bytes.bend as B
4import bend-osdev-gf@0.1.2.0/gf.bend as G
5import bend-osdev-gf@0.1.2.0/tables.bend as T
6import bend-osdev-gf@0.1.2.0/gf128.bend as H
7import bend-osdev-gf@0.1.2.0/gfm.bend as M
8import bend-osdev-array@0.1.0.1/array.bend as A
9import bend-osdev-array@0.1.0.1/LAWS.bend as AL
10import bend-osdev-array@0.1.0.1/PROOF.bend as APF
11import bend-osdev-gf@0.1.2.0/proof_tab.bend as GT
12import bend-osdev-gf@0.1.2.0/proof_tab_cases.bend as GC
13import bend-osdev-gf@0.1.2.0/LAWS.bend as Laws
14import bend-osdev-u32@0.1.0.0/LAWS.bend as UL
15import bend-osdev-u32@0.1.0.0/PROOF.bend as UP
16
17# 1. Bool identities, by cases
18
19def bx_comm(+a: Bool, +b: Bool) -> {Bool.xor(a, b) == Bool.xor(b, a) : Bool}:
20 match a:
21 case True{}:
22 match b:
23 case True{}:
24 {==}
25 case False{}:
26 {==}
27 case False{}:
28 match b:
29 case True{}:
30 {==}
31 case False{}:
32 {==}
33
34def bx_assoc(+a: Bool, +b: Bool, +c: Bool) -> {Bool.xor(Bool.xor(a, b), c) == Bool.xor(a, Bool.xor(b, c)) : Bool}:
35 match a:
36 case True{}:
37 match b:
38 case True{}:
39 match c:
40 case True{}:
41 {==}
42 case False{}:
43 {==}
44 case False{}:
45 match c:
46 case True{}:
47 {==}
48 case False{}:
49 {==}
50 case False{}:
51 match b:
52 case True{}:
53 match c:
54 case True{}:
55 {==}
56 case False{}:
57 {==}
58 case False{}:
59 match c:
60 case True{}:
61 {==}
62 case False{}:
63 {==}
64
65def bx_zr(+a: Bool) -> {Bool.xor(a, False{}) == a : Bool}:
66 match a:
67 case True{}:
68 {==}
69 case False{}:
70 {==}
71
72def bx_self(+a: Bool) -> {Bool.xor(a, a) == False{} : Bool}:
73 match a:
74 case True{}:
75 {==}
76 case False{}:
77 {==}
78
79def bx_swap(+a: Bool, +b: Bool, +c: Bool, +d: Bool) -> {Bool.xor(Bool.xor(a, b), Bool.xor(c, d)) == Bool.xor(Bool.xor(a, c), Bool.xor(b, d)) : Bool}:
80 match a:
81 case True{}:
82 match b:
83 case True{}:
84 match c:
85 case True{}:
86 match d:
87 case True{}:
88 {==}
89 case False{}:
90 {==}
91 case False{}:
92 match d:
93 case True{}:
94 {==}
95 case False{}:
96 {==}
97 case False{}:
98 match c:
99 case True{}:
100 match d:
101 case True{}:
102 {==}
103 case False{}:
104 {==}
105 case False{}:
106 match d:
107 case True{}:
108 {==}
109 case False{}:
110 {==}
111 case False{}:
112 match b:
113 case True{}:
114 match c:
115 case True{}:
116 match d:
117 case True{}:
118 {==}
119 case False{}:
120 {==}
121 case False{}:
122 match d:
123 case True{}:
124 {==}
125 case False{}:
126 {==}
127 case False{}:
128 match c:
129 case True{}:
130 match d:
131 case True{}:
132 {==}
133 case False{}:
134 {==}
135 case False{}:
136 match d:
137 case True{}:
138 {==}
139 case False{}:
140 {==}
141
142def band_xor(+a: Bool, +b: Bool, +q: Bool) -> {Bool.and(Bool.xor(a, b), q) == Bool.xor(Bool.and(a, q), Bool.and(b, q)) : Bool}:
143 match a:
144 case True{}:
145 match b:
146 case True{}:
147 match q:
148 case True{}:
149 {==}
150 case False{}:
151 {==}
152 case False{}:
153 match q:
154 case True{}:
155 {==}
156 case False{}:
157 {==}
158 case False{}:
159 match b:
160 case True{}:
161 match q:
162 case True{}:
163 {==}
164 case False{}:
165 {==}
166 case False{}:
167 match q:
168 case True{}:
169 {==}
170 case False{}:
171 {==}
172
173def blin(+a: Bool, +b: Bool, +u: Bool, +v: Bool, +q: Bool) -> {Bool.xor(Bool.xor(a, b), Bool.and(Bool.xor(u, v), q)) == Bool.xor(Bool.xor(a, Bool.and(u, q)), Bool.xor(b, Bool.and(v, q))) : Bool}:
174 match a:
175 case True{}:
176 match b:
177 case True{}:
178 match u:
179 case True{}:
180 match v:
181 case True{}:
182 match q:
183 case True{}:
184 {==}
185 case False{}:
186 {==}
187 case False{}:
188 match q:
189 case True{}:
190 {==}
191 case False{}:
192 {==}
193 case False{}:
194 match v:
195 case True{}:
196 match q:
197 case True{}:
198 {==}
199 case False{}:
200 {==}
201 case False{}:
202 match q:
203 case True{}:
204 {==}
205 case False{}:
206 {==}
207 case False{}:
208 match u:
209 case True{}:
210 match v:
211 case True{}:
212 match q:
213 case True{}:
214 {==}
215 case False{}:
216 {==}
217 case False{}:
218 match q:
219 case True{}:
220 {==}
221 case False{}:
222 {==}
223 case False{}:
224 match v:
225 case True{}:
226 match q:
227 case True{}:
228 {==}
229 case False{}:
230 {==}
231 case False{}:
232 match q:
233 case True{}:
234 {==}
235 case False{}:
236 {==}
237 case False{}:
238 match b:
239 case True{}:
240 match u:
241 case True{}:
242 match v:
243 case True{}:
244 match q:
245 case True{}:
246 {==}
247 case False{}:
248 {==}
249 case False{}:
250 match q:
251 case True{}:
252 {==}
253 case False{}:
254 {==}
255 case False{}:
256 match v:
257 case True{}:
258 match q:
259 case True{}:
260 {==}
261 case False{}:
262 {==}
263 case False{}:
264 match q:
265 case True{}:
266 {==}
267 case False{}:
268 {==}
269 case False{}:
270 match u:
271 case True{}:
272 match v:
273 case True{}:
274 match q:
275 case True{}:
276 {==}
277 case False{}:
278 {==}
279 case False{}:
280 match q:
281 case True{}:
282 {==}
283 case False{}:
284 {==}
285 case False{}:
286 match v:
287 case True{}:
288 match q:
289 case True{}:
290 {==}
291 case False{}:
292 {==}
293 case False{}:
294 match q:
295 case True{}:
296 {==}
297 case False{}:
298 {==}
299
300# 2. A byte's eight bits at once
301
302def rb_eq(-a0: Bool, -a1: Bool, -a2: Bool, -a3: Bool, -a4: Bool, -a5: Bool, -a6: Bool, -a7: Bool, -c0: Bool, -c1: Bool, -c2: Bool, -c3: Bool, -c4: Bool, -c5: Bool, -c6: Bool, -c7: Bool, e0: {a0 == c0 : Bool}, e1: {a1 == c1 : Bool}, e2: {a2 == c2 : Bool}, e3: {a3 == c3 : Bool}, e4: {a4 == c4 : Bool}, e5: {a5 == c5 : Bool}, e6: {a6 == c6 : Bool}, e7: {a7 == c7 : Bool}) -> {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{c0, c1, c2, c3, c4, c5, c6, c7} : G.Gf8Bits}:
303 %e0 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{_, c1, c2, c3, c4, c5, c6, c7} : G.Gf8Bits}
304 %e1 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, _, c2, c3, c4, c5, c6, c7} : G.Gf8Bits}
305 %e2 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, _, c3, c4, c5, c6, c7} : G.Gf8Bits}
306 %e3 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, _, c4, c5, c6, c7} : G.Gf8Bits}
307 %e4 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, _, c5, c6, c7} : G.Gf8Bits}
308 %e5 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, a4, _, c6, c7} : G.Gf8Bits}
309 %e6 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, a4, a5, _, c7} : G.Gf8Bits}
310 %e7 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, _} : G.Gf8Bits}
311 {==}
312
313def rx_comm(+a: G.Gf8Bits, +b: G.Gf8Bits) -> {G.Gf8Bits.xor(a, b) == G.Gf8Bits.xor(b, a) : G.Gf8Bits}:
314 match a b:
315 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7} G.Gf8Bits{+b0, +b1, +b2, +b3, +b4, +b5, +b6, +b7}:
316 rb_eq(Bool.xor(a0, b0), Bool.xor(a1, b1), Bool.xor(a2, b2), Bool.xor(a3, b3), Bool.xor(a4, b4), Bool.xor(a5, b5), Bool.xor(a6, b6), Bool.xor(a7, b7), Bool.xor(b0, a0), Bool.xor(b1, a1), Bool.xor(b2, a2), Bool.xor(b3, a3), Bool.xor(b4, a4), Bool.xor(b5, a5), Bool.xor(b6, a6), Bool.xor(b7, a7), bx_comm(a0, b0), bx_comm(a1, b1), bx_comm(a2, b2), bx_comm(a3, b3), bx_comm(a4, b4), bx_comm(a5, b5), bx_comm(a6, b6), bx_comm(a7, b7))
317
318def rx_assoc(+a: G.Gf8Bits, +b: G.Gf8Bits, +c: G.Gf8Bits) -> {G.Gf8Bits.xor(G.Gf8Bits.xor(a, b), c) == G.Gf8Bits.xor(a, G.Gf8Bits.xor(b, c)) : G.Gf8Bits}:
319 match a b c:
320 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7} G.Gf8Bits{+b0, +b1, +b2, +b3, +b4, +b5, +b6, +b7} G.Gf8Bits{+c0, +c1, +c2, +c3, +c4, +c5, +c6, +c7}:
321 rb_eq(Bool.xor(Bool.xor(a0, b0), c0), Bool.xor(Bool.xor(a1, b1), c1), Bool.xor(Bool.xor(a2, b2), c2), Bool.xor(Bool.xor(a3, b3), c3), Bool.xor(Bool.xor(a4, b4), c4), Bool.xor(Bool.xor(a5, b5), c5), Bool.xor(Bool.xor(a6, b6), c6), Bool.xor(Bool.xor(a7, b7), c7), Bool.xor(a0, Bool.xor(b0, c0)), Bool.xor(a1, Bool.xor(b1, c1)), Bool.xor(a2, Bool.xor(b2, c2)), Bool.xor(a3, Bool.xor(b3, c3)), Bool.xor(a4, Bool.xor(b4, c4)), Bool.xor(a5, Bool.xor(b5, c5)), Bool.xor(a6, Bool.xor(b6, c6)), Bool.xor(a7, Bool.xor(b7, c7)), bx_assoc(a0, b0, c0), bx_assoc(a1, b1, c1), bx_assoc(a2, b2, c2), bx_assoc(a3, b3, c3), bx_assoc(a4, b4, c4), bx_assoc(a5, b5, c5), bx_assoc(a6, b6, c6), bx_assoc(a7, b7, c7))
322
323def rx_zr(+a: G.Gf8Bits) -> {G.Gf8Bits.xor(a, G.Gf8Bits.zero()) == a : G.Gf8Bits}:
324 match a:
325 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7}:
326 rb_eq(Bool.xor(a0, False{}), Bool.xor(a1, False{}), Bool.xor(a2, False{}), Bool.xor(a3, False{}), Bool.xor(a4, False{}), Bool.xor(a5, False{}), Bool.xor(a6, False{}), Bool.xor(a7, False{}), a0, a1, a2, a3, a4, a5, a6, a7, bx_zr(a0), bx_zr(a1), bx_zr(a2), bx_zr(a3), bx_zr(a4), bx_zr(a5), bx_zr(a6), bx_zr(a7))
327
328def rx_self(+a: G.Gf8Bits) -> {G.Gf8Bits.xor(a, a) == G.Gf8Bits.zero() : G.Gf8Bits}:
329 match a:
330 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7}:
331 rb_eq(Bool.xor(a0, a0), Bool.xor(a1, a1), Bool.xor(a2, a2), Bool.xor(a3, a3), Bool.xor(a4, a4), Bool.xor(a5, a5), Bool.xor(a6, a6), Bool.xor(a7, a7), False{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}, bx_self(a0), bx_self(a1), bx_self(a2), bx_self(a3), bx_self(a4), bx_self(a5), bx_self(a6), bx_self(a7))
332
333def rx_swap(+a: G.Gf8Bits, +b: G.Gf8Bits, +c: G.Gf8Bits, +d: G.Gf8Bits) -> {G.Gf8Bits.xor(G.Gf8Bits.xor(a, b), G.Gf8Bits.xor(c, d)) == G.Gf8Bits.xor(G.Gf8Bits.xor(a, c), G.Gf8Bits.xor(b, d)) : G.Gf8Bits}:
334 match a b c d:
335 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7} G.Gf8Bits{+b0, +b1, +b2, +b3, +b4, +b5, +b6, +b7} G.Gf8Bits{+c0, +c1, +c2, +c3, +c4, +c5, +c6, +c7} G.Gf8Bits{+d0, +d1, +d2, +d3, +d4, +d5, +d6, +d7}:
336 rb_eq(Bool.xor(Bool.xor(a0, b0), Bool.xor(c0, d0)), Bool.xor(Bool.xor(a1, b1), Bool.xor(c1, d1)), Bool.xor(Bool.xor(a2, b2), Bool.xor(c2, d2)), Bool.xor(Bool.xor(a3, b3), Bool.xor(c3, d3)), Bool.xor(Bool.xor(a4, b4), Bool.xor(c4, d4)), Bool.xor(Bool.xor(a5, b5), Bool.xor(c5, d5)), Bool.xor(Bool.xor(a6, b6), Bool.xor(c6, d6)), Bool.xor(Bool.xor(a7, b7), Bool.xor(c7, d7)), Bool.xor(Bool.xor(a0, c0), Bool.xor(b0, d0)), Bool.xor(Bool.xor(a1, c1), Bool.xor(b1, d1)), Bool.xor(Bool.xor(a2, c2), Bool.xor(b2, d2)), Bool.xor(Bool.xor(a3, c3), Bool.xor(b3, d3)), Bool.xor(Bool.xor(a4, c4), Bool.xor(b4, d4)), Bool.xor(Bool.xor(a5, c5), Bool.xor(b5, d5)), Bool.xor(Bool.xor(a6, c6), Bool.xor(b6, d6)), Bool.xor(Bool.xor(a7, c7), Bool.xor(b7, d7)), bx_swap(a0, b0, c0, d0), bx_swap(a1, b1, c1, d1), bx_swap(a2, b2, c2, d2), bx_swap(a3, b3, c3, d3), bx_swap(a4, b4, c4, d4), bx_swap(a5, b5, c5, d5), bx_swap(a6, b6, c6, d6), bx_swap(a7, b7, c7, d7))
337
338def rx_zl(+a: G.Gf8Bits) -> {G.Gf8Bits.xor(G.Gf8Bits.zero(), a) == a : G.Gf8Bits}:
339 match a:
340 case G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7}:
341 {==}
342
343def x_lin(+u: G.Gf8Bits, +v: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.x(G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(G.Gf8Bits.x(u, p), G.Gf8Bits.x(v, p)) : G.Gf8Bits}:
344 match u v p:
345 case G.Gf8Bits{+u0, +u1, +u2, +u3, +u4, +u5, +u6, +u7} G.Gf8Bits{+v0, +v1, +v2, +v3, +v4, +v5, +v6, +v7} G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
346 rb_eq(Bool.and(Bool.xor(u7, v7), p0), Bool.xor(Bool.xor(u0, v0), Bool.and(Bool.xor(u7, v7), p1)), Bool.xor(Bool.xor(u1, v1), Bool.and(Bool.xor(u7, v7), p2)), Bool.xor(Bool.xor(u2, v2), Bool.and(Bool.xor(u7, v7), p3)), Bool.xor(Bool.xor(u3, v3), Bool.and(Bool.xor(u7, v7), p4)), Bool.xor(Bool.xor(u4, v4), Bool.and(Bool.xor(u7, v7), p5)), Bool.xor(Bool.xor(u5, v5), Bool.and(Bool.xor(u7, v7), p6)), Bool.xor(Bool.xor(u6, v6), Bool.and(Bool.xor(u7, v7), p7)), Bool.xor(Bool.and(u7, p0), Bool.and(v7, p0)), Bool.xor(Bool.xor(u0, Bool.and(u7, p1)), Bool.xor(v0, Bool.and(v7, p1))), Bool.xor(Bool.xor(u1, Bool.and(u7, p2)), Bool.xor(v1, Bool.and(v7, p2))), Bool.xor(Bool.xor(u2, Bool.and(u7, p3)), Bool.xor(v2, Bool.and(v7, p3))), Bool.xor(Bool.xor(u3, Bool.and(u7, p4)), Bool.xor(v3, Bool.and(v7, p4))), Bool.xor(Bool.xor(u4, Bool.and(u7, p5)), Bool.xor(v4, Bool.and(v7, p5))), Bool.xor(Bool.xor(u5, Bool.and(u7, p6)), Bool.xor(v5, Bool.and(v7, p6))), Bool.xor(Bool.xor(u6, Bool.and(u7, p7)), Bool.xor(v6, Bool.and(v7, p7))), band_xor(u7, v7, p0), blin(u0, v0, u7, v7, p1), blin(u1, v1, u7, v7, p2), blin(u2, v2, u7, v7, p3), blin(u3, v3, u7, v7, p4), blin(u4, v4, u7, v7, p5), blin(u5, v5, u7, v7, p6), blin(u6, v6, u7, v7, p7))
347
348def x_zero(+p: G.Gf8Bits) -> {G.Gf8Bits.x(G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
349 match p:
350 case G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
351 {==}
352
353# 3. Selection, and a Horner step, are linear; so the product is linear in
354# each factor
355
356def sel_xor(+t: Bool, +u: G.Gf8Bits, +v: G.Gf8Bits) -> {G.Gf8Bits.sel(t, G.Gf8Bits.xor(u, v)) == G.Gf8Bits.xor(G.Gf8Bits.sel(t, u), G.Gf8Bits.sel(t, v)) : G.Gf8Bits}:
357 match t:
358 case True{}:
359 {==}
360 case False{}:
361 {==}
362
363def sel_txor(+s: Bool, +t: Bool, +b: G.Gf8Bits) -> {G.Gf8Bits.sel(Bool.xor(s, t), b) == G.Gf8Bits.xor(G.Gf8Bits.sel(s, b), G.Gf8Bits.sel(t, b)) : G.Gf8Bits}:
364 match s t:
365 case True{} True{}:
366 Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(b, b), G.Gf8Bits.zero(), rx_self(b))
367 case True{} False{}:
368 Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(b, G.Gf8Bits.zero()), b, rx_zr(b))
369 case False{} True{}:
370 Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(G.Gf8Bits.zero(), b), b, rx_zl(b))
371 case False{} False{}:
372 {==}
373
374def x_sel(+t: Bool, +u: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.x(G.Gf8Bits.sel(t, u), p) == G.Gf8Bits.sel(t, G.Gf8Bits.x(u, p)) : G.Gf8Bits}:
375 match t:
376 case True{}:
377 {==}
378 case False{}:
379 x_zero(p)
380
381def step_lin_b(+t: Bool, +A: G.Gf8Bits, +C: G.Gf8Bits, +u: G.Gf8Bits, +v: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.step(t, G.Gf8Bits.xor(A, C), G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(G.Gf8Bits.step(t, A, u, p), G.Gf8Bits.step(t, C, v, p)) : G.Gf8Bits}:
382 %rx_swap(G.Gf8Bits.x(A, p), G.Gf8Bits.x(C, p), G.Gf8Bits.sel(t, u), G.Gf8Bits.sel(t, v)) : {G.Gf8Bits.step(t, G.Gf8Bits.xor(A, C), G.Gf8Bits.xor(u, v), p) == _ : G.Gf8Bits}
383 %x_lin(A, C, p) : {G.Gf8Bits.step(t, G.Gf8Bits.xor(A, C), G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(_, G.Gf8Bits.xor(G.Gf8Bits.sel(t, u), G.Gf8Bits.sel(t, v))) : G.Gf8Bits}
384 %sel_xor(t, u, v) : {G.Gf8Bits.step(t, G.Gf8Bits.xor(A, C), G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(G.Gf8Bits.x(G.Gf8Bits.xor(A, C), p), _) : G.Gf8Bits}
385 {==}
386
387def horner_lin_b(ts: List<&2, Bool>, +A: G.Gf8Bits, +C: G.Gf8Bits, +u: G.Gf8Bits, +v: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.horner(ts, G.Gf8Bits.xor(A, C), G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(G.Gf8Bits.horner(ts, A, u, p), G.Gf8Bits.horner(ts, C, v, p)) : G.Gf8Bits}:
388 match ts:
389 case Nil{}:
390 {==}
391 case Con{+t, rest}:
392 %Equal.sym(G.Gf8Bits, G.Gf8Bits.step(t, G.Gf8Bits.xor(A, C), G.Gf8Bits.xor(u, v), p), G.Gf8Bits.xor(G.Gf8Bits.step(t, A, u, p), G.Gf8Bits.step(t, C, v, p)), step_lin_b(t, A, C, u, v, p)) : {G.Gf8Bits.horner(rest, _, G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(G.Gf8Bits.horner(rest, G.Gf8Bits.step(t, A, u, p), u, p), G.Gf8Bits.horner(rest, G.Gf8Bits.step(t, C, v, p), v, p)) : G.Gf8Bits}
393 horner_lin_b(rest, G.Gf8Bits.step(t, A, u, p), G.Gf8Bits.step(t, C, v, p), u, v, p)
394
395def m_lin_r(+a: G.Gf8Bits, +u: G.Gf8Bits, +v: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(a, G.Gf8Bits.xor(u, v), p) == G.Gf8Bits.xor(G.Gf8Bits.mul(a, u, p), G.Gf8Bits.mul(a, v, p)) : G.Gf8Bits}:
396 horner_lin_b(G.Gf8Bits.top(a), G.Gf8Bits.zero(), G.Gf8Bits.zero(), u, v, p)
397
398# pairs of bits, for the product's linearity in its first factor
399type GfPb is Data:
400 GfPb{s: Bool, t: Bool}
401
402def pl.x(ps: List<&2, GfPb>) -> List<&2, Bool>:
403 match ps:
404 case Nil{}:
405 Nil{}
406 case Con{h, rest}:
407 match h:
408 case GfPb{s, t}:
409 Con{Bool.xor(s, t), pl.x(rest)}
410
411def pl.l(ps: List<&2, GfPb>) -> List<&2, Bool>:
412 match ps:
413 case Nil{}:
414 Nil{}
415 case Con{h, rest}:
416 match h:
417 case GfPb{s, t}:
418 Con{s, pl.l(rest)}
419
420def pl.r(ps: List<&2, GfPb>) -> List<&2, Bool>:
421 match ps:
422 case Nil{}:
423 Nil{}
424 case Con{h, rest}:
425 match h:
426 case GfPb{s, t}:
427 Con{t, pl.r(rest)}
428
429def step_lin_a(+s: Bool, +t: Bool, +A: G.Gf8Bits, +C: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.step(Bool.xor(s, t), G.Gf8Bits.xor(A, C), b, p) == G.Gf8Bits.xor(G.Gf8Bits.step(s, A, b, p), G.Gf8Bits.step(t, C, b, p)) : G.Gf8Bits}:
430 %rx_swap(G.Gf8Bits.x(A, p), G.Gf8Bits.x(C, p), G.Gf8Bits.sel(s, b), G.Gf8Bits.sel(t, b)) : {G.Gf8Bits.step(Bool.xor(s, t), G.Gf8Bits.xor(A, C), b, p) == _ : G.Gf8Bits}
431 %x_lin(A, C, p) : {G.Gf8Bits.step(Bool.xor(s, t), G.Gf8Bits.xor(A, C), b, p) == G.Gf8Bits.xor(_, G.Gf8Bits.xor(G.Gf8Bits.sel(s, b), G.Gf8Bits.sel(t, b))) : G.Gf8Bits}
432 %sel_txor(s, t, b) : {G.Gf8Bits.step(Bool.xor(s, t), G.Gf8Bits.xor(A, C), b, p) == G.Gf8Bits.xor(G.Gf8Bits.x(G.Gf8Bits.xor(A, C), p), _) : G.Gf8Bits}
433 {==}
434
435def horner_lin_a(ps: List<&2, GfPb>, +A: G.Gf8Bits, +C: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.horner(pl.x(ps), G.Gf8Bits.xor(A, C), b, p) == G.Gf8Bits.xor(G.Gf8Bits.horner(pl.l(ps), A, b, p), G.Gf8Bits.horner(pl.r(ps), C, b, p)) : G.Gf8Bits}:
436 match ps:
437 case Nil{}:
438 {==}
439 case Con{h, rest}:
440 match h:
441 case GfPb{+s, +t}:
442 %Equal.sym(G.Gf8Bits, G.Gf8Bits.step(Bool.xor(s, t), G.Gf8Bits.xor(A, C), b, p), G.Gf8Bits.xor(G.Gf8Bits.step(s, A, b, p), G.Gf8Bits.step(t, C, b, p)), step_lin_a(s, t, A, C, b, p)) : {G.Gf8Bits.horner(pl.x(rest), _, b, p) == G.Gf8Bits.xor(G.Gf8Bits.horner(pl.l(rest), G.Gf8Bits.step(s, A, b, p), b, p), G.Gf8Bits.horner(pl.r(rest), G.Gf8Bits.step(t, C, b, p), b, p)) : G.Gf8Bits}
443 horner_lin_a(rest, G.Gf8Bits.step(s, A, b, p), G.Gf8Bits.step(t, C, b, p), b, p)
444
445def m_lin_l(+s: G.Gf8Bits, +t: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits.xor(s, t), b, p) == G.Gf8Bits.xor(G.Gf8Bits.mul(s, b, p), G.Gf8Bits.mul(t, b, p)) : G.Gf8Bits}:
446 match s t:
447 case G.Gf8Bits{+s0, +s1, +s2, +s3, +s4, +s5, +s6, +s7} G.Gf8Bits{+t0, +t1, +t2, +t3, +t4, +t5, +t6, +t7}:
448 horner_lin_a([GfPb{s7, t7}, GfPb{s6, t6}, GfPb{s5, t5}, GfPb{s4, t4}, GfPb{s3, t3}, GfPb{s2, t2}, GfPb{s1, t1}, GfPb{s0, t0}], G.Gf8Bits.zero(), G.Gf8Bits.zero(), b, p)
449
450def step_zero(+t: Bool, +p: G.Gf8Bits) -> {G.Gf8Bits.step(t, G.Gf8Bits.zero(), G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
451 match t p:
452 case True{} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
453 {==}
454 case False{} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
455 {==}
456
457def horner_zero(ts: List<&2, Bool>, +p: G.Gf8Bits) -> {G.Gf8Bits.horner(ts, G.Gf8Bits.zero(), G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
458 match ts:
459 case Nil{}:
460 {==}
461 case Con{+t, rest}:
462 %Equal.sym(G.Gf8Bits, G.Gf8Bits.step(t, G.Gf8Bits.zero(), G.Gf8Bits.zero(), p), G.Gf8Bits.zero(), step_zero(t, p)) : {G.Gf8Bits.horner(rest, _, G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}
463 horner_zero(rest, p)
464
465def m_zero_r(+a: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(a, G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
466 horner_zero(G.Gf8Bits.top(a), p)
467
468def m_zero_l(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits.zero(), b, p) == G.Gf8Bits.zero() : G.Gf8Bits}:
469 match p:
470 case G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
471 {==}
472
473def m_sel_l(+t: Bool, +a: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits.sel(t, a), b, p) == G.Gf8Bits.sel(t, G.Gf8Bits.mul(a, b, p)) : G.Gf8Bits}:
474 match t:
475 case True{}:
476 {==}
477 case False{}:
478 m_zero_l(b, p)
479
480def m_sel_r(+t: Bool, +a: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(a, G.Gf8Bits.sel(t, b), p) == G.Gf8Bits.sel(t, G.Gf8Bits.mul(a, b, p)) : G.Gf8Bits}:
481 match t:
482 case True{}:
483 {==}
484 case False{}:
485 m_zero_r(a, p)
486
487# 4. Sums over the basis 1, x, ..., x^7
488
489# the sum of t_i * v_i
490def ss(ts: List<&2, Bool>, vs: List<&2, G.Gf8Bits>) -> G.Gf8Bits:
491 match ts:
492 case Nil{}:
493 G.Gf8Bits.zero()
494 case Con{t, tr}:
495 match vs:
496 case Nil{}:
497 G.Gf8Bits.zero()
498 case Con{v, vr}:
499 G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr))
500
501def ml(vs: List<&2, G.Gf8Bits>, +b: G.Gf8Bits, +p: G.Gf8Bits) -> List<&2, G.Gf8Bits>:
502 match vs:
503 case Nil{}:
504 Nil{}
505 case Con{+v, +vr}:
506 Con{G.Gf8Bits.mul(v, b, p), ml(vr, b, p)}
507
508def mr(vs: List<&2, G.Gf8Bits>, +b: G.Gf8Bits, +p: G.Gf8Bits) -> List<&2, G.Gf8Bits>:
509 match vs:
510 case Nil{}:
511 Nil{}
512 case Con{+v, +vr}:
513 Con{G.Gf8Bits.mul(b, v, p), mr(vr, b, p)}
514
515def xl(vs: List<&2, G.Gf8Bits>, +p: G.Gf8Bits) -> List<&2, G.Gf8Bits>:
516 match vs:
517 case Nil{}:
518 Nil{}
519 case Con{+v, +vr}:
520 Con{G.Gf8Bits.x(v, p), xl(vr, p)}
521
522def basis() -> List<&2, G.Gf8Bits>:
523 [G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}]
524
525def bl(a: G.Gf8Bits) -> List<&2, Bool>:
526 match a:
527 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}:
528 [b0, b1, b2, b3, b4, b5, b6, b7]
529
530def xk(n: Nat, b: G.Gf8Bits, +p: G.Gf8Bits) -> G.Gf8Bits:
531 match n:
532 case 0n:
533 b
534 case 1n+k:
535 xk(k, G.Gf8Bits.x(b, p), p)
536
537def xs(+b: G.Gf8Bits, +p: G.Gf8Bits) -> List<&2, G.Gf8Bits>:
538 [xk(0n, b, p), xk(1n, b, p), xk(2n, b, p), xk(3n, b, p), xk(4n, b, p), xk(5n, b, p), xk(6n, b, p), xk(7n, b, p)]
539
540def fs(n: Nat) -> List<&2, Bool>:
541 match n:
542 case 0n:
543 Nil{}
544 case 1n+k:
545 Con{False{}, fs(k)}
546
547def lin_l(ts: List<&2, Bool>, vs: List<&2, G.Gf8Bits>, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(ss(ts, vs), b, p) == ss(ts, ml(vs, b, p)) : G.Gf8Bits}:
548 match ts:
549 case Nil{}:
550 m_zero_l(b, p)
551 case Con{+t, +tr}:
552 match vs:
553 case Nil{}:
554 m_zero_l(b, p)
555 case Con{+v, +vr}:
556 %lin_l(tr, vr, b, p) : {G.Gf8Bits.mul(G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr)), b, p) == G.Gf8Bits.xor(G.Gf8Bits.sel(t, G.Gf8Bits.mul(v, b, p)), _) : G.Gf8Bits}
557 %m_sel_l(t, v, b, p) : {G.Gf8Bits.mul(G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr)), b, p) == G.Gf8Bits.xor(_, G.Gf8Bits.mul(ss(tr, vr), b, p)) : G.Gf8Bits}
558 m_lin_l(G.Gf8Bits.sel(t, v), ss(tr, vr), b, p)
559
560def lin_r(ts: List<&2, Bool>, vs: List<&2, G.Gf8Bits>, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(b, ss(ts, vs), p) == ss(ts, mr(vs, b, p)) : G.Gf8Bits}:
561 match ts:
562 case Nil{}:
563 m_zero_r(b, p)
564 case Con{+t, +tr}:
565 match vs:
566 case Nil{}:
567 m_zero_r(b, p)
568 case Con{+v, +vr}:
569 %lin_r(tr, vr, b, p) : {G.Gf8Bits.mul(b, G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr)), p) == G.Gf8Bits.xor(G.Gf8Bits.sel(t, G.Gf8Bits.mul(b, v, p)), _) : G.Gf8Bits}
570 %m_sel_r(t, b, v, p) : {G.Gf8Bits.mul(b, G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr)), p) == G.Gf8Bits.xor(_, G.Gf8Bits.mul(b, ss(tr, vr), p)) : G.Gf8Bits}
571 m_lin_r(b, G.Gf8Bits.sel(t, v), ss(tr, vr), p)
572
573def lin_x(ts: List<&2, Bool>, vs: List<&2, G.Gf8Bits>, +p: G.Gf8Bits) -> {G.Gf8Bits.x(ss(ts, vs), p) == ss(ts, xl(vs, p)) : G.Gf8Bits}:
574 match ts:
575 case Nil{}:
576 x_zero(p)
577 case Con{+t, +tr}:
578 match vs:
579 case Nil{}:
580 x_zero(p)
581 case Con{+v, +vr}:
582 %lin_x(tr, vr, p) : {G.Gf8Bits.x(G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr)), p) == G.Gf8Bits.xor(G.Gf8Bits.sel(t, G.Gf8Bits.x(v, p)), _) : G.Gf8Bits}
583 %x_sel(t, v, p) : {G.Gf8Bits.x(G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr)), p) == G.Gf8Bits.xor(_, G.Gf8Bits.x(ss(tr, vr), p)) : G.Gf8Bits}
584 x_lin(G.Gf8Bits.sel(t, v), ss(tr, vr), p)
585
586# every byte is the sum of its bits times the basis (by cases)
587def dec(+a: G.Gf8Bits) -> {ss(bl(a), basis()) == a : G.Gf8Bits}:
588 match a:
589 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}:
590 match b0:
591 case True{}:
592 match b1:
593 case True{}:
594 match b2:
595 case True{}:
596 match b3:
597 case True{}:
598 match b4:
599 case True{}:
600 match b5:
601 case True{}:
602 match b6:
603 case True{}:
604 match b7:
605 case True{}:
606 {==}
607 case False{}:
608 {==}
609 case False{}:
610 match b7:
611 case True{}:
612 {==}
613 case False{}:
614 {==}
615 case False{}:
616 match b6:
617 case True{}:
618 match b7:
619 case True{}:
620 {==}
621 case False{}:
622 {==}
623 case False{}:
624 match b7:
625 case True{}:
626 {==}
627 case False{}:
628 {==}
629 case False{}:
630 match b5:
631 case True{}:
632 match b6:
633 case True{}:
634 match b7:
635 case True{}:
636 {==}
637 case False{}:
638 {==}
639 case False{}:
640 match b7:
641 case True{}:
642 {==}
643 case False{}:
644 {==}
645 case False{}:
646 match b6:
647 case True{}:
648 match b7:
649 case True{}:
650 {==}
651 case False{}:
652 {==}
653 case False{}:
654 match b7:
655 case True{}:
656 {==}
657 case False{}:
658 {==}
659 case False{}:
660 match b4:
661 case True{}:
662 match b5:
663 case True{}:
664 match b6:
665 case True{}:
666 match b7:
667 case True{}:
668 {==}
669 case False{}:
670 {==}
671 case False{}:
672 match b7:
673 case True{}:
674 {==}
675 case False{}:
676 {==}
677 case False{}:
678 match b6:
679 case True{}:
680 match b7:
681 case True{}:
682 {==}
683 case False{}:
684 {==}
685 case False{}:
686 match b7:
687 case True{}:
688 {==}
689 case False{}:
690 {==}
691 case False{}:
692 match b5:
693 case True{}:
694 match b6:
695 case True{}:
696 match b7:
697 case True{}:
698 {==}
699 case False{}:
700 {==}
701 case False{}:
702 match b7:
703 case True{}:
704 {==}
705 case False{}:
706 {==}
707 case False{}:
708 match b6:
709 case True{}:
710 match b7:
711 case True{}:
712 {==}
713 case False{}:
714 {==}
715 case False{}:
716 match b7:
717 case True{}:
718 {==}
719 case False{}:
720 {==}
721 case False{}:
722 match b3:
723 case True{}:
724 match b4:
725 case True{}:
726 match b5:
727 case True{}:
728 match b6:
729 case True{}:
730 match b7:
731 case True{}:
732 {==}
733 case False{}:
734 {==}
735 case False{}:
736 match b7:
737 case True{}:
738 {==}
739 case False{}:
740 {==}
741 case False{}:
742 match b6:
743 case True{}:
744 match b7:
745 case True{}:
746 {==}
747 case False{}:
748 {==}
749 case False{}:
750 match b7:
751 case True{}:
752 {==}
753 case False{}:
754 {==}
755 case False{}:
756 match b5:
757 case True{}:
758 match b6:
759 case True{}:
760 match b7:
761 case True{}:
762 {==}
763 case False{}:
764 {==}
765 case False{}:
766 match b7:
767 case True{}:
768 {==}
769 case False{}:
770 {==}
771 case False{}:
772 match b6:
773 case True{}:
774 match b7:
775 case True{}:
776 {==}
777 case False{}:
778 {==}
779 case False{}:
780 match b7:
781 case True{}:
782 {==}
783 case False{}:
784 {==}
785 case False{}:
786 match b4:
787 case True{}:
788 match b5:
789 case True{}:
790 match b6:
791 case True{}:
792 match b7:
793 case True{}:
794 {==}
795 case False{}:
796 {==}
797 case False{}:
798 match b7:
799 case True{}:
800 {==}
801 case False{}:
802 {==}
803 case False{}:
804 match b6:
805 case True{}:
806 match b7:
807 case True{}:
808 {==}
809 case False{}:
810 {==}
811 case False{}:
812 match b7:
813 case True{}:
814 {==}
815 case False{}:
816 {==}
817 case False{}:
818 match b5:
819 case True{}:
820 match b6:
821 case True{}:
822 match b7:
823 case True{}:
824 {==}
825 case False{}:
826 {==}
827 case False{}:
828 match b7:
829 case True{}:
830 {==}
831 case False{}:
832 {==}
833 case False{}:
834 match b6:
835 case True{}:
836 match b7:
837 case True{}:
838 {==}
839 case False{}:
840 {==}
841 case False{}:
842 match b7:
843 case True{}:
844 {==}
845 case False{}:
846 {==}
847 case False{}:
848 match b2:
849 case True{}:
850 match b3:
851 case True{}:
852 match b4:
853 case True{}:
854 match b5:
855 case True{}:
856 match b6:
857 case True{}:
858 match b7:
859 case True{}:
860 {==}
861 case False{}:
862 {==}
863 case False{}:
864 match b7:
865 case True{}:
866 {==}
867 case False{}:
868 {==}
869 case False{}:
870 match b6:
871 case True{}:
872 match b7:
873 case True{}:
874 {==}
875 case False{}:
876 {==}
877 case False{}:
878 match b7:
879 case True{}:
880 {==}
881 case False{}:
882 {==}
883 case False{}:
884 match b5:
885 case True{}:
886 match b6:
887 case True{}:
888 match b7:
889 case True{}:
890 {==}
891 case False{}:
892 {==}
893 case False{}:
894 match b7:
895 case True{}:
896 {==}
897 case False{}:
898 {==}
899 case False{}:
900 match b6:
901 case True{}:
902 match b7:
903 case True{}:
904 {==}
905 case False{}:
906 {==}
907 case False{}:
908 match b7:
909 case True{}:
910 {==}
911 case False{}:
912 {==}
913 case False{}:
914 match b4:
915 case True{}:
916 match b5:
917 case True{}:
918 match b6:
919 case True{}:
920 match b7:
921 case True{}:
922 {==}
923 case False{}:
924 {==}
925 case False{}:
926 match b7:
927 case True{}:
928 {==}
929 case False{}:
930 {==}
931 case False{}:
932 match b6:
933 case True{}:
934 match b7:
935 case True{}:
936 {==}
937 case False{}:
938 {==}
939 case False{}:
940 match b7:
941 case True{}:
942 {==}
943 case False{}:
944 {==}
945 case False{}:
946 match b5:
947 case True{}:
948 match b6:
949 case True{}:
950 match b7:
951 case True{}:
952 {==}
953 case False{}:
954 {==}
955 case False{}:
956 match b7:
957 case True{}:
958 {==}
959 case False{}:
960 {==}
961 case False{}:
962 match b6:
963 case True{}:
964 match b7:
965 case True{}:
966 {==}
967 case False{}:
968 {==}
969 case False{}:
970 match b7:
971 case True{}:
972 {==}
973 case False{}:
974 {==}
975 case False{}:
976 match b3:
977 case True{}:
978 match b4:
979 case True{}:
980 match b5:
981 case True{}:
982 match b6:
983 case True{}:
984 match b7:
985 case True{}:
986 {==}
987 case False{}:
988 {==}
989 case False{}:
990 match b7:
991 case True{}:
992 {==}
993 case False{}:
994 {==}
995 case False{}:
996 match b6:
997 case True{}:
998 match b7:
999 case True{}:
1000 {==}
1001 case False{}:
1002 {==}
1003 case False{}:
1004 match b7:
1005 case True{}:
1006 {==}
1007 case False{}:
1008 {==}
1009 case False{}:
1010 match b5:
1011 case True{}:
1012 match b6:
1013 case True{}:
1014 match b7:
1015 case True{}:
1016 {==}
1017 case False{}:
1018 {==}
1019 case False{}:
1020 match b7:
1021 case True{}:
1022 {==}
1023 case False{}:
1024 {==}
1025 case False{}:
1026 match b6:
1027 case True{}:
1028 match b7:
1029 case True{}:
1030 {==}
1031 case False{}:
1032 {==}
1033 case False{}:
1034 match b7:
1035 case True{}:
1036 {==}
1037 case False{}:
1038 {==}
1039 case False{}:
1040 match b4:
1041 case True{}:
1042 match b5:
1043 case True{}:
1044 match b6:
1045 case True{}:
1046 match b7:
1047 case True{}:
1048 {==}
1049 case False{}:
1050 {==}
1051 case False{}:
1052 match b7:
1053 case True{}:
1054 {==}
1055 case False{}:
1056 {==}
1057 case False{}:
1058 match b6:
1059 case True{}:
1060 match b7:
1061 case True{}:
1062 {==}
1063 case False{}:
1064 {==}
1065 case False{}:
1066 match b7:
1067 case True{}:
1068 {==}
1069 case False{}:
1070 {==}
1071 case False{}:
1072 match b5:
1073 case True{}:
1074 match b6:
1075 case True{}:
1076 match b7:
1077 case True{}:
1078 {==}
1079 case False{}:
1080 {==}
1081 case False{}:
1082 match b7:
1083 case True{}:
1084 {==}
1085 case False{}:
1086 {==}
1087 case False{}:
1088 match b6:
1089 case True{}:
1090 match b7:
1091 case True{}:
1092 {==}
1093 case False{}:
1094 {==}
1095 case False{}:
1096 match b7:
1097 case True{}:
1098 {==}
1099 case False{}:
1100 {==}
1101 case False{}:
1102 match b1:
1103 case True{}:
1104 match b2:
1105 case True{}:
1106 match b3:
1107 case True{}:
1108 match b4:
1109 case True{}:
1110 match b5:
1111 case True{}:
1112 match b6:
1113 case True{}:
1114 match b7:
1115 case True{}:
1116 {==}
1117 case False{}:
1118 {==}
1119 case False{}:
1120 match b7:
1121 case True{}:
1122 {==}
1123 case False{}:
1124 {==}
1125 case False{}:
1126 match b6:
1127 case True{}:
1128 match b7:
1129 case True{}:
1130 {==}
1131 case False{}:
1132 {==}
1133 case False{}:
1134 match b7:
1135 case True{}:
1136 {==}
1137 case False{}:
1138 {==}
1139 case False{}:
1140 match b5:
1141 case True{}:
1142 match b6:
1143 case True{}:
1144 match b7:
1145 case True{}:
1146 {==}
1147 case False{}:
1148 {==}
1149 case False{}:
1150 match b7:
1151 case True{}:
1152 {==}
1153 case False{}:
1154 {==}
1155 case False{}:
1156 match b6:
1157 case True{}:
1158 match b7:
1159 case True{}:
1160 {==}
1161 case False{}:
1162 {==}
1163 case False{}:
1164 match b7:
1165 case True{}:
1166 {==}
1167 case False{}:
1168 {==}
1169 case False{}:
1170 match b4:
1171 case True{}:
1172 match b5:
1173 case True{}:
1174 match b6:
1175 case True{}:
1176 match b7:
1177 case True{}:
1178 {==}
1179 case False{}:
1180 {==}
1181 case False{}:
1182 match b7:
1183 case True{}:
1184 {==}
1185 case False{}:
1186 {==}
1187 case False{}:
1188 match b6:
1189 case True{}:
1190 match b7:
1191 case True{}:
1192 {==}
1193 case False{}:
1194 {==}
1195 case False{}:
1196 match b7:
1197 case True{}:
1198 {==}
1199 case False{}:
1200 {==}
1201 case False{}:
1202 match b5:
1203 case True{}:
1204 match b6:
1205 case True{}:
1206 match b7:
1207 case True{}:
1208 {==}
1209 case False{}:
1210 {==}
1211 case False{}:
1212 match b7:
1213 case True{}:
1214 {==}
1215 case False{}:
1216 {==}
1217 case False{}:
1218 match b6:
1219 case True{}:
1220 match b7:
1221 case True{}:
1222 {==}
1223 case False{}:
1224 {==}
1225 case False{}:
1226 match b7:
1227 case True{}:
1228 {==}
1229 case False{}:
1230 {==}
1231 case False{}:
1232 match b3:
1233 case True{}:
1234 match b4:
1235 case True{}:
1236 match b5:
1237 case True{}:
1238 match b6:
1239 case True{}:
1240 match b7:
1241 case True{}:
1242 {==}
1243 case False{}:
1244 {==}
1245 case False{}:
1246 match b7:
1247 case True{}:
1248 {==}
1249 case False{}:
1250 {==}
1251 case False{}:
1252 match b6:
1253 case True{}:
1254 match b7:
1255 case True{}:
1256 {==}
1257 case False{}:
1258 {==}
1259 case False{}:
1260 match b7:
1261 case True{}:
1262 {==}
1263 case False{}:
1264 {==}
1265 case False{}:
1266 match b5:
1267 case True{}:
1268 match b6:
1269 case True{}:
1270 match b7:
1271 case True{}:
1272 {==}
1273 case False{}:
1274 {==}
1275 case False{}:
1276 match b7:
1277 case True{}:
1278 {==}
1279 case False{}:
1280 {==}
1281 case False{}:
1282 match b6:
1283 case True{}:
1284 match b7:
1285 case True{}:
1286 {==}
1287 case False{}:
1288 {==}
1289 case False{}:
1290 match b7:
1291 case True{}:
1292 {==}
1293 case False{}:
1294 {==}
1295 case False{}:
1296 match b4:
1297 case True{}:
1298 match b5:
1299 case True{}:
1300 match b6:
1301 case True{}:
1302 match b7:
1303 case True{}:
1304 {==}
1305 case False{}:
1306 {==}
1307 case False{}:
1308 match b7:
1309 case True{}:
1310 {==}
1311 case False{}:
1312 {==}
1313 case False{}:
1314 match b6:
1315 case True{}:
1316 match b7:
1317 case True{}:
1318 {==}
1319 case False{}:
1320 {==}
1321 case False{}:
1322 match b7:
1323 case True{}:
1324 {==}
1325 case False{}:
1326 {==}
1327 case False{}:
1328 match b5:
1329 case True{}:
1330 match b6:
1331 case True{}:
1332 match b7:
1333 case True{}:
1334 {==}
1335 case False{}:
1336 {==}
1337 case False{}:
1338 match b7:
1339 case True{}:
1340 {==}
1341 case False{}:
1342 {==}
1343 case False{}:
1344 match b6:
1345 case True{}:
1346 match b7:
1347 case True{}:
1348 {==}
1349 case False{}:
1350 {==}
1351 case False{}:
1352 match b7:
1353 case True{}:
1354 {==}
1355 case False{}:
1356 {==}
1357 case False{}:
1358 match b2:
1359 case True{}:
1360 match b3:
1361 case True{}:
1362 match b4:
1363 case True{}:
1364 match b5:
1365 case True{}:
1366 match b6:
1367 case True{}:
1368 match b7:
1369 case True{}:
1370 {==}
1371 case False{}:
1372 {==}
1373 case False{}:
1374 match b7:
1375 case True{}:
1376 {==}
1377 case False{}:
1378 {==}
1379 case False{}:
1380 match b6:
1381 case True{}:
1382 match b7:
1383 case True{}:
1384 {==}
1385 case False{}:
1386 {==}
1387 case False{}:
1388 match b7:
1389 case True{}:
1390 {==}
1391 case False{}:
1392 {==}
1393 case False{}:
1394 match b5:
1395 case True{}:
1396 match b6:
1397 case True{}:
1398 match b7:
1399 case True{}:
1400 {==}
1401 case False{}:
1402 {==}
1403 case False{}:
1404 match b7:
1405 case True{}:
1406 {==}
1407 case False{}:
1408 {==}
1409 case False{}:
1410 match b6:
1411 case True{}:
1412 match b7:
1413 case True{}:
1414 {==}
1415 case False{}:
1416 {==}
1417 case False{}:
1418 match b7:
1419 case True{}:
1420 {==}
1421 case False{}:
1422 {==}
1423 case False{}:
1424 match b4:
1425 case True{}:
1426 match b5:
1427 case True{}:
1428 match b6:
1429 case True{}:
1430 match b7:
1431 case True{}:
1432 {==}
1433 case False{}:
1434 {==}
1435 case False{}:
1436 match b7:
1437 case True{}:
1438 {==}
1439 case False{}:
1440 {==}
1441 case False{}:
1442 match b6:
1443 case True{}:
1444 match b7:
1445 case True{}:
1446 {==}
1447 case False{}:
1448 {==}
1449 case False{}:
1450 match b7:
1451 case True{}:
1452 {==}
1453 case False{}:
1454 {==}
1455 case False{}:
1456 match b5:
1457 case True{}:
1458 match b6:
1459 case True{}:
1460 match b7:
1461 case True{}:
1462 {==}
1463 case False{}:
1464 {==}
1465 case False{}:
1466 match b7:
1467 case True{}:
1468 {==}
1469 case False{}:
1470 {==}
1471 case False{}:
1472 match b6:
1473 case True{}:
1474 match b7:
1475 case True{}:
1476 {==}
1477 case False{}:
1478 {==}
1479 case False{}:
1480 match b7:
1481 case True{}:
1482 {==}
1483 case False{}:
1484 {==}
1485 case False{}:
1486 match b3:
1487 case True{}:
1488 match b4:
1489 case True{}:
1490 match b5:
1491 case True{}:
1492 match b6:
1493 case True{}:
1494 match b7:
1495 case True{}:
1496 {==}
1497 case False{}:
1498 {==}
1499 case False{}:
1500 match b7:
1501 case True{}:
1502 {==}
1503 case False{}:
1504 {==}
1505 case False{}:
1506 match b6:
1507 case True{}:
1508 match b7:
1509 case True{}:
1510 {==}
1511 case False{}:
1512 {==}
1513 case False{}:
1514 match b7:
1515 case True{}:
1516 {==}
1517 case False{}:
1518 {==}
1519 case False{}:
1520 match b5:
1521 case True{}:
1522 match b6:
1523 case True{}:
1524 match b7:
1525 case True{}:
1526 {==}
1527 case False{}:
1528 {==}
1529 case False{}:
1530 match b7:
1531 case True{}:
1532 {==}
1533 case False{}:
1534 {==}
1535 case False{}:
1536 match b6:
1537 case True{}:
1538 match b7:
1539 case True{}:
1540 {==}
1541 case False{}:
1542 {==}
1543 case False{}:
1544 match b7:
1545 case True{}:
1546 {==}
1547 case False{}:
1548 {==}
1549 case False{}:
1550 match b4:
1551 case True{}:
1552 match b5:
1553 case True{}:
1554 match b6:
1555 case True{}:
1556 match b7:
1557 case True{}:
1558 {==}
1559 case False{}:
1560 {==}
1561 case False{}:
1562 match b7:
1563 case True{}:
1564 {==}
1565 case False{}:
1566 {==}
1567 case False{}:
1568 match b6:
1569 case True{}:
1570 match b7:
1571 case True{}:
1572 {==}
1573 case False{}:
1574 {==}
1575 case False{}:
1576 match b7:
1577 case True{}:
1578 {==}
1579 case False{}:
1580 {==}
1581 case False{}:
1582 match b5:
1583 case True{}:
1584 match b6:
1585 case True{}:
1586 match b7:
1587 case True{}:
1588 {==}
1589 case False{}:
1590 {==}
1591 case False{}:
1592 match b7:
1593 case True{}:
1594 {==}
1595 case False{}:
1596 {==}
1597 case False{}:
1598 match b6:
1599 case True{}:
1600 match b7:
1601 case True{}:
1602 {==}
1603 case False{}:
1604 {==}
1605 case False{}:
1606 match b7:
1607 case True{}:
1608 {==}
1609 case False{}:
1610 {==}
1611
1612def hf(n: Nat, +acc: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.horner(fs(n), acc, b, p) == xk(n, acc, p) : G.Gf8Bits}:
1613 match n:
1614 case 0n:
1615 {==}
1616 case 1n+k:
1617 %Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(G.Gf8Bits.x(acc, p), G.Gf8Bits.zero()), G.Gf8Bits.x(acc, p), rx_zr(G.Gf8Bits.x(acc, p))) : {G.Gf8Bits.horner(fs(k), _, b, p) == xk(k, G.Gf8Bits.x(acc, p), p) : G.Gf8Bits}
1618 hf(k, G.Gf8Bits.x(acc, p), b, p)
1619
1620def me0(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p) == xk(0n, b, p) : G.Gf8Bits}:
1621 match b p:
1622 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1623 hf(0n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1624
1625def me1(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p) == xk(1n, b, p) : G.Gf8Bits}:
1626 match b p:
1627 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1628 hf(1n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1629
1630def me2(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p) == xk(2n, b, p) : G.Gf8Bits}:
1631 match b p:
1632 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1633 hf(2n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1634
1635def me3(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p) == xk(3n, b, p) : G.Gf8Bits}:
1636 match b p:
1637 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1638 hf(3n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1639
1640def me4(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p) == xk(4n, b, p) : G.Gf8Bits}:
1641 match b p:
1642 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1643 hf(4n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1644
1645def me5(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, b, p) == xk(5n, b, p) : G.Gf8Bits}:
1646 match b p:
1647 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1648 hf(5n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1649
1650def me6(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, b, p) == xk(6n, b, p) : G.Gf8Bits}:
1651 match b p:
1652 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1653 hf(6n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1654
1655def me7(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, b, p) == xk(7n, b, p) : G.Gf8Bits}:
1656 match b p:
1657 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1658 hf(7n, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})
1659
1660# 5. Commutativity and associativity
1661
1662def comm_e0(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, p) : G.Gf8Bits}:
1663 match p:
1664 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1665 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1666 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1667 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1668
1669def comm_e1(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, p) : G.Gf8Bits}:
1670 match p:
1671 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1672 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1673 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1674 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1675
1676def comm_e2(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, p) : G.Gf8Bits}:
1677 match p:
1678 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1679 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1680 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1681 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1682
1683def comm_e3(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, p) : G.Gf8Bits}:
1684 match p:
1685 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1686 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1687 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1688 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1689
1690def comm_e4(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, p) : G.Gf8Bits}:
1691 match p:
1692 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1693 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1694 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1695 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1696
1697def comm_e5(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, p) : G.Gf8Bits}:
1698 match p:
1699 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1700 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1701 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1702 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1703
1704def comm_e6(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p) : G.Gf8Bits}:
1705 match p:
1706 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1707 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1708 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1709 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1710
1711def comm_e7(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, b, p) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p) : G.Gf8Bits}:
1712 match p:
1713 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1714 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, _, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1715 %dec(b) : {G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) == G.Gf8Bits.mul(_, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}) : G.Gf8Bits}
1716 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, ss(bl(b), basis()), G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), mr(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), lin_r(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(b), basis()), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}), ss(bl(b), ml(basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})), lin_l(bl(b), basis(), G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7})))
1717
1718def mlr(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {ml(basis(), b, p) == mr(basis(), b, p) : List<&2, G.Gf8Bits>}:
1719 %comm_e0(b, p) : {ml(basis(), b, p) == [_, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1720 %comm_e1(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), _, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1721 %comm_e2(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), _, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1722 %comm_e3(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), _, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1723 %comm_e4(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), _, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1724 %comm_e5(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p), _, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, p), G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1725 %comm_e6(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, b, p), _, G.Gf8Bits.mul(b, G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, False{}, True{}}, p)] : List<&2, G.Gf8Bits>}
1726 %comm_e7(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, b, p), _] : List<&2, G.Gf8Bits>}
1727 {==}
1728
1729def comm(+a: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(a, b, p) == G.Gf8Bits.mul(b, a, p) : G.Gf8Bits}:
1730 %dec(a) : {G.Gf8Bits.mul(_, b, p) == G.Gf8Bits.mul(b, a, p) : G.Gf8Bits}
1731 %dec(a) : {G.Gf8Bits.mul(ss(bl(a), basis()), b, p) == G.Gf8Bits.mul(b, _, p) : G.Gf8Bits}
1732 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(a), basis()), b, p), ss(bl(a), ml(basis(), b, p)), G.Gf8Bits.mul(b, ss(bl(a), basis()), p), lin_l(bl(a), basis(), b, p), Equal.trans(G.Gf8Bits, ss(bl(a), ml(basis(), b, p)), ss(bl(a), mr(basis(), b, p)), G.Gf8Bits.mul(b, ss(bl(a), basis()), p), Equal.cong(List<&2, G.Gf8Bits>, G.Gf8Bits, l => ss(bl(a), l), ml(basis(), b, p), mr(basis(), b, p), mlr(b, p)), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(b, ss(bl(a), basis()), p), ss(bl(a), mr(basis(), b, p)), lin_r(bl(a), basis(), b, p))))
1733
1734def ml_x(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {ml(basis(), b, p) == xs(b, p) : List<&2, G.Gf8Bits>}:
1735 %me0(b, p) : {ml(basis(), b, p) == [_, xk(1n, b, p), xk(2n, b, p), xk(3n, b, p), xk(4n, b, p), xk(5n, b, p), xk(6n, b, p), xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1736 %me1(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), _, xk(2n, b, p), xk(3n, b, p), xk(4n, b, p), xk(5n, b, p), xk(6n, b, p), xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1737 %me2(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), _, xk(3n, b, p), xk(4n, b, p), xk(5n, b, p), xk(6n, b, p), xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1738 %me3(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), _, xk(4n, b, p), xk(5n, b, p), xk(6n, b, p), xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1739 %me4(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), _, xk(5n, b, p), xk(6n, b, p), xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1740 %me5(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p), _, xk(6n, b, p), xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1741 %me6(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, b, p), _, xk(7n, b, p)] : List<&2, G.Gf8Bits>}
1742 %me7(b, p) : {ml(basis(), b, p) == [G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, False{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, True{}, False{}, False{}}, b, p), G.Gf8Bits.mul(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, False{}, True{}, False{}}, b, p), _] : List<&2, G.Gf8Bits>}
1743 {==}
1744
1745def ax(+b: G.Gf8Bits, +c: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits.x(b, p), c, p) == G.Gf8Bits.x(G.Gf8Bits.mul(b, c, p), p) : G.Gf8Bits}:
1746 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits.x(b, p), c, p), ss(bl(c), xs(G.Gf8Bits.x(b, p), p)), G.Gf8Bits.x(G.Gf8Bits.mul(b, c, p), p), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits.x(b, p), c, p), G.Gf8Bits.mul(c, G.Gf8Bits.x(b, p), p), ss(bl(c), xs(G.Gf8Bits.x(b, p), p)), comm(G.Gf8Bits.x(b, p), c, p), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(c, G.Gf8Bits.x(b, p), p), G.Gf8Bits.mul(ss(bl(c), basis()), G.Gf8Bits.x(b, p), p), ss(bl(c), xs(G.Gf8Bits.x(b, p), p)), Equal.cong(G.Gf8Bits, G.Gf8Bits, z => G.Gf8Bits.mul(z, G.Gf8Bits.x(b, p), p), c, ss(bl(c), basis()), Equal.sym(G.Gf8Bits, ss(bl(c), basis()), c, dec(c))), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(c), basis()), G.Gf8Bits.x(b, p), p), ss(bl(c), ml(basis(), G.Gf8Bits.x(b, p), p)), ss(bl(c), xs(G.Gf8Bits.x(b, p), p)), lin_l(bl(c), basis(), G.Gf8Bits.x(b, p), p), Equal.cong(List<&2, G.Gf8Bits>, G.Gf8Bits, l => ss(bl(c), l), ml(basis(), G.Gf8Bits.x(b, p), p), xs(G.Gf8Bits.x(b, p), p), ml_x(G.Gf8Bits.x(b, p), p))))), Equal.sym(G.Gf8Bits, G.Gf8Bits.x(G.Gf8Bits.mul(b, c, p), p), ss(bl(c), xl(xs(b, p), p)), Equal.trans(G.Gf8Bits, G.Gf8Bits.x(G.Gf8Bits.mul(b, c, p), p), G.Gf8Bits.x(G.Gf8Bits.mul(c, b, p), p), ss(bl(c), xl(xs(b, p), p)), Equal.cong(G.Gf8Bits, G.Gf8Bits, z => G.Gf8Bits.x(z, p), G.Gf8Bits.mul(b, c, p), G.Gf8Bits.mul(c, b, p), comm(b, c, p)), Equal.trans(G.Gf8Bits, G.Gf8Bits.x(G.Gf8Bits.mul(c, b, p), p), G.Gf8Bits.x(G.Gf8Bits.mul(ss(bl(c), basis()), b, p), p), ss(bl(c), xl(xs(b, p), p)), Equal.cong(G.Gf8Bits, G.Gf8Bits, z => G.Gf8Bits.x(G.Gf8Bits.mul(z, b, p), p), c, ss(bl(c), basis()), Equal.sym(G.Gf8Bits, ss(bl(c), basis()), c, dec(c))), Equal.trans(G.Gf8Bits, G.Gf8Bits.x(G.Gf8Bits.mul(ss(bl(c), basis()), b, p), p), G.Gf8Bits.x(ss(bl(c), ml(basis(), b, p)), p), ss(bl(c), xl(xs(b, p), p)), Equal.cong(G.Gf8Bits, G.Gf8Bits, z => G.Gf8Bits.x(z, p), G.Gf8Bits.mul(ss(bl(c), basis()), b, p), ss(bl(c), ml(basis(), b, p)), lin_l(bl(c), basis(), b, p)), Equal.trans(G.Gf8Bits, G.Gf8Bits.x(ss(bl(c), ml(basis(), b, p)), p), G.Gf8Bits.x(ss(bl(c), xs(b, p)), p), ss(bl(c), xl(xs(b, p), p)), Equal.cong(List<&2, G.Gf8Bits>, G.Gf8Bits, l => G.Gf8Bits.x(ss(bl(c), l), p), ml(basis(), b, p), xs(b, p), ml_x(b, p)), lin_x(bl(c), xs(b, p), p)))))))
1747
1748def ak(n: Nat, +b: G.Gf8Bits, +c: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(xk(n, b, p), c, p) == xk(n, G.Gf8Bits.mul(b, c, p), p) : G.Gf8Bits}:
1749 match n:
1750 case 0n:
1751 {==}
1752 case 1n+k:
1753 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(xk(k, G.Gf8Bits.x(b, p), p), c, p), xk(k, G.Gf8Bits.mul(G.Gf8Bits.x(b, p), c, p), p), xk(k, G.Gf8Bits.x(G.Gf8Bits.mul(b, c, p), p), p), ak(k, G.Gf8Bits.x(b, p), c, p), Equal.cong(G.Gf8Bits, G.Gf8Bits, z => xk(k, z, p), G.Gf8Bits.mul(G.Gf8Bits.x(b, p), c, p), G.Gf8Bits.x(G.Gf8Bits.mul(b, c, p), p), ax(b, c, p)))
1754
1755def mlx_c(+b: G.Gf8Bits, +c: G.Gf8Bits, +p: G.Gf8Bits) -> {ml(xs(b, p), c, p) == xs(G.Gf8Bits.mul(b, c, p), p) : List<&2, G.Gf8Bits>}:
1756 %ak(0n, b, c, p) : {ml(xs(b, p), c, p) == [_, xk(1n, G.Gf8Bits.mul(b, c, p), p), xk(2n, G.Gf8Bits.mul(b, c, p), p), xk(3n, G.Gf8Bits.mul(b, c, p), p), xk(4n, G.Gf8Bits.mul(b, c, p), p), xk(5n, G.Gf8Bits.mul(b, c, p), p), xk(6n, G.Gf8Bits.mul(b, c, p), p), xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1757 %ak(1n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), _, xk(2n, G.Gf8Bits.mul(b, c, p), p), xk(3n, G.Gf8Bits.mul(b, c, p), p), xk(4n, G.Gf8Bits.mul(b, c, p), p), xk(5n, G.Gf8Bits.mul(b, c, p), p), xk(6n, G.Gf8Bits.mul(b, c, p), p), xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1758 %ak(2n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), G.Gf8Bits.mul(xk(1n, b, p), c, p), _, xk(3n, G.Gf8Bits.mul(b, c, p), p), xk(4n, G.Gf8Bits.mul(b, c, p), p), xk(5n, G.Gf8Bits.mul(b, c, p), p), xk(6n, G.Gf8Bits.mul(b, c, p), p), xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1759 %ak(3n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), G.Gf8Bits.mul(xk(1n, b, p), c, p), G.Gf8Bits.mul(xk(2n, b, p), c, p), _, xk(4n, G.Gf8Bits.mul(b, c, p), p), xk(5n, G.Gf8Bits.mul(b, c, p), p), xk(6n, G.Gf8Bits.mul(b, c, p), p), xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1760 %ak(4n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), G.Gf8Bits.mul(xk(1n, b, p), c, p), G.Gf8Bits.mul(xk(2n, b, p), c, p), G.Gf8Bits.mul(xk(3n, b, p), c, p), _, xk(5n, G.Gf8Bits.mul(b, c, p), p), xk(6n, G.Gf8Bits.mul(b, c, p), p), xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1761 %ak(5n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), G.Gf8Bits.mul(xk(1n, b, p), c, p), G.Gf8Bits.mul(xk(2n, b, p), c, p), G.Gf8Bits.mul(xk(3n, b, p), c, p), G.Gf8Bits.mul(xk(4n, b, p), c, p), _, xk(6n, G.Gf8Bits.mul(b, c, p), p), xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1762 %ak(6n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), G.Gf8Bits.mul(xk(1n, b, p), c, p), G.Gf8Bits.mul(xk(2n, b, p), c, p), G.Gf8Bits.mul(xk(3n, b, p), c, p), G.Gf8Bits.mul(xk(4n, b, p), c, p), G.Gf8Bits.mul(xk(5n, b, p), c, p), _, xk(7n, G.Gf8Bits.mul(b, c, p), p)] : List<&2, G.Gf8Bits>}
1763 %ak(7n, b, c, p) : {ml(xs(b, p), c, p) == [G.Gf8Bits.mul(xk(0n, b, p), c, p), G.Gf8Bits.mul(xk(1n, b, p), c, p), G.Gf8Bits.mul(xk(2n, b, p), c, p), G.Gf8Bits.mul(xk(3n, b, p), c, p), G.Gf8Bits.mul(xk(4n, b, p), c, p), G.Gf8Bits.mul(xk(5n, b, p), c, p), G.Gf8Bits.mul(xk(6n, b, p), c, p), _] : List<&2, G.Gf8Bits>}
1764 {==}
1765
1766def assoc(+a: G.Gf8Bits, +b: G.Gf8Bits, +c: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits.mul(a, b, p), c, p) == G.Gf8Bits.mul(a, G.Gf8Bits.mul(b, c, p), p) : G.Gf8Bits}:
1767 %dec(a) : {G.Gf8Bits.mul(G.Gf8Bits.mul(_, b, p), c, p) == G.Gf8Bits.mul(a, G.Gf8Bits.mul(b, c, p), p) : G.Gf8Bits}
1768 %dec(a) : {G.Gf8Bits.mul(G.Gf8Bits.mul(ss(bl(a), basis()), b, p), c, p) == G.Gf8Bits.mul(_, G.Gf8Bits.mul(b, c, p), p) : G.Gf8Bits}
1769 Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits.mul(ss(bl(a), basis()), b, p), c, p), ss(bl(a), xs(G.Gf8Bits.mul(b, c, p), p)), G.Gf8Bits.mul(ss(bl(a), basis()), G.Gf8Bits.mul(b, c, p), p), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(G.Gf8Bits.mul(ss(bl(a), basis()), b, p), c, p), G.Gf8Bits.mul(ss(bl(a), ml(basis(), b, p)), c, p), ss(bl(a), xs(G.Gf8Bits.mul(b, c, p), p)), Equal.cong(G.Gf8Bits, G.Gf8Bits, z => G.Gf8Bits.mul(z, c, p), G.Gf8Bits.mul(ss(bl(a), basis()), b, p), ss(bl(a), ml(basis(), b, p)), lin_l(bl(a), basis(), b, p)), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(a), ml(basis(), b, p)), c, p), G.Gf8Bits.mul(ss(bl(a), xs(b, p)), c, p), ss(bl(a), xs(G.Gf8Bits.mul(b, c, p), p)), Equal.cong(List<&2, G.Gf8Bits>, G.Gf8Bits, l => G.Gf8Bits.mul(ss(bl(a), l), c, p), ml(basis(), b, p), xs(b, p), ml_x(b, p)), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(a), xs(b, p)), c, p), ss(bl(a), ml(xs(b, p), c, p)), ss(bl(a), xs(G.Gf8Bits.mul(b, c, p), p)), lin_l(bl(a), xs(b, p), c, p), Equal.cong(List<&2, G.Gf8Bits>, G.Gf8Bits, l => ss(bl(a), l), ml(xs(b, p), c, p), xs(G.Gf8Bits.mul(b, c, p), p), mlx_c(b, c, p))))), Equal.sym(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(a), basis()), G.Gf8Bits.mul(b, c, p), p), ss(bl(a), xs(G.Gf8Bits.mul(b, c, p), p)), Equal.trans(G.Gf8Bits, G.Gf8Bits.mul(ss(bl(a), basis()), G.Gf8Bits.mul(b, c, p), p), ss(bl(a), ml(basis(), G.Gf8Bits.mul(b, c, p), p)), ss(bl(a), xs(G.Gf8Bits.mul(b, c, p), p)), lin_l(bl(a), basis(), G.Gf8Bits.mul(b, c, p), p), Equal.cong(List<&2, G.Gf8Bits>, G.Gf8Bits, l => ss(bl(a), l), ml(basis(), G.Gf8Bits.mul(b, c, p), p), xs(G.Gf8Bits.mul(b, c, p), p), ml_x(G.Gf8Bits.mul(b, c, p), p)))))
1770
1771# 6. The laws, on U32, through Gf8Bits.of (Gf8Bits.to (r)) = r
1772
1773def ot(+r: G.Gf8Bits) -> {G.Gf8Bits.of(G.Gf8Bits.to(r)) == r : G.Gf8Bits}:
1774 match r:
1775 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}:
1776 {==}
1777
1778def bdisc(+b: Bool) -> Type:
1779 match b:
1780 case True{}:
1781 Unit
1782 case False{}:
1783 Empty
1784
1785def bt_absurd(+e: {True{} == False{} : Bool}) -> Empty:
1786 %e : bdisc(_)
1787 Unit{}
1788
1789def Laws.mul_comm(f, a, b):
1790 match f:
1791 case G.Gf8Field{+poly, gen}:
1792 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), G.Gf8Bits.mul(G.Gf8Bits.of(b), G.Gf8Bits.of(a), G.Gf8Bits.of(poly)), comm(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)))
1793
1794def Laws.mul_assoc(f, a, b, c):
1795 match f:
1796 case G.Gf8Field{+poly, gen}:
1797 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)))), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), ot(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)))) : {G.Gf8Bits.to(G.Gf8Bits.mul(_, G.Gf8Bits.of(c), G.Gf8Bits.of(poly))) == G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))), G.Gf8Bits.of(poly))) : U32}
1798 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))), G.Gf8Bits.mul(G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)), ot(G.Gf8Bits.mul(G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))) : {G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), G.Gf8Bits.of(c), G.Gf8Bits.of(poly))) == G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), _, G.Gf8Bits.of(poly))) : U32}
1799 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.mul(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.mul(G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)), G.Gf8Bits.of(poly)), assoc(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))
1800
1801def Laws.mul_distrib(f, a, b, c):
1802 match f:
1803 case G.Gf8Field{+poly, gen}:
1804 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)))), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)), ot(G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)))) : {G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), _, G.Gf8Bits.of(poly))) == G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)))), G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))))) : U32}
1805 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)))), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), ot(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)))) : {G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)), G.Gf8Bits.of(poly))) == G.Gf8Bits.to(G.Gf8Bits.xor(_, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))))) : U32}
1806 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)), ot(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))) : {G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)), G.Gf8Bits.of(poly))) == G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), _)) : U32}
1807 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)), G.Gf8Bits.of(poly)), G.Gf8Bits.xor(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(poly)), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(c), G.Gf8Bits.of(poly))), m_lin_r(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(c), G.Gf8Bits.of(poly)))
1808
1809def Laws.mul_one(f, a):
1810 match f:
1811 case G.Gf8Field{+poly, gen}:
1812 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.mul(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits.of(a), G.Gf8Bits.of(poly)), G.Gf8Bits.of(a), me0(G.Gf8Bits.of(a), G.Gf8Bits.of(poly)))
1813
1814def Laws.mul_zero(f, a):
1815 match f:
1816 case G.Gf8Field{+poly, gen}:
1817 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.mul(G.Gf8Bits.zero(), G.Gf8Bits.of(a), G.Gf8Bits.of(poly)), G.Gf8Bits.zero(), m_zero_l(G.Gf8Bits.of(a), G.Gf8Bits.of(poly)))
1818
1819def Laws.xtime_mul_x(f, a):
1820 match f:
1821 case G.Gf8Field{+poly, gen}:
1822 Equal.sym(U32, G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits.of(a), G.Gf8Bits.of(poly))), G.Gf8Bits.to(G.Gf8Bits.x(G.Gf8Bits.of(a), G.Gf8Bits.of(poly))), Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.mul(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, False{}, False{}, False{}}, G.Gf8Bits.of(a), G.Gf8Bits.of(poly)), G.Gf8Bits.x(G.Gf8Bits.of(a), G.Gf8Bits.of(poly)), me1(G.Gf8Bits.of(a), G.Gf8Bits.of(poly))))
1823
1824def Laws.add_comm(a, b):
1825 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(b)), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(a)), rx_comm(G.Gf8Bits.of(a), G.Gf8Bits.of(b)))
1826
1827def Laws.add_assoc(a, b, c):
1828 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(b)))), G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(b)), ot(G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(b)))) : {G.Gf8Bits.to(G.Gf8Bits.xor(_, G.Gf8Bits.of(c))) == G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)))))) : U32}
1829 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)))), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)), ot(G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c)))) : {G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(b)), G.Gf8Bits.of(c))) == G.Gf8Bits.to(G.Gf8Bits.xor(G.Gf8Bits.of(a), _)) : U32}
1830 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.xor(G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(b)), G.Gf8Bits.of(c)), G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.xor(G.Gf8Bits.of(b), G.Gf8Bits.of(c))), rx_assoc(G.Gf8Bits.of(a), G.Gf8Bits.of(b), G.Gf8Bits.of(c)))
1831
1832def Laws.add_zero(a):
1833 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.zero()), G.Gf8Bits.of(a), rx_zr(G.Gf8Bits.of(a)))
1834
1835def Laws.add_self(a):
1836 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.xor(G.Gf8Bits.of(a), G.Gf8Bits.of(a)), G.Gf8Bits.zero(), rx_self(G.Gf8Bits.of(a)))
1837
1838def elt_pow(n: Nat, +f: G.Gf8Field, +a: U32) -> {G.Gf8.elt(G.Gf8.pow(f, a, n)) == G.Gf8.pow(f, a, n) : U32}:
1839 match n:
1840 case 0n:
1841 {==}
1842 case 1n+k:
1843 match f:
1844 case G.Gf8Field{+poly, +gen}:
1845 Equal.cong(G.Gf8Bits, U32, r => G.Gf8Bits.to(r), G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8.pow(G.Gf8Field{poly, gen}, a, k)), G.Gf8Bits.of(poly)))), G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8.pow(G.Gf8Field{poly, gen}, a, k)), G.Gf8Bits.of(poly)), ot(G.Gf8Bits.mul(G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8.pow(G.Gf8Field{poly, gen}, a, k)), G.Gf8Bits.of(poly))))
1846
1847def Laws.pow_add(f, a, m, n):
1848 match m:
1849 case 0n:
1850 Equal.sym(U32, G.Gf8.mul(f, 1, G.Gf8.pow(f, a, n)), G.Gf8.pow(f, a, n), Equal.trans(U32, G.Gf8.mul(f, 1, G.Gf8.pow(f, a, n)), G.Gf8.elt(G.Gf8.pow(f, a, n)), G.Gf8.pow(f, a, n), Laws.mul_one(f, G.Gf8.pow(f, a, n)), elt_pow(n, f, a)))
1851 case 1n+k:
1852 Equal.trans(U32, G.Gf8.mul(f, a, G.Gf8.pow(f, a, Nat.add(k, n))), G.Gf8.mul(f, a, G.Gf8.mul(f, G.Gf8.pow(f, a, k), G.Gf8.pow(f, a, n))), G.Gf8.mul(f, G.Gf8.mul(f, a, G.Gf8.pow(f, a, k)), G.Gf8.pow(f, a, n)), Equal.cong(U32, U32, z => G.Gf8.mul(f, a, z), G.Gf8.pow(f, a, Nat.add(k, n)), G.Gf8.mul(f, G.Gf8.pow(f, a, k), G.Gf8.pow(f, a, n)), Laws.pow_add(f, a, k, n)), Equal.sym(U32, G.Gf8.mul(f, G.Gf8.mul(f, a, G.Gf8.pow(f, a, k)), G.Gf8.pow(f, a, n)), G.Gf8.mul(f, a, G.Gf8.mul(f, G.Gf8.pow(f, a, k), G.Gf8.pow(f, a, n))), Laws.mul_assoc(f, a, G.Gf8.pow(f, a, k), G.Gf8.pow(f, a, n))))
1853
1854def Laws.inv_zero(f):
1855 Laws.mul_zero(f, G.Gf8.pow(f, 0, 253n))
1856
1857def mul_elt_l(+f: G.Gf8Field, +a: U32, +b: U32) -> {G.Gf8.mul(f, a, b) == G.Gf8.mul(f, G.Gf8.elt(a), b) : U32}:
1858 match f:
1859 case G.Gf8Field{+poly, gen}:
1860 Equal.cong(G.Gf8Bits, U32, z => G.Gf8Bits.to(G.Gf8Bits.mul(z, G.Gf8Bits.of(b), G.Gf8Bits.of(poly))), G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.of(a))), Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.of(a))), G.Gf8Bits.of(a), ot(G.Gf8Bits.of(a))))
1861
1862def pow_elt(+n: Nat, +f: G.Gf8Field, +a: U32) -> {G.Gf8.pow(f, a, n) == G.Gf8.pow(f, G.Gf8.elt(a), n) : U32}:
1863 match n:
1864 case 0n:
1865 {==}
1866 case 1n+k:
1867 Equal.trans(U32, G.Gf8.mul(f, a, G.Gf8.pow(f, a, k)), G.Gf8.mul(f, G.Gf8.elt(a), G.Gf8.pow(f, a, k)), G.Gf8.mul(f, G.Gf8.elt(a), G.Gf8.pow(f, G.Gf8.elt(a), k)), mul_elt_l(f, a, G.Gf8.pow(f, a, k)), Equal.cong(U32, U32, z => G.Gf8.mul(f, G.Gf8.elt(a), z), G.Gf8.pow(f, a, k), G.Gf8.pow(f, G.Gf8.elt(a), k), pow_elt(k, f, a)))
1868
1869def log_elt(+f: G.Gf8Field, +a: U32) -> {G.Gf8.log(f, a) == G.Gf8.log(f, G.Gf8.elt(a)) : Nat}:
1870 Equal.cong(G.Gf8Bits, Nat, +z => G.Gf8.log.go(254n, U32.is_eq(1, G.Gf8Bits.to(z)), f, G.Gf8Bits.to(z), 1, 0n), G.Gf8Bits.of(a), G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.of(a))), Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.of(a))), G.Gf8Bits.of(a), ot(G.Gf8Bits.of(a))))
1871
1872def elt_bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool, +b5: Bool, +b6: Bool, +b7: Bool, +r: Word(24n)) -> {G.Gf8.elt(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, WCon{b5, WCon{b6, WCon{b7, r}}}}}}}}}) == G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}) : U32}:
1873 {==}
1874
1875# a nonzero byte as itself, and 0 as 1, so that the per-byte facts hold
1876# for every byte and need no hypothesis while they are split into cases
1877def fixz(+x: U32) -> U32:
1878 Bool.pick(U32, G.Gf8.is_zero(x), 1, x)
1879
1880def fix_nz(+a: U32, nz: {G.Gf8.is_zero(a) == False{} : Bool}) -> {fixz(G.Gf8.elt(a)) == G.Gf8.elt(a) : U32}:
1881 %Equal.sym(G.Gf8Bits, G.Gf8Bits.of(G.Gf8Bits.to(G.Gf8Bits.of(a))), G.Gf8Bits.of(a), ot(G.Gf8Bits.of(a))) : {Bool.pick(U32, G.Gf8Bits.is_zero(_), 1, G.Gf8.elt(a)) == G.Gf8.elt(a) : U32}
1882 %Equal.sym(Bool, G.Gf8.is_zero(a), False{}, nz) : {Bool.pick(U32, _, 1, G.Gf8.elt(a)) == G.Gf8.elt(a) : U32}
1883 {==}
1884
1885def mul_inv_aes.s11111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
1886 match b5:
1887 case True{}:
1888 match b6:
1889 case True{}:
1890 match b7:
1891 case True{}:
1892 {==}
1893 case False{}:
1894 {==}
1895 case False{}:
1896 match b7:
1897 case True{}:
1898 {==}
1899 case False{}:
1900 {==}
1901 case False{}:
1902 match b6:
1903 case True{}:
1904 match b7:
1905 case True{}:
1906 {==}
1907 case False{}:
1908 {==}
1909 case False{}:
1910 match b7:
1911 case True{}:
1912 {==}
1913 case False{}:
1914 {==}
1915
1916def mul_inv_aes.s11110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
1917 match b5:
1918 case True{}:
1919 match b6:
1920 case True{}:
1921 match b7:
1922 case True{}:
1923 {==}
1924 case False{}:
1925 {==}
1926 case False{}:
1927 match b7:
1928 case True{}:
1929 {==}
1930 case False{}:
1931 {==}
1932 case False{}:
1933 match b6:
1934 case True{}:
1935 match b7:
1936 case True{}:
1937 {==}
1938 case False{}:
1939 {==}
1940 case False{}:
1941 match b7:
1942 case True{}:
1943 {==}
1944 case False{}:
1945 {==}
1946
1947def mul_inv_aes.s11101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
1948 match b5:
1949 case True{}:
1950 match b6:
1951 case True{}:
1952 match b7:
1953 case True{}:
1954 {==}
1955 case False{}:
1956 {==}
1957 case False{}:
1958 match b7:
1959 case True{}:
1960 {==}
1961 case False{}:
1962 {==}
1963 case False{}:
1964 match b6:
1965 case True{}:
1966 match b7:
1967 case True{}:
1968 {==}
1969 case False{}:
1970 {==}
1971 case False{}:
1972 match b7:
1973 case True{}:
1974 {==}
1975 case False{}:
1976 {==}
1977
1978def mul_inv_aes.s11100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
1979 match b5:
1980 case True{}:
1981 match b6:
1982 case True{}:
1983 match b7:
1984 case True{}:
1985 {==}
1986 case False{}:
1987 {==}
1988 case False{}:
1989 match b7:
1990 case True{}:
1991 {==}
1992 case False{}:
1993 {==}
1994 case False{}:
1995 match b6:
1996 case True{}:
1997 match b7:
1998 case True{}:
1999 {==}
2000 case False{}:
2001 {==}
2002 case False{}:
2003 match b7:
2004 case True{}:
2005 {==}
2006 case False{}:
2007 {==}
2008
2009def mul_inv_aes.s11011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2010 match b5:
2011 case True{}:
2012 match b6:
2013 case True{}:
2014 match b7:
2015 case True{}:
2016 {==}
2017 case False{}:
2018 {==}
2019 case False{}:
2020 match b7:
2021 case True{}:
2022 {==}
2023 case False{}:
2024 {==}
2025 case False{}:
2026 match b6:
2027 case True{}:
2028 match b7:
2029 case True{}:
2030 {==}
2031 case False{}:
2032 {==}
2033 case False{}:
2034 match b7:
2035 case True{}:
2036 {==}
2037 case False{}:
2038 {==}
2039
2040def mul_inv_aes.s11010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2041 match b5:
2042 case True{}:
2043 match b6:
2044 case True{}:
2045 match b7:
2046 case True{}:
2047 {==}
2048 case False{}:
2049 {==}
2050 case False{}:
2051 match b7:
2052 case True{}:
2053 {==}
2054 case False{}:
2055 {==}
2056 case False{}:
2057 match b6:
2058 case True{}:
2059 match b7:
2060 case True{}:
2061 {==}
2062 case False{}:
2063 {==}
2064 case False{}:
2065 match b7:
2066 case True{}:
2067 {==}
2068 case False{}:
2069 {==}
2070
2071def mul_inv_aes.s11001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2072 match b5:
2073 case True{}:
2074 match b6:
2075 case True{}:
2076 match b7:
2077 case True{}:
2078 {==}
2079 case False{}:
2080 {==}
2081 case False{}:
2082 match b7:
2083 case True{}:
2084 {==}
2085 case False{}:
2086 {==}
2087 case False{}:
2088 match b6:
2089 case True{}:
2090 match b7:
2091 case True{}:
2092 {==}
2093 case False{}:
2094 {==}
2095 case False{}:
2096 match b7:
2097 case True{}:
2098 {==}
2099 case False{}:
2100 {==}
2101
2102def mul_inv_aes.s11000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2103 match b5:
2104 case True{}:
2105 match b6:
2106 case True{}:
2107 match b7:
2108 case True{}:
2109 {==}
2110 case False{}:
2111 {==}
2112 case False{}:
2113 match b7:
2114 case True{}:
2115 {==}
2116 case False{}:
2117 {==}
2118 case False{}:
2119 match b6:
2120 case True{}:
2121 match b7:
2122 case True{}:
2123 {==}
2124 case False{}:
2125 {==}
2126 case False{}:
2127 match b7:
2128 case True{}:
2129 {==}
2130 case False{}:
2131 {==}
2132
2133def mul_inv_aes.s10111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2134 match b5:
2135 case True{}:
2136 match b6:
2137 case True{}:
2138 match b7:
2139 case True{}:
2140 {==}
2141 case False{}:
2142 {==}
2143 case False{}:
2144 match b7:
2145 case True{}:
2146 {==}
2147 case False{}:
2148 {==}
2149 case False{}:
2150 match b6:
2151 case True{}:
2152 match b7:
2153 case True{}:
2154 {==}
2155 case False{}:
2156 {==}
2157 case False{}:
2158 match b7:
2159 case True{}:
2160 {==}
2161 case False{}:
2162 {==}
2163
2164def mul_inv_aes.s10110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2165 match b5:
2166 case True{}:
2167 match b6:
2168 case True{}:
2169 match b7:
2170 case True{}:
2171 {==}
2172 case False{}:
2173 {==}
2174 case False{}:
2175 match b7:
2176 case True{}:
2177 {==}
2178 case False{}:
2179 {==}
2180 case False{}:
2181 match b6:
2182 case True{}:
2183 match b7:
2184 case True{}:
2185 {==}
2186 case False{}:
2187 {==}
2188 case False{}:
2189 match b7:
2190 case True{}:
2191 {==}
2192 case False{}:
2193 {==}
2194
2195def mul_inv_aes.s10101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2196 match b5:
2197 case True{}:
2198 match b6:
2199 case True{}:
2200 match b7:
2201 case True{}:
2202 {==}
2203 case False{}:
2204 {==}
2205 case False{}:
2206 match b7:
2207 case True{}:
2208 {==}
2209 case False{}:
2210 {==}
2211 case False{}:
2212 match b6:
2213 case True{}:
2214 match b7:
2215 case True{}:
2216 {==}
2217 case False{}:
2218 {==}
2219 case False{}:
2220 match b7:
2221 case True{}:
2222 {==}
2223 case False{}:
2224 {==}
2225
2226def mul_inv_aes.s10100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2227 match b5:
2228 case True{}:
2229 match b6:
2230 case True{}:
2231 match b7:
2232 case True{}:
2233 {==}
2234 case False{}:
2235 {==}
2236 case False{}:
2237 match b7:
2238 case True{}:
2239 {==}
2240 case False{}:
2241 {==}
2242 case False{}:
2243 match b6:
2244 case True{}:
2245 match b7:
2246 case True{}:
2247 {==}
2248 case False{}:
2249 {==}
2250 case False{}:
2251 match b7:
2252 case True{}:
2253 {==}
2254 case False{}:
2255 {==}
2256
2257def mul_inv_aes.s10011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2258 match b5:
2259 case True{}:
2260 match b6:
2261 case True{}:
2262 match b7:
2263 case True{}:
2264 {==}
2265 case False{}:
2266 {==}
2267 case False{}:
2268 match b7:
2269 case True{}:
2270 {==}
2271 case False{}:
2272 {==}
2273 case False{}:
2274 match b6:
2275 case True{}:
2276 match b7:
2277 case True{}:
2278 {==}
2279 case False{}:
2280 {==}
2281 case False{}:
2282 match b7:
2283 case True{}:
2284 {==}
2285 case False{}:
2286 {==}
2287
2288def mul_inv_aes.s10010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2289 match b5:
2290 case True{}:
2291 match b6:
2292 case True{}:
2293 match b7:
2294 case True{}:
2295 {==}
2296 case False{}:
2297 {==}
2298 case False{}:
2299 match b7:
2300 case True{}:
2301 {==}
2302 case False{}:
2303 {==}
2304 case False{}:
2305 match b6:
2306 case True{}:
2307 match b7:
2308 case True{}:
2309 {==}
2310 case False{}:
2311 {==}
2312 case False{}:
2313 match b7:
2314 case True{}:
2315 {==}
2316 case False{}:
2317 {==}
2318
2319def mul_inv_aes.s10001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2320 match b5:
2321 case True{}:
2322 match b6:
2323 case True{}:
2324 match b7:
2325 case True{}:
2326 {==}
2327 case False{}:
2328 {==}
2329 case False{}:
2330 match b7:
2331 case True{}:
2332 {==}
2333 case False{}:
2334 {==}
2335 case False{}:
2336 match b6:
2337 case True{}:
2338 match b7:
2339 case True{}:
2340 {==}
2341 case False{}:
2342 {==}
2343 case False{}:
2344 match b7:
2345 case True{}:
2346 {==}
2347 case False{}:
2348 {==}
2349
2350def mul_inv_aes.s10000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2351 match b5:
2352 case True{}:
2353 match b6:
2354 case True{}:
2355 match b7:
2356 case True{}:
2357 {==}
2358 case False{}:
2359 {==}
2360 case False{}:
2361 match b7:
2362 case True{}:
2363 {==}
2364 case False{}:
2365 {==}
2366 case False{}:
2367 match b6:
2368 case True{}:
2369 match b7:
2370 case True{}:
2371 {==}
2372 case False{}:
2373 {==}
2374 case False{}:
2375 match b7:
2376 case True{}:
2377 {==}
2378 case False{}:
2379 {==}
2380
2381def mul_inv_aes.s01111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2382 match b5:
2383 case True{}:
2384 match b6:
2385 case True{}:
2386 match b7:
2387 case True{}:
2388 {==}
2389 case False{}:
2390 {==}
2391 case False{}:
2392 match b7:
2393 case True{}:
2394 {==}
2395 case False{}:
2396 {==}
2397 case False{}:
2398 match b6:
2399 case True{}:
2400 match b7:
2401 case True{}:
2402 {==}
2403 case False{}:
2404 {==}
2405 case False{}:
2406 match b7:
2407 case True{}:
2408 {==}
2409 case False{}:
2410 {==}
2411
2412def mul_inv_aes.s01110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2413 match b5:
2414 case True{}:
2415 match b6:
2416 case True{}:
2417 match b7:
2418 case True{}:
2419 {==}
2420 case False{}:
2421 {==}
2422 case False{}:
2423 match b7:
2424 case True{}:
2425 {==}
2426 case False{}:
2427 {==}
2428 case False{}:
2429 match b6:
2430 case True{}:
2431 match b7:
2432 case True{}:
2433 {==}
2434 case False{}:
2435 {==}
2436 case False{}:
2437 match b7:
2438 case True{}:
2439 {==}
2440 case False{}:
2441 {==}
2442
2443def mul_inv_aes.s01101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2444 match b5:
2445 case True{}:
2446 match b6:
2447 case True{}:
2448 match b7:
2449 case True{}:
2450 {==}
2451 case False{}:
2452 {==}
2453 case False{}:
2454 match b7:
2455 case True{}:
2456 {==}
2457 case False{}:
2458 {==}
2459 case False{}:
2460 match b6:
2461 case True{}:
2462 match b7:
2463 case True{}:
2464 {==}
2465 case False{}:
2466 {==}
2467 case False{}:
2468 match b7:
2469 case True{}:
2470 {==}
2471 case False{}:
2472 {==}
2473
2474def mul_inv_aes.s01100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2475 match b5:
2476 case True{}:
2477 match b6:
2478 case True{}:
2479 match b7:
2480 case True{}:
2481 {==}
2482 case False{}:
2483 {==}
2484 case False{}:
2485 match b7:
2486 case True{}:
2487 {==}
2488 case False{}:
2489 {==}
2490 case False{}:
2491 match b6:
2492 case True{}:
2493 match b7:
2494 case True{}:
2495 {==}
2496 case False{}:
2497 {==}
2498 case False{}:
2499 match b7:
2500 case True{}:
2501 {==}
2502 case False{}:
2503 {==}
2504
2505def mul_inv_aes.s01011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2506 match b5:
2507 case True{}:
2508 match b6:
2509 case True{}:
2510 match b7:
2511 case True{}:
2512 {==}
2513 case False{}:
2514 {==}
2515 case False{}:
2516 match b7:
2517 case True{}:
2518 {==}
2519 case False{}:
2520 {==}
2521 case False{}:
2522 match b6:
2523 case True{}:
2524 match b7:
2525 case True{}:
2526 {==}
2527 case False{}:
2528 {==}
2529 case False{}:
2530 match b7:
2531 case True{}:
2532 {==}
2533 case False{}:
2534 {==}
2535
2536def mul_inv_aes.s01010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2537 match b5:
2538 case True{}:
2539 match b6:
2540 case True{}:
2541 match b7:
2542 case True{}:
2543 {==}
2544 case False{}:
2545 {==}
2546 case False{}:
2547 match b7:
2548 case True{}:
2549 {==}
2550 case False{}:
2551 {==}
2552 case False{}:
2553 match b6:
2554 case True{}:
2555 match b7:
2556 case True{}:
2557 {==}
2558 case False{}:
2559 {==}
2560 case False{}:
2561 match b7:
2562 case True{}:
2563 {==}
2564 case False{}:
2565 {==}
2566
2567def mul_inv_aes.s01001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2568 match b5:
2569 case True{}:
2570 match b6:
2571 case True{}:
2572 match b7:
2573 case True{}:
2574 {==}
2575 case False{}:
2576 {==}
2577 case False{}:
2578 match b7:
2579 case True{}:
2580 {==}
2581 case False{}:
2582 {==}
2583 case False{}:
2584 match b6:
2585 case True{}:
2586 match b7:
2587 case True{}:
2588 {==}
2589 case False{}:
2590 {==}
2591 case False{}:
2592 match b7:
2593 case True{}:
2594 {==}
2595 case False{}:
2596 {==}
2597
2598def mul_inv_aes.s01000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2599 match b5:
2600 case True{}:
2601 match b6:
2602 case True{}:
2603 match b7:
2604 case True{}:
2605 {==}
2606 case False{}:
2607 {==}
2608 case False{}:
2609 match b7:
2610 case True{}:
2611 {==}
2612 case False{}:
2613 {==}
2614 case False{}:
2615 match b6:
2616 case True{}:
2617 match b7:
2618 case True{}:
2619 {==}
2620 case False{}:
2621 {==}
2622 case False{}:
2623 match b7:
2624 case True{}:
2625 {==}
2626 case False{}:
2627 {==}
2628
2629def mul_inv_aes.s00111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2630 match b5:
2631 case True{}:
2632 match b6:
2633 case True{}:
2634 match b7:
2635 case True{}:
2636 {==}
2637 case False{}:
2638 {==}
2639 case False{}:
2640 match b7:
2641 case True{}:
2642 {==}
2643 case False{}:
2644 {==}
2645 case False{}:
2646 match b6:
2647 case True{}:
2648 match b7:
2649 case True{}:
2650 {==}
2651 case False{}:
2652 {==}
2653 case False{}:
2654 match b7:
2655 case True{}:
2656 {==}
2657 case False{}:
2658 {==}
2659
2660def mul_inv_aes.s00110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2661 match b5:
2662 case True{}:
2663 match b6:
2664 case True{}:
2665 match b7:
2666 case True{}:
2667 {==}
2668 case False{}:
2669 {==}
2670 case False{}:
2671 match b7:
2672 case True{}:
2673 {==}
2674 case False{}:
2675 {==}
2676 case False{}:
2677 match b6:
2678 case True{}:
2679 match b7:
2680 case True{}:
2681 {==}
2682 case False{}:
2683 {==}
2684 case False{}:
2685 match b7:
2686 case True{}:
2687 {==}
2688 case False{}:
2689 {==}
2690
2691def mul_inv_aes.s00101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2692 match b5:
2693 case True{}:
2694 match b6:
2695 case True{}:
2696 match b7:
2697 case True{}:
2698 {==}
2699 case False{}:
2700 {==}
2701 case False{}:
2702 match b7:
2703 case True{}:
2704 {==}
2705 case False{}:
2706 {==}
2707 case False{}:
2708 match b6:
2709 case True{}:
2710 match b7:
2711 case True{}:
2712 {==}
2713 case False{}:
2714 {==}
2715 case False{}:
2716 match b7:
2717 case True{}:
2718 {==}
2719 case False{}:
2720 {==}
2721
2722def mul_inv_aes.s00100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2723 match b5:
2724 case True{}:
2725 match b6:
2726 case True{}:
2727 match b7:
2728 case True{}:
2729 {==}
2730 case False{}:
2731 {==}
2732 case False{}:
2733 match b7:
2734 case True{}:
2735 {==}
2736 case False{}:
2737 {==}
2738 case False{}:
2739 match b6:
2740 case True{}:
2741 match b7:
2742 case True{}:
2743 {==}
2744 case False{}:
2745 {==}
2746 case False{}:
2747 match b7:
2748 case True{}:
2749 {==}
2750 case False{}:
2751 {==}
2752
2753def mul_inv_aes.s00011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
2754 match b5:
2755 case True{}:
2756 match b6:
2757 case True{}:
2758 match b7:
2759 case True{}:
2760 {==}
2761 case False{}:
2762 {==}
2763 case False{}:
2764 match b7:
2765 case True{}:
2766 {==}
2767 case False{}:
2768 {==}
2769 case False{}:
2770 match b6:
2771 case True{}:
2772 match b7:
2773 case True{}:
2774 {==}
2775 case False{}:
2776 {==}
2777 case False{}:
2778 match b7:
2779 case True{}:
2780 {==}
2781 case False{}:
2782 {==}
2783
2784def mul_inv_aes.s00010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
2785 match b5:
2786 case True{}:
2787 match b6:
2788 case True{}:
2789 match b7:
2790 case True{}:
2791 {==}
2792 case False{}:
2793 {==}
2794 case False{}:
2795 match b7:
2796 case True{}:
2797 {==}
2798 case False{}:
2799 {==}
2800 case False{}:
2801 match b6:
2802 case True{}:
2803 match b7:
2804 case True{}:
2805 {==}
2806 case False{}:
2807 {==}
2808 case False{}:
2809 match b7:
2810 case True{}:
2811 {==}
2812 case False{}:
2813 {==}
2814
2815def mul_inv_aes.s00001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
2816 match b5:
2817 case True{}:
2818 match b6:
2819 case True{}:
2820 match b7:
2821 case True{}:
2822 {==}
2823 case False{}:
2824 {==}
2825 case False{}:
2826 match b7:
2827 case True{}:
2828 {==}
2829 case False{}:
2830 {==}
2831 case False{}:
2832 match b6:
2833 case True{}:
2834 match b7:
2835 case True{}:
2836 {==}
2837 case False{}:
2838 {==}
2839 case False{}:
2840 match b7:
2841 case True{}:
2842 {==}
2843 case False{}:
2844 {==}
2845
2846def mul_inv_aes.s00000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
2847 match b5:
2848 case True{}:
2849 match b6:
2850 case True{}:
2851 match b7:
2852 case True{}:
2853 {==}
2854 case False{}:
2855 {==}
2856 case False{}:
2857 match b7:
2858 case True{}:
2859 {==}
2860 case False{}:
2861 {==}
2862 case False{}:
2863 match b6:
2864 case True{}:
2865 match b7:
2866 case True{}:
2867 {==}
2868 case False{}:
2869 {==}
2870 case False{}:
2871 match b7:
2872 case True{}:
2873 {==}
2874 case False{}:
2875 {==}
2876
2877def mul_inv_aes.bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool, +b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})))) == 1 : U32}:
2878 match b0:
2879 case True{}:
2880 match b1:
2881 case True{}:
2882 match b2:
2883 case True{}:
2884 match b3:
2885 case True{}:
2886 match b4:
2887 case True{}:
2888 mul_inv_aes.s11111(b5, b6, b7)
2889 case False{}:
2890 mul_inv_aes.s11110(b5, b6, b7)
2891 case False{}:
2892 match b4:
2893 case True{}:
2894 mul_inv_aes.s11101(b5, b6, b7)
2895 case False{}:
2896 mul_inv_aes.s11100(b5, b6, b7)
2897 case False{}:
2898 match b3:
2899 case True{}:
2900 match b4:
2901 case True{}:
2902 mul_inv_aes.s11011(b5, b6, b7)
2903 case False{}:
2904 mul_inv_aes.s11010(b5, b6, b7)
2905 case False{}:
2906 match b4:
2907 case True{}:
2908 mul_inv_aes.s11001(b5, b6, b7)
2909 case False{}:
2910 mul_inv_aes.s11000(b5, b6, b7)
2911 case False{}:
2912 match b2:
2913 case True{}:
2914 match b3:
2915 case True{}:
2916 match b4:
2917 case True{}:
2918 mul_inv_aes.s10111(b5, b6, b7)
2919 case False{}:
2920 mul_inv_aes.s10110(b5, b6, b7)
2921 case False{}:
2922 match b4:
2923 case True{}:
2924 mul_inv_aes.s10101(b5, b6, b7)
2925 case False{}:
2926 mul_inv_aes.s10100(b5, b6, b7)
2927 case False{}:
2928 match b3:
2929 case True{}:
2930 match b4:
2931 case True{}:
2932 mul_inv_aes.s10011(b5, b6, b7)
2933 case False{}:
2934 mul_inv_aes.s10010(b5, b6, b7)
2935 case False{}:
2936 match b4:
2937 case True{}:
2938 mul_inv_aes.s10001(b5, b6, b7)
2939 case False{}:
2940 mul_inv_aes.s10000(b5, b6, b7)
2941 case False{}:
2942 match b1:
2943 case True{}:
2944 match b2:
2945 case True{}:
2946 match b3:
2947 case True{}:
2948 match b4:
2949 case True{}:
2950 mul_inv_aes.s01111(b5, b6, b7)
2951 case False{}:
2952 mul_inv_aes.s01110(b5, b6, b7)
2953 case False{}:
2954 match b4:
2955 case True{}:
2956 mul_inv_aes.s01101(b5, b6, b7)
2957 case False{}:
2958 mul_inv_aes.s01100(b5, b6, b7)
2959 case False{}:
2960 match b3:
2961 case True{}:
2962 match b4:
2963 case True{}:
2964 mul_inv_aes.s01011(b5, b6, b7)
2965 case False{}:
2966 mul_inv_aes.s01010(b5, b6, b7)
2967 case False{}:
2968 match b4:
2969 case True{}:
2970 mul_inv_aes.s01001(b5, b6, b7)
2971 case False{}:
2972 mul_inv_aes.s01000(b5, b6, b7)
2973 case False{}:
2974 match b2:
2975 case True{}:
2976 match b3:
2977 case True{}:
2978 match b4:
2979 case True{}:
2980 mul_inv_aes.s00111(b5, b6, b7)
2981 case False{}:
2982 mul_inv_aes.s00110(b5, b6, b7)
2983 case False{}:
2984 match b4:
2985 case True{}:
2986 mul_inv_aes.s00101(b5, b6, b7)
2987 case False{}:
2988 mul_inv_aes.s00100(b5, b6, b7)
2989 case False{}:
2990 match b3:
2991 case True{}:
2992 match b4:
2993 case True{}:
2994 mul_inv_aes.s00011(b5, b6, b7)
2995 case False{}:
2996 mul_inv_aes.s00010(b5, b6, b7)
2997 case False{}:
2998 match b4:
2999 case True{}:
3000 mul_inv_aes.s00001(b5, b6, b7)
3001 case False{}:
3002 mul_inv_aes.s00000(b5, b6, b7)
3003
3004def mul_inv_aes.core(+a: U32) -> {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8.elt(a)), G.Gf8.inv(G.Gf8.aes(), fixz(G.Gf8.elt(a)))) == 1 : U32}:
3005 match a:
3006 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
3007 %Equal.sym(U32, G.Gf8.elt(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, WCon{b5, WCon{b6, WCon{b7, r}}}}}}}}}), G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}), elt_bits(b0, b1, b2, b3, b4, b5, b6, b7, r)) : {G.Gf8.mul(G.Gf8.aes(), fixz(_), G.Gf8.inv(G.Gf8.aes(), fixz(_))) == 1 : U32}
3008 mul_inv_aes.bits(b0, b1, b2, b3, b4, b5, b6, b7)
3009
3010def mul_inv_aes.lift(+a: U32, +nz: {G.Gf8.is_zero(a) == False{} : Bool}) -> {G.Gf8.mul(G.Gf8.aes(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.aes(), G.Gf8.elt(a))) == 1 : U32}:
3011 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.aes(), _, G.Gf8.inv(G.Gf8.aes(), G.Gf8.elt(a))) == 1 : U32}
3012 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8.elt(a)), G.Gf8.inv(G.Gf8.aes(), _)) == 1 : U32}
3013 mul_inv_aes.core(a)
3014
3015def Laws.mul_inv_aes(a, nz):
3016 Equal.trans(U32, G.Gf8.mul(G.Gf8.aes(), a, G.Gf8.inv(G.Gf8.aes(), a)), G.Gf8.mul(G.Gf8.aes(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.aes(), a)), 1, mul_elt_l(G.Gf8.aes(), a, G.Gf8.inv(G.Gf8.aes(), a)), Equal.trans(U32, G.Gf8.mul(G.Gf8.aes(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.aes(), a)), G.Gf8.mul(G.Gf8.aes(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.aes(), G.Gf8.elt(a))), 1, Equal.cong(U32, U32, z => G.Gf8.mul(G.Gf8.aes(), G.Gf8.elt(a), z), G.Gf8.inv(G.Gf8.aes(), a), G.Gf8.inv(G.Gf8.aes(), G.Gf8.elt(a)), pow_elt(254n, G.Gf8.aes(), a)), mul_inv_aes.lift(a, nz)))
3017
3018def exp_log_aes.s11111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
3019 match b5:
3020 case True{}:
3021 match b6:
3022 case True{}:
3023 match b7:
3024 case True{}:
3025 {==}
3026 case False{}:
3027 {==}
3028 case False{}:
3029 match b7:
3030 case True{}:
3031 {==}
3032 case False{}:
3033 {==}
3034 case False{}:
3035 match b6:
3036 case True{}:
3037 match b7:
3038 case True{}:
3039 {==}
3040 case False{}:
3041 {==}
3042 case False{}:
3043 match b7:
3044 case True{}:
3045 {==}
3046 case False{}:
3047 {==}
3048
3049def exp_log_aes.s11110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
3050 match b5:
3051 case True{}:
3052 match b6:
3053 case True{}:
3054 match b7:
3055 case True{}:
3056 {==}
3057 case False{}:
3058 {==}
3059 case False{}:
3060 match b7:
3061 case True{}:
3062 {==}
3063 case False{}:
3064 {==}
3065 case False{}:
3066 match b6:
3067 case True{}:
3068 match b7:
3069 case True{}:
3070 {==}
3071 case False{}:
3072 {==}
3073 case False{}:
3074 match b7:
3075 case True{}:
3076 {==}
3077 case False{}:
3078 {==}
3079
3080def exp_log_aes.s11101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
3081 match b5:
3082 case True{}:
3083 match b6:
3084 case True{}:
3085 match b7:
3086 case True{}:
3087 {==}
3088 case False{}:
3089 {==}
3090 case False{}:
3091 match b7:
3092 case True{}:
3093 {==}
3094 case False{}:
3095 {==}
3096 case False{}:
3097 match b6:
3098 case True{}:
3099 match b7:
3100 case True{}:
3101 {==}
3102 case False{}:
3103 {==}
3104 case False{}:
3105 match b7:
3106 case True{}:
3107 {==}
3108 case False{}:
3109 {==}
3110
3111def exp_log_aes.s11100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
3112 match b5:
3113 case True{}:
3114 match b6:
3115 case True{}:
3116 match b7:
3117 case True{}:
3118 {==}
3119 case False{}:
3120 {==}
3121 case False{}:
3122 match b7:
3123 case True{}:
3124 {==}
3125 case False{}:
3126 {==}
3127 case False{}:
3128 match b6:
3129 case True{}:
3130 match b7:
3131 case True{}:
3132 {==}
3133 case False{}:
3134 {==}
3135 case False{}:
3136 match b7:
3137 case True{}:
3138 {==}
3139 case False{}:
3140 {==}
3141
3142def exp_log_aes.s11011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
3143 match b5:
3144 case True{}:
3145 match b6:
3146 case True{}:
3147 match b7:
3148 case True{}:
3149 {==}
3150 case False{}:
3151 {==}
3152 case False{}:
3153 match b7:
3154 case True{}:
3155 {==}
3156 case False{}:
3157 {==}
3158 case False{}:
3159 match b6:
3160 case True{}:
3161 match b7:
3162 case True{}:
3163 {==}
3164 case False{}:
3165 {==}
3166 case False{}:
3167 match b7:
3168 case True{}:
3169 {==}
3170 case False{}:
3171 {==}
3172
3173def exp_log_aes.s11010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
3174 match b5:
3175 case True{}:
3176 match b6:
3177 case True{}:
3178 match b7:
3179 case True{}:
3180 {==}
3181 case False{}:
3182 {==}
3183 case False{}:
3184 match b7:
3185 case True{}:
3186 {==}
3187 case False{}:
3188 {==}
3189 case False{}:
3190 match b6:
3191 case True{}:
3192 match b7:
3193 case True{}:
3194 {==}
3195 case False{}:
3196 {==}
3197 case False{}:
3198 match b7:
3199 case True{}:
3200 {==}
3201 case False{}:
3202 {==}
3203
3204def exp_log_aes.s11001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
3205 match b5:
3206 case True{}:
3207 match b6:
3208 case True{}:
3209 match b7:
3210 case True{}:
3211 {==}
3212 case False{}:
3213 {==}
3214 case False{}:
3215 match b7:
3216 case True{}:
3217 {==}
3218 case False{}:
3219 {==}
3220 case False{}:
3221 match b6:
3222 case True{}:
3223 match b7:
3224 case True{}:
3225 {==}
3226 case False{}:
3227 {==}
3228 case False{}:
3229 match b7:
3230 case True{}:
3231 {==}
3232 case False{}:
3233 {==}
3234
3235def exp_log_aes.s11000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
3236 match b5:
3237 case True{}:
3238 match b6:
3239 case True{}:
3240 match b7:
3241 case True{}:
3242 {==}
3243 case False{}:
3244 {==}
3245 case False{}:
3246 match b7:
3247 case True{}:
3248 {==}
3249 case False{}:
3250 {==}
3251 case False{}:
3252 match b6:
3253 case True{}:
3254 match b7:
3255 case True{}:
3256 {==}
3257 case False{}:
3258 {==}
3259 case False{}:
3260 match b7:
3261 case True{}:
3262 {==}
3263 case False{}:
3264 {==}
3265
3266def exp_log_aes.s10111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
3267 match b5:
3268 case True{}:
3269 match b6:
3270 case True{}:
3271 match b7:
3272 case True{}:
3273 {==}
3274 case False{}:
3275 {==}
3276 case False{}:
3277 match b7:
3278 case True{}:
3279 {==}
3280 case False{}:
3281 {==}
3282 case False{}:
3283 match b6:
3284 case True{}:
3285 match b7:
3286 case True{}:
3287 {==}
3288 case False{}:
3289 {==}
3290 case False{}:
3291 match b7:
3292 case True{}:
3293 {==}
3294 case False{}:
3295 {==}
3296
3297def exp_log_aes.s10110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
3298 match b5:
3299 case True{}:
3300 match b6:
3301 case True{}:
3302 match b7:
3303 case True{}:
3304 {==}
3305 case False{}:
3306 {==}
3307 case False{}:
3308 match b7:
3309 case True{}:
3310 {==}
3311 case False{}:
3312 {==}
3313 case False{}:
3314 match b6:
3315 case True{}:
3316 match b7:
3317 case True{}:
3318 {==}
3319 case False{}:
3320 {==}
3321 case False{}:
3322 match b7:
3323 case True{}:
3324 {==}
3325 case False{}:
3326 {==}
3327
3328def exp_log_aes.s10101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
3329 match b5:
3330 case True{}:
3331 match b6:
3332 case True{}:
3333 match b7:
3334 case True{}:
3335 {==}
3336 case False{}:
3337 {==}
3338 case False{}:
3339 match b7:
3340 case True{}:
3341 {==}
3342 case False{}:
3343 {==}
3344 case False{}:
3345 match b6:
3346 case True{}:
3347 match b7:
3348 case True{}:
3349 {==}
3350 case False{}:
3351 {==}
3352 case False{}:
3353 match b7:
3354 case True{}:
3355 {==}
3356 case False{}:
3357 {==}
3358
3359def exp_log_aes.s10100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
3360 match b5:
3361 case True{}:
3362 match b6:
3363 case True{}:
3364 match b7:
3365 case True{}:
3366 {==}
3367 case False{}:
3368 {==}
3369 case False{}:
3370 match b7:
3371 case True{}:
3372 {==}
3373 case False{}:
3374 {==}
3375 case False{}:
3376 match b6:
3377 case True{}:
3378 match b7:
3379 case True{}:
3380 {==}
3381 case False{}:
3382 {==}
3383 case False{}:
3384 match b7:
3385 case True{}:
3386 {==}
3387 case False{}:
3388 {==}
3389
3390def exp_log_aes.s10011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
3391 match b5:
3392 case True{}:
3393 match b6:
3394 case True{}:
3395 match b7:
3396 case True{}:
3397 {==}
3398 case False{}:
3399 {==}
3400 case False{}:
3401 match b7:
3402 case True{}:
3403 {==}
3404 case False{}:
3405 {==}
3406 case False{}:
3407 match b6:
3408 case True{}:
3409 match b7:
3410 case True{}:
3411 {==}
3412 case False{}:
3413 {==}
3414 case False{}:
3415 match b7:
3416 case True{}:
3417 {==}
3418 case False{}:
3419 {==}
3420
3421def exp_log_aes.s10010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
3422 match b5:
3423 case True{}:
3424 match b6:
3425 case True{}:
3426 match b7:
3427 case True{}:
3428 {==}
3429 case False{}:
3430 {==}
3431 case False{}:
3432 match b7:
3433 case True{}:
3434 {==}
3435 case False{}:
3436 {==}
3437 case False{}:
3438 match b6:
3439 case True{}:
3440 match b7:
3441 case True{}:
3442 {==}
3443 case False{}:
3444 {==}
3445 case False{}:
3446 match b7:
3447 case True{}:
3448 {==}
3449 case False{}:
3450 {==}
3451
3452def exp_log_aes.s10001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
3453 match b5:
3454 case True{}:
3455 match b6:
3456 case True{}:
3457 match b7:
3458 case True{}:
3459 {==}
3460 case False{}:
3461 {==}
3462 case False{}:
3463 match b7:
3464 case True{}:
3465 {==}
3466 case False{}:
3467 {==}
3468 case False{}:
3469 match b6:
3470 case True{}:
3471 match b7:
3472 case True{}:
3473 {==}
3474 case False{}:
3475 {==}
3476 case False{}:
3477 match b7:
3478 case True{}:
3479 {==}
3480 case False{}:
3481 {==}
3482
3483def exp_log_aes.s10000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
3484 match b5:
3485 case True{}:
3486 match b6:
3487 case True{}:
3488 match b7:
3489 case True{}:
3490 {==}
3491 case False{}:
3492 {==}
3493 case False{}:
3494 match b7:
3495 case True{}:
3496 {==}
3497 case False{}:
3498 {==}
3499 case False{}:
3500 match b6:
3501 case True{}:
3502 match b7:
3503 case True{}:
3504 {==}
3505 case False{}:
3506 {==}
3507 case False{}:
3508 match b7:
3509 case True{}:
3510 {==}
3511 case False{}:
3512 {==}
3513
3514def exp_log_aes.s01111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
3515 match b5:
3516 case True{}:
3517 match b6:
3518 case True{}:
3519 match b7:
3520 case True{}:
3521 {==}
3522 case False{}:
3523 {==}
3524 case False{}:
3525 match b7:
3526 case True{}:
3527 {==}
3528 case False{}:
3529 {==}
3530 case False{}:
3531 match b6:
3532 case True{}:
3533 match b7:
3534 case True{}:
3535 {==}
3536 case False{}:
3537 {==}
3538 case False{}:
3539 match b7:
3540 case True{}:
3541 {==}
3542 case False{}:
3543 {==}
3544
3545def exp_log_aes.s01110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
3546 match b5:
3547 case True{}:
3548 match b6:
3549 case True{}:
3550 match b7:
3551 case True{}:
3552 {==}
3553 case False{}:
3554 {==}
3555 case False{}:
3556 match b7:
3557 case True{}:
3558 {==}
3559 case False{}:
3560 {==}
3561 case False{}:
3562 match b6:
3563 case True{}:
3564 match b7:
3565 case True{}:
3566 {==}
3567 case False{}:
3568 {==}
3569 case False{}:
3570 match b7:
3571 case True{}:
3572 {==}
3573 case False{}:
3574 {==}
3575
3576def exp_log_aes.s01101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
3577 match b5:
3578 case True{}:
3579 match b6:
3580 case True{}:
3581 match b7:
3582 case True{}:
3583 {==}
3584 case False{}:
3585 {==}
3586 case False{}:
3587 match b7:
3588 case True{}:
3589 {==}
3590 case False{}:
3591 {==}
3592 case False{}:
3593 match b6:
3594 case True{}:
3595 match b7:
3596 case True{}:
3597 {==}
3598 case False{}:
3599 {==}
3600 case False{}:
3601 match b7:
3602 case True{}:
3603 {==}
3604 case False{}:
3605 {==}
3606
3607def exp_log_aes.s01100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
3608 match b5:
3609 case True{}:
3610 match b6:
3611 case True{}:
3612 match b7:
3613 case True{}:
3614 {==}
3615 case False{}:
3616 {==}
3617 case False{}:
3618 match b7:
3619 case True{}:
3620 {==}
3621 case False{}:
3622 {==}
3623 case False{}:
3624 match b6:
3625 case True{}:
3626 match b7:
3627 case True{}:
3628 {==}
3629 case False{}:
3630 {==}
3631 case False{}:
3632 match b7:
3633 case True{}:
3634 {==}
3635 case False{}:
3636 {==}
3637
3638def exp_log_aes.s01011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
3639 match b5:
3640 case True{}:
3641 match b6:
3642 case True{}:
3643 match b7:
3644 case True{}:
3645 {==}
3646 case False{}:
3647 {==}
3648 case False{}:
3649 match b7:
3650 case True{}:
3651 {==}
3652 case False{}:
3653 {==}
3654 case False{}:
3655 match b6:
3656 case True{}:
3657 match b7:
3658 case True{}:
3659 {==}
3660 case False{}:
3661 {==}
3662 case False{}:
3663 match b7:
3664 case True{}:
3665 {==}
3666 case False{}:
3667 {==}
3668
3669def exp_log_aes.s01010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
3670 match b5:
3671 case True{}:
3672 match b6:
3673 case True{}:
3674 match b7:
3675 case True{}:
3676 {==}
3677 case False{}:
3678 {==}
3679 case False{}:
3680 match b7:
3681 case True{}:
3682 {==}
3683 case False{}:
3684 {==}
3685 case False{}:
3686 match b6:
3687 case True{}:
3688 match b7:
3689 case True{}:
3690 {==}
3691 case False{}:
3692 {==}
3693 case False{}:
3694 match b7:
3695 case True{}:
3696 {==}
3697 case False{}:
3698 {==}
3699
3700def exp_log_aes.s01001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
3701 match b5:
3702 case True{}:
3703 match b6:
3704 case True{}:
3705 match b7:
3706 case True{}:
3707 {==}
3708 case False{}:
3709 {==}
3710 case False{}:
3711 match b7:
3712 case True{}:
3713 {==}
3714 case False{}:
3715 {==}
3716 case False{}:
3717 match b6:
3718 case True{}:
3719 match b7:
3720 case True{}:
3721 {==}
3722 case False{}:
3723 {==}
3724 case False{}:
3725 match b7:
3726 case True{}:
3727 {==}
3728 case False{}:
3729 {==}
3730
3731def exp_log_aes.s01000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
3732 match b5:
3733 case True{}:
3734 match b6:
3735 case True{}:
3736 match b7:
3737 case True{}:
3738 {==}
3739 case False{}:
3740 {==}
3741 case False{}:
3742 match b7:
3743 case True{}:
3744 {==}
3745 case False{}:
3746 {==}
3747 case False{}:
3748 match b6:
3749 case True{}:
3750 match b7:
3751 case True{}:
3752 {==}
3753 case False{}:
3754 {==}
3755 case False{}:
3756 match b7:
3757 case True{}:
3758 {==}
3759 case False{}:
3760 {==}
3761
3762def exp_log_aes.s00111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
3763 match b5:
3764 case True{}:
3765 match b6:
3766 case True{}:
3767 match b7:
3768 case True{}:
3769 {==}
3770 case False{}:
3771 {==}
3772 case False{}:
3773 match b7:
3774 case True{}:
3775 {==}
3776 case False{}:
3777 {==}
3778 case False{}:
3779 match b6:
3780 case True{}:
3781 match b7:
3782 case True{}:
3783 {==}
3784 case False{}:
3785 {==}
3786 case False{}:
3787 match b7:
3788 case True{}:
3789 {==}
3790 case False{}:
3791 {==}
3792
3793def exp_log_aes.s00110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
3794 match b5:
3795 case True{}:
3796 match b6:
3797 case True{}:
3798 match b7:
3799 case True{}:
3800 {==}
3801 case False{}:
3802 {==}
3803 case False{}:
3804 match b7:
3805 case True{}:
3806 {==}
3807 case False{}:
3808 {==}
3809 case False{}:
3810 match b6:
3811 case True{}:
3812 match b7:
3813 case True{}:
3814 {==}
3815 case False{}:
3816 {==}
3817 case False{}:
3818 match b7:
3819 case True{}:
3820 {==}
3821 case False{}:
3822 {==}
3823
3824def exp_log_aes.s00101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
3825 match b5:
3826 case True{}:
3827 match b6:
3828 case True{}:
3829 match b7:
3830 case True{}:
3831 {==}
3832 case False{}:
3833 {==}
3834 case False{}:
3835 match b7:
3836 case True{}:
3837 {==}
3838 case False{}:
3839 {==}
3840 case False{}:
3841 match b6:
3842 case True{}:
3843 match b7:
3844 case True{}:
3845 {==}
3846 case False{}:
3847 {==}
3848 case False{}:
3849 match b7:
3850 case True{}:
3851 {==}
3852 case False{}:
3853 {==}
3854
3855def exp_log_aes.s00100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
3856 match b5:
3857 case True{}:
3858 match b6:
3859 case True{}:
3860 match b7:
3861 case True{}:
3862 {==}
3863 case False{}:
3864 {==}
3865 case False{}:
3866 match b7:
3867 case True{}:
3868 {==}
3869 case False{}:
3870 {==}
3871 case False{}:
3872 match b6:
3873 case True{}:
3874 match b7:
3875 case True{}:
3876 {==}
3877 case False{}:
3878 {==}
3879 case False{}:
3880 match b7:
3881 case True{}:
3882 {==}
3883 case False{}:
3884 {==}
3885
3886def exp_log_aes.s00011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
3887 match b5:
3888 case True{}:
3889 match b6:
3890 case True{}:
3891 match b7:
3892 case True{}:
3893 {==}
3894 case False{}:
3895 {==}
3896 case False{}:
3897 match b7:
3898 case True{}:
3899 {==}
3900 case False{}:
3901 {==}
3902 case False{}:
3903 match b6:
3904 case True{}:
3905 match b7:
3906 case True{}:
3907 {==}
3908 case False{}:
3909 {==}
3910 case False{}:
3911 match b7:
3912 case True{}:
3913 {==}
3914 case False{}:
3915 {==}
3916
3917def exp_log_aes.s00010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
3918 match b5:
3919 case True{}:
3920 match b6:
3921 case True{}:
3922 match b7:
3923 case True{}:
3924 {==}
3925 case False{}:
3926 {==}
3927 case False{}:
3928 match b7:
3929 case True{}:
3930 {==}
3931 case False{}:
3932 {==}
3933 case False{}:
3934 match b6:
3935 case True{}:
3936 match b7:
3937 case True{}:
3938 {==}
3939 case False{}:
3940 {==}
3941 case False{}:
3942 match b7:
3943 case True{}:
3944 {==}
3945 case False{}:
3946 {==}
3947
3948def exp_log_aes.s00001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
3949 match b5:
3950 case True{}:
3951 match b6:
3952 case True{}:
3953 match b7:
3954 case True{}:
3955 {==}
3956 case False{}:
3957 {==}
3958 case False{}:
3959 match b7:
3960 case True{}:
3961 {==}
3962 case False{}:
3963 {==}
3964 case False{}:
3965 match b6:
3966 case True{}:
3967 match b7:
3968 case True{}:
3969 {==}
3970 case False{}:
3971 {==}
3972 case False{}:
3973 match b7:
3974 case True{}:
3975 {==}
3976 case False{}:
3977 {==}
3978
3979def exp_log_aes.s00000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
3980 match b5:
3981 case True{}:
3982 match b6:
3983 case True{}:
3984 match b7:
3985 case True{}:
3986 {==}
3987 case False{}:
3988 {==}
3989 case False{}:
3990 match b7:
3991 case True{}:
3992 {==}
3993 case False{}:
3994 {==}
3995 case False{}:
3996 match b6:
3997 case True{}:
3998 match b7:
3999 case True{}:
4000 {==}
4001 case False{}:
4002 {==}
4003 case False{}:
4004 match b7:
4005 case True{}:
4006 {==}
4007 case False{}:
4008 {==}
4009
4010def exp_log_aes.bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool, +b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})) : U32}:
4011 match b0:
4012 case True{}:
4013 match b1:
4014 case True{}:
4015 match b2:
4016 case True{}:
4017 match b3:
4018 case True{}:
4019 match b4:
4020 case True{}:
4021 exp_log_aes.s11111(b5, b6, b7)
4022 case False{}:
4023 exp_log_aes.s11110(b5, b6, b7)
4024 case False{}:
4025 match b4:
4026 case True{}:
4027 exp_log_aes.s11101(b5, b6, b7)
4028 case False{}:
4029 exp_log_aes.s11100(b5, b6, b7)
4030 case False{}:
4031 match b3:
4032 case True{}:
4033 match b4:
4034 case True{}:
4035 exp_log_aes.s11011(b5, b6, b7)
4036 case False{}:
4037 exp_log_aes.s11010(b5, b6, b7)
4038 case False{}:
4039 match b4:
4040 case True{}:
4041 exp_log_aes.s11001(b5, b6, b7)
4042 case False{}:
4043 exp_log_aes.s11000(b5, b6, b7)
4044 case False{}:
4045 match b2:
4046 case True{}:
4047 match b3:
4048 case True{}:
4049 match b4:
4050 case True{}:
4051 exp_log_aes.s10111(b5, b6, b7)
4052 case False{}:
4053 exp_log_aes.s10110(b5, b6, b7)
4054 case False{}:
4055 match b4:
4056 case True{}:
4057 exp_log_aes.s10101(b5, b6, b7)
4058 case False{}:
4059 exp_log_aes.s10100(b5, b6, b7)
4060 case False{}:
4061 match b3:
4062 case True{}:
4063 match b4:
4064 case True{}:
4065 exp_log_aes.s10011(b5, b6, b7)
4066 case False{}:
4067 exp_log_aes.s10010(b5, b6, b7)
4068 case False{}:
4069 match b4:
4070 case True{}:
4071 exp_log_aes.s10001(b5, b6, b7)
4072 case False{}:
4073 exp_log_aes.s10000(b5, b6, b7)
4074 case False{}:
4075 match b1:
4076 case True{}:
4077 match b2:
4078 case True{}:
4079 match b3:
4080 case True{}:
4081 match b4:
4082 case True{}:
4083 exp_log_aes.s01111(b5, b6, b7)
4084 case False{}:
4085 exp_log_aes.s01110(b5, b6, b7)
4086 case False{}:
4087 match b4:
4088 case True{}:
4089 exp_log_aes.s01101(b5, b6, b7)
4090 case False{}:
4091 exp_log_aes.s01100(b5, b6, b7)
4092 case False{}:
4093 match b3:
4094 case True{}:
4095 match b4:
4096 case True{}:
4097 exp_log_aes.s01011(b5, b6, b7)
4098 case False{}:
4099 exp_log_aes.s01010(b5, b6, b7)
4100 case False{}:
4101 match b4:
4102 case True{}:
4103 exp_log_aes.s01001(b5, b6, b7)
4104 case False{}:
4105 exp_log_aes.s01000(b5, b6, b7)
4106 case False{}:
4107 match b2:
4108 case True{}:
4109 match b3:
4110 case True{}:
4111 match b4:
4112 case True{}:
4113 exp_log_aes.s00111(b5, b6, b7)
4114 case False{}:
4115 exp_log_aes.s00110(b5, b6, b7)
4116 case False{}:
4117 match b4:
4118 case True{}:
4119 exp_log_aes.s00101(b5, b6, b7)
4120 case False{}:
4121 exp_log_aes.s00100(b5, b6, b7)
4122 case False{}:
4123 match b3:
4124 case True{}:
4125 match b4:
4126 case True{}:
4127 exp_log_aes.s00011(b5, b6, b7)
4128 case False{}:
4129 exp_log_aes.s00010(b5, b6, b7)
4130 case False{}:
4131 match b4:
4132 case True{}:
4133 exp_log_aes.s00001(b5, b6, b7)
4134 case False{}:
4135 exp_log_aes.s00000(b5, b6, b7)
4136
4137def exp_log_aes.core(+a: U32) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8.elt(a)))) == fixz(G.Gf8.elt(a)) : U32}:
4138 match a:
4139 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
4140 %Equal.sym(U32, G.Gf8.elt(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, WCon{b5, WCon{b6, WCon{b7, r}}}}}}}}}), G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}), elt_bits(b0, b1, b2, b3, b4, b5, b6, b7, r)) : {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(_))) == fixz(_) : U32}
4141 exp_log_aes.bits(b0, b1, b2, b3, b4, b5, b6, b7)
4142
4143def exp_log_aes.lift(+a: U32, +nz: {G.Gf8.is_zero(a) == False{} : Bool}) -> {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), G.Gf8.elt(a))) == G.Gf8.elt(a) : U32}:
4144 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), _)) == G.Gf8.elt(a) : U32}
4145 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8.elt(a)))) == _ : U32}
4146 exp_log_aes.core(a)
4147
4148def Laws.exp_log_aes(a, nz):
4149 Equal.trans(U32, G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), a)), G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), G.Gf8.elt(a))), G.Gf8.elt(a), Equal.cong(Nat, U32, z => G.Gf8.exp(G.Gf8.aes(), z), G.Gf8.log(G.Gf8.aes(), a), G.Gf8.log(G.Gf8.aes(), G.Gf8.elt(a)), log_elt(G.Gf8.aes(), a)), exp_log_aes.lift(a, nz))
4150
4151def mul_inv_rs.s11111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4152 match b5:
4153 case True{}:
4154 match b6:
4155 case True{}:
4156 match b7:
4157 case True{}:
4158 {==}
4159 case False{}:
4160 {==}
4161 case False{}:
4162 match b7:
4163 case True{}:
4164 {==}
4165 case False{}:
4166 {==}
4167 case False{}:
4168 match b6:
4169 case True{}:
4170 match b7:
4171 case True{}:
4172 {==}
4173 case False{}:
4174 {==}
4175 case False{}:
4176 match b7:
4177 case True{}:
4178 {==}
4179 case False{}:
4180 {==}
4181
4182def mul_inv_rs.s11110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4183 match b5:
4184 case True{}:
4185 match b6:
4186 case True{}:
4187 match b7:
4188 case True{}:
4189 {==}
4190 case False{}:
4191 {==}
4192 case False{}:
4193 match b7:
4194 case True{}:
4195 {==}
4196 case False{}:
4197 {==}
4198 case False{}:
4199 match b6:
4200 case True{}:
4201 match b7:
4202 case True{}:
4203 {==}
4204 case False{}:
4205 {==}
4206 case False{}:
4207 match b7:
4208 case True{}:
4209 {==}
4210 case False{}:
4211 {==}
4212
4213def mul_inv_rs.s11101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4214 match b5:
4215 case True{}:
4216 match b6:
4217 case True{}:
4218 match b7:
4219 case True{}:
4220 {==}
4221 case False{}:
4222 {==}
4223 case False{}:
4224 match b7:
4225 case True{}:
4226 {==}
4227 case False{}:
4228 {==}
4229 case False{}:
4230 match b6:
4231 case True{}:
4232 match b7:
4233 case True{}:
4234 {==}
4235 case False{}:
4236 {==}
4237 case False{}:
4238 match b7:
4239 case True{}:
4240 {==}
4241 case False{}:
4242 {==}
4243
4244def mul_inv_rs.s11100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4245 match b5:
4246 case True{}:
4247 match b6:
4248 case True{}:
4249 match b7:
4250 case True{}:
4251 {==}
4252 case False{}:
4253 {==}
4254 case False{}:
4255 match b7:
4256 case True{}:
4257 {==}
4258 case False{}:
4259 {==}
4260 case False{}:
4261 match b6:
4262 case True{}:
4263 match b7:
4264 case True{}:
4265 {==}
4266 case False{}:
4267 {==}
4268 case False{}:
4269 match b7:
4270 case True{}:
4271 {==}
4272 case False{}:
4273 {==}
4274
4275def mul_inv_rs.s11011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4276 match b5:
4277 case True{}:
4278 match b6:
4279 case True{}:
4280 match b7:
4281 case True{}:
4282 {==}
4283 case False{}:
4284 {==}
4285 case False{}:
4286 match b7:
4287 case True{}:
4288 {==}
4289 case False{}:
4290 {==}
4291 case False{}:
4292 match b6:
4293 case True{}:
4294 match b7:
4295 case True{}:
4296 {==}
4297 case False{}:
4298 {==}
4299 case False{}:
4300 match b7:
4301 case True{}:
4302 {==}
4303 case False{}:
4304 {==}
4305
4306def mul_inv_rs.s11010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4307 match b5:
4308 case True{}:
4309 match b6:
4310 case True{}:
4311 match b7:
4312 case True{}:
4313 {==}
4314 case False{}:
4315 {==}
4316 case False{}:
4317 match b7:
4318 case True{}:
4319 {==}
4320 case False{}:
4321 {==}
4322 case False{}:
4323 match b6:
4324 case True{}:
4325 match b7:
4326 case True{}:
4327 {==}
4328 case False{}:
4329 {==}
4330 case False{}:
4331 match b7:
4332 case True{}:
4333 {==}
4334 case False{}:
4335 {==}
4336
4337def mul_inv_rs.s11001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4338 match b5:
4339 case True{}:
4340 match b6:
4341 case True{}:
4342 match b7:
4343 case True{}:
4344 {==}
4345 case False{}:
4346 {==}
4347 case False{}:
4348 match b7:
4349 case True{}:
4350 {==}
4351 case False{}:
4352 {==}
4353 case False{}:
4354 match b6:
4355 case True{}:
4356 match b7:
4357 case True{}:
4358 {==}
4359 case False{}:
4360 {==}
4361 case False{}:
4362 match b7:
4363 case True{}:
4364 {==}
4365 case False{}:
4366 {==}
4367
4368def mul_inv_rs.s11000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4369 match b5:
4370 case True{}:
4371 match b6:
4372 case True{}:
4373 match b7:
4374 case True{}:
4375 {==}
4376 case False{}:
4377 {==}
4378 case False{}:
4379 match b7:
4380 case True{}:
4381 {==}
4382 case False{}:
4383 {==}
4384 case False{}:
4385 match b6:
4386 case True{}:
4387 match b7:
4388 case True{}:
4389 {==}
4390 case False{}:
4391 {==}
4392 case False{}:
4393 match b7:
4394 case True{}:
4395 {==}
4396 case False{}:
4397 {==}
4398
4399def mul_inv_rs.s10111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4400 match b5:
4401 case True{}:
4402 match b6:
4403 case True{}:
4404 match b7:
4405 case True{}:
4406 {==}
4407 case False{}:
4408 {==}
4409 case False{}:
4410 match b7:
4411 case True{}:
4412 {==}
4413 case False{}:
4414 {==}
4415 case False{}:
4416 match b6:
4417 case True{}:
4418 match b7:
4419 case True{}:
4420 {==}
4421 case False{}:
4422 {==}
4423 case False{}:
4424 match b7:
4425 case True{}:
4426 {==}
4427 case False{}:
4428 {==}
4429
4430def mul_inv_rs.s10110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4431 match b5:
4432 case True{}:
4433 match b6:
4434 case True{}:
4435 match b7:
4436 case True{}:
4437 {==}
4438 case False{}:
4439 {==}
4440 case False{}:
4441 match b7:
4442 case True{}:
4443 {==}
4444 case False{}:
4445 {==}
4446 case False{}:
4447 match b6:
4448 case True{}:
4449 match b7:
4450 case True{}:
4451 {==}
4452 case False{}:
4453 {==}
4454 case False{}:
4455 match b7:
4456 case True{}:
4457 {==}
4458 case False{}:
4459 {==}
4460
4461def mul_inv_rs.s10101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4462 match b5:
4463 case True{}:
4464 match b6:
4465 case True{}:
4466 match b7:
4467 case True{}:
4468 {==}
4469 case False{}:
4470 {==}
4471 case False{}:
4472 match b7:
4473 case True{}:
4474 {==}
4475 case False{}:
4476 {==}
4477 case False{}:
4478 match b6:
4479 case True{}:
4480 match b7:
4481 case True{}:
4482 {==}
4483 case False{}:
4484 {==}
4485 case False{}:
4486 match b7:
4487 case True{}:
4488 {==}
4489 case False{}:
4490 {==}
4491
4492def mul_inv_rs.s10100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4493 match b5:
4494 case True{}:
4495 match b6:
4496 case True{}:
4497 match b7:
4498 case True{}:
4499 {==}
4500 case False{}:
4501 {==}
4502 case False{}:
4503 match b7:
4504 case True{}:
4505 {==}
4506 case False{}:
4507 {==}
4508 case False{}:
4509 match b6:
4510 case True{}:
4511 match b7:
4512 case True{}:
4513 {==}
4514 case False{}:
4515 {==}
4516 case False{}:
4517 match b7:
4518 case True{}:
4519 {==}
4520 case False{}:
4521 {==}
4522
4523def mul_inv_rs.s10011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4524 match b5:
4525 case True{}:
4526 match b6:
4527 case True{}:
4528 match b7:
4529 case True{}:
4530 {==}
4531 case False{}:
4532 {==}
4533 case False{}:
4534 match b7:
4535 case True{}:
4536 {==}
4537 case False{}:
4538 {==}
4539 case False{}:
4540 match b6:
4541 case True{}:
4542 match b7:
4543 case True{}:
4544 {==}
4545 case False{}:
4546 {==}
4547 case False{}:
4548 match b7:
4549 case True{}:
4550 {==}
4551 case False{}:
4552 {==}
4553
4554def mul_inv_rs.s10010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4555 match b5:
4556 case True{}:
4557 match b6:
4558 case True{}:
4559 match b7:
4560 case True{}:
4561 {==}
4562 case False{}:
4563 {==}
4564 case False{}:
4565 match b7:
4566 case True{}:
4567 {==}
4568 case False{}:
4569 {==}
4570 case False{}:
4571 match b6:
4572 case True{}:
4573 match b7:
4574 case True{}:
4575 {==}
4576 case False{}:
4577 {==}
4578 case False{}:
4579 match b7:
4580 case True{}:
4581 {==}
4582 case False{}:
4583 {==}
4584
4585def mul_inv_rs.s10001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4586 match b5:
4587 case True{}:
4588 match b6:
4589 case True{}:
4590 match b7:
4591 case True{}:
4592 {==}
4593 case False{}:
4594 {==}
4595 case False{}:
4596 match b7:
4597 case True{}:
4598 {==}
4599 case False{}:
4600 {==}
4601 case False{}:
4602 match b6:
4603 case True{}:
4604 match b7:
4605 case True{}:
4606 {==}
4607 case False{}:
4608 {==}
4609 case False{}:
4610 match b7:
4611 case True{}:
4612 {==}
4613 case False{}:
4614 {==}
4615
4616def mul_inv_rs.s10000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4617 match b5:
4618 case True{}:
4619 match b6:
4620 case True{}:
4621 match b7:
4622 case True{}:
4623 {==}
4624 case False{}:
4625 {==}
4626 case False{}:
4627 match b7:
4628 case True{}:
4629 {==}
4630 case False{}:
4631 {==}
4632 case False{}:
4633 match b6:
4634 case True{}:
4635 match b7:
4636 case True{}:
4637 {==}
4638 case False{}:
4639 {==}
4640 case False{}:
4641 match b7:
4642 case True{}:
4643 {==}
4644 case False{}:
4645 {==}
4646
4647def mul_inv_rs.s01111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4648 match b5:
4649 case True{}:
4650 match b6:
4651 case True{}:
4652 match b7:
4653 case True{}:
4654 {==}
4655 case False{}:
4656 {==}
4657 case False{}:
4658 match b7:
4659 case True{}:
4660 {==}
4661 case False{}:
4662 {==}
4663 case False{}:
4664 match b6:
4665 case True{}:
4666 match b7:
4667 case True{}:
4668 {==}
4669 case False{}:
4670 {==}
4671 case False{}:
4672 match b7:
4673 case True{}:
4674 {==}
4675 case False{}:
4676 {==}
4677
4678def mul_inv_rs.s01110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4679 match b5:
4680 case True{}:
4681 match b6:
4682 case True{}:
4683 match b7:
4684 case True{}:
4685 {==}
4686 case False{}:
4687 {==}
4688 case False{}:
4689 match b7:
4690 case True{}:
4691 {==}
4692 case False{}:
4693 {==}
4694 case False{}:
4695 match b6:
4696 case True{}:
4697 match b7:
4698 case True{}:
4699 {==}
4700 case False{}:
4701 {==}
4702 case False{}:
4703 match b7:
4704 case True{}:
4705 {==}
4706 case False{}:
4707 {==}
4708
4709def mul_inv_rs.s01101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4710 match b5:
4711 case True{}:
4712 match b6:
4713 case True{}:
4714 match b7:
4715 case True{}:
4716 {==}
4717 case False{}:
4718 {==}
4719 case False{}:
4720 match b7:
4721 case True{}:
4722 {==}
4723 case False{}:
4724 {==}
4725 case False{}:
4726 match b6:
4727 case True{}:
4728 match b7:
4729 case True{}:
4730 {==}
4731 case False{}:
4732 {==}
4733 case False{}:
4734 match b7:
4735 case True{}:
4736 {==}
4737 case False{}:
4738 {==}
4739
4740def mul_inv_rs.s01100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4741 match b5:
4742 case True{}:
4743 match b6:
4744 case True{}:
4745 match b7:
4746 case True{}:
4747 {==}
4748 case False{}:
4749 {==}
4750 case False{}:
4751 match b7:
4752 case True{}:
4753 {==}
4754 case False{}:
4755 {==}
4756 case False{}:
4757 match b6:
4758 case True{}:
4759 match b7:
4760 case True{}:
4761 {==}
4762 case False{}:
4763 {==}
4764 case False{}:
4765 match b7:
4766 case True{}:
4767 {==}
4768 case False{}:
4769 {==}
4770
4771def mul_inv_rs.s01011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4772 match b5:
4773 case True{}:
4774 match b6:
4775 case True{}:
4776 match b7:
4777 case True{}:
4778 {==}
4779 case False{}:
4780 {==}
4781 case False{}:
4782 match b7:
4783 case True{}:
4784 {==}
4785 case False{}:
4786 {==}
4787 case False{}:
4788 match b6:
4789 case True{}:
4790 match b7:
4791 case True{}:
4792 {==}
4793 case False{}:
4794 {==}
4795 case False{}:
4796 match b7:
4797 case True{}:
4798 {==}
4799 case False{}:
4800 {==}
4801
4802def mul_inv_rs.s01010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4803 match b5:
4804 case True{}:
4805 match b6:
4806 case True{}:
4807 match b7:
4808 case True{}:
4809 {==}
4810 case False{}:
4811 {==}
4812 case False{}:
4813 match b7:
4814 case True{}:
4815 {==}
4816 case False{}:
4817 {==}
4818 case False{}:
4819 match b6:
4820 case True{}:
4821 match b7:
4822 case True{}:
4823 {==}
4824 case False{}:
4825 {==}
4826 case False{}:
4827 match b7:
4828 case True{}:
4829 {==}
4830 case False{}:
4831 {==}
4832
4833def mul_inv_rs.s01001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4834 match b5:
4835 case True{}:
4836 match b6:
4837 case True{}:
4838 match b7:
4839 case True{}:
4840 {==}
4841 case False{}:
4842 {==}
4843 case False{}:
4844 match b7:
4845 case True{}:
4846 {==}
4847 case False{}:
4848 {==}
4849 case False{}:
4850 match b6:
4851 case True{}:
4852 match b7:
4853 case True{}:
4854 {==}
4855 case False{}:
4856 {==}
4857 case False{}:
4858 match b7:
4859 case True{}:
4860 {==}
4861 case False{}:
4862 {==}
4863
4864def mul_inv_rs.s01000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4865 match b5:
4866 case True{}:
4867 match b6:
4868 case True{}:
4869 match b7:
4870 case True{}:
4871 {==}
4872 case False{}:
4873 {==}
4874 case False{}:
4875 match b7:
4876 case True{}:
4877 {==}
4878 case False{}:
4879 {==}
4880 case False{}:
4881 match b6:
4882 case True{}:
4883 match b7:
4884 case True{}:
4885 {==}
4886 case False{}:
4887 {==}
4888 case False{}:
4889 match b7:
4890 case True{}:
4891 {==}
4892 case False{}:
4893 {==}
4894
4895def mul_inv_rs.s00111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
4896 match b5:
4897 case True{}:
4898 match b6:
4899 case True{}:
4900 match b7:
4901 case True{}:
4902 {==}
4903 case False{}:
4904 {==}
4905 case False{}:
4906 match b7:
4907 case True{}:
4908 {==}
4909 case False{}:
4910 {==}
4911 case False{}:
4912 match b6:
4913 case True{}:
4914 match b7:
4915 case True{}:
4916 {==}
4917 case False{}:
4918 {==}
4919 case False{}:
4920 match b7:
4921 case True{}:
4922 {==}
4923 case False{}:
4924 {==}
4925
4926def mul_inv_rs.s00110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
4927 match b5:
4928 case True{}:
4929 match b6:
4930 case True{}:
4931 match b7:
4932 case True{}:
4933 {==}
4934 case False{}:
4935 {==}
4936 case False{}:
4937 match b7:
4938 case True{}:
4939 {==}
4940 case False{}:
4941 {==}
4942 case False{}:
4943 match b6:
4944 case True{}:
4945 match b7:
4946 case True{}:
4947 {==}
4948 case False{}:
4949 {==}
4950 case False{}:
4951 match b7:
4952 case True{}:
4953 {==}
4954 case False{}:
4955 {==}
4956
4957def mul_inv_rs.s00101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
4958 match b5:
4959 case True{}:
4960 match b6:
4961 case True{}:
4962 match b7:
4963 case True{}:
4964 {==}
4965 case False{}:
4966 {==}
4967 case False{}:
4968 match b7:
4969 case True{}:
4970 {==}
4971 case False{}:
4972 {==}
4973 case False{}:
4974 match b6:
4975 case True{}:
4976 match b7:
4977 case True{}:
4978 {==}
4979 case False{}:
4980 {==}
4981 case False{}:
4982 match b7:
4983 case True{}:
4984 {==}
4985 case False{}:
4986 {==}
4987
4988def mul_inv_rs.s00100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
4989 match b5:
4990 case True{}:
4991 match b6:
4992 case True{}:
4993 match b7:
4994 case True{}:
4995 {==}
4996 case False{}:
4997 {==}
4998 case False{}:
4999 match b7:
5000 case True{}:
5001 {==}
5002 case False{}:
5003 {==}
5004 case False{}:
5005 match b6:
5006 case True{}:
5007 match b7:
5008 case True{}:
5009 {==}
5010 case False{}:
5011 {==}
5012 case False{}:
5013 match b7:
5014 case True{}:
5015 {==}
5016 case False{}:
5017 {==}
5018
5019def mul_inv_rs.s00011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == 1 : U32}:
5020 match b5:
5021 case True{}:
5022 match b6:
5023 case True{}:
5024 match b7:
5025 case True{}:
5026 {==}
5027 case False{}:
5028 {==}
5029 case False{}:
5030 match b7:
5031 case True{}:
5032 {==}
5033 case False{}:
5034 {==}
5035 case False{}:
5036 match b6:
5037 case True{}:
5038 match b7:
5039 case True{}:
5040 {==}
5041 case False{}:
5042 {==}
5043 case False{}:
5044 match b7:
5045 case True{}:
5046 {==}
5047 case False{}:
5048 {==}
5049
5050def mul_inv_rs.s00010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == 1 : U32}:
5051 match b5:
5052 case True{}:
5053 match b6:
5054 case True{}:
5055 match b7:
5056 case True{}:
5057 {==}
5058 case False{}:
5059 {==}
5060 case False{}:
5061 match b7:
5062 case True{}:
5063 {==}
5064 case False{}:
5065 {==}
5066 case False{}:
5067 match b6:
5068 case True{}:
5069 match b7:
5070 case True{}:
5071 {==}
5072 case False{}:
5073 {==}
5074 case False{}:
5075 match b7:
5076 case True{}:
5077 {==}
5078 case False{}:
5079 {==}
5080
5081def mul_inv_rs.s00001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == 1 : U32}:
5082 match b5:
5083 case True{}:
5084 match b6:
5085 case True{}:
5086 match b7:
5087 case True{}:
5088 {==}
5089 case False{}:
5090 {==}
5091 case False{}:
5092 match b7:
5093 case True{}:
5094 {==}
5095 case False{}:
5096 {==}
5097 case False{}:
5098 match b6:
5099 case True{}:
5100 match b7:
5101 case True{}:
5102 {==}
5103 case False{}:
5104 {==}
5105 case False{}:
5106 match b7:
5107 case True{}:
5108 {==}
5109 case False{}:
5110 {==}
5111
5112def mul_inv_rs.s00000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == 1 : U32}:
5113 match b5:
5114 case True{}:
5115 match b6:
5116 case True{}:
5117 match b7:
5118 case True{}:
5119 {==}
5120 case False{}:
5121 {==}
5122 case False{}:
5123 match b7:
5124 case True{}:
5125 {==}
5126 case False{}:
5127 {==}
5128 case False{}:
5129 match b6:
5130 case True{}:
5131 match b7:
5132 case True{}:
5133 {==}
5134 case False{}:
5135 {==}
5136 case False{}:
5137 match b7:
5138 case True{}:
5139 {==}
5140 case False{}:
5141 {==}
5142
5143def mul_inv_rs.bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool, +b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})))) == 1 : U32}:
5144 match b0:
5145 case True{}:
5146 match b1:
5147 case True{}:
5148 match b2:
5149 case True{}:
5150 match b3:
5151 case True{}:
5152 match b4:
5153 case True{}:
5154 mul_inv_rs.s11111(b5, b6, b7)
5155 case False{}:
5156 mul_inv_rs.s11110(b5, b6, b7)
5157 case False{}:
5158 match b4:
5159 case True{}:
5160 mul_inv_rs.s11101(b5, b6, b7)
5161 case False{}:
5162 mul_inv_rs.s11100(b5, b6, b7)
5163 case False{}:
5164 match b3:
5165 case True{}:
5166 match b4:
5167 case True{}:
5168 mul_inv_rs.s11011(b5, b6, b7)
5169 case False{}:
5170 mul_inv_rs.s11010(b5, b6, b7)
5171 case False{}:
5172 match b4:
5173 case True{}:
5174 mul_inv_rs.s11001(b5, b6, b7)
5175 case False{}:
5176 mul_inv_rs.s11000(b5, b6, b7)
5177 case False{}:
5178 match b2:
5179 case True{}:
5180 match b3:
5181 case True{}:
5182 match b4:
5183 case True{}:
5184 mul_inv_rs.s10111(b5, b6, b7)
5185 case False{}:
5186 mul_inv_rs.s10110(b5, b6, b7)
5187 case False{}:
5188 match b4:
5189 case True{}:
5190 mul_inv_rs.s10101(b5, b6, b7)
5191 case False{}:
5192 mul_inv_rs.s10100(b5, b6, b7)
5193 case False{}:
5194 match b3:
5195 case True{}:
5196 match b4:
5197 case True{}:
5198 mul_inv_rs.s10011(b5, b6, b7)
5199 case False{}:
5200 mul_inv_rs.s10010(b5, b6, b7)
5201 case False{}:
5202 match b4:
5203 case True{}:
5204 mul_inv_rs.s10001(b5, b6, b7)
5205 case False{}:
5206 mul_inv_rs.s10000(b5, b6, b7)
5207 case False{}:
5208 match b1:
5209 case True{}:
5210 match b2:
5211 case True{}:
5212 match b3:
5213 case True{}:
5214 match b4:
5215 case True{}:
5216 mul_inv_rs.s01111(b5, b6, b7)
5217 case False{}:
5218 mul_inv_rs.s01110(b5, b6, b7)
5219 case False{}:
5220 match b4:
5221 case True{}:
5222 mul_inv_rs.s01101(b5, b6, b7)
5223 case False{}:
5224 mul_inv_rs.s01100(b5, b6, b7)
5225 case False{}:
5226 match b3:
5227 case True{}:
5228 match b4:
5229 case True{}:
5230 mul_inv_rs.s01011(b5, b6, b7)
5231 case False{}:
5232 mul_inv_rs.s01010(b5, b6, b7)
5233 case False{}:
5234 match b4:
5235 case True{}:
5236 mul_inv_rs.s01001(b5, b6, b7)
5237 case False{}:
5238 mul_inv_rs.s01000(b5, b6, b7)
5239 case False{}:
5240 match b2:
5241 case True{}:
5242 match b3:
5243 case True{}:
5244 match b4:
5245 case True{}:
5246 mul_inv_rs.s00111(b5, b6, b7)
5247 case False{}:
5248 mul_inv_rs.s00110(b5, b6, b7)
5249 case False{}:
5250 match b4:
5251 case True{}:
5252 mul_inv_rs.s00101(b5, b6, b7)
5253 case False{}:
5254 mul_inv_rs.s00100(b5, b6, b7)
5255 case False{}:
5256 match b3:
5257 case True{}:
5258 match b4:
5259 case True{}:
5260 mul_inv_rs.s00011(b5, b6, b7)
5261 case False{}:
5262 mul_inv_rs.s00010(b5, b6, b7)
5263 case False{}:
5264 match b4:
5265 case True{}:
5266 mul_inv_rs.s00001(b5, b6, b7)
5267 case False{}:
5268 mul_inv_rs.s00000(b5, b6, b7)
5269
5270def mul_inv_rs.core(+a: U32) -> {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8.elt(a)), G.Gf8.inv(G.Gf8.rs(), fixz(G.Gf8.elt(a)))) == 1 : U32}:
5271 match a:
5272 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
5273 %Equal.sym(U32, G.Gf8.elt(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, WCon{b5, WCon{b6, WCon{b7, r}}}}}}}}}), G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}), elt_bits(b0, b1, b2, b3, b4, b5, b6, b7, r)) : {G.Gf8.mul(G.Gf8.rs(), fixz(_), G.Gf8.inv(G.Gf8.rs(), fixz(_))) == 1 : U32}
5274 mul_inv_rs.bits(b0, b1, b2, b3, b4, b5, b6, b7)
5275
5276def mul_inv_rs.lift(+a: U32, +nz: {G.Gf8.is_zero(a) == False{} : Bool}) -> {G.Gf8.mul(G.Gf8.rs(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.rs(), G.Gf8.elt(a))) == 1 : U32}:
5277 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.rs(), _, G.Gf8.inv(G.Gf8.rs(), G.Gf8.elt(a))) == 1 : U32}
5278 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8.elt(a)), G.Gf8.inv(G.Gf8.rs(), _)) == 1 : U32}
5279 mul_inv_rs.core(a)
5280
5281def Laws.mul_inv_rs(a, nz):
5282 Equal.trans(U32, G.Gf8.mul(G.Gf8.rs(), a, G.Gf8.inv(G.Gf8.rs(), a)), G.Gf8.mul(G.Gf8.rs(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.rs(), a)), 1, mul_elt_l(G.Gf8.rs(), a, G.Gf8.inv(G.Gf8.rs(), a)), Equal.trans(U32, G.Gf8.mul(G.Gf8.rs(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.rs(), a)), G.Gf8.mul(G.Gf8.rs(), G.Gf8.elt(a), G.Gf8.inv(G.Gf8.rs(), G.Gf8.elt(a))), 1, Equal.cong(U32, U32, z => G.Gf8.mul(G.Gf8.rs(), G.Gf8.elt(a), z), G.Gf8.inv(G.Gf8.rs(), a), G.Gf8.inv(G.Gf8.rs(), G.Gf8.elt(a)), pow_elt(254n, G.Gf8.rs(), a)), mul_inv_rs.lift(a, nz)))
5283
5284def exp_log_rs.s11111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
5285 match b5:
5286 case True{}:
5287 match b6:
5288 case True{}:
5289 match b7:
5290 case True{}:
5291 {==}
5292 case False{}:
5293 {==}
5294 case False{}:
5295 match b7:
5296 case True{}:
5297 {==}
5298 case False{}:
5299 {==}
5300 case False{}:
5301 match b6:
5302 case True{}:
5303 match b7:
5304 case True{}:
5305 {==}
5306 case False{}:
5307 {==}
5308 case False{}:
5309 match b7:
5310 case True{}:
5311 {==}
5312 case False{}:
5313 {==}
5314
5315def exp_log_rs.s11110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
5316 match b5:
5317 case True{}:
5318 match b6:
5319 case True{}:
5320 match b7:
5321 case True{}:
5322 {==}
5323 case False{}:
5324 {==}
5325 case False{}:
5326 match b7:
5327 case True{}:
5328 {==}
5329 case False{}:
5330 {==}
5331 case False{}:
5332 match b6:
5333 case True{}:
5334 match b7:
5335 case True{}:
5336 {==}
5337 case False{}:
5338 {==}
5339 case False{}:
5340 match b7:
5341 case True{}:
5342 {==}
5343 case False{}:
5344 {==}
5345
5346def exp_log_rs.s11101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
5347 match b5:
5348 case True{}:
5349 match b6:
5350 case True{}:
5351 match b7:
5352 case True{}:
5353 {==}
5354 case False{}:
5355 {==}
5356 case False{}:
5357 match b7:
5358 case True{}:
5359 {==}
5360 case False{}:
5361 {==}
5362 case False{}:
5363 match b6:
5364 case True{}:
5365 match b7:
5366 case True{}:
5367 {==}
5368 case False{}:
5369 {==}
5370 case False{}:
5371 match b7:
5372 case True{}:
5373 {==}
5374 case False{}:
5375 {==}
5376
5377def exp_log_rs.s11100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
5378 match b5:
5379 case True{}:
5380 match b6:
5381 case True{}:
5382 match b7:
5383 case True{}:
5384 {==}
5385 case False{}:
5386 {==}
5387 case False{}:
5388 match b7:
5389 case True{}:
5390 {==}
5391 case False{}:
5392 {==}
5393 case False{}:
5394 match b6:
5395 case True{}:
5396 match b7:
5397 case True{}:
5398 {==}
5399 case False{}:
5400 {==}
5401 case False{}:
5402 match b7:
5403 case True{}:
5404 {==}
5405 case False{}:
5406 {==}
5407
5408def exp_log_rs.s11011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
5409 match b5:
5410 case True{}:
5411 match b6:
5412 case True{}:
5413 match b7:
5414 case True{}:
5415 {==}
5416 case False{}:
5417 {==}
5418 case False{}:
5419 match b7:
5420 case True{}:
5421 {==}
5422 case False{}:
5423 {==}
5424 case False{}:
5425 match b6:
5426 case True{}:
5427 match b7:
5428 case True{}:
5429 {==}
5430 case False{}:
5431 {==}
5432 case False{}:
5433 match b7:
5434 case True{}:
5435 {==}
5436 case False{}:
5437 {==}
5438
5439def exp_log_rs.s11010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
5440 match b5:
5441 case True{}:
5442 match b6:
5443 case True{}:
5444 match b7:
5445 case True{}:
5446 {==}
5447 case False{}:
5448 {==}
5449 case False{}:
5450 match b7:
5451 case True{}:
5452 {==}
5453 case False{}:
5454 {==}
5455 case False{}:
5456 match b6:
5457 case True{}:
5458 match b7:
5459 case True{}:
5460 {==}
5461 case False{}:
5462 {==}
5463 case False{}:
5464 match b7:
5465 case True{}:
5466 {==}
5467 case False{}:
5468 {==}
5469
5470def exp_log_rs.s11001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
5471 match b5:
5472 case True{}:
5473 match b6:
5474 case True{}:
5475 match b7:
5476 case True{}:
5477 {==}
5478 case False{}:
5479 {==}
5480 case False{}:
5481 match b7:
5482 case True{}:
5483 {==}
5484 case False{}:
5485 {==}
5486 case False{}:
5487 match b6:
5488 case True{}:
5489 match b7:
5490 case True{}:
5491 {==}
5492 case False{}:
5493 {==}
5494 case False{}:
5495 match b7:
5496 case True{}:
5497 {==}
5498 case False{}:
5499 {==}
5500
5501def exp_log_rs.s11000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, True{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
5502 match b5:
5503 case True{}:
5504 match b6:
5505 case True{}:
5506 match b7:
5507 case True{}:
5508 {==}
5509 case False{}:
5510 {==}
5511 case False{}:
5512 match b7:
5513 case True{}:
5514 {==}
5515 case False{}:
5516 {==}
5517 case False{}:
5518 match b6:
5519 case True{}:
5520 match b7:
5521 case True{}:
5522 {==}
5523 case False{}:
5524 {==}
5525 case False{}:
5526 match b7:
5527 case True{}:
5528 {==}
5529 case False{}:
5530 {==}
5531
5532def exp_log_rs.s10111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
5533 match b5:
5534 case True{}:
5535 match b6:
5536 case True{}:
5537 match b7:
5538 case True{}:
5539 {==}
5540 case False{}:
5541 {==}
5542 case False{}:
5543 match b7:
5544 case True{}:
5545 {==}
5546 case False{}:
5547 {==}
5548 case False{}:
5549 match b6:
5550 case True{}:
5551 match b7:
5552 case True{}:
5553 {==}
5554 case False{}:
5555 {==}
5556 case False{}:
5557 match b7:
5558 case True{}:
5559 {==}
5560 case False{}:
5561 {==}
5562
5563def exp_log_rs.s10110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
5564 match b5:
5565 case True{}:
5566 match b6:
5567 case True{}:
5568 match b7:
5569 case True{}:
5570 {==}
5571 case False{}:
5572 {==}
5573 case False{}:
5574 match b7:
5575 case True{}:
5576 {==}
5577 case False{}:
5578 {==}
5579 case False{}:
5580 match b6:
5581 case True{}:
5582 match b7:
5583 case True{}:
5584 {==}
5585 case False{}:
5586 {==}
5587 case False{}:
5588 match b7:
5589 case True{}:
5590 {==}
5591 case False{}:
5592 {==}
5593
5594def exp_log_rs.s10101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
5595 match b5:
5596 case True{}:
5597 match b6:
5598 case True{}:
5599 match b7:
5600 case True{}:
5601 {==}
5602 case False{}:
5603 {==}
5604 case False{}:
5605 match b7:
5606 case True{}:
5607 {==}
5608 case False{}:
5609 {==}
5610 case False{}:
5611 match b6:
5612 case True{}:
5613 match b7:
5614 case True{}:
5615 {==}
5616 case False{}:
5617 {==}
5618 case False{}:
5619 match b7:
5620 case True{}:
5621 {==}
5622 case False{}:
5623 {==}
5624
5625def exp_log_rs.s10100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
5626 match b5:
5627 case True{}:
5628 match b6:
5629 case True{}:
5630 match b7:
5631 case True{}:
5632 {==}
5633 case False{}:
5634 {==}
5635 case False{}:
5636 match b7:
5637 case True{}:
5638 {==}
5639 case False{}:
5640 {==}
5641 case False{}:
5642 match b6:
5643 case True{}:
5644 match b7:
5645 case True{}:
5646 {==}
5647 case False{}:
5648 {==}
5649 case False{}:
5650 match b7:
5651 case True{}:
5652 {==}
5653 case False{}:
5654 {==}
5655
5656def exp_log_rs.s10011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
5657 match b5:
5658 case True{}:
5659 match b6:
5660 case True{}:
5661 match b7:
5662 case True{}:
5663 {==}
5664 case False{}:
5665 {==}
5666 case False{}:
5667 match b7:
5668 case True{}:
5669 {==}
5670 case False{}:
5671 {==}
5672 case False{}:
5673 match b6:
5674 case True{}:
5675 match b7:
5676 case True{}:
5677 {==}
5678 case False{}:
5679 {==}
5680 case False{}:
5681 match b7:
5682 case True{}:
5683 {==}
5684 case False{}:
5685 {==}
5686
5687def exp_log_rs.s10010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
5688 match b5:
5689 case True{}:
5690 match b6:
5691 case True{}:
5692 match b7:
5693 case True{}:
5694 {==}
5695 case False{}:
5696 {==}
5697 case False{}:
5698 match b7:
5699 case True{}:
5700 {==}
5701 case False{}:
5702 {==}
5703 case False{}:
5704 match b6:
5705 case True{}:
5706 match b7:
5707 case True{}:
5708 {==}
5709 case False{}:
5710 {==}
5711 case False{}:
5712 match b7:
5713 case True{}:
5714 {==}
5715 case False{}:
5716 {==}
5717
5718def exp_log_rs.s10001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
5719 match b5:
5720 case True{}:
5721 match b6:
5722 case True{}:
5723 match b7:
5724 case True{}:
5725 {==}
5726 case False{}:
5727 {==}
5728 case False{}:
5729 match b7:
5730 case True{}:
5731 {==}
5732 case False{}:
5733 {==}
5734 case False{}:
5735 match b6:
5736 case True{}:
5737 match b7:
5738 case True{}:
5739 {==}
5740 case False{}:
5741 {==}
5742 case False{}:
5743 match b7:
5744 case True{}:
5745 {==}
5746 case False{}:
5747 {==}
5748
5749def exp_log_rs.s10000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{True{}, False{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
5750 match b5:
5751 case True{}:
5752 match b6:
5753 case True{}:
5754 match b7:
5755 case True{}:
5756 {==}
5757 case False{}:
5758 {==}
5759 case False{}:
5760 match b7:
5761 case True{}:
5762 {==}
5763 case False{}:
5764 {==}
5765 case False{}:
5766 match b6:
5767 case True{}:
5768 match b7:
5769 case True{}:
5770 {==}
5771 case False{}:
5772 {==}
5773 case False{}:
5774 match b7:
5775 case True{}:
5776 {==}
5777 case False{}:
5778 {==}
5779
5780def exp_log_rs.s01111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
5781 match b5:
5782 case True{}:
5783 match b6:
5784 case True{}:
5785 match b7:
5786 case True{}:
5787 {==}
5788 case False{}:
5789 {==}
5790 case False{}:
5791 match b7:
5792 case True{}:
5793 {==}
5794 case False{}:
5795 {==}
5796 case False{}:
5797 match b6:
5798 case True{}:
5799 match b7:
5800 case True{}:
5801 {==}
5802 case False{}:
5803 {==}
5804 case False{}:
5805 match b7:
5806 case True{}:
5807 {==}
5808 case False{}:
5809 {==}
5810
5811def exp_log_rs.s01110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
5812 match b5:
5813 case True{}:
5814 match b6:
5815 case True{}:
5816 match b7:
5817 case True{}:
5818 {==}
5819 case False{}:
5820 {==}
5821 case False{}:
5822 match b7:
5823 case True{}:
5824 {==}
5825 case False{}:
5826 {==}
5827 case False{}:
5828 match b6:
5829 case True{}:
5830 match b7:
5831 case True{}:
5832 {==}
5833 case False{}:
5834 {==}
5835 case False{}:
5836 match b7:
5837 case True{}:
5838 {==}
5839 case False{}:
5840 {==}
5841
5842def exp_log_rs.s01101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
5843 match b5:
5844 case True{}:
5845 match b6:
5846 case True{}:
5847 match b7:
5848 case True{}:
5849 {==}
5850 case False{}:
5851 {==}
5852 case False{}:
5853 match b7:
5854 case True{}:
5855 {==}
5856 case False{}:
5857 {==}
5858 case False{}:
5859 match b6:
5860 case True{}:
5861 match b7:
5862 case True{}:
5863 {==}
5864 case False{}:
5865 {==}
5866 case False{}:
5867 match b7:
5868 case True{}:
5869 {==}
5870 case False{}:
5871 {==}
5872
5873def exp_log_rs.s01100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
5874 match b5:
5875 case True{}:
5876 match b6:
5877 case True{}:
5878 match b7:
5879 case True{}:
5880 {==}
5881 case False{}:
5882 {==}
5883 case False{}:
5884 match b7:
5885 case True{}:
5886 {==}
5887 case False{}:
5888 {==}
5889 case False{}:
5890 match b6:
5891 case True{}:
5892 match b7:
5893 case True{}:
5894 {==}
5895 case False{}:
5896 {==}
5897 case False{}:
5898 match b7:
5899 case True{}:
5900 {==}
5901 case False{}:
5902 {==}
5903
5904def exp_log_rs.s01011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
5905 match b5:
5906 case True{}:
5907 match b6:
5908 case True{}:
5909 match b7:
5910 case True{}:
5911 {==}
5912 case False{}:
5913 {==}
5914 case False{}:
5915 match b7:
5916 case True{}:
5917 {==}
5918 case False{}:
5919 {==}
5920 case False{}:
5921 match b6:
5922 case True{}:
5923 match b7:
5924 case True{}:
5925 {==}
5926 case False{}:
5927 {==}
5928 case False{}:
5929 match b7:
5930 case True{}:
5931 {==}
5932 case False{}:
5933 {==}
5934
5935def exp_log_rs.s01010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
5936 match b5:
5937 case True{}:
5938 match b6:
5939 case True{}:
5940 match b7:
5941 case True{}:
5942 {==}
5943 case False{}:
5944 {==}
5945 case False{}:
5946 match b7:
5947 case True{}:
5948 {==}
5949 case False{}:
5950 {==}
5951 case False{}:
5952 match b6:
5953 case True{}:
5954 match b7:
5955 case True{}:
5956 {==}
5957 case False{}:
5958 {==}
5959 case False{}:
5960 match b7:
5961 case True{}:
5962 {==}
5963 case False{}:
5964 {==}
5965
5966def exp_log_rs.s01001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
5967 match b5:
5968 case True{}:
5969 match b6:
5970 case True{}:
5971 match b7:
5972 case True{}:
5973 {==}
5974 case False{}:
5975 {==}
5976 case False{}:
5977 match b7:
5978 case True{}:
5979 {==}
5980 case False{}:
5981 {==}
5982 case False{}:
5983 match b6:
5984 case True{}:
5985 match b7:
5986 case True{}:
5987 {==}
5988 case False{}:
5989 {==}
5990 case False{}:
5991 match b7:
5992 case True{}:
5993 {==}
5994 case False{}:
5995 {==}
5996
5997def exp_log_rs.s01000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, True{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
5998 match b5:
5999 case True{}:
6000 match b6:
6001 case True{}:
6002 match b7:
6003 case True{}:
6004 {==}
6005 case False{}:
6006 {==}
6007 case False{}:
6008 match b7:
6009 case True{}:
6010 {==}
6011 case False{}:
6012 {==}
6013 case False{}:
6014 match b6:
6015 case True{}:
6016 match b7:
6017 case True{}:
6018 {==}
6019 case False{}:
6020 {==}
6021 case False{}:
6022 match b7:
6023 case True{}:
6024 {==}
6025 case False{}:
6026 {==}
6027
6028def exp_log_rs.s00111(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, True{}, b5, b6, b7})) : U32}:
6029 match b5:
6030 case True{}:
6031 match b6:
6032 case True{}:
6033 match b7:
6034 case True{}:
6035 {==}
6036 case False{}:
6037 {==}
6038 case False{}:
6039 match b7:
6040 case True{}:
6041 {==}
6042 case False{}:
6043 {==}
6044 case False{}:
6045 match b6:
6046 case True{}:
6047 match b7:
6048 case True{}:
6049 {==}
6050 case False{}:
6051 {==}
6052 case False{}:
6053 match b7:
6054 case True{}:
6055 {==}
6056 case False{}:
6057 {==}
6058
6059def exp_log_rs.s00110(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, True{}, False{}, b5, b6, b7})) : U32}:
6060 match b5:
6061 case True{}:
6062 match b6:
6063 case True{}:
6064 match b7:
6065 case True{}:
6066 {==}
6067 case False{}:
6068 {==}
6069 case False{}:
6070 match b7:
6071 case True{}:
6072 {==}
6073 case False{}:
6074 {==}
6075 case False{}:
6076 match b6:
6077 case True{}:
6078 match b7:
6079 case True{}:
6080 {==}
6081 case False{}:
6082 {==}
6083 case False{}:
6084 match b7:
6085 case True{}:
6086 {==}
6087 case False{}:
6088 {==}
6089
6090def exp_log_rs.s00101(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, True{}, b5, b6, b7})) : U32}:
6091 match b5:
6092 case True{}:
6093 match b6:
6094 case True{}:
6095 match b7:
6096 case True{}:
6097 {==}
6098 case False{}:
6099 {==}
6100 case False{}:
6101 match b7:
6102 case True{}:
6103 {==}
6104 case False{}:
6105 {==}
6106 case False{}:
6107 match b6:
6108 case True{}:
6109 match b7:
6110 case True{}:
6111 {==}
6112 case False{}:
6113 {==}
6114 case False{}:
6115 match b7:
6116 case True{}:
6117 {==}
6118 case False{}:
6119 {==}
6120
6121def exp_log_rs.s00100(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, True{}, False{}, False{}, b5, b6, b7})) : U32}:
6122 match b5:
6123 case True{}:
6124 match b6:
6125 case True{}:
6126 match b7:
6127 case True{}:
6128 {==}
6129 case False{}:
6130 {==}
6131 case False{}:
6132 match b7:
6133 case True{}:
6134 {==}
6135 case False{}:
6136 {==}
6137 case False{}:
6138 match b6:
6139 case True{}:
6140 match b7:
6141 case True{}:
6142 {==}
6143 case False{}:
6144 {==}
6145 case False{}:
6146 match b7:
6147 case True{}:
6148 {==}
6149 case False{}:
6150 {==}
6151
6152def exp_log_rs.s00011(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, True{}, b5, b6, b7})) : U32}:
6153 match b5:
6154 case True{}:
6155 match b6:
6156 case True{}:
6157 match b7:
6158 case True{}:
6159 {==}
6160 case False{}:
6161 {==}
6162 case False{}:
6163 match b7:
6164 case True{}:
6165 {==}
6166 case False{}:
6167 {==}
6168 case False{}:
6169 match b6:
6170 case True{}:
6171 match b7:
6172 case True{}:
6173 {==}
6174 case False{}:
6175 {==}
6176 case False{}:
6177 match b7:
6178 case True{}:
6179 {==}
6180 case False{}:
6181 {==}
6182
6183def exp_log_rs.s00010(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, True{}, False{}, b5, b6, b7})) : U32}:
6184 match b5:
6185 case True{}:
6186 match b6:
6187 case True{}:
6188 match b7:
6189 case True{}:
6190 {==}
6191 case False{}:
6192 {==}
6193 case False{}:
6194 match b7:
6195 case True{}:
6196 {==}
6197 case False{}:
6198 {==}
6199 case False{}:
6200 match b6:
6201 case True{}:
6202 match b7:
6203 case True{}:
6204 {==}
6205 case False{}:
6206 {==}
6207 case False{}:
6208 match b7:
6209 case True{}:
6210 {==}
6211 case False{}:
6212 {==}
6213
6214def exp_log_rs.s00001(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, True{}, b5, b6, b7})) : U32}:
6215 match b5:
6216 case True{}:
6217 match b6:
6218 case True{}:
6219 match b7:
6220 case True{}:
6221 {==}
6222 case False{}:
6223 {==}
6224 case False{}:
6225 match b7:
6226 case True{}:
6227 {==}
6228 case False{}:
6229 {==}
6230 case False{}:
6231 match b6:
6232 case True{}:
6233 match b7:
6234 case True{}:
6235 {==}
6236 case False{}:
6237 {==}
6238 case False{}:
6239 match b7:
6240 case True{}:
6241 {==}
6242 case False{}:
6243 {==}
6244
6245def exp_log_rs.s00000(+b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{False{}, False{}, False{}, False{}, False{}, b5, b6, b7})) : U32}:
6246 match b5:
6247 case True{}:
6248 match b6:
6249 case True{}:
6250 match b7:
6251 case True{}:
6252 {==}
6253 case False{}:
6254 {==}
6255 case False{}:
6256 match b7:
6257 case True{}:
6258 {==}
6259 case False{}:
6260 {==}
6261 case False{}:
6262 match b6:
6263 case True{}:
6264 match b7:
6265 case True{}:
6266 {==}
6267 case False{}:
6268 {==}
6269 case False{}:
6270 match b7:
6271 case True{}:
6272 {==}
6273 case False{}:
6274 {==}
6275
6276def exp_log_rs.bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool, +b5: Bool, +b6: Bool, +b7: Bool) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})))) == fixz(G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7})) : U32}:
6277 match b0:
6278 case True{}:
6279 match b1:
6280 case True{}:
6281 match b2:
6282 case True{}:
6283 match b3:
6284 case True{}:
6285 match b4:
6286 case True{}:
6287 exp_log_rs.s11111(b5, b6, b7)
6288 case False{}:
6289 exp_log_rs.s11110(b5, b6, b7)
6290 case False{}:
6291 match b4:
6292 case True{}:
6293 exp_log_rs.s11101(b5, b6, b7)
6294 case False{}:
6295 exp_log_rs.s11100(b5, b6, b7)
6296 case False{}:
6297 match b3:
6298 case True{}:
6299 match b4:
6300 case True{}:
6301 exp_log_rs.s11011(b5, b6, b7)
6302 case False{}:
6303 exp_log_rs.s11010(b5, b6, b7)
6304 case False{}:
6305 match b4:
6306 case True{}:
6307 exp_log_rs.s11001(b5, b6, b7)
6308 case False{}:
6309 exp_log_rs.s11000(b5, b6, b7)
6310 case False{}:
6311 match b2:
6312 case True{}:
6313 match b3:
6314 case True{}:
6315 match b4:
6316 case True{}:
6317 exp_log_rs.s10111(b5, b6, b7)
6318 case False{}:
6319 exp_log_rs.s10110(b5, b6, b7)
6320 case False{}:
6321 match b4:
6322 case True{}:
6323 exp_log_rs.s10101(b5, b6, b7)
6324 case False{}:
6325 exp_log_rs.s10100(b5, b6, b7)
6326 case False{}:
6327 match b3:
6328 case True{}:
6329 match b4:
6330 case True{}:
6331 exp_log_rs.s10011(b5, b6, b7)
6332 case False{}:
6333 exp_log_rs.s10010(b5, b6, b7)
6334 case False{}:
6335 match b4:
6336 case True{}:
6337 exp_log_rs.s10001(b5, b6, b7)
6338 case False{}:
6339 exp_log_rs.s10000(b5, b6, b7)
6340 case False{}:
6341 match b1:
6342 case True{}:
6343 match b2:
6344 case True{}:
6345 match b3:
6346 case True{}:
6347 match b4:
6348 case True{}:
6349 exp_log_rs.s01111(b5, b6, b7)
6350 case False{}:
6351 exp_log_rs.s01110(b5, b6, b7)
6352 case False{}:
6353 match b4:
6354 case True{}:
6355 exp_log_rs.s01101(b5, b6, b7)
6356 case False{}:
6357 exp_log_rs.s01100(b5, b6, b7)
6358 case False{}:
6359 match b3:
6360 case True{}:
6361 match b4:
6362 case True{}:
6363 exp_log_rs.s01011(b5, b6, b7)
6364 case False{}:
6365 exp_log_rs.s01010(b5, b6, b7)
6366 case False{}:
6367 match b4:
6368 case True{}:
6369 exp_log_rs.s01001(b5, b6, b7)
6370 case False{}:
6371 exp_log_rs.s01000(b5, b6, b7)
6372 case False{}:
6373 match b2:
6374 case True{}:
6375 match b3:
6376 case True{}:
6377 match b4:
6378 case True{}:
6379 exp_log_rs.s00111(b5, b6, b7)
6380 case False{}:
6381 exp_log_rs.s00110(b5, b6, b7)
6382 case False{}:
6383 match b4:
6384 case True{}:
6385 exp_log_rs.s00101(b5, b6, b7)
6386 case False{}:
6387 exp_log_rs.s00100(b5, b6, b7)
6388 case False{}:
6389 match b3:
6390 case True{}:
6391 match b4:
6392 case True{}:
6393 exp_log_rs.s00011(b5, b6, b7)
6394 case False{}:
6395 exp_log_rs.s00010(b5, b6, b7)
6396 case False{}:
6397 match b4:
6398 case True{}:
6399 exp_log_rs.s00001(b5, b6, b7)
6400 case False{}:
6401 exp_log_rs.s00000(b5, b6, b7)
6402
6403def exp_log_rs.core(+a: U32) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8.elt(a)))) == fixz(G.Gf8.elt(a)) : U32}:
6404 match a:
6405 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
6406 %Equal.sym(U32, G.Gf8.elt(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, WCon{b5, WCon{b6, WCon{b7, r}}}}}}}}}), G.Gf8Bits.to(G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}), elt_bits(b0, b1, b2, b3, b4, b5, b6, b7, r)) : {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(_))) == fixz(_) : U32}
6407 exp_log_rs.bits(b0, b1, b2, b3, b4, b5, b6, b7)
6408
6409def exp_log_rs.lift(+a: U32, +nz: {G.Gf8.is_zero(a) == False{} : Bool}) -> {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), G.Gf8.elt(a))) == G.Gf8.elt(a) : U32}:
6410 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), _)) == G.Gf8.elt(a) : U32}
6411 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8.elt(a)))) == _ : U32}
6412 exp_log_rs.core(a)
6413
6414def Laws.exp_log_rs(a, nz):
6415 Equal.trans(U32, G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), a)), G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), G.Gf8.elt(a))), G.Gf8.elt(a), Equal.cong(Nat, U32, z => G.Gf8.exp(G.Gf8.rs(), z), G.Gf8.log(G.Gf8.rs(), a), G.Gf8.log(G.Gf8.rs(), G.Gf8.elt(a)), log_elt(G.Gf8.rs(), a)), exp_log_rs.lift(a, nz))
6416
6417# vectors, by computation
6418def Laws.v_aes_mul():
6419 {==}
6420
6421def Laws.v_aes_mul13():
6422 {==}
6423
6424def Laws.v_aes_xtime():
6425 {==}
6426
6427def Laws.v_aes_inv():
6428 {==}
6429
6430def Laws.v_rs_x8():
6431 {==}
6432
6433def Laws.v_rs_order():
6434 {==}
6435
6436def Laws.v_div():
6437 {==}
6438
6439def Laws.v_tab_mul_aes():
6440 {==}
6441
6442def Laws.v_tab_inv_aes():
6443 {==}
6444
6445def Laws.v_tab_mul_rs():
6446 {==}
6447
6448def Laws.v_tab_zero():
6449 {==}
6450
6451# 7. GF(2^m): addition commutes (XOR, bit by bit); for the small named
6452# fields, products and inverses by cases on the element's m bits
6453
6454def Laws.gfm_add_comm(f, a, b):
6455 Equal.cong(U32, U32, z => U32.and(M.Gfm.mask(f), z), U32.xor(a, b), U32.xor(b, a), UL.u32_xor_comm(a, b))
6456
6457def word_and_zero(+n: Nat, +r: Word(n)) -> {Word.and(n, Word.zero(n), r) == Word.zero(n) : Word(n)}:
6458 match n:
6459 case 0n:
6460 {==}
6461 case 1n+p:
6462 match r:
6463 case WCon{+x, +rt}:
6464 %word_and_zero(p, rt) : {WCon{False{}, Word.and(p, Word.zero(p), rt)} == WCon{False{}, _} : Word(1n+p)}
6465 {==}
6466
6467def elt_bits4(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +r: Word(28n)) -> {M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, r}}}}}) == U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}} : U32}:
6468 Equal.cong(Word(28n), U32, z => U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, z}}}}}, Word.and(28n, Word.zero(28n), r), Word.zero(28n), word_and_zero(28n, r))
6469
6470def elt_bits5(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool, +r: Word(27n)) -> {M.Gfm.elt(M.Gfm.gf32(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, r}}}}}}) == U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}} : U32}:
6471 Equal.cong(Word(27n), U32, z => U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, z}}}}}}, Word.and(27n, Word.zero(27n), r), Word.zero(27n), word_and_zero(27n, r))
6472
6473def comm16.s1111(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{True{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{True{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
6474 match b0:
6475 case True{}:
6476 match b1:
6477 case True{}:
6478 match b2:
6479 case True{}:
6480 match b3:
6481 case True{}:
6482 {==}
6483 case False{}:
6484 {==}
6485 case False{}:
6486 match b3:
6487 case True{}:
6488 {==}
6489 case False{}:
6490 {==}
6491 case False{}:
6492 match b2:
6493 case True{}:
6494 match b3:
6495 case True{}:
6496 {==}
6497 case False{}:
6498 {==}
6499 case False{}:
6500 match b3:
6501 case True{}:
6502 {==}
6503 case False{}:
6504 {==}
6505 case False{}:
6506 match b1:
6507 case True{}:
6508 match b2:
6509 case True{}:
6510 match b3:
6511 case True{}:
6512 {==}
6513 case False{}:
6514 {==}
6515 case False{}:
6516 match b3:
6517 case True{}:
6518 {==}
6519 case False{}:
6520 {==}
6521 case False{}:
6522 match b2:
6523 case True{}:
6524 match b3:
6525 case True{}:
6526 {==}
6527 case False{}:
6528 {==}
6529 case False{}:
6530 match b3:
6531 case True{}:
6532 {==}
6533 case False{}:
6534 {==}
6535
6536def comm16.s1110(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{True{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{True{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
6537 match b0:
6538 case True{}:
6539 match b1:
6540 case True{}:
6541 match b2:
6542 case True{}:
6543 match b3:
6544 case True{}:
6545 {==}
6546 case False{}:
6547 {==}
6548 case False{}:
6549 match b3:
6550 case True{}:
6551 {==}
6552 case False{}:
6553 {==}
6554 case False{}:
6555 match b2:
6556 case True{}:
6557 match b3:
6558 case True{}:
6559 {==}
6560 case False{}:
6561 {==}
6562 case False{}:
6563 match b3:
6564 case True{}:
6565 {==}
6566 case False{}:
6567 {==}
6568 case False{}:
6569 match b1:
6570 case True{}:
6571 match b2:
6572 case True{}:
6573 match b3:
6574 case True{}:
6575 {==}
6576 case False{}:
6577 {==}
6578 case False{}:
6579 match b3:
6580 case True{}:
6581 {==}
6582 case False{}:
6583 {==}
6584 case False{}:
6585 match b2:
6586 case True{}:
6587 match b3:
6588 case True{}:
6589 {==}
6590 case False{}:
6591 {==}
6592 case False{}:
6593 match b3:
6594 case True{}:
6595 {==}
6596 case False{}:
6597 {==}
6598
6599def comm16.s1101(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{True{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{True{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
6600 match b0:
6601 case True{}:
6602 match b1:
6603 case True{}:
6604 match b2:
6605 case True{}:
6606 match b3:
6607 case True{}:
6608 {==}
6609 case False{}:
6610 {==}
6611 case False{}:
6612 match b3:
6613 case True{}:
6614 {==}
6615 case False{}:
6616 {==}
6617 case False{}:
6618 match b2:
6619 case True{}:
6620 match b3:
6621 case True{}:
6622 {==}
6623 case False{}:
6624 {==}
6625 case False{}:
6626 match b3:
6627 case True{}:
6628 {==}
6629 case False{}:
6630 {==}
6631 case False{}:
6632 match b1:
6633 case True{}:
6634 match b2:
6635 case True{}:
6636 match b3:
6637 case True{}:
6638 {==}
6639 case False{}:
6640 {==}
6641 case False{}:
6642 match b3:
6643 case True{}:
6644 {==}
6645 case False{}:
6646 {==}
6647 case False{}:
6648 match b2:
6649 case True{}:
6650 match b3:
6651 case True{}:
6652 {==}
6653 case False{}:
6654 {==}
6655 case False{}:
6656 match b3:
6657 case True{}:
6658 {==}
6659 case False{}:
6660 {==}
6661
6662def comm16.s1100(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{True{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{True{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
6663 match b0:
6664 case True{}:
6665 match b1:
6666 case True{}:
6667 match b2:
6668 case True{}:
6669 match b3:
6670 case True{}:
6671 {==}
6672 case False{}:
6673 {==}
6674 case False{}:
6675 match b3:
6676 case True{}:
6677 {==}
6678 case False{}:
6679 {==}
6680 case False{}:
6681 match b2:
6682 case True{}:
6683 match b3:
6684 case True{}:
6685 {==}
6686 case False{}:
6687 {==}
6688 case False{}:
6689 match b3:
6690 case True{}:
6691 {==}
6692 case False{}:
6693 {==}
6694 case False{}:
6695 match b1:
6696 case True{}:
6697 match b2:
6698 case True{}:
6699 match b3:
6700 case True{}:
6701 {==}
6702 case False{}:
6703 {==}
6704 case False{}:
6705 match b3:
6706 case True{}:
6707 {==}
6708 case False{}:
6709 {==}
6710 case False{}:
6711 match b2:
6712 case True{}:
6713 match b3:
6714 case True{}:
6715 {==}
6716 case False{}:
6717 {==}
6718 case False{}:
6719 match b3:
6720 case True{}:
6721 {==}
6722 case False{}:
6723 {==}
6724
6725def comm16.s1011(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{False{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{False{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
6726 match b0:
6727 case True{}:
6728 match b1:
6729 case True{}:
6730 match b2:
6731 case True{}:
6732 match b3:
6733 case True{}:
6734 {==}
6735 case False{}:
6736 {==}
6737 case False{}:
6738 match b3:
6739 case True{}:
6740 {==}
6741 case False{}:
6742 {==}
6743 case False{}:
6744 match b2:
6745 case True{}:
6746 match b3:
6747 case True{}:
6748 {==}
6749 case False{}:
6750 {==}
6751 case False{}:
6752 match b3:
6753 case True{}:
6754 {==}
6755 case False{}:
6756 {==}
6757 case False{}:
6758 match b1:
6759 case True{}:
6760 match b2:
6761 case True{}:
6762 match b3:
6763 case True{}:
6764 {==}
6765 case False{}:
6766 {==}
6767 case False{}:
6768 match b3:
6769 case True{}:
6770 {==}
6771 case False{}:
6772 {==}
6773 case False{}:
6774 match b2:
6775 case True{}:
6776 match b3:
6777 case True{}:
6778 {==}
6779 case False{}:
6780 {==}
6781 case False{}:
6782 match b3:
6783 case True{}:
6784 {==}
6785 case False{}:
6786 {==}
6787
6788def comm16.s1010(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{False{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{False{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
6789 match b0:
6790 case True{}:
6791 match b1:
6792 case True{}:
6793 match b2:
6794 case True{}:
6795 match b3:
6796 case True{}:
6797 {==}
6798 case False{}:
6799 {==}
6800 case False{}:
6801 match b3:
6802 case True{}:
6803 {==}
6804 case False{}:
6805 {==}
6806 case False{}:
6807 match b2:
6808 case True{}:
6809 match b3:
6810 case True{}:
6811 {==}
6812 case False{}:
6813 {==}
6814 case False{}:
6815 match b3:
6816 case True{}:
6817 {==}
6818 case False{}:
6819 {==}
6820 case False{}:
6821 match b1:
6822 case True{}:
6823 match b2:
6824 case True{}:
6825 match b3:
6826 case True{}:
6827 {==}
6828 case False{}:
6829 {==}
6830 case False{}:
6831 match b3:
6832 case True{}:
6833 {==}
6834 case False{}:
6835 {==}
6836 case False{}:
6837 match b2:
6838 case True{}:
6839 match b3:
6840 case True{}:
6841 {==}
6842 case False{}:
6843 {==}
6844 case False{}:
6845 match b3:
6846 case True{}:
6847 {==}
6848 case False{}:
6849 {==}
6850
6851def comm16.s1001(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{False{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{False{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
6852 match b0:
6853 case True{}:
6854 match b1:
6855 case True{}:
6856 match b2:
6857 case True{}:
6858 match b3:
6859 case True{}:
6860 {==}
6861 case False{}:
6862 {==}
6863 case False{}:
6864 match b3:
6865 case True{}:
6866 {==}
6867 case False{}:
6868 {==}
6869 case False{}:
6870 match b2:
6871 case True{}:
6872 match b3:
6873 case True{}:
6874 {==}
6875 case False{}:
6876 {==}
6877 case False{}:
6878 match b3:
6879 case True{}:
6880 {==}
6881 case False{}:
6882 {==}
6883 case False{}:
6884 match b1:
6885 case True{}:
6886 match b2:
6887 case True{}:
6888 match b3:
6889 case True{}:
6890 {==}
6891 case False{}:
6892 {==}
6893 case False{}:
6894 match b3:
6895 case True{}:
6896 {==}
6897 case False{}:
6898 {==}
6899 case False{}:
6900 match b2:
6901 case True{}:
6902 match b3:
6903 case True{}:
6904 {==}
6905 case False{}:
6906 {==}
6907 case False{}:
6908 match b3:
6909 case True{}:
6910 {==}
6911 case False{}:
6912 {==}
6913
6914def comm16.s1000(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{True{}, WCon{False{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{True{}, WCon{False{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
6915 match b0:
6916 case True{}:
6917 match b1:
6918 case True{}:
6919 match b2:
6920 case True{}:
6921 match b3:
6922 case True{}:
6923 {==}
6924 case False{}:
6925 {==}
6926 case False{}:
6927 match b3:
6928 case True{}:
6929 {==}
6930 case False{}:
6931 {==}
6932 case False{}:
6933 match b2:
6934 case True{}:
6935 match b3:
6936 case True{}:
6937 {==}
6938 case False{}:
6939 {==}
6940 case False{}:
6941 match b3:
6942 case True{}:
6943 {==}
6944 case False{}:
6945 {==}
6946 case False{}:
6947 match b1:
6948 case True{}:
6949 match b2:
6950 case True{}:
6951 match b3:
6952 case True{}:
6953 {==}
6954 case False{}:
6955 {==}
6956 case False{}:
6957 match b3:
6958 case True{}:
6959 {==}
6960 case False{}:
6961 {==}
6962 case False{}:
6963 match b2:
6964 case True{}:
6965 match b3:
6966 case True{}:
6967 {==}
6968 case False{}:
6969 {==}
6970 case False{}:
6971 match b3:
6972 case True{}:
6973 {==}
6974 case False{}:
6975 {==}
6976
6977def comm16.s0111(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{True{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{True{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
6978 match b0:
6979 case True{}:
6980 match b1:
6981 case True{}:
6982 match b2:
6983 case True{}:
6984 match b3:
6985 case True{}:
6986 {==}
6987 case False{}:
6988 {==}
6989 case False{}:
6990 match b3:
6991 case True{}:
6992 {==}
6993 case False{}:
6994 {==}
6995 case False{}:
6996 match b2:
6997 case True{}:
6998 match b3:
6999 case True{}:
7000 {==}
7001 case False{}:
7002 {==}
7003 case False{}:
7004 match b3:
7005 case True{}:
7006 {==}
7007 case False{}:
7008 {==}
7009 case False{}:
7010 match b1:
7011 case True{}:
7012 match b2:
7013 case True{}:
7014 match b3:
7015 case True{}:
7016 {==}
7017 case False{}:
7018 {==}
7019 case False{}:
7020 match b3:
7021 case True{}:
7022 {==}
7023 case False{}:
7024 {==}
7025 case False{}:
7026 match b2:
7027 case True{}:
7028 match b3:
7029 case True{}:
7030 {==}
7031 case False{}:
7032 {==}
7033 case False{}:
7034 match b3:
7035 case True{}:
7036 {==}
7037 case False{}:
7038 {==}
7039
7040def comm16.s0110(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{True{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{True{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
7041 match b0:
7042 case True{}:
7043 match b1:
7044 case True{}:
7045 match b2:
7046 case True{}:
7047 match b3:
7048 case True{}:
7049 {==}
7050 case False{}:
7051 {==}
7052 case False{}:
7053 match b3:
7054 case True{}:
7055 {==}
7056 case False{}:
7057 {==}
7058 case False{}:
7059 match b2:
7060 case True{}:
7061 match b3:
7062 case True{}:
7063 {==}
7064 case False{}:
7065 {==}
7066 case False{}:
7067 match b3:
7068 case True{}:
7069 {==}
7070 case False{}:
7071 {==}
7072 case False{}:
7073 match b1:
7074 case True{}:
7075 match b2:
7076 case True{}:
7077 match b3:
7078 case True{}:
7079 {==}
7080 case False{}:
7081 {==}
7082 case False{}:
7083 match b3:
7084 case True{}:
7085 {==}
7086 case False{}:
7087 {==}
7088 case False{}:
7089 match b2:
7090 case True{}:
7091 match b3:
7092 case True{}:
7093 {==}
7094 case False{}:
7095 {==}
7096 case False{}:
7097 match b3:
7098 case True{}:
7099 {==}
7100 case False{}:
7101 {==}
7102
7103def comm16.s0101(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{True{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{True{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
7104 match b0:
7105 case True{}:
7106 match b1:
7107 case True{}:
7108 match b2:
7109 case True{}:
7110 match b3:
7111 case True{}:
7112 {==}
7113 case False{}:
7114 {==}
7115 case False{}:
7116 match b3:
7117 case True{}:
7118 {==}
7119 case False{}:
7120 {==}
7121 case False{}:
7122 match b2:
7123 case True{}:
7124 match b3:
7125 case True{}:
7126 {==}
7127 case False{}:
7128 {==}
7129 case False{}:
7130 match b3:
7131 case True{}:
7132 {==}
7133 case False{}:
7134 {==}
7135 case False{}:
7136 match b1:
7137 case True{}:
7138 match b2:
7139 case True{}:
7140 match b3:
7141 case True{}:
7142 {==}
7143 case False{}:
7144 {==}
7145 case False{}:
7146 match b3:
7147 case True{}:
7148 {==}
7149 case False{}:
7150 {==}
7151 case False{}:
7152 match b2:
7153 case True{}:
7154 match b3:
7155 case True{}:
7156 {==}
7157 case False{}:
7158 {==}
7159 case False{}:
7160 match b3:
7161 case True{}:
7162 {==}
7163 case False{}:
7164 {==}
7165
7166def comm16.s0100(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{True{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{True{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
7167 match b0:
7168 case True{}:
7169 match b1:
7170 case True{}:
7171 match b2:
7172 case True{}:
7173 match b3:
7174 case True{}:
7175 {==}
7176 case False{}:
7177 {==}
7178 case False{}:
7179 match b3:
7180 case True{}:
7181 {==}
7182 case False{}:
7183 {==}
7184 case False{}:
7185 match b2:
7186 case True{}:
7187 match b3:
7188 case True{}:
7189 {==}
7190 case False{}:
7191 {==}
7192 case False{}:
7193 match b3:
7194 case True{}:
7195 {==}
7196 case False{}:
7197 {==}
7198 case False{}:
7199 match b1:
7200 case True{}:
7201 match b2:
7202 case True{}:
7203 match b3:
7204 case True{}:
7205 {==}
7206 case False{}:
7207 {==}
7208 case False{}:
7209 match b3:
7210 case True{}:
7211 {==}
7212 case False{}:
7213 {==}
7214 case False{}:
7215 match b2:
7216 case True{}:
7217 match b3:
7218 case True{}:
7219 {==}
7220 case False{}:
7221 {==}
7222 case False{}:
7223 match b3:
7224 case True{}:
7225 {==}
7226 case False{}:
7227 {==}
7228
7229def comm16.s0011(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{False{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{False{}, WCon{True{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
7230 match b0:
7231 case True{}:
7232 match b1:
7233 case True{}:
7234 match b2:
7235 case True{}:
7236 match b3:
7237 case True{}:
7238 {==}
7239 case False{}:
7240 {==}
7241 case False{}:
7242 match b3:
7243 case True{}:
7244 {==}
7245 case False{}:
7246 {==}
7247 case False{}:
7248 match b2:
7249 case True{}:
7250 match b3:
7251 case True{}:
7252 {==}
7253 case False{}:
7254 {==}
7255 case False{}:
7256 match b3:
7257 case True{}:
7258 {==}
7259 case False{}:
7260 {==}
7261 case False{}:
7262 match b1:
7263 case True{}:
7264 match b2:
7265 case True{}:
7266 match b3:
7267 case True{}:
7268 {==}
7269 case False{}:
7270 {==}
7271 case False{}:
7272 match b3:
7273 case True{}:
7274 {==}
7275 case False{}:
7276 {==}
7277 case False{}:
7278 match b2:
7279 case True{}:
7280 match b3:
7281 case True{}:
7282 {==}
7283 case False{}:
7284 {==}
7285 case False{}:
7286 match b3:
7287 case True{}:
7288 {==}
7289 case False{}:
7290 {==}
7291
7292def comm16.s0010(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{False{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{False{}, WCon{True{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
7293 match b0:
7294 case True{}:
7295 match b1:
7296 case True{}:
7297 match b2:
7298 case True{}:
7299 match b3:
7300 case True{}:
7301 {==}
7302 case False{}:
7303 {==}
7304 case False{}:
7305 match b3:
7306 case True{}:
7307 {==}
7308 case False{}:
7309 {==}
7310 case False{}:
7311 match b2:
7312 case True{}:
7313 match b3:
7314 case True{}:
7315 {==}
7316 case False{}:
7317 {==}
7318 case False{}:
7319 match b3:
7320 case True{}:
7321 {==}
7322 case False{}:
7323 {==}
7324 case False{}:
7325 match b1:
7326 case True{}:
7327 match b2:
7328 case True{}:
7329 match b3:
7330 case True{}:
7331 {==}
7332 case False{}:
7333 {==}
7334 case False{}:
7335 match b3:
7336 case True{}:
7337 {==}
7338 case False{}:
7339 {==}
7340 case False{}:
7341 match b2:
7342 case True{}:
7343 match b3:
7344 case True{}:
7345 {==}
7346 case False{}:
7347 {==}
7348 case False{}:
7349 match b3:
7350 case True{}:
7351 {==}
7352 case False{}:
7353 {==}
7354
7355def comm16.s0001(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{False{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{False{}, WCon{False{}, WCon{True{}, Word.zero(28n)}}}}}) : U32}:
7356 match b0:
7357 case True{}:
7358 match b1:
7359 case True{}:
7360 match b2:
7361 case True{}:
7362 match b3:
7363 case True{}:
7364 {==}
7365 case False{}:
7366 {==}
7367 case False{}:
7368 match b3:
7369 case True{}:
7370 {==}
7371 case False{}:
7372 {==}
7373 case False{}:
7374 match b2:
7375 case True{}:
7376 match b3:
7377 case True{}:
7378 {==}
7379 case False{}:
7380 {==}
7381 case False{}:
7382 match b3:
7383 case True{}:
7384 {==}
7385 case False{}:
7386 {==}
7387 case False{}:
7388 match b1:
7389 case True{}:
7390 match b2:
7391 case True{}:
7392 match b3:
7393 case True{}:
7394 {==}
7395 case False{}:
7396 {==}
7397 case False{}:
7398 match b3:
7399 case True{}:
7400 {==}
7401 case False{}:
7402 {==}
7403 case False{}:
7404 match b2:
7405 case True{}:
7406 match b3:
7407 case True{}:
7408 {==}
7409 case False{}:
7410 {==}
7411 case False{}:
7412 match b3:
7413 case True{}:
7414 {==}
7415 case False{}:
7416 {==}
7417
7418def comm16.s0000(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{False{}, WCon{False{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{False{}, WCon{False{}, WCon{False{}, WCon{False{}, Word.zero(28n)}}}}}) : U32}:
7419 match b0:
7420 case True{}:
7421 match b1:
7422 case True{}:
7423 match b2:
7424 case True{}:
7425 match b3:
7426 case True{}:
7427 {==}
7428 case False{}:
7429 {==}
7430 case False{}:
7431 match b3:
7432 case True{}:
7433 {==}
7434 case False{}:
7435 {==}
7436 case False{}:
7437 match b2:
7438 case True{}:
7439 match b3:
7440 case True{}:
7441 {==}
7442 case False{}:
7443 {==}
7444 case False{}:
7445 match b3:
7446 case True{}:
7447 {==}
7448 case False{}:
7449 {==}
7450 case False{}:
7451 match b1:
7452 case True{}:
7453 match b2:
7454 case True{}:
7455 match b3:
7456 case True{}:
7457 {==}
7458 case False{}:
7459 {==}
7460 case False{}:
7461 match b3:
7462 case True{}:
7463 {==}
7464 case False{}:
7465 {==}
7466 case False{}:
7467 match b2:
7468 case True{}:
7469 match b3:
7470 case True{}:
7471 {==}
7472 case False{}:
7473 {==}
7474 case False{}:
7475 match b3:
7476 case True{}:
7477 {==}
7478 case False{}:
7479 {==}
7480
7481def comm16.bits(+a0: Bool, +a1: Bool, +a2: Bool, +a3: Bool, +b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}) : U32}:
7482 match a0:
7483 case True{}:
7484 match a1:
7485 case True{}:
7486 match a2:
7487 case True{}:
7488 match a3:
7489 case True{}:
7490 comm16.s1111(b0, b1, b2, b3)
7491 case False{}:
7492 comm16.s1110(b0, b1, b2, b3)
7493 case False{}:
7494 match a3:
7495 case True{}:
7496 comm16.s1101(b0, b1, b2, b3)
7497 case False{}:
7498 comm16.s1100(b0, b1, b2, b3)
7499 case False{}:
7500 match a2:
7501 case True{}:
7502 match a3:
7503 case True{}:
7504 comm16.s1011(b0, b1, b2, b3)
7505 case False{}:
7506 comm16.s1010(b0, b1, b2, b3)
7507 case False{}:
7508 match a3:
7509 case True{}:
7510 comm16.s1001(b0, b1, b2, b3)
7511 case False{}:
7512 comm16.s1000(b0, b1, b2, b3)
7513 case False{}:
7514 match a1:
7515 case True{}:
7516 match a2:
7517 case True{}:
7518 match a3:
7519 case True{}:
7520 comm16.s0111(b0, b1, b2, b3)
7521 case False{}:
7522 comm16.s0110(b0, b1, b2, b3)
7523 case False{}:
7524 match a3:
7525 case True{}:
7526 comm16.s0101(b0, b1, b2, b3)
7527 case False{}:
7528 comm16.s0100(b0, b1, b2, b3)
7529 case False{}:
7530 match a2:
7531 case True{}:
7532 match a3:
7533 case True{}:
7534 comm16.s0011(b0, b1, b2, b3)
7535 case False{}:
7536 comm16.s0010(b0, b1, b2, b3)
7537 case False{}:
7538 match a3:
7539 case True{}:
7540 comm16.s0001(b0, b1, b2, b3)
7541 case False{}:
7542 comm16.s0000(b0, b1, b2, b3)
7543
7544def comm16.core(+a: U32, +b: U32) -> {M.gfm.mul.raw(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), a), M.Gfm.elt(M.Gfm.gf16(), b)) == M.gfm.mul.raw(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), b), M.Gfm.elt(M.Gfm.gf16(), a)) : U32}:
7545 match a b:
7546 case U32{WCon{+a0, WCon{+a1, WCon{+a2, WCon{+a3, +ra}}}}} U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, +rb}}}}}:
7547 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, ra}}}}}), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}, elt_bits4(a0, a1, a2, a3, ra)) : {M.gfm.mul.raw(M.Gfm.gf16(), _, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}})) == M.gfm.mul.raw(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}}), M.Gfm.elt(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, ra}}}}})) : U32}
7548 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, ra}}}}}), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}, elt_bits4(a0, a1, a2, a3, ra)) : {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}})) == M.gfm.mul.raw(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}}), _) : U32}
7549 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}}), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, elt_bits4(b0, b1, b2, b3, rb)) : {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}, _) == M.gfm.mul.raw(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}}), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}) : U32}
7550 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, rb}}}}}), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, elt_bits4(b0, b1, b2, b3, rb)) : {M.gfm.mul.raw(M.Gfm.gf16(), U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}, U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}) == M.gfm.mul.raw(M.Gfm.gf16(), _, U32{WCon{a0, WCon{a1, WCon{a2, WCon{a3, Word.zero(28n)}}}}}) : U32}
7551 comm16.bits(a0, a1, a2, a3, b0, b1, b2, b3)
7552
7553def Laws.gfm_mul_comm_gf16(a, b):
7554 comm16.core(a, b)
7555
7556# a nonzero element as itself, and 0 as 1
7557def fixm(+x: U32) -> U32:
7558 Bool.pick(U32, U32.is_eq(x, 0), 1, x)
7559
7560def fixm_nz(+x: U32, nz: {U32.is_eq(x, 0) == False{} : Bool}) -> {fixm(x) == x : U32}:
7561 %Equal.sym(Bool, U32.is_eq(x, 0), False{}, nz) : {Bool.pick(U32, _, 1, x) == x : U32}
7562 {==}
7563
7564def inv16.s(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}:
7565 match b0:
7566 case True{}:
7567 match b1:
7568 case True{}:
7569 match b2:
7570 case True{}:
7571 match b3:
7572 case True{}:
7573 {==}
7574 case False{}:
7575 {==}
7576 case False{}:
7577 match b3:
7578 case True{}:
7579 {==}
7580 case False{}:
7581 {==}
7582 case False{}:
7583 match b2:
7584 case True{}:
7585 match b3:
7586 case True{}:
7587 {==}
7588 case False{}:
7589 {==}
7590 case False{}:
7591 match b3:
7592 case True{}:
7593 {==}
7594 case False{}:
7595 {==}
7596 case False{}:
7597 match b1:
7598 case True{}:
7599 match b2:
7600 case True{}:
7601 match b3:
7602 case True{}:
7603 {==}
7604 case False{}:
7605 {==}
7606 case False{}:
7607 match b3:
7608 case True{}:
7609 {==}
7610 case False{}:
7611 {==}
7612 case False{}:
7613 match b2:
7614 case True{}:
7615 match b3:
7616 case True{}:
7617 {==}
7618 case False{}:
7619 {==}
7620 case False{}:
7621 match b3:
7622 case True{}:
7623 {==}
7624 case False{}:
7625 {==}
7626
7627def inv16.bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool) -> {M.gfm.mul.raw(M.Gfm.gf16(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}:
7628 inv16.s(b0, b1, b2, b3)
7629
7630def inv16.core(+a: U32) -> {M.gfm.mul.raw(M.Gfm.gf16(), fixm(M.Gfm.elt(M.Gfm.gf16(), a)), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), fixm(M.Gfm.elt(M.Gfm.gf16(), a)), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}:
7631 match a:
7632 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, +r}}}}}:
7633 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, r}}}}}), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, elt_bits4(b0, b1, b2, b3, r)) : {M.gfm.mul.raw(M.Gfm.gf16(), fixm(_), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), fixm(M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, r}}}}})), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}
7634 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf16(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, r}}}}}), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}, elt_bits4(b0, b1, b2, b3, r)) : {M.gfm.mul.raw(M.Gfm.gf16(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, Word.zero(28n)}}}}}), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), fixm(_), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}
7635 inv16.bits(b0, b1, b2, b3)
7636
7637def inv16.lift(+a: U32, +nz: {U32.is_eq(M.Gfm.elt(M.Gfm.gf16(), a), 0) == False{} : Bool}) -> {M.gfm.mul.raw(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), a), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), a), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}:
7638 %fixm_nz(M.Gfm.elt(M.Gfm.gf16(), a), nz) : {M.gfm.mul.raw(M.Gfm.gf16(), _, M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), M.Gfm.elt(M.Gfm.gf16(), a), U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}
7639 %fixm_nz(M.Gfm.elt(M.Gfm.gf16(), a), nz) : {M.gfm.mul.raw(M.Gfm.gf16(), fixm(M.Gfm.elt(M.Gfm.gf16(), a)), M.Gfm.elt(M.Gfm.gf16(), M.gfm.pow.start(M.Gfm.gf16(), _, U32.sub(M.Gfm.mask(M.Gfm.gf16()), 1)))) == 1 : U32}
7640 inv16.core(a)
7641
7642def Laws.gfm_mul_inv_gf16(a, nz):
7643 inv16.lift(a, nz)
7644
7645def inv32.s1(+b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool) -> {M.gfm.mul.raw(M.Gfm.gf32(), fixm(U32{WCon{True{}, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), fixm(U32{WCon{True{}, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}:
7646 match b1:
7647 case True{}:
7648 match b2:
7649 case True{}:
7650 match b3:
7651 case True{}:
7652 match b4:
7653 case True{}:
7654 {==}
7655 case False{}:
7656 {==}
7657 case False{}:
7658 match b4:
7659 case True{}:
7660 {==}
7661 case False{}:
7662 {==}
7663 case False{}:
7664 match b3:
7665 case True{}:
7666 match b4:
7667 case True{}:
7668 {==}
7669 case False{}:
7670 {==}
7671 case False{}:
7672 match b4:
7673 case True{}:
7674 {==}
7675 case False{}:
7676 {==}
7677 case False{}:
7678 match b2:
7679 case True{}:
7680 match b3:
7681 case True{}:
7682 match b4:
7683 case True{}:
7684 {==}
7685 case False{}:
7686 {==}
7687 case False{}:
7688 match b4:
7689 case True{}:
7690 {==}
7691 case False{}:
7692 {==}
7693 case False{}:
7694 match b3:
7695 case True{}:
7696 match b4:
7697 case True{}:
7698 {==}
7699 case False{}:
7700 {==}
7701 case False{}:
7702 match b4:
7703 case True{}:
7704 {==}
7705 case False{}:
7706 {==}
7707
7708def inv32.s0(+b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool) -> {M.gfm.mul.raw(M.Gfm.gf32(), fixm(U32{WCon{False{}, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), fixm(U32{WCon{False{}, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}:
7709 match b1:
7710 case True{}:
7711 match b2:
7712 case True{}:
7713 match b3:
7714 case True{}:
7715 match b4:
7716 case True{}:
7717 {==}
7718 case False{}:
7719 {==}
7720 case False{}:
7721 match b4:
7722 case True{}:
7723 {==}
7724 case False{}:
7725 {==}
7726 case False{}:
7727 match b3:
7728 case True{}:
7729 match b4:
7730 case True{}:
7731 {==}
7732 case False{}:
7733 {==}
7734 case False{}:
7735 match b4:
7736 case True{}:
7737 {==}
7738 case False{}:
7739 {==}
7740 case False{}:
7741 match b2:
7742 case True{}:
7743 match b3:
7744 case True{}:
7745 match b4:
7746 case True{}:
7747 {==}
7748 case False{}:
7749 {==}
7750 case False{}:
7751 match b4:
7752 case True{}:
7753 {==}
7754 case False{}:
7755 {==}
7756 case False{}:
7757 match b3:
7758 case True{}:
7759 match b4:
7760 case True{}:
7761 {==}
7762 case False{}:
7763 {==}
7764 case False{}:
7765 match b4:
7766 case True{}:
7767 {==}
7768 case False{}:
7769 {==}
7770
7771def inv32.bits(+b0: Bool, +b1: Bool, +b2: Bool, +b3: Bool, +b4: Bool) -> {M.gfm.mul.raw(M.Gfm.gf32(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}:
7772 match b0:
7773 case True{}:
7774 inv32.s1(b1, b2, b3, b4)
7775 case False{}:
7776 inv32.s0(b1, b2, b3, b4)
7777
7778def inv32.core(+a: U32) -> {M.gfm.mul.raw(M.Gfm.gf32(), fixm(M.Gfm.elt(M.Gfm.gf32(), a)), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), fixm(M.Gfm.elt(M.Gfm.gf32(), a)), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}:
7779 match a:
7780 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, +r}}}}}}:
7781 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf32(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, r}}}}}}), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}, elt_bits5(b0, b1, b2, b3, b4, r)) : {M.gfm.mul.raw(M.Gfm.gf32(), fixm(_), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), fixm(M.Gfm.elt(M.Gfm.gf32(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, r}}}}}})), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}
7782 %Equal.sym(U32, M.Gfm.elt(M.Gfm.gf32(), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, r}}}}}}), U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}, elt_bits5(b0, b1, b2, b3, b4, r)) : {M.gfm.mul.raw(M.Gfm.gf32(), fixm(U32{WCon{b0, WCon{b1, WCon{b2, WCon{b3, WCon{b4, Word.zero(27n)}}}}}}), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), fixm(_), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}
7783 inv32.bits(b0, b1, b2, b3, b4)
7784
7785def inv32.lift(+a: U32, +nz: {U32.is_eq(M.Gfm.elt(M.Gfm.gf32(), a), 0) == False{} : Bool}) -> {M.gfm.mul.raw(M.Gfm.gf32(), M.Gfm.elt(M.Gfm.gf32(), a), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), M.Gfm.elt(M.Gfm.gf32(), a), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}:
7786 %fixm_nz(M.Gfm.elt(M.Gfm.gf32(), a), nz) : {M.gfm.mul.raw(M.Gfm.gf32(), _, M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), M.Gfm.elt(M.Gfm.gf32(), a), U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}
7787 %fixm_nz(M.Gfm.elt(M.Gfm.gf32(), a), nz) : {M.gfm.mul.raw(M.Gfm.gf32(), fixm(M.Gfm.elt(M.Gfm.gf32(), a)), M.Gfm.elt(M.Gfm.gf32(), M.gfm.pow.start(M.Gfm.gf32(), _, U32.sub(M.Gfm.mask(M.Gfm.gf32()), 1)))) == 1 : U32}
7788 inv32.core(a)
7789
7790def Laws.gfm_mul_inv_gf32(a, nz):
7791 inv32.lift(a, nz)
7792
7793# vectors, by computation
7794def Laws.v_gcm_x1():
7795 {==}
7796
7797def Laws.v_gcm_ghash():
7798 {==}
7799
7800def Laws.v_cmac_k1():
7801 {==}
7802
7803def Laws.v_cmac_k2():
7804 {==}
7805
7806def Laws.v_gcm_mul_x():
7807 {==}
7808
7809def Laws.v_gcm_mul_x_value():
7810 {==}
7811
7812def Laws.v_be_mul_x():
7813 {==}
7814
7815def Laws.v_be_mul():
7816 {==}
7817
7818def Laws.v_xts_wrap():
7819 {==}
7820
7821def Laws.v_xts_double():
7822 {==}
7823
7824def Laws.v_gf128_octets():
7825 {==}
7826
7827def Laws.v_gf128_short():
7828 {==}
7829
7830def Laws.v_bch13_x13():
7831 {==}
7832
7833def Laws.v_bch13_order():
7834 {==}
7835
7836def Laws.v_bch13_mul():
7837 {==}
7838
7839def Laws.v_bch13_inv():
7840 {==}
7841
7842def Laws.v_bch13_log():
7843 {==}
7844
7845def Laws.v_bch14_mul():
7846 {==}
7847
7848# 7. The tables, for the named fields (proof_tab.bend, proof_tab_cases.bend)
7849
7850# a product with a factor whose table zero test is true is 0
7851def tl.zero_l(+f: G.Gf8Field, +a: U32, +b: U32, +h: {U32.is_eq(G.Gf8.elt(a), 0) == True{} : Bool}) -> {G.Gf8.mul(f, a, b) == 0 : U32}:
7852 %Equal.sym(U32, G.Gf8.mul(f, a, b), G.Gf8.mul(f, G.Gf8.elt(a), b), mul_elt_l(f, a, b)) : {_ == 0 : U32}
7853 %Equal.sym(U32, G.Gf8.elt(a), 0, GC.gc.elt0(a, h)) : {G.Gf8.mul(f, _, b) == 0 : U32}
7854 Laws.mul_zero(f, b)
7855
7856def tl.mul_elt(+f: G.Gf8Field, +a: U32, +b: U32) -> {G.Gf8.mul(f, G.Gf8.elt(a), G.Gf8.elt(b)) == G.Gf8.mul(f, a, b) : U32}:
7857 Equal.trans(U32, G.Gf8.mul(f, G.Gf8.elt(a), G.Gf8.elt(b)), G.Gf8.mul(f, a, G.Gf8.elt(b)), G.Gf8.mul(f, a, b), Equal.sym(U32, G.Gf8.mul(f, a, G.Gf8.elt(b)), G.Gf8.mul(f, G.Gf8.elt(a), G.Gf8.elt(b)), mul_elt_l(f, a, G.Gf8.elt(b))), Equal.trans(U32, G.Gf8.mul(f, a, G.Gf8.elt(b)), G.Gf8.mul(f, G.Gf8.elt(b), a), G.Gf8.mul(f, a, b), Laws.mul_comm(f, a, G.Gf8.elt(b)), Equal.trans(U32, G.Gf8.mul(f, G.Gf8.elt(b), a), G.Gf8.mul(f, b, a), G.Gf8.mul(f, a, b), Equal.sym(U32, G.Gf8.mul(f, b, a), G.Gf8.mul(f, G.Gf8.elt(b), a), mul_elt_l(f, b, a)), Laws.mul_comm(f, b, a))))
7858
7859# both factors nonzero: the exp table's entry at log a + log b is the
7860# product, for a field f whose log list l gives log a and log b
7861def tl.nz(+f: G.Gf8Field, +l: List<&2, U32>, +a: U32, +b: U32, +hxa: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0) == U32.from_nat(G.Gf8.log(f, a)) : U32}, +hxb: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0) == U32.from_nat(G.Gf8.log(f, b)) : U32}, +ela: {G.Gf8.exp(f, G.Gf8.log(f, a)) == G.Gf8.elt(a) : U32}, +elb: {G.Gf8.exp(f, G.Gf8.log(f, b)) == G.Gf8.elt(b) : U32}) -> {A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, U32.add(A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0))), 0) == G.Gf8.mul(f, a, b) : U32}:
7862 %Equal.sym(U32, A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), U32.from_nat(G.Gf8.log(f, a)), hxa) : {A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, U32.add(_, A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0))), 0) == G.Gf8.mul(f, a, b) : U32}
7863 %Equal.sym(U32, A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0), U32.from_nat(G.Gf8.log(f, b)), hxb) : {A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, U32.add(U32.from_nat(G.Gf8.log(f, a)), _)), 0) == G.Gf8.mul(f, a, b) : U32}
7864 %Equal.sym(U32, U32.add(U32.from_nat(G.Gf8.log(f, a)), U32.from_nat(G.Gf8.log(f, b))), U32.from_nat(Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a))), GT.gt.add_nat(G.Gf8.log(f, a), G.Gf8.log(f, b))) : {A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, _), 0) == G.Gf8.mul(f, a, b) : U32}
7865 %Equal.sym(Nat, A.Arrays.index(9n, U32.from_nat(Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)))), Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), AL.index_of_nat(9n, GT.gt.hd9(), Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), GT.gt.sum_lt(G.Gf8.log(f, b), G.Gf8.log(f, a), GT.gt.log_lt(f, b), GT.gt.log_lt(f, a)))) : {A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), _, 0) == G.Gf8.mul(f, a, b) : U32}
7866 %Equal.sym(U32, A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), 0), G.Gf8.exp(f, Nat.add(Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), 0n)), GT.gt.elist_nth(510n, f, 0n, Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), GT.gt.lt_sum(G.Gf8.log(f, b), 255n, G.Gf8.log(f, a), 255n, GT.gt.log_lt(f, b), GT.gt.log_lt(f, a)))) : {_ == G.Gf8.mul(f, a, b) : U32}
7867 %Equal.sym(Nat, Nat.add(Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), 0n), Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)), UL.nat_add_zero(Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a)))) : {G.Gf8.exp(f, _) == G.Gf8.mul(f, a, b) : U32}
7868 %Equal.sym(U32, G.Gf8.pow(f, G.Gf8.gen(f), Nat.add(G.Gf8.log(f, b), G.Gf8.log(f, a))), G.Gf8.mul(f, G.Gf8.pow(f, G.Gf8.gen(f), G.Gf8.log(f, b)), G.Gf8.pow(f, G.Gf8.gen(f), G.Gf8.log(f, a))), Laws.pow_add(f, G.Gf8.gen(f), G.Gf8.log(f, b), G.Gf8.log(f, a))) : {_ == G.Gf8.mul(f, a, b) : U32}
7869 %Equal.sym(U32, G.Gf8.exp(f, G.Gf8.log(f, b)), G.Gf8.elt(b), elb) : {G.Gf8.mul(f, _, G.Gf8.pow(f, G.Gf8.gen(f), G.Gf8.log(f, a))) == G.Gf8.mul(f, a, b) : U32}
7870 %Equal.sym(U32, G.Gf8.exp(f, G.Gf8.log(f, a)), G.Gf8.elt(a), ela) : {G.Gf8.mul(f, G.Gf8.elt(b), _) == G.Gf8.mul(f, a, b) : U32}
7871 Equal.trans(U32, G.Gf8.mul(f, G.Gf8.elt(b), G.Gf8.elt(a)), G.Gf8.mul(f, b, a), G.Gf8.mul(f, a, b), tl.mul_elt(f, b, a), Laws.mul_comm(f, b, a))
7872
7873# both factors nonzero: the table's product, through its three reads
7874def tl.nzpick(+f: G.Gf8Field, +l: List<&2, U32>, +a: U32, +b: U32, +hl: {List.length(&2, U32, l) == A.Arrays.slots(8n) : Nat}, +hxa: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0) == U32.from_nat(G.Gf8.log(f, a)) : U32}, +hxb: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0) == U32.from_nat(G.Gf8.log(f, b)) : U32}, +ela: {G.Gf8.exp(f, G.Gf8.log(f, a)) == G.Gf8.elt(a) : U32}, +elb: {G.Gf8.exp(f, G.Gf8.log(f, b)) == G.Gf8.elt(b) : U32}) -> {T.gf8tab.two.pick(Bool.or(False{}, False{}), GT.gt.tab(f, l), G.Gf8.elt(a), G.Gf8.elt(b), False{}) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}:
7875 %Equal.sym(Array<U32> & U32, Array.get(U32, A.Arrays.of_list(U32, 8n, l, 0), G.Gf8.elt(a)), (A.Arrays.of_list(U32, 8n, l, 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0)), AL.of_list_get(U32, 8n, l, 0, hl, GT.gt.hd8(), G.Gf8.elt(a))) : {T.gf8tab.two.mid(A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), _, G.Gf8.elt(b), False{}) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}
7876 %Equal.sym(Array<U32> & U32, Array.get(U32, A.Arrays.of_list(U32, 8n, l, 0), G.Gf8.elt(b)), (A.Arrays.of_list(U32, 8n, l, 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0)), AL.of_list_get(U32, 8n, l, 0, hl, GT.gt.hd8(), G.Gf8.elt(b))) : {T.gf8tab.two.fin(A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), _, A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), False{}) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}
7877 %Equal.sym(Array<U32> & U32, Array.get(U32, A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), U32.add(A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0))), (A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, U32.add(A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0))), 0)), AL.of_list_get(U32, 9n, GT.gt.elist(510n, f, 0n), 0, GT.gt.hl_elist(f), GT.gt.hd9(), U32.add(A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0)))) : {T.gf8tab.exp.fin(_, A.Arrays.of_list(U32, 8n, l, 0)) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}
7878 %Equal.sym(U32, A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, U32.add(A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0))), 0), G.Gf8.mul(f, a, b), tl.nz(f, l, a, b, hxa, hxb, ela, elb)) : {(T.Gf8Tab{A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.of_list(U32, 8n, l, 0)}, _) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}
7879 {==}
7880
7881# a logarithm through the table
7882def tl.log(+f: G.Gf8Field, +l: List<&2, U32>, +a: U32, +hl: {List.length(&2, U32, l) == A.Arrays.slots(8n) : Nat}, +hxa: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0) == U32.from_nat(G.Gf8.log(f, a)) : U32}) -> {T.Gf8Tab.log(GT.gt.tab(f, l), a) == (GT.gt.tab(f, l), U32.from_nat(G.Gf8.log(f, a))) : T.Gf8Tab & U32}:
7883 %Equal.sym(Array<U32> & U32, Array.get(U32, A.Arrays.of_list(U32, 8n, l, 0), G.Gf8.elt(a)), (A.Arrays.of_list(U32, 8n, l, 0), A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0)), AL.of_list_get(U32, 8n, l, 0, hl, GT.gt.hd8(), G.Gf8.elt(a))) : {T.gf8tab.log.fin(A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), _) == (GT.gt.tab(f, l), U32.from_nat(G.Gf8.log(f, a))) : T.Gf8Tab & U32}
7884 %Equal.sym(U32, A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0), U32.from_nat(G.Gf8.log(f, a)), hxa) : {(T.Gf8Tab{A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.of_list(U32, 8n, l, 0)}, _) == (GT.gt.tab(f, l), U32.from_nat(G.Gf8.log(f, a))) : T.Gf8Tab & U32}
7885 {==}
7886
7887# an exponential through the table
7888def tl.exp(+f: G.Gf8Field, +l: List<&2, U32>, +i: U32, +hi: {Nat.is_lt(U32.to_nat(i), 510n) == True{} : Bool}) -> {T.Gf8Tab.exp(GT.gt.tab(f, l), i) == (GT.gt.tab(f, l), G.Gf8.exp(f, U32.to_nat(i))) : T.Gf8Tab & U32}:
7889 %Equal.sym(Array<U32> & U32, Array.get(U32, A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), i), (A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), A.Arrays.index(9n, i), 0)), AL.of_list_get(U32, 9n, GT.gt.elist(510n, f, 0n), 0, GT.gt.hl_elist(f), GT.gt.hd9(), i)) : {T.gf8tab.exp.fin(_, A.Arrays.of_list(U32, 8n, l, 0)) == (GT.gt.tab(f, l), G.Gf8.exp(f, U32.to_nat(i))) : T.Gf8Tab & U32}
7890 %Equal.sym(Nat, A.Arrays.index(9n, i), U32.to_nat(i), AL.index_of_u32(9n, i, GT.gt.lt_add_left(2n, U32.to_nat(i), 510n, hi))) : {(T.Gf8Tab{A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.of_list(U32, 8n, l, 0)}, A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), _, 0)) == (GT.gt.tab(f, l), G.Gf8.exp(f, U32.to_nat(i))) : T.Gf8Tab & U32}
7891 %Equal.sym(U32, A.Arrays.nth(U32, GT.gt.elist(510n, f, 0n), U32.to_nat(i), 0), G.Gf8.exp(f, Nat.add(U32.to_nat(i), 0n)), GT.gt.elist_nth(510n, f, 0n, U32.to_nat(i), hi)) : {(T.Gf8Tab{A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.of_list(U32, 8n, l, 0)}, _) == (GT.gt.tab(f, l), G.Gf8.exp(f, U32.to_nat(i))) : T.Gf8Tab & U32}
7892 %Equal.sym(Nat, Nat.add(U32.to_nat(i), 0n), U32.to_nat(i), UL.nat_add_zero(U32.to_nat(i))) : {(T.Gf8Tab{A.Arrays.of_list(U32, 9n, GT.gt.elist(510n, f, 0n), 0), A.Arrays.of_list(U32, 8n, l, 0)}, G.Gf8.exp(f, _)) == (GT.gt.tab(f, l), G.Gf8.exp(f, U32.to_nat(i))) : T.Gf8Tab & U32}
7893 {==}
7894
7895# the product through the table, by whether each factor is zero
7896def tl.pick(+f: G.Gf8Field, +l: List<&2, U32>, zx: Bool, zy: Bool, +a: U32, +b: U32, +ex: {U32.is_eq(G.Gf8.elt(a), 0) == zx : Bool}, +ey: {U32.is_eq(G.Gf8.elt(b), 0) == zy : Bool}, +hl: {List.length(&2, U32, l) == A.Arrays.slots(8n) : Nat}, +hxa: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0) == U32.from_nat(G.Gf8.log(f, a)) : U32}, +hxb: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0) == U32.from_nat(G.Gf8.log(f, b)) : U32}, ela: {G.Gf8.is_zero(a) == False{} : Bool} -> {G.Gf8.exp(f, G.Gf8.log(f, a)) == G.Gf8.elt(a) : U32}, elb: {G.Gf8.is_zero(b) == False{} : Bool} -> {G.Gf8.exp(f, G.Gf8.log(f, b)) == G.Gf8.elt(b) : U32}) -> {T.gf8tab.two.pick(Bool.or(zx, zy), GT.gt.tab(f, l), G.Gf8.elt(a), G.Gf8.elt(b), False{}) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}:
7897 match zx zy:
7898 case True{} _:
7899 %Equal.sym(U32, G.Gf8.mul(f, a, b), 0, tl.zero_l(f, a, b, ex)) : {(GT.gt.tab(f, l), 0) == (GT.gt.tab(f, l), _) : T.Gf8Tab & U32}
7900 {==}
7901 case False{} True{}:
7902 %Equal.sym(U32, G.Gf8.mul(f, a, b), 0, Equal.trans(U32, G.Gf8.mul(f, a, b), G.Gf8.mul(f, b, a), 0, Laws.mul_comm(f, a, b), tl.zero_l(f, b, a, ey))) : {(GT.gt.tab(f, l), 0) == (GT.gt.tab(f, l), _) : T.Gf8Tab & U32}
7903 {==}
7904 case False{} False{}:
7905 tl.nzpick(f, l, a, b, hl, hxa, hxb, ela(Equal.trans(Bool, G.Gf8.is_zero(a), U32.is_eq(G.Gf8.elt(a), 0), False{}, Equal.sym(Bool, U32.is_eq(G.Gf8.elt(a), 0), G.Gf8.is_zero(a), GC.gc.isz(a)), ex)), elb(Equal.trans(Bool, G.Gf8.is_zero(b), U32.is_eq(G.Gf8.elt(b), 0), False{}, Equal.sym(Bool, U32.is_eq(G.Gf8.elt(b), 0), G.Gf8.is_zero(b), GC.gc.isz(b)), ey)))
7906
7907# a product through the table
7908def tl.mul(+f: G.Gf8Field, +l: List<&2, U32>, +a: U32, +b: U32, +hl: {List.length(&2, U32, l) == A.Arrays.slots(8n) : Nat}, +hxa: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(a)), 0) == U32.from_nat(G.Gf8.log(f, a)) : U32}, +hxb: {A.Arrays.nth(U32, l, A.Arrays.index(8n, G.Gf8.elt(b)), 0) == U32.from_nat(G.Gf8.log(f, b)) : U32}, ela: {G.Gf8.is_zero(a) == False{} : Bool} -> {G.Gf8.exp(f, G.Gf8.log(f, a)) == G.Gf8.elt(a) : U32}, elb: {G.Gf8.is_zero(b) == False{} : Bool} -> {G.Gf8.exp(f, G.Gf8.log(f, b)) == G.Gf8.elt(b) : U32}) -> {T.Gf8Tab.mul(GT.gt.tab(f, l), a, b) == (GT.gt.tab(f, l), G.Gf8.mul(f, a, b)) : T.Gf8Tab & U32}:
7909 tl.pick(f, l, U32.is_eq(G.Gf8.elt(a), 0), U32.is_eq(G.Gf8.elt(b), 0), a, b, {==}, {==}, hl, hxa, hxb, ela, elb)
7910
7911# The aes field
7912
7913def tl.hl8_aes() -> {List.length(&2, U32, GC.gc.aes.llist()) == A.Arrays.slots(8n) : Nat}:
7914 {==}
7915
7916def Laws.tab_mul_aes(a, b):
7917 %GC.gc.aes.new() : {T.Gf8Tab.mul(_, a, b) == (_, G.Gf8.mul(G.Gf8.aes(), a, b)) : T.Gf8Tab & U32}
7918 tl.mul(G.Gf8.aes(), GC.gc.aes.llist(), a, b, tl.hl8_aes(), GC.gc.aes.log(a), GC.gc.aes.log(b), nz => Laws.exp_log_aes(a, nz), nz => Laws.exp_log_aes(b, nz))
7919
7920def Laws.tab_log_aes(a):
7921 %GC.gc.aes.new() : {T.Gf8Tab.log(_, a) == (_, U32.from_nat(G.Gf8.log(G.Gf8.aes(), a))) : T.Gf8Tab & U32}
7922 tl.log(G.Gf8.aes(), GC.gc.aes.llist(), a, tl.hl8_aes(), GC.gc.aes.log(a))
7923
7924def Laws.tab_exp_aes(i, hi):
7925 %GC.gc.aes.new() : {T.Gf8Tab.exp(_, i) == (_, G.Gf8.exp(G.Gf8.aes(), U32.to_nat(i))) : T.Gf8Tab & U32}
7926 tl.exp(G.Gf8.aes(), GC.gc.aes.llist(), i, hi)
7927
7928# The rs field
7929
7930def tl.hl8_rs() -> {List.length(&2, U32, GC.gc.rs.llist()) == A.Arrays.slots(8n) : Nat}:
7931 {==}
7932
7933def Laws.tab_mul_rs(a, b):
7934 %GC.gc.rs.new() : {T.Gf8Tab.mul(_, a, b) == (_, G.Gf8.mul(G.Gf8.rs(), a, b)) : T.Gf8Tab & U32}
7935 tl.mul(G.Gf8.rs(), GC.gc.rs.llist(), a, b, tl.hl8_rs(), GC.gc.rs.log(a), GC.gc.rs.log(b), nz => Laws.exp_log_rs(a, nz), nz => Laws.exp_log_rs(b, nz))
7936
7937def Laws.tab_log_rs(a):
7938 %GC.gc.rs.new() : {T.Gf8Tab.log(_, a) == (_, U32.from_nat(G.Gf8.log(G.Gf8.rs(), a))) : T.Gf8Tab & U32}
7939 tl.log(G.Gf8.rs(), GC.gc.rs.llist(), a, tl.hl8_rs(), GC.gc.rs.log(a))
7940
7941def Laws.tab_exp_rs(i, hi):
7942 %GC.gc.rs.new() : {T.Gf8Tab.exp(_, i) == (_, G.Gf8.exp(G.Gf8.rs(), U32.to_nat(i))) : T.Gf8Tab & U32}
7943 tl.exp(G.Gf8.rs(), GC.gc.rs.llist(), i, hi)
7944
7945def Laws.witness_tab_exp():
7946 {==}
7947