PROOF.bend
bend-osdev-gf@0.1.0.0 · 7,856 lines · 0 definitions
1# Generated by gen/proof.py; do not edit by hand.
2import Base
3import bend-osdev-bytes@0.1.0.0/bytes.bend as B
4import bend-osdev-gf@0.1.0.0/gf.bend as G
5import bend-osdev-gf@0.1.0.0/tables.bend as T
6import bend-osdev-gf@0.1.0.0/gf128.bend as H
7import bend-osdev-gf@0.1.0.0/gfm.bend as M
8import bend-osdev-gf@0.1.0.0/LAWS.bend as Laws
9
10# 1. Bool identities, by cases
11
12def bx_comm(+a: Bool, +b: Bool) -> {Bool.xor(a, b) == Bool.xor(b, a) : Bool}:
13 match a:
14 case True{}:
15 match b:
16 case True{}:
17 {==}
18 case False{}:
19 {==}
20 case False{}:
21 match b:
22 case True{}:
23 {==}
24 case False{}:
25 {==}
26
27def bx_assoc(+a: Bool, +b: Bool, +c: Bool) -> {Bool.xor(Bool.xor(a, b), c) == Bool.xor(a, Bool.xor(b, c)) : Bool}:
28 match a:
29 case True{}:
30 match b:
31 case True{}:
32 match c:
33 case True{}:
34 {==}
35 case False{}:
36 {==}
37 case False{}:
38 match c:
39 case True{}:
40 {==}
41 case False{}:
42 {==}
43 case False{}:
44 match b:
45 case True{}:
46 match c:
47 case True{}:
48 {==}
49 case False{}:
50 {==}
51 case False{}:
52 match c:
53 case True{}:
54 {==}
55 case False{}:
56 {==}
57
58def bx_zr(+a: Bool) -> {Bool.xor(a, False{}) == a : Bool}:
59 match a:
60 case True{}:
61 {==}
62 case False{}:
63 {==}
64
65def bx_self(+a: Bool) -> {Bool.xor(a, a) == False{} : Bool}:
66 match a:
67 case True{}:
68 {==}
69 case False{}:
70 {==}
71
72def 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}:
73 match a:
74 case True{}:
75 match b:
76 case True{}:
77 match c:
78 case True{}:
79 match d:
80 case True{}:
81 {==}
82 case False{}:
83 {==}
84 case False{}:
85 match d:
86 case True{}:
87 {==}
88 case False{}:
89 {==}
90 case False{}:
91 match c:
92 case True{}:
93 match d:
94 case True{}:
95 {==}
96 case False{}:
97 {==}
98 case False{}:
99 match d:
100 case True{}:
101 {==}
102 case False{}:
103 {==}
104 case False{}:
105 match b:
106 case True{}:
107 match c:
108 case True{}:
109 match d:
110 case True{}:
111 {==}
112 case False{}:
113 {==}
114 case False{}:
115 match d:
116 case True{}:
117 {==}
118 case False{}:
119 {==}
120 case False{}:
121 match c:
122 case True{}:
123 match d:
124 case True{}:
125 {==}
126 case False{}:
127 {==}
128 case False{}:
129 match d:
130 case True{}:
131 {==}
132 case False{}:
133 {==}
134
135def 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}:
136 match a:
137 case True{}:
138 match b:
139 case True{}:
140 match q:
141 case True{}:
142 {==}
143 case False{}:
144 {==}
145 case False{}:
146 match q:
147 case True{}:
148 {==}
149 case False{}:
150 {==}
151 case False{}:
152 match b:
153 case True{}:
154 match q:
155 case True{}:
156 {==}
157 case False{}:
158 {==}
159 case False{}:
160 match q:
161 case True{}:
162 {==}
163 case False{}:
164 {==}
165
166def 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}:
167 match a:
168 case True{}:
169 match b:
170 case True{}:
171 match u:
172 case True{}:
173 match v:
174 case True{}:
175 match q:
176 case True{}:
177 {==}
178 case False{}:
179 {==}
180 case False{}:
181 match q:
182 case True{}:
183 {==}
184 case False{}:
185 {==}
186 case False{}:
187 match v:
188 case True{}:
189 match q:
190 case True{}:
191 {==}
192 case False{}:
193 {==}
194 case False{}:
195 match q:
196 case True{}:
197 {==}
198 case False{}:
199 {==}
200 case False{}:
201 match u:
202 case True{}:
203 match v:
204 case True{}:
205 match q:
206 case True{}:
207 {==}
208 case False{}:
209 {==}
210 case False{}:
211 match q:
212 case True{}:
213 {==}
214 case False{}:
215 {==}
216 case False{}:
217 match v:
218 case True{}:
219 match q:
220 case True{}:
221 {==}
222 case False{}:
223 {==}
224 case False{}:
225 match q:
226 case True{}:
227 {==}
228 case False{}:
229 {==}
230 case False{}:
231 match b:
232 case True{}:
233 match u:
234 case True{}:
235 match v:
236 case True{}:
237 match q:
238 case True{}:
239 {==}
240 case False{}:
241 {==}
242 case False{}:
243 match q:
244 case True{}:
245 {==}
246 case False{}:
247 {==}
248 case False{}:
249 match v:
250 case True{}:
251 match q:
252 case True{}:
253 {==}
254 case False{}:
255 {==}
256 case False{}:
257 match q:
258 case True{}:
259 {==}
260 case False{}:
261 {==}
262 case False{}:
263 match u:
264 case True{}:
265 match v:
266 case True{}:
267 match q:
268 case True{}:
269 {==}
270 case False{}:
271 {==}
272 case False{}:
273 match q:
274 case True{}:
275 {==}
276 case False{}:
277 {==}
278 case False{}:
279 match v:
280 case True{}:
281 match q:
282 case True{}:
283 {==}
284 case False{}:
285 {==}
286 case False{}:
287 match q:
288 case True{}:
289 {==}
290 case False{}:
291 {==}
292
293# 2. A byte's eight bits at once
294
295def 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}:
296 %e0 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{_, c1, c2, c3, c4, c5, c6, c7} : G.Gf8Bits}
297 %e1 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, _, c2, c3, c4, c5, c6, c7} : G.Gf8Bits}
298 %e2 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, _, c3, c4, c5, c6, c7} : G.Gf8Bits}
299 %e3 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, _, c4, c5, c6, c7} : G.Gf8Bits}
300 %e4 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, _, c5, c6, c7} : G.Gf8Bits}
301 %e5 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, a4, _, c6, c7} : G.Gf8Bits}
302 %e6 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, a4, a5, _, c7} : G.Gf8Bits}
303 %e7 : {G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7} == G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, _} : G.Gf8Bits}
304 {==}
305
306def rx_comm(+a: G.Gf8Bits, +b: G.Gf8Bits) -> {G.Gf8Bits.xor(a, b) == G.Gf8Bits.xor(b, a) : G.Gf8Bits}:
307 match a b:
308 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7} G.Gf8Bits{+b0, +b1, +b2, +b3, +b4, +b5, +b6, +b7}:
309 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))
310
311def 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}:
312 match a b c:
313 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}:
314 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))
315
316def rx_zr(+a: G.Gf8Bits) -> {G.Gf8Bits.xor(a, G.Gf8Bits.zero()) == a : G.Gf8Bits}:
317 match a:
318 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7}:
319 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))
320
321def rx_self(+a: G.Gf8Bits) -> {G.Gf8Bits.xor(a, a) == G.Gf8Bits.zero() : G.Gf8Bits}:
322 match a:
323 case G.Gf8Bits{+a0, +a1, +a2, +a3, +a4, +a5, +a6, +a7}:
324 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))
325
326def 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}:
327 match a b c d:
328 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}:
329 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))
330
331def rx_zl(+a: G.Gf8Bits) -> {G.Gf8Bits.xor(G.Gf8Bits.zero(), a) == a : G.Gf8Bits}:
332 match a:
333 case G.Gf8Bits{a0, a1, a2, a3, a4, a5, a6, a7}:
334 {==}
335
336def 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}:
337 match u v p:
338 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}:
339 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))
340
341def x_zero(+p: G.Gf8Bits) -> {G.Gf8Bits.x(G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
342 match p:
343 case G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
344 {==}
345
346# 3. Selection, and a Horner step, are linear; so the product is linear in
347# each factor
348
349def 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}:
350 match t:
351 case True{}:
352 {==}
353 case False{}:
354 {==}
355
356def 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}:
357 match s t:
358 case True{} True{}:
359 Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(b, b), G.Gf8Bits.zero(), rx_self(b))
360 case True{} False{}:
361 Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(b, G.Gf8Bits.zero()), b, rx_zr(b))
362 case False{} True{}:
363 Equal.sym(G.Gf8Bits, G.Gf8Bits.xor(G.Gf8Bits.zero(), b), b, rx_zl(b))
364 case False{} False{}:
365 {==}
366
367def 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}:
368 match t:
369 case True{}:
370 {==}
371 case False{}:
372 x_zero(p)
373
374def 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}:
375 %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}
376 %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}
377 %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}
378 {==}
379
380def 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}:
381 match ts:
382 case Nil{}:
383 {==}
384 case Con{+t, rest}:
385 %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}
386 horner_lin_b(rest, G.Gf8Bits.step(t, A, u, p), G.Gf8Bits.step(t, C, v, p), u, v, p)
387
388def 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}:
389 horner_lin_b(G.Gf8Bits.top(a), G.Gf8Bits.zero(), G.Gf8Bits.zero(), u, v, p)
390
391# pairs of bits, for the product's linearity in its first factor
392type GfPb is Data:
393 GfPb{s: Bool, t: Bool}
394
395def pl.x(ps: List<&2, GfPb>) -> List<&2, Bool>:
396 match ps:
397 case Nil{}:
398 Nil{}
399 case Con{h, rest}:
400 match h:
401 case GfPb{s, t}:
402 Con{Bool.xor(s, t), pl.x(rest)}
403
404def pl.l(ps: List<&2, GfPb>) -> List<&2, Bool>:
405 match ps:
406 case Nil{}:
407 Nil{}
408 case Con{h, rest}:
409 match h:
410 case GfPb{s, t}:
411 Con{s, pl.l(rest)}
412
413def pl.r(ps: List<&2, GfPb>) -> List<&2, Bool>:
414 match ps:
415 case Nil{}:
416 Nil{}
417 case Con{h, rest}:
418 match h:
419 case GfPb{s, t}:
420 Con{t, pl.r(rest)}
421
422def 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}:
423 %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}
424 %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}
425 %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}
426 {==}
427
428def 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}:
429 match ps:
430 case Nil{}:
431 {==}
432 case Con{h, rest}:
433 match h:
434 case GfPb{+s, +t}:
435 %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}
436 horner_lin_a(rest, G.Gf8Bits.step(s, A, b, p), G.Gf8Bits.step(t, C, b, p), b, p)
437
438def 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}:
439 match s t:
440 case G.Gf8Bits{+s0, +s1, +s2, +s3, +s4, +s5, +s6, +s7} G.Gf8Bits{+t0, +t1, +t2, +t3, +t4, +t5, +t6, +t7}:
441 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)
442
443def step_zero(+t: Bool, +p: G.Gf8Bits) -> {G.Gf8Bits.step(t, G.Gf8Bits.zero(), G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
444 match t p:
445 case True{} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
446 {==}
447 case False{} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
448 {==}
449
450def 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}:
451 match ts:
452 case Nil{}:
453 {==}
454 case Con{+t, rest}:
455 %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}
456 horner_zero(rest, p)
457
458def m_zero_r(+a: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(a, G.Gf8Bits.zero(), p) == G.Gf8Bits.zero() : G.Gf8Bits}:
459 horner_zero(G.Gf8Bits.top(a), p)
460
461def m_zero_l(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(G.Gf8Bits.zero(), b, p) == G.Gf8Bits.zero() : G.Gf8Bits}:
462 match p:
463 case G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
464 {==}
465
466def 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}:
467 match t:
468 case True{}:
469 {==}
470 case False{}:
471 m_zero_l(b, p)
472
473def 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}:
474 match t:
475 case True{}:
476 {==}
477 case False{}:
478 m_zero_r(a, p)
479
480# 4. Sums over the basis 1, x, ..., x^7
481
482# the sum of t_i * v_i
483def ss(ts: List<&2, Bool>, vs: List<&2, G.Gf8Bits>) -> G.Gf8Bits:
484 match ts:
485 case Nil{}:
486 G.Gf8Bits.zero()
487 case Con{t, tr}:
488 match vs:
489 case Nil{}:
490 G.Gf8Bits.zero()
491 case Con{v, vr}:
492 G.Gf8Bits.xor(G.Gf8Bits.sel(t, v), ss(tr, vr))
493
494def ml(vs: List<&2, G.Gf8Bits>, +b: G.Gf8Bits, +p: G.Gf8Bits) -> List<&2, G.Gf8Bits>:
495 match vs:
496 case Nil{}:
497 Nil{}
498 case Con{+v, +vr}:
499 Con{G.Gf8Bits.mul(v, b, p), ml(vr, b, p)}
500
501def mr(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(b, v, p), mr(vr, b, p)}
507
508def xl(vs: List<&2, 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.x(v, p), xl(vr, p)}
514
515def basis() -> List<&2, G.Gf8Bits>:
516 [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{}}]
517
518def bl(a: G.Gf8Bits) -> List<&2, Bool>:
519 match a:
520 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}:
521 [b0, b1, b2, b3, b4, b5, b6, b7]
522
523def xk(n: Nat, b: G.Gf8Bits, +p: G.Gf8Bits) -> G.Gf8Bits:
524 match n:
525 case 0n:
526 b
527 case 1n+k:
528 xk(k, G.Gf8Bits.x(b, p), p)
529
530def xs(+b: G.Gf8Bits, +p: G.Gf8Bits) -> List<&2, G.Gf8Bits>:
531 [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)]
532
533def fs(n: Nat) -> List<&2, Bool>:
534 match n:
535 case 0n:
536 Nil{}
537 case 1n+k:
538 Con{False{}, fs(k)}
539
540def 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}:
541 match ts:
542 case Nil{}:
543 m_zero_l(b, p)
544 case Con{+t, +tr}:
545 match vs:
546 case Nil{}:
547 m_zero_l(b, p)
548 case Con{+v, +vr}:
549 %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}
550 %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}
551 m_lin_l(G.Gf8Bits.sel(t, v), ss(tr, vr), b, p)
552
553def 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}:
554 match ts:
555 case Nil{}:
556 m_zero_r(b, p)
557 case Con{+t, +tr}:
558 match vs:
559 case Nil{}:
560 m_zero_r(b, p)
561 case Con{+v, +vr}:
562 %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}
563 %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}
564 m_lin_r(b, G.Gf8Bits.sel(t, v), ss(tr, vr), p)
565
566def 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}:
567 match ts:
568 case Nil{}:
569 x_zero(p)
570 case Con{+t, +tr}:
571 match vs:
572 case Nil{}:
573 x_zero(p)
574 case Con{+v, +vr}:
575 %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}
576 %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}
577 x_lin(G.Gf8Bits.sel(t, v), ss(tr, vr), p)
578
579# every byte is the sum of its bits times the basis (by cases)
580def dec(+a: G.Gf8Bits) -> {ss(bl(a), basis()) == a : G.Gf8Bits}:
581 match a:
582 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}:
583 match b0:
584 case True{}:
585 match b1:
586 case True{}:
587 match b2:
588 case True{}:
589 match b3:
590 case True{}:
591 match b4:
592 case True{}:
593 match b5:
594 case True{}:
595 match b6:
596 case True{}:
597 match b7:
598 case True{}:
599 {==}
600 case False{}:
601 {==}
602 case False{}:
603 match b7:
604 case True{}:
605 {==}
606 case False{}:
607 {==}
608 case False{}:
609 match b6:
610 case True{}:
611 match b7:
612 case True{}:
613 {==}
614 case False{}:
615 {==}
616 case False{}:
617 match b7:
618 case True{}:
619 {==}
620 case False{}:
621 {==}
622 case False{}:
623 match b5:
624 case True{}:
625 match b6:
626 case True{}:
627 match b7:
628 case True{}:
629 {==}
630 case False{}:
631 {==}
632 case False{}:
633 match b7:
634 case True{}:
635 {==}
636 case False{}:
637 {==}
638 case False{}:
639 match b6:
640 case True{}:
641 match b7:
642 case True{}:
643 {==}
644 case False{}:
645 {==}
646 case False{}:
647 match b7:
648 case True{}:
649 {==}
650 case False{}:
651 {==}
652 case False{}:
653 match b4:
654 case True{}:
655 match b5:
656 case True{}:
657 match b6:
658 case True{}:
659 match b7:
660 case True{}:
661 {==}
662 case False{}:
663 {==}
664 case False{}:
665 match b7:
666 case True{}:
667 {==}
668 case False{}:
669 {==}
670 case False{}:
671 match b6:
672 case True{}:
673 match b7:
674 case True{}:
675 {==}
676 case False{}:
677 {==}
678 case False{}:
679 match b7:
680 case True{}:
681 {==}
682 case False{}:
683 {==}
684 case False{}:
685 match b5:
686 case True{}:
687 match b6:
688 case True{}:
689 match b7:
690 case True{}:
691 {==}
692 case False{}:
693 {==}
694 case False{}:
695 match b7:
696 case True{}:
697 {==}
698 case False{}:
699 {==}
700 case False{}:
701 match b6:
702 case True{}:
703 match b7:
704 case True{}:
705 {==}
706 case False{}:
707 {==}
708 case False{}:
709 match b7:
710 case True{}:
711 {==}
712 case False{}:
713 {==}
714 case False{}:
715 match b3:
716 case True{}:
717 match b4:
718 case True{}:
719 match b5:
720 case True{}:
721 match b6:
722 case True{}:
723 match b7:
724 case True{}:
725 {==}
726 case False{}:
727 {==}
728 case False{}:
729 match b7:
730 case True{}:
731 {==}
732 case False{}:
733 {==}
734 case False{}:
735 match b6:
736 case True{}:
737 match b7:
738 case True{}:
739 {==}
740 case False{}:
741 {==}
742 case False{}:
743 match b7:
744 case True{}:
745 {==}
746 case False{}:
747 {==}
748 case False{}:
749 match b5:
750 case True{}:
751 match b6:
752 case True{}:
753 match b7:
754 case True{}:
755 {==}
756 case False{}:
757 {==}
758 case False{}:
759 match b7:
760 case True{}:
761 {==}
762 case False{}:
763 {==}
764 case False{}:
765 match b6:
766 case True{}:
767 match b7:
768 case True{}:
769 {==}
770 case False{}:
771 {==}
772 case False{}:
773 match b7:
774 case True{}:
775 {==}
776 case False{}:
777 {==}
778 case False{}:
779 match b4:
780 case True{}:
781 match b5:
782 case True{}:
783 match b6:
784 case True{}:
785 match b7:
786 case True{}:
787 {==}
788 case False{}:
789 {==}
790 case False{}:
791 match b7:
792 case True{}:
793 {==}
794 case False{}:
795 {==}
796 case False{}:
797 match b6:
798 case True{}:
799 match b7:
800 case True{}:
801 {==}
802 case False{}:
803 {==}
804 case False{}:
805 match b7:
806 case True{}:
807 {==}
808 case False{}:
809 {==}
810 case False{}:
811 match b5:
812 case True{}:
813 match b6:
814 case True{}:
815 match b7:
816 case True{}:
817 {==}
818 case False{}:
819 {==}
820 case False{}:
821 match b7:
822 case True{}:
823 {==}
824 case False{}:
825 {==}
826 case False{}:
827 match b6:
828 case True{}:
829 match b7:
830 case True{}:
831 {==}
832 case False{}:
833 {==}
834 case False{}:
835 match b7:
836 case True{}:
837 {==}
838 case False{}:
839 {==}
840 case False{}:
841 match b2:
842 case True{}:
843 match b3:
844 case True{}:
845 match b4:
846 case True{}:
847 match b5:
848 case True{}:
849 match b6:
850 case True{}:
851 match b7:
852 case True{}:
853 {==}
854 case False{}:
855 {==}
856 case False{}:
857 match b7:
858 case True{}:
859 {==}
860 case False{}:
861 {==}
862 case False{}:
863 match b6:
864 case True{}:
865 match b7:
866 case True{}:
867 {==}
868 case False{}:
869 {==}
870 case False{}:
871 match b7:
872 case True{}:
873 {==}
874 case False{}:
875 {==}
876 case False{}:
877 match b5:
878 case True{}:
879 match b6:
880 case True{}:
881 match b7:
882 case True{}:
883 {==}
884 case False{}:
885 {==}
886 case False{}:
887 match b7:
888 case True{}:
889 {==}
890 case False{}:
891 {==}
892 case False{}:
893 match b6:
894 case True{}:
895 match b7:
896 case True{}:
897 {==}
898 case False{}:
899 {==}
900 case False{}:
901 match b7:
902 case True{}:
903 {==}
904 case False{}:
905 {==}
906 case False{}:
907 match b4:
908 case True{}:
909 match b5:
910 case True{}:
911 match b6:
912 case True{}:
913 match b7:
914 case True{}:
915 {==}
916 case False{}:
917 {==}
918 case False{}:
919 match b7:
920 case True{}:
921 {==}
922 case False{}:
923 {==}
924 case False{}:
925 match b6:
926 case True{}:
927 match b7:
928 case True{}:
929 {==}
930 case False{}:
931 {==}
932 case False{}:
933 match b7:
934 case True{}:
935 {==}
936 case False{}:
937 {==}
938 case False{}:
939 match b5:
940 case True{}:
941 match b6:
942 case True{}:
943 match b7:
944 case True{}:
945 {==}
946 case False{}:
947 {==}
948 case False{}:
949 match b7:
950 case True{}:
951 {==}
952 case False{}:
953 {==}
954 case False{}:
955 match b6:
956 case True{}:
957 match b7:
958 case True{}:
959 {==}
960 case False{}:
961 {==}
962 case False{}:
963 match b7:
964 case True{}:
965 {==}
966 case False{}:
967 {==}
968 case False{}:
969 match b3:
970 case True{}:
971 match b4:
972 case True{}:
973 match b5:
974 case True{}:
975 match b6:
976 case True{}:
977 match b7:
978 case True{}:
979 {==}
980 case False{}:
981 {==}
982 case False{}:
983 match b7:
984 case True{}:
985 {==}
986 case False{}:
987 {==}
988 case False{}:
989 match b6:
990 case True{}:
991 match b7:
992 case True{}:
993 {==}
994 case False{}:
995 {==}
996 case False{}:
997 match b7:
998 case True{}:
999 {==}
1000 case False{}:
1001 {==}
1002 case False{}:
1003 match b5:
1004 case True{}:
1005 match b6:
1006 case True{}:
1007 match b7:
1008 case True{}:
1009 {==}
1010 case False{}:
1011 {==}
1012 case False{}:
1013 match b7:
1014 case True{}:
1015 {==}
1016 case False{}:
1017 {==}
1018 case False{}:
1019 match b6:
1020 case True{}:
1021 match b7:
1022 case True{}:
1023 {==}
1024 case False{}:
1025 {==}
1026 case False{}:
1027 match b7:
1028 case True{}:
1029 {==}
1030 case False{}:
1031 {==}
1032 case False{}:
1033 match b4:
1034 case True{}:
1035 match b5:
1036 case True{}:
1037 match b6:
1038 case True{}:
1039 match b7:
1040 case True{}:
1041 {==}
1042 case False{}:
1043 {==}
1044 case False{}:
1045 match b7:
1046 case True{}:
1047 {==}
1048 case False{}:
1049 {==}
1050 case False{}:
1051 match b6:
1052 case True{}:
1053 match b7:
1054 case True{}:
1055 {==}
1056 case False{}:
1057 {==}
1058 case False{}:
1059 match b7:
1060 case True{}:
1061 {==}
1062 case False{}:
1063 {==}
1064 case False{}:
1065 match b5:
1066 case True{}:
1067 match b6:
1068 case True{}:
1069 match b7:
1070 case True{}:
1071 {==}
1072 case False{}:
1073 {==}
1074 case False{}:
1075 match b7:
1076 case True{}:
1077 {==}
1078 case False{}:
1079 {==}
1080 case False{}:
1081 match b6:
1082 case True{}:
1083 match b7:
1084 case True{}:
1085 {==}
1086 case False{}:
1087 {==}
1088 case False{}:
1089 match b7:
1090 case True{}:
1091 {==}
1092 case False{}:
1093 {==}
1094 case False{}:
1095 match b1:
1096 case True{}:
1097 match b2:
1098 case True{}:
1099 match b3:
1100 case True{}:
1101 match b4:
1102 case True{}:
1103 match b5:
1104 case True{}:
1105 match b6:
1106 case True{}:
1107 match b7:
1108 case True{}:
1109 {==}
1110 case False{}:
1111 {==}
1112 case False{}:
1113 match b7:
1114 case True{}:
1115 {==}
1116 case False{}:
1117 {==}
1118 case False{}:
1119 match b6:
1120 case True{}:
1121 match b7:
1122 case True{}:
1123 {==}
1124 case False{}:
1125 {==}
1126 case False{}:
1127 match b7:
1128 case True{}:
1129 {==}
1130 case False{}:
1131 {==}
1132 case False{}:
1133 match b5:
1134 case True{}:
1135 match b6:
1136 case True{}:
1137 match b7:
1138 case True{}:
1139 {==}
1140 case False{}:
1141 {==}
1142 case False{}:
1143 match b7:
1144 case True{}:
1145 {==}
1146 case False{}:
1147 {==}
1148 case False{}:
1149 match b6:
1150 case True{}:
1151 match b7:
1152 case True{}:
1153 {==}
1154 case False{}:
1155 {==}
1156 case False{}:
1157 match b7:
1158 case True{}:
1159 {==}
1160 case False{}:
1161 {==}
1162 case False{}:
1163 match b4:
1164 case True{}:
1165 match b5:
1166 case True{}:
1167 match b6:
1168 case True{}:
1169 match b7:
1170 case True{}:
1171 {==}
1172 case False{}:
1173 {==}
1174 case False{}:
1175 match b7:
1176 case True{}:
1177 {==}
1178 case False{}:
1179 {==}
1180 case False{}:
1181 match b6:
1182 case True{}:
1183 match b7:
1184 case True{}:
1185 {==}
1186 case False{}:
1187 {==}
1188 case False{}:
1189 match b7:
1190 case True{}:
1191 {==}
1192 case False{}:
1193 {==}
1194 case False{}:
1195 match b5:
1196 case True{}:
1197 match b6:
1198 case True{}:
1199 match b7:
1200 case True{}:
1201 {==}
1202 case False{}:
1203 {==}
1204 case False{}:
1205 match b7:
1206 case True{}:
1207 {==}
1208 case False{}:
1209 {==}
1210 case False{}:
1211 match b6:
1212 case True{}:
1213 match b7:
1214 case True{}:
1215 {==}
1216 case False{}:
1217 {==}
1218 case False{}:
1219 match b7:
1220 case True{}:
1221 {==}
1222 case False{}:
1223 {==}
1224 case False{}:
1225 match b3:
1226 case True{}:
1227 match b4:
1228 case True{}:
1229 match b5:
1230 case True{}:
1231 match b6:
1232 case True{}:
1233 match b7:
1234 case True{}:
1235 {==}
1236 case False{}:
1237 {==}
1238 case False{}:
1239 match b7:
1240 case True{}:
1241 {==}
1242 case False{}:
1243 {==}
1244 case False{}:
1245 match b6:
1246 case True{}:
1247 match b7:
1248 case True{}:
1249 {==}
1250 case False{}:
1251 {==}
1252 case False{}:
1253 match b7:
1254 case True{}:
1255 {==}
1256 case False{}:
1257 {==}
1258 case False{}:
1259 match b5:
1260 case True{}:
1261 match b6:
1262 case True{}:
1263 match b7:
1264 case True{}:
1265 {==}
1266 case False{}:
1267 {==}
1268 case False{}:
1269 match b7:
1270 case True{}:
1271 {==}
1272 case False{}:
1273 {==}
1274 case False{}:
1275 match b6:
1276 case True{}:
1277 match b7:
1278 case True{}:
1279 {==}
1280 case False{}:
1281 {==}
1282 case False{}:
1283 match b7:
1284 case True{}:
1285 {==}
1286 case False{}:
1287 {==}
1288 case False{}:
1289 match b4:
1290 case True{}:
1291 match b5:
1292 case True{}:
1293 match b6:
1294 case True{}:
1295 match b7:
1296 case True{}:
1297 {==}
1298 case False{}:
1299 {==}
1300 case False{}:
1301 match b7:
1302 case True{}:
1303 {==}
1304 case False{}:
1305 {==}
1306 case False{}:
1307 match b6:
1308 case True{}:
1309 match b7:
1310 case True{}:
1311 {==}
1312 case False{}:
1313 {==}
1314 case False{}:
1315 match b7:
1316 case True{}:
1317 {==}
1318 case False{}:
1319 {==}
1320 case False{}:
1321 match b5:
1322 case True{}:
1323 match b6:
1324 case True{}:
1325 match b7:
1326 case True{}:
1327 {==}
1328 case False{}:
1329 {==}
1330 case False{}:
1331 match b7:
1332 case True{}:
1333 {==}
1334 case False{}:
1335 {==}
1336 case False{}:
1337 match b6:
1338 case True{}:
1339 match b7:
1340 case True{}:
1341 {==}
1342 case False{}:
1343 {==}
1344 case False{}:
1345 match b7:
1346 case True{}:
1347 {==}
1348 case False{}:
1349 {==}
1350 case False{}:
1351 match b2:
1352 case True{}:
1353 match b3:
1354 case True{}:
1355 match b4:
1356 case True{}:
1357 match b5:
1358 case True{}:
1359 match b6:
1360 case True{}:
1361 match b7:
1362 case True{}:
1363 {==}
1364 case False{}:
1365 {==}
1366 case False{}:
1367 match b7:
1368 case True{}:
1369 {==}
1370 case False{}:
1371 {==}
1372 case False{}:
1373 match b6:
1374 case True{}:
1375 match b7:
1376 case True{}:
1377 {==}
1378 case False{}:
1379 {==}
1380 case False{}:
1381 match b7:
1382 case True{}:
1383 {==}
1384 case False{}:
1385 {==}
1386 case False{}:
1387 match b5:
1388 case True{}:
1389 match b6:
1390 case True{}:
1391 match b7:
1392 case True{}:
1393 {==}
1394 case False{}:
1395 {==}
1396 case False{}:
1397 match b7:
1398 case True{}:
1399 {==}
1400 case False{}:
1401 {==}
1402 case False{}:
1403 match b6:
1404 case True{}:
1405 match b7:
1406 case True{}:
1407 {==}
1408 case False{}:
1409 {==}
1410 case False{}:
1411 match b7:
1412 case True{}:
1413 {==}
1414 case False{}:
1415 {==}
1416 case False{}:
1417 match b4:
1418 case True{}:
1419 match b5:
1420 case True{}:
1421 match b6:
1422 case True{}:
1423 match b7:
1424 case True{}:
1425 {==}
1426 case False{}:
1427 {==}
1428 case False{}:
1429 match b7:
1430 case True{}:
1431 {==}
1432 case False{}:
1433 {==}
1434 case False{}:
1435 match b6:
1436 case True{}:
1437 match b7:
1438 case True{}:
1439 {==}
1440 case False{}:
1441 {==}
1442 case False{}:
1443 match b7:
1444 case True{}:
1445 {==}
1446 case False{}:
1447 {==}
1448 case False{}:
1449 match b5:
1450 case True{}:
1451 match b6:
1452 case True{}:
1453 match b7:
1454 case True{}:
1455 {==}
1456 case False{}:
1457 {==}
1458 case False{}:
1459 match b7:
1460 case True{}:
1461 {==}
1462 case False{}:
1463 {==}
1464 case False{}:
1465 match b6:
1466 case True{}:
1467 match b7:
1468 case True{}:
1469 {==}
1470 case False{}:
1471 {==}
1472 case False{}:
1473 match b7:
1474 case True{}:
1475 {==}
1476 case False{}:
1477 {==}
1478 case False{}:
1479 match b3:
1480 case True{}:
1481 match b4:
1482 case True{}:
1483 match b5:
1484 case True{}:
1485 match b6:
1486 case True{}:
1487 match b7:
1488 case True{}:
1489 {==}
1490 case False{}:
1491 {==}
1492 case False{}:
1493 match b7:
1494 case True{}:
1495 {==}
1496 case False{}:
1497 {==}
1498 case False{}:
1499 match b6:
1500 case True{}:
1501 match b7:
1502 case True{}:
1503 {==}
1504 case False{}:
1505 {==}
1506 case False{}:
1507 match b7:
1508 case True{}:
1509 {==}
1510 case False{}:
1511 {==}
1512 case False{}:
1513 match b5:
1514 case True{}:
1515 match b6:
1516 case True{}:
1517 match b7:
1518 case True{}:
1519 {==}
1520 case False{}:
1521 {==}
1522 case False{}:
1523 match b7:
1524 case True{}:
1525 {==}
1526 case False{}:
1527 {==}
1528 case False{}:
1529 match b6:
1530 case True{}:
1531 match b7:
1532 case True{}:
1533 {==}
1534 case False{}:
1535 {==}
1536 case False{}:
1537 match b7:
1538 case True{}:
1539 {==}
1540 case False{}:
1541 {==}
1542 case False{}:
1543 match b4:
1544 case True{}:
1545 match b5:
1546 case True{}:
1547 match b6:
1548 case True{}:
1549 match b7:
1550 case True{}:
1551 {==}
1552 case False{}:
1553 {==}
1554 case False{}:
1555 match b7:
1556 case True{}:
1557 {==}
1558 case False{}:
1559 {==}
1560 case False{}:
1561 match b6:
1562 case True{}:
1563 match b7:
1564 case True{}:
1565 {==}
1566 case False{}:
1567 {==}
1568 case False{}:
1569 match b7:
1570 case True{}:
1571 {==}
1572 case False{}:
1573 {==}
1574 case False{}:
1575 match b5:
1576 case True{}:
1577 match b6:
1578 case True{}:
1579 match b7:
1580 case True{}:
1581 {==}
1582 case False{}:
1583 {==}
1584 case False{}:
1585 match b7:
1586 case True{}:
1587 {==}
1588 case False{}:
1589 {==}
1590 case False{}:
1591 match b6:
1592 case True{}:
1593 match b7:
1594 case True{}:
1595 {==}
1596 case False{}:
1597 {==}
1598 case False{}:
1599 match b7:
1600 case True{}:
1601 {==}
1602 case False{}:
1603 {==}
1604
1605def 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}:
1606 match n:
1607 case 0n:
1608 {==}
1609 case 1n+k:
1610 %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}
1611 hf(k, G.Gf8Bits.x(acc, p), b, p)
1612
1613def 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}:
1614 match b p:
1615 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1616 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})
1617
1618def 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}:
1619 match b p:
1620 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1621 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})
1622
1623def 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}:
1624 match b p:
1625 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1626 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})
1627
1628def 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}:
1629 match b p:
1630 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1631 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})
1632
1633def 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}:
1634 match b p:
1635 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1636 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})
1637
1638def 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}:
1639 match b p:
1640 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1641 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})
1642
1643def 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}:
1644 match b p:
1645 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1646 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})
1647
1648def 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}:
1649 match b p:
1650 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7} G.Gf8Bits{p0, p1, p2, p3, p4, p5, p6, p7}:
1651 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})
1652
1653# 5. Commutativity and associativity
1654
1655def 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}:
1656 match p:
1657 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1658 %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}
1659 %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}
1660 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})))
1661
1662def 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}:
1663 match p:
1664 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1665 %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}
1666 %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}
1667 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})))
1668
1669def 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}:
1670 match p:
1671 case G.Gf8Bits{+p0, +p1, +p2, +p3, +p4, +p5, +p6, +p7}:
1672 %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}
1673 %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}
1674 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})))
1675
1676def 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}:
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{}, 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}
1680 %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}
1681 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})))
1682
1683def 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}:
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{}, 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}
1687 %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}
1688 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})))
1689
1690def 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}:
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{}, 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}
1694 %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}
1695 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})))
1696
1697def 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}:
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{}, 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}
1701 %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}
1702 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})))
1703
1704def 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}:
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{}, 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}
1708 %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}
1709 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})))
1710
1711def mlr(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {ml(basis(), b, p) == mr(basis(), b, p) : List<&2, G.Gf8Bits>}:
1712 %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>}
1713 %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>}
1714 %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>}
1715 %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>}
1716 %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>}
1717 %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>}
1718 %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>}
1719 %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>}
1720 {==}
1721
1722def comm(+a: G.Gf8Bits, +b: G.Gf8Bits, +p: G.Gf8Bits) -> {G.Gf8Bits.mul(a, b, p) == G.Gf8Bits.mul(b, a, p) : G.Gf8Bits}:
1723 %dec(a) : {G.Gf8Bits.mul(_, b, p) == G.Gf8Bits.mul(b, a, p) : G.Gf8Bits}
1724 %dec(a) : {G.Gf8Bits.mul(ss(bl(a), basis()), b, p) == G.Gf8Bits.mul(b, _, p) : G.Gf8Bits}
1725 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))))
1726
1727def ml_x(+b: G.Gf8Bits, +p: G.Gf8Bits) -> {ml(basis(), b, p) == xs(b, p) : List<&2, G.Gf8Bits>}:
1728 %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>}
1729 %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>}
1730 %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>}
1731 %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>}
1732 %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>}
1733 %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>}
1734 %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>}
1735 %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>}
1736 {==}
1737
1738def 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}:
1739 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)))))))
1740
1741def 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}:
1742 match n:
1743 case 0n:
1744 {==}
1745 case 1n+k:
1746 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)))
1747
1748def 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>}:
1749 %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>}
1750 %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>}
1751 %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>}
1752 %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>}
1753 %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>}
1754 %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>}
1755 %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>}
1756 %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>}
1757 {==}
1758
1759def 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}:
1760 %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}
1761 %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}
1762 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)))))
1763
1764# 6. The laws, on U32, through Gf8Bits.of (Gf8Bits.to (r)) = r
1765
1766def ot(+r: G.Gf8Bits) -> {G.Gf8Bits.of(G.Gf8Bits.to(r)) == r : G.Gf8Bits}:
1767 match r:
1768 case G.Gf8Bits{b0, b1, b2, b3, b4, b5, b6, b7}:
1769 {==}
1770
1771def bdisc(+b: Bool) -> Type:
1772 match b:
1773 case True{}:
1774 Unit
1775 case False{}:
1776 Empty
1777
1778def bt_absurd(+e: {True{} == False{} : Bool}) -> Empty:
1779 %e : bdisc(_)
1780 Unit{}
1781
1782def Laws.mul_comm(f, a, b):
1783 match f:
1784 case G.Gf8Field{+poly, gen}:
1785 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)))
1786
1787def Laws.mul_assoc(f, a, b, c):
1788 match f:
1789 case G.Gf8Field{+poly, gen}:
1790 %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}
1791 %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}
1792 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)))
1793
1794def Laws.mul_distrib(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.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}
1798 %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}
1799 %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}
1800 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)))
1801
1802def Laws.mul_one(f, a):
1803 match f:
1804 case G.Gf8Field{+poly, gen}:
1805 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)))
1806
1807def Laws.mul_zero(f, a):
1808 match f:
1809 case G.Gf8Field{+poly, gen}:
1810 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)))
1811
1812def Laws.xtime_mul_x(f, a):
1813 match f:
1814 case G.Gf8Field{+poly, gen}:
1815 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))))
1816
1817def Laws.add_comm(a, b):
1818 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)))
1819
1820def Laws.add_assoc(a, b, c):
1821 %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}
1822 %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}
1823 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)))
1824
1825def Laws.add_zero(a):
1826 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)))
1827
1828def Laws.add_self(a):
1829 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)))
1830
1831def 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}:
1832 match n:
1833 case 0n:
1834 {==}
1835 case 1n+k:
1836 match f:
1837 case G.Gf8Field{+poly, +gen}:
1838 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))))
1839
1840def Laws.pow_add(f, a, m, n):
1841 match m:
1842 case 0n:
1843 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)))
1844 case 1n+k:
1845 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))))
1846
1847def Laws.inv_zero(f):
1848 Laws.mul_zero(f, G.Gf8.pow(f, 0, 253n))
1849
1850def 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}:
1851 match f:
1852 case G.Gf8Field{+poly, gen}:
1853 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))))
1854
1855def 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}:
1856 match n:
1857 case 0n:
1858 {==}
1859 case 1n+k:
1860 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)))
1861
1862def log_elt(+f: G.Gf8Field, +a: U32) -> {G.Gf8.log(f, a) == G.Gf8.log(f, G.Gf8.elt(a)) : Nat}:
1863 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))))
1864
1865def 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}:
1866 {==}
1867
1868# a nonzero byte as itself, and 0 as 1, so that the per-byte facts hold
1869# for every byte and need no hypothesis while they are split into cases
1870def fixz(+x: U32) -> U32:
1871 Bool.pick(U32, G.Gf8.is_zero(x), 1, x)
1872
1873def fix_nz(+a: U32, nz: {G.Gf8.is_zero(a) == False{} : Bool}) -> {fixz(G.Gf8.elt(a)) == G.Gf8.elt(a) : U32}:
1874 %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}
1875 %Equal.sym(Bool, G.Gf8.is_zero(a), False{}, nz) : {Bool.pick(U32, _, 1, G.Gf8.elt(a)) == G.Gf8.elt(a) : U32}
1876 {==}
1877
1878def 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}:
1879 match b5:
1880 case True{}:
1881 match b6:
1882 case True{}:
1883 match b7:
1884 case True{}:
1885 {==}
1886 case False{}:
1887 {==}
1888 case False{}:
1889 match b7:
1890 case True{}:
1891 {==}
1892 case False{}:
1893 {==}
1894 case False{}:
1895 match b6:
1896 case True{}:
1897 match b7:
1898 case True{}:
1899 {==}
1900 case False{}:
1901 {==}
1902 case False{}:
1903 match b7:
1904 case True{}:
1905 {==}
1906 case False{}:
1907 {==}
1908
1909def 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}:
1910 match b5:
1911 case True{}:
1912 match b6:
1913 case True{}:
1914 match b7:
1915 case True{}:
1916 {==}
1917 case False{}:
1918 {==}
1919 case False{}:
1920 match b7:
1921 case True{}:
1922 {==}
1923 case False{}:
1924 {==}
1925 case False{}:
1926 match b6:
1927 case True{}:
1928 match b7:
1929 case True{}:
1930 {==}
1931 case False{}:
1932 {==}
1933 case False{}:
1934 match b7:
1935 case True{}:
1936 {==}
1937 case False{}:
1938 {==}
1939
1940def 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}:
1941 match b5:
1942 case True{}:
1943 match b6:
1944 case True{}:
1945 match b7:
1946 case True{}:
1947 {==}
1948 case False{}:
1949 {==}
1950 case False{}:
1951 match b7:
1952 case True{}:
1953 {==}
1954 case False{}:
1955 {==}
1956 case False{}:
1957 match b6:
1958 case True{}:
1959 match b7:
1960 case True{}:
1961 {==}
1962 case False{}:
1963 {==}
1964 case False{}:
1965 match b7:
1966 case True{}:
1967 {==}
1968 case False{}:
1969 {==}
1970
1971def 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}:
1972 match b5:
1973 case True{}:
1974 match b6:
1975 case True{}:
1976 match b7:
1977 case True{}:
1978 {==}
1979 case False{}:
1980 {==}
1981 case False{}:
1982 match b7:
1983 case True{}:
1984 {==}
1985 case False{}:
1986 {==}
1987 case False{}:
1988 match b6:
1989 case True{}:
1990 match b7:
1991 case True{}:
1992 {==}
1993 case False{}:
1994 {==}
1995 case False{}:
1996 match b7:
1997 case True{}:
1998 {==}
1999 case False{}:
2000 {==}
2001
2002def 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}:
2003 match b5:
2004 case True{}:
2005 match b6:
2006 case True{}:
2007 match b7:
2008 case True{}:
2009 {==}
2010 case False{}:
2011 {==}
2012 case False{}:
2013 match b7:
2014 case True{}:
2015 {==}
2016 case False{}:
2017 {==}
2018 case False{}:
2019 match b6:
2020 case True{}:
2021 match b7:
2022 case True{}:
2023 {==}
2024 case False{}:
2025 {==}
2026 case False{}:
2027 match b7:
2028 case True{}:
2029 {==}
2030 case False{}:
2031 {==}
2032
2033def 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}:
2034 match b5:
2035 case True{}:
2036 match b6:
2037 case True{}:
2038 match b7:
2039 case True{}:
2040 {==}
2041 case False{}:
2042 {==}
2043 case False{}:
2044 match b7:
2045 case True{}:
2046 {==}
2047 case False{}:
2048 {==}
2049 case False{}:
2050 match b6:
2051 case True{}:
2052 match b7:
2053 case True{}:
2054 {==}
2055 case False{}:
2056 {==}
2057 case False{}:
2058 match b7:
2059 case True{}:
2060 {==}
2061 case False{}:
2062 {==}
2063
2064def 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}:
2065 match b5:
2066 case True{}:
2067 match b6:
2068 case True{}:
2069 match b7:
2070 case True{}:
2071 {==}
2072 case False{}:
2073 {==}
2074 case False{}:
2075 match b7:
2076 case True{}:
2077 {==}
2078 case False{}:
2079 {==}
2080 case False{}:
2081 match b6:
2082 case True{}:
2083 match b7:
2084 case True{}:
2085 {==}
2086 case False{}:
2087 {==}
2088 case False{}:
2089 match b7:
2090 case True{}:
2091 {==}
2092 case False{}:
2093 {==}
2094
2095def 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}:
2096 match b5:
2097 case True{}:
2098 match b6:
2099 case True{}:
2100 match b7:
2101 case True{}:
2102 {==}
2103 case False{}:
2104 {==}
2105 case False{}:
2106 match b7:
2107 case True{}:
2108 {==}
2109 case False{}:
2110 {==}
2111 case False{}:
2112 match b6:
2113 case True{}:
2114 match b7:
2115 case True{}:
2116 {==}
2117 case False{}:
2118 {==}
2119 case False{}:
2120 match b7:
2121 case True{}:
2122 {==}
2123 case False{}:
2124 {==}
2125
2126def 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}:
2127 match b5:
2128 case True{}:
2129 match b6:
2130 case True{}:
2131 match b7:
2132 case True{}:
2133 {==}
2134 case False{}:
2135 {==}
2136 case False{}:
2137 match b7:
2138 case True{}:
2139 {==}
2140 case False{}:
2141 {==}
2142 case False{}:
2143 match b6:
2144 case True{}:
2145 match b7:
2146 case True{}:
2147 {==}
2148 case False{}:
2149 {==}
2150 case False{}:
2151 match b7:
2152 case True{}:
2153 {==}
2154 case False{}:
2155 {==}
2156
2157def 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}:
2158 match b5:
2159 case True{}:
2160 match b6:
2161 case True{}:
2162 match b7:
2163 case True{}:
2164 {==}
2165 case False{}:
2166 {==}
2167 case False{}:
2168 match b7:
2169 case True{}:
2170 {==}
2171 case False{}:
2172 {==}
2173 case False{}:
2174 match b6:
2175 case True{}:
2176 match b7:
2177 case True{}:
2178 {==}
2179 case False{}:
2180 {==}
2181 case False{}:
2182 match b7:
2183 case True{}:
2184 {==}
2185 case False{}:
2186 {==}
2187
2188def 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}:
2189 match b5:
2190 case True{}:
2191 match b6:
2192 case True{}:
2193 match b7:
2194 case True{}:
2195 {==}
2196 case False{}:
2197 {==}
2198 case False{}:
2199 match b7:
2200 case True{}:
2201 {==}
2202 case False{}:
2203 {==}
2204 case False{}:
2205 match b6:
2206 case True{}:
2207 match b7:
2208 case True{}:
2209 {==}
2210 case False{}:
2211 {==}
2212 case False{}:
2213 match b7:
2214 case True{}:
2215 {==}
2216 case False{}:
2217 {==}
2218
2219def 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}:
2220 match b5:
2221 case True{}:
2222 match b6:
2223 case True{}:
2224 match b7:
2225 case True{}:
2226 {==}
2227 case False{}:
2228 {==}
2229 case False{}:
2230 match b7:
2231 case True{}:
2232 {==}
2233 case False{}:
2234 {==}
2235 case False{}:
2236 match b6:
2237 case True{}:
2238 match b7:
2239 case True{}:
2240 {==}
2241 case False{}:
2242 {==}
2243 case False{}:
2244 match b7:
2245 case True{}:
2246 {==}
2247 case False{}:
2248 {==}
2249
2250def 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}:
2251 match b5:
2252 case True{}:
2253 match b6:
2254 case True{}:
2255 match b7:
2256 case True{}:
2257 {==}
2258 case False{}:
2259 {==}
2260 case False{}:
2261 match b7:
2262 case True{}:
2263 {==}
2264 case False{}:
2265 {==}
2266 case False{}:
2267 match b6:
2268 case True{}:
2269 match b7:
2270 case True{}:
2271 {==}
2272 case False{}:
2273 {==}
2274 case False{}:
2275 match b7:
2276 case True{}:
2277 {==}
2278 case False{}:
2279 {==}
2280
2281def 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}:
2282 match b5:
2283 case True{}:
2284 match b6:
2285 case True{}:
2286 match b7:
2287 case True{}:
2288 {==}
2289 case False{}:
2290 {==}
2291 case False{}:
2292 match b7:
2293 case True{}:
2294 {==}
2295 case False{}:
2296 {==}
2297 case False{}:
2298 match b6:
2299 case True{}:
2300 match b7:
2301 case True{}:
2302 {==}
2303 case False{}:
2304 {==}
2305 case False{}:
2306 match b7:
2307 case True{}:
2308 {==}
2309 case False{}:
2310 {==}
2311
2312def 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}:
2313 match b5:
2314 case True{}:
2315 match b6:
2316 case True{}:
2317 match b7:
2318 case True{}:
2319 {==}
2320 case False{}:
2321 {==}
2322 case False{}:
2323 match b7:
2324 case True{}:
2325 {==}
2326 case False{}:
2327 {==}
2328 case False{}:
2329 match b6:
2330 case True{}:
2331 match b7:
2332 case True{}:
2333 {==}
2334 case False{}:
2335 {==}
2336 case False{}:
2337 match b7:
2338 case True{}:
2339 {==}
2340 case False{}:
2341 {==}
2342
2343def 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}:
2344 match b5:
2345 case True{}:
2346 match b6:
2347 case True{}:
2348 match b7:
2349 case True{}:
2350 {==}
2351 case False{}:
2352 {==}
2353 case False{}:
2354 match b7:
2355 case True{}:
2356 {==}
2357 case False{}:
2358 {==}
2359 case False{}:
2360 match b6:
2361 case True{}:
2362 match b7:
2363 case True{}:
2364 {==}
2365 case False{}:
2366 {==}
2367 case False{}:
2368 match b7:
2369 case True{}:
2370 {==}
2371 case False{}:
2372 {==}
2373
2374def 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}:
2375 match b5:
2376 case True{}:
2377 match b6:
2378 case True{}:
2379 match b7:
2380 case True{}:
2381 {==}
2382 case False{}:
2383 {==}
2384 case False{}:
2385 match b7:
2386 case True{}:
2387 {==}
2388 case False{}:
2389 {==}
2390 case False{}:
2391 match b6:
2392 case True{}:
2393 match b7:
2394 case True{}:
2395 {==}
2396 case False{}:
2397 {==}
2398 case False{}:
2399 match b7:
2400 case True{}:
2401 {==}
2402 case False{}:
2403 {==}
2404
2405def 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}:
2406 match b5:
2407 case True{}:
2408 match b6:
2409 case True{}:
2410 match b7:
2411 case True{}:
2412 {==}
2413 case False{}:
2414 {==}
2415 case False{}:
2416 match b7:
2417 case True{}:
2418 {==}
2419 case False{}:
2420 {==}
2421 case False{}:
2422 match b6:
2423 case True{}:
2424 match b7:
2425 case True{}:
2426 {==}
2427 case False{}:
2428 {==}
2429 case False{}:
2430 match b7:
2431 case True{}:
2432 {==}
2433 case False{}:
2434 {==}
2435
2436def 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}:
2437 match b5:
2438 case True{}:
2439 match b6:
2440 case True{}:
2441 match b7:
2442 case True{}:
2443 {==}
2444 case False{}:
2445 {==}
2446 case False{}:
2447 match b7:
2448 case True{}:
2449 {==}
2450 case False{}:
2451 {==}
2452 case False{}:
2453 match b6:
2454 case True{}:
2455 match b7:
2456 case True{}:
2457 {==}
2458 case False{}:
2459 {==}
2460 case False{}:
2461 match b7:
2462 case True{}:
2463 {==}
2464 case False{}:
2465 {==}
2466
2467def 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}:
2468 match b5:
2469 case True{}:
2470 match b6:
2471 case True{}:
2472 match b7:
2473 case True{}:
2474 {==}
2475 case False{}:
2476 {==}
2477 case False{}:
2478 match b7:
2479 case True{}:
2480 {==}
2481 case False{}:
2482 {==}
2483 case False{}:
2484 match b6:
2485 case True{}:
2486 match b7:
2487 case True{}:
2488 {==}
2489 case False{}:
2490 {==}
2491 case False{}:
2492 match b7:
2493 case True{}:
2494 {==}
2495 case False{}:
2496 {==}
2497
2498def 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}:
2499 match b5:
2500 case True{}:
2501 match b6:
2502 case True{}:
2503 match b7:
2504 case True{}:
2505 {==}
2506 case False{}:
2507 {==}
2508 case False{}:
2509 match b7:
2510 case True{}:
2511 {==}
2512 case False{}:
2513 {==}
2514 case False{}:
2515 match b6:
2516 case True{}:
2517 match b7:
2518 case True{}:
2519 {==}
2520 case False{}:
2521 {==}
2522 case False{}:
2523 match b7:
2524 case True{}:
2525 {==}
2526 case False{}:
2527 {==}
2528
2529def 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}:
2530 match b5:
2531 case True{}:
2532 match b6:
2533 case True{}:
2534 match b7:
2535 case True{}:
2536 {==}
2537 case False{}:
2538 {==}
2539 case False{}:
2540 match b7:
2541 case True{}:
2542 {==}
2543 case False{}:
2544 {==}
2545 case False{}:
2546 match b6:
2547 case True{}:
2548 match b7:
2549 case True{}:
2550 {==}
2551 case False{}:
2552 {==}
2553 case False{}:
2554 match b7:
2555 case True{}:
2556 {==}
2557 case False{}:
2558 {==}
2559
2560def 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}:
2561 match b5:
2562 case True{}:
2563 match b6:
2564 case True{}:
2565 match b7:
2566 case True{}:
2567 {==}
2568 case False{}:
2569 {==}
2570 case False{}:
2571 match b7:
2572 case True{}:
2573 {==}
2574 case False{}:
2575 {==}
2576 case False{}:
2577 match b6:
2578 case True{}:
2579 match b7:
2580 case True{}:
2581 {==}
2582 case False{}:
2583 {==}
2584 case False{}:
2585 match b7:
2586 case True{}:
2587 {==}
2588 case False{}:
2589 {==}
2590
2591def 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}:
2592 match b5:
2593 case True{}:
2594 match b6:
2595 case True{}:
2596 match b7:
2597 case True{}:
2598 {==}
2599 case False{}:
2600 {==}
2601 case False{}:
2602 match b7:
2603 case True{}:
2604 {==}
2605 case False{}:
2606 {==}
2607 case False{}:
2608 match b6:
2609 case True{}:
2610 match b7:
2611 case True{}:
2612 {==}
2613 case False{}:
2614 {==}
2615 case False{}:
2616 match b7:
2617 case True{}:
2618 {==}
2619 case False{}:
2620 {==}
2621
2622def 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}:
2623 match b5:
2624 case True{}:
2625 match b6:
2626 case True{}:
2627 match b7:
2628 case True{}:
2629 {==}
2630 case False{}:
2631 {==}
2632 case False{}:
2633 match b7:
2634 case True{}:
2635 {==}
2636 case False{}:
2637 {==}
2638 case False{}:
2639 match b6:
2640 case True{}:
2641 match b7:
2642 case True{}:
2643 {==}
2644 case False{}:
2645 {==}
2646 case False{}:
2647 match b7:
2648 case True{}:
2649 {==}
2650 case False{}:
2651 {==}
2652
2653def 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}:
2654 match b5:
2655 case True{}:
2656 match b6:
2657 case True{}:
2658 match b7:
2659 case True{}:
2660 {==}
2661 case False{}:
2662 {==}
2663 case False{}:
2664 match b7:
2665 case True{}:
2666 {==}
2667 case False{}:
2668 {==}
2669 case False{}:
2670 match b6:
2671 case True{}:
2672 match b7:
2673 case True{}:
2674 {==}
2675 case False{}:
2676 {==}
2677 case False{}:
2678 match b7:
2679 case True{}:
2680 {==}
2681 case False{}:
2682 {==}
2683
2684def 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}:
2685 match b5:
2686 case True{}:
2687 match b6:
2688 case True{}:
2689 match b7:
2690 case True{}:
2691 {==}
2692 case False{}:
2693 {==}
2694 case False{}:
2695 match b7:
2696 case True{}:
2697 {==}
2698 case False{}:
2699 {==}
2700 case False{}:
2701 match b6:
2702 case True{}:
2703 match b7:
2704 case True{}:
2705 {==}
2706 case False{}:
2707 {==}
2708 case False{}:
2709 match b7:
2710 case True{}:
2711 {==}
2712 case False{}:
2713 {==}
2714
2715def 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}:
2716 match b5:
2717 case True{}:
2718 match b6:
2719 case True{}:
2720 match b7:
2721 case True{}:
2722 {==}
2723 case False{}:
2724 {==}
2725 case False{}:
2726 match b7:
2727 case True{}:
2728 {==}
2729 case False{}:
2730 {==}
2731 case False{}:
2732 match b6:
2733 case True{}:
2734 match b7:
2735 case True{}:
2736 {==}
2737 case False{}:
2738 {==}
2739 case False{}:
2740 match b7:
2741 case True{}:
2742 {==}
2743 case False{}:
2744 {==}
2745
2746def 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}:
2747 match b5:
2748 case True{}:
2749 match b6:
2750 case True{}:
2751 match b7:
2752 case True{}:
2753 {==}
2754 case False{}:
2755 {==}
2756 case False{}:
2757 match b7:
2758 case True{}:
2759 {==}
2760 case False{}:
2761 {==}
2762 case False{}:
2763 match b6:
2764 case True{}:
2765 match b7:
2766 case True{}:
2767 {==}
2768 case False{}:
2769 {==}
2770 case False{}:
2771 match b7:
2772 case True{}:
2773 {==}
2774 case False{}:
2775 {==}
2776
2777def 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}:
2778 match b5:
2779 case True{}:
2780 match b6:
2781 case True{}:
2782 match b7:
2783 case True{}:
2784 {==}
2785 case False{}:
2786 {==}
2787 case False{}:
2788 match b7:
2789 case True{}:
2790 {==}
2791 case False{}:
2792 {==}
2793 case False{}:
2794 match b6:
2795 case True{}:
2796 match b7:
2797 case True{}:
2798 {==}
2799 case False{}:
2800 {==}
2801 case False{}:
2802 match b7:
2803 case True{}:
2804 {==}
2805 case False{}:
2806 {==}
2807
2808def 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}:
2809 match b5:
2810 case True{}:
2811 match b6:
2812 case True{}:
2813 match b7:
2814 case True{}:
2815 {==}
2816 case False{}:
2817 {==}
2818 case False{}:
2819 match b7:
2820 case True{}:
2821 {==}
2822 case False{}:
2823 {==}
2824 case False{}:
2825 match b6:
2826 case True{}:
2827 match b7:
2828 case True{}:
2829 {==}
2830 case False{}:
2831 {==}
2832 case False{}:
2833 match b7:
2834 case True{}:
2835 {==}
2836 case False{}:
2837 {==}
2838
2839def 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}:
2840 match b5:
2841 case True{}:
2842 match b6:
2843 case True{}:
2844 match b7:
2845 case True{}:
2846 {==}
2847 case False{}:
2848 {==}
2849 case False{}:
2850 match b7:
2851 case True{}:
2852 {==}
2853 case False{}:
2854 {==}
2855 case False{}:
2856 match b6:
2857 case True{}:
2858 match b7:
2859 case True{}:
2860 {==}
2861 case False{}:
2862 {==}
2863 case False{}:
2864 match b7:
2865 case True{}:
2866 {==}
2867 case False{}:
2868 {==}
2869
2870def 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}:
2871 match b0:
2872 case True{}:
2873 match b1:
2874 case True{}:
2875 match b2:
2876 case True{}:
2877 match b3:
2878 case True{}:
2879 match b4:
2880 case True{}:
2881 mul_inv_aes.s11111(b5, b6, b7)
2882 case False{}:
2883 mul_inv_aes.s11110(b5, b6, b7)
2884 case False{}:
2885 match b4:
2886 case True{}:
2887 mul_inv_aes.s11101(b5, b6, b7)
2888 case False{}:
2889 mul_inv_aes.s11100(b5, b6, b7)
2890 case False{}:
2891 match b3:
2892 case True{}:
2893 match b4:
2894 case True{}:
2895 mul_inv_aes.s11011(b5, b6, b7)
2896 case False{}:
2897 mul_inv_aes.s11010(b5, b6, b7)
2898 case False{}:
2899 match b4:
2900 case True{}:
2901 mul_inv_aes.s11001(b5, b6, b7)
2902 case False{}:
2903 mul_inv_aes.s11000(b5, b6, b7)
2904 case False{}:
2905 match b2:
2906 case True{}:
2907 match b3:
2908 case True{}:
2909 match b4:
2910 case True{}:
2911 mul_inv_aes.s10111(b5, b6, b7)
2912 case False{}:
2913 mul_inv_aes.s10110(b5, b6, b7)
2914 case False{}:
2915 match b4:
2916 case True{}:
2917 mul_inv_aes.s10101(b5, b6, b7)
2918 case False{}:
2919 mul_inv_aes.s10100(b5, b6, b7)
2920 case False{}:
2921 match b3:
2922 case True{}:
2923 match b4:
2924 case True{}:
2925 mul_inv_aes.s10011(b5, b6, b7)
2926 case False{}:
2927 mul_inv_aes.s10010(b5, b6, b7)
2928 case False{}:
2929 match b4:
2930 case True{}:
2931 mul_inv_aes.s10001(b5, b6, b7)
2932 case False{}:
2933 mul_inv_aes.s10000(b5, b6, b7)
2934 case False{}:
2935 match b1:
2936 case True{}:
2937 match b2:
2938 case True{}:
2939 match b3:
2940 case True{}:
2941 match b4:
2942 case True{}:
2943 mul_inv_aes.s01111(b5, b6, b7)
2944 case False{}:
2945 mul_inv_aes.s01110(b5, b6, b7)
2946 case False{}:
2947 match b4:
2948 case True{}:
2949 mul_inv_aes.s01101(b5, b6, b7)
2950 case False{}:
2951 mul_inv_aes.s01100(b5, b6, b7)
2952 case False{}:
2953 match b3:
2954 case True{}:
2955 match b4:
2956 case True{}:
2957 mul_inv_aes.s01011(b5, b6, b7)
2958 case False{}:
2959 mul_inv_aes.s01010(b5, b6, b7)
2960 case False{}:
2961 match b4:
2962 case True{}:
2963 mul_inv_aes.s01001(b5, b6, b7)
2964 case False{}:
2965 mul_inv_aes.s01000(b5, b6, b7)
2966 case False{}:
2967 match b2:
2968 case True{}:
2969 match b3:
2970 case True{}:
2971 match b4:
2972 case True{}:
2973 mul_inv_aes.s00111(b5, b6, b7)
2974 case False{}:
2975 mul_inv_aes.s00110(b5, b6, b7)
2976 case False{}:
2977 match b4:
2978 case True{}:
2979 mul_inv_aes.s00101(b5, b6, b7)
2980 case False{}:
2981 mul_inv_aes.s00100(b5, b6, b7)
2982 case False{}:
2983 match b3:
2984 case True{}:
2985 match b4:
2986 case True{}:
2987 mul_inv_aes.s00011(b5, b6, b7)
2988 case False{}:
2989 mul_inv_aes.s00010(b5, b6, b7)
2990 case False{}:
2991 match b4:
2992 case True{}:
2993 mul_inv_aes.s00001(b5, b6, b7)
2994 case False{}:
2995 mul_inv_aes.s00000(b5, b6, b7)
2996
2997def 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}:
2998 match a:
2999 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
3000 %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}
3001 mul_inv_aes.bits(b0, b1, b2, b3, b4, b5, b6, b7)
3002
3003def 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}:
3004 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.aes(), _, G.Gf8.inv(G.Gf8.aes(), G.Gf8.elt(a))) == 1 : U32}
3005 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.aes(), fixz(G.Gf8.elt(a)), G.Gf8.inv(G.Gf8.aes(), _)) == 1 : U32}
3006 mul_inv_aes.core(a)
3007
3008def Laws.mul_inv_aes(a, nz):
3009 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)))
3010
3011def 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}:
3012 match b5:
3013 case True{}:
3014 match b6:
3015 case True{}:
3016 match b7:
3017 case True{}:
3018 {==}
3019 case False{}:
3020 {==}
3021 case False{}:
3022 match b7:
3023 case True{}:
3024 {==}
3025 case False{}:
3026 {==}
3027 case False{}:
3028 match b6:
3029 case True{}:
3030 match b7:
3031 case True{}:
3032 {==}
3033 case False{}:
3034 {==}
3035 case False{}:
3036 match b7:
3037 case True{}:
3038 {==}
3039 case False{}:
3040 {==}
3041
3042def 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}:
3043 match b5:
3044 case True{}:
3045 match b6:
3046 case True{}:
3047 match b7:
3048 case True{}:
3049 {==}
3050 case False{}:
3051 {==}
3052 case False{}:
3053 match b7:
3054 case True{}:
3055 {==}
3056 case False{}:
3057 {==}
3058 case False{}:
3059 match b6:
3060 case True{}:
3061 match b7:
3062 case True{}:
3063 {==}
3064 case False{}:
3065 {==}
3066 case False{}:
3067 match b7:
3068 case True{}:
3069 {==}
3070 case False{}:
3071 {==}
3072
3073def 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}:
3074 match b5:
3075 case True{}:
3076 match b6:
3077 case True{}:
3078 match b7:
3079 case True{}:
3080 {==}
3081 case False{}:
3082 {==}
3083 case False{}:
3084 match b7:
3085 case True{}:
3086 {==}
3087 case False{}:
3088 {==}
3089 case False{}:
3090 match b6:
3091 case True{}:
3092 match b7:
3093 case True{}:
3094 {==}
3095 case False{}:
3096 {==}
3097 case False{}:
3098 match b7:
3099 case True{}:
3100 {==}
3101 case False{}:
3102 {==}
3103
3104def 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}:
3105 match b5:
3106 case True{}:
3107 match b6:
3108 case True{}:
3109 match b7:
3110 case True{}:
3111 {==}
3112 case False{}:
3113 {==}
3114 case False{}:
3115 match b7:
3116 case True{}:
3117 {==}
3118 case False{}:
3119 {==}
3120 case False{}:
3121 match b6:
3122 case True{}:
3123 match b7:
3124 case True{}:
3125 {==}
3126 case False{}:
3127 {==}
3128 case False{}:
3129 match b7:
3130 case True{}:
3131 {==}
3132 case False{}:
3133 {==}
3134
3135def 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}:
3136 match b5:
3137 case True{}:
3138 match b6:
3139 case True{}:
3140 match b7:
3141 case True{}:
3142 {==}
3143 case False{}:
3144 {==}
3145 case False{}:
3146 match b7:
3147 case True{}:
3148 {==}
3149 case False{}:
3150 {==}
3151 case False{}:
3152 match b6:
3153 case True{}:
3154 match b7:
3155 case True{}:
3156 {==}
3157 case False{}:
3158 {==}
3159 case False{}:
3160 match b7:
3161 case True{}:
3162 {==}
3163 case False{}:
3164 {==}
3165
3166def 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}:
3167 match b5:
3168 case True{}:
3169 match b6:
3170 case True{}:
3171 match b7:
3172 case True{}:
3173 {==}
3174 case False{}:
3175 {==}
3176 case False{}:
3177 match b7:
3178 case True{}:
3179 {==}
3180 case False{}:
3181 {==}
3182 case False{}:
3183 match b6:
3184 case True{}:
3185 match b7:
3186 case True{}:
3187 {==}
3188 case False{}:
3189 {==}
3190 case False{}:
3191 match b7:
3192 case True{}:
3193 {==}
3194 case False{}:
3195 {==}
3196
3197def 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}:
3198 match b5:
3199 case True{}:
3200 match b6:
3201 case True{}:
3202 match b7:
3203 case True{}:
3204 {==}
3205 case False{}:
3206 {==}
3207 case False{}:
3208 match b7:
3209 case True{}:
3210 {==}
3211 case False{}:
3212 {==}
3213 case False{}:
3214 match b6:
3215 case True{}:
3216 match b7:
3217 case True{}:
3218 {==}
3219 case False{}:
3220 {==}
3221 case False{}:
3222 match b7:
3223 case True{}:
3224 {==}
3225 case False{}:
3226 {==}
3227
3228def 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}:
3229 match b5:
3230 case True{}:
3231 match b6:
3232 case True{}:
3233 match b7:
3234 case True{}:
3235 {==}
3236 case False{}:
3237 {==}
3238 case False{}:
3239 match b7:
3240 case True{}:
3241 {==}
3242 case False{}:
3243 {==}
3244 case False{}:
3245 match b6:
3246 case True{}:
3247 match b7:
3248 case True{}:
3249 {==}
3250 case False{}:
3251 {==}
3252 case False{}:
3253 match b7:
3254 case True{}:
3255 {==}
3256 case False{}:
3257 {==}
3258
3259def 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}:
3260 match b5:
3261 case True{}:
3262 match b6:
3263 case True{}:
3264 match b7:
3265 case True{}:
3266 {==}
3267 case False{}:
3268 {==}
3269 case False{}:
3270 match b7:
3271 case True{}:
3272 {==}
3273 case False{}:
3274 {==}
3275 case False{}:
3276 match b6:
3277 case True{}:
3278 match b7:
3279 case True{}:
3280 {==}
3281 case False{}:
3282 {==}
3283 case False{}:
3284 match b7:
3285 case True{}:
3286 {==}
3287 case False{}:
3288 {==}
3289
3290def 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}:
3291 match b5:
3292 case True{}:
3293 match b6:
3294 case True{}:
3295 match b7:
3296 case True{}:
3297 {==}
3298 case False{}:
3299 {==}
3300 case False{}:
3301 match b7:
3302 case True{}:
3303 {==}
3304 case False{}:
3305 {==}
3306 case False{}:
3307 match b6:
3308 case True{}:
3309 match b7:
3310 case True{}:
3311 {==}
3312 case False{}:
3313 {==}
3314 case False{}:
3315 match b7:
3316 case True{}:
3317 {==}
3318 case False{}:
3319 {==}
3320
3321def 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}:
3322 match b5:
3323 case True{}:
3324 match b6:
3325 case True{}:
3326 match b7:
3327 case True{}:
3328 {==}
3329 case False{}:
3330 {==}
3331 case False{}:
3332 match b7:
3333 case True{}:
3334 {==}
3335 case False{}:
3336 {==}
3337 case False{}:
3338 match b6:
3339 case True{}:
3340 match b7:
3341 case True{}:
3342 {==}
3343 case False{}:
3344 {==}
3345 case False{}:
3346 match b7:
3347 case True{}:
3348 {==}
3349 case False{}:
3350 {==}
3351
3352def 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}:
3353 match b5:
3354 case True{}:
3355 match b6:
3356 case True{}:
3357 match b7:
3358 case True{}:
3359 {==}
3360 case False{}:
3361 {==}
3362 case False{}:
3363 match b7:
3364 case True{}:
3365 {==}
3366 case False{}:
3367 {==}
3368 case False{}:
3369 match b6:
3370 case True{}:
3371 match b7:
3372 case True{}:
3373 {==}
3374 case False{}:
3375 {==}
3376 case False{}:
3377 match b7:
3378 case True{}:
3379 {==}
3380 case False{}:
3381 {==}
3382
3383def 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}:
3384 match b5:
3385 case True{}:
3386 match b6:
3387 case True{}:
3388 match b7:
3389 case True{}:
3390 {==}
3391 case False{}:
3392 {==}
3393 case False{}:
3394 match b7:
3395 case True{}:
3396 {==}
3397 case False{}:
3398 {==}
3399 case False{}:
3400 match b6:
3401 case True{}:
3402 match b7:
3403 case True{}:
3404 {==}
3405 case False{}:
3406 {==}
3407 case False{}:
3408 match b7:
3409 case True{}:
3410 {==}
3411 case False{}:
3412 {==}
3413
3414def 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}:
3415 match b5:
3416 case True{}:
3417 match b6:
3418 case True{}:
3419 match b7:
3420 case True{}:
3421 {==}
3422 case False{}:
3423 {==}
3424 case False{}:
3425 match b7:
3426 case True{}:
3427 {==}
3428 case False{}:
3429 {==}
3430 case False{}:
3431 match b6:
3432 case True{}:
3433 match b7:
3434 case True{}:
3435 {==}
3436 case False{}:
3437 {==}
3438 case False{}:
3439 match b7:
3440 case True{}:
3441 {==}
3442 case False{}:
3443 {==}
3444
3445def 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}:
3446 match b5:
3447 case True{}:
3448 match b6:
3449 case True{}:
3450 match b7:
3451 case True{}:
3452 {==}
3453 case False{}:
3454 {==}
3455 case False{}:
3456 match b7:
3457 case True{}:
3458 {==}
3459 case False{}:
3460 {==}
3461 case False{}:
3462 match b6:
3463 case True{}:
3464 match b7:
3465 case True{}:
3466 {==}
3467 case False{}:
3468 {==}
3469 case False{}:
3470 match b7:
3471 case True{}:
3472 {==}
3473 case False{}:
3474 {==}
3475
3476def 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}:
3477 match b5:
3478 case True{}:
3479 match b6:
3480 case True{}:
3481 match b7:
3482 case True{}:
3483 {==}
3484 case False{}:
3485 {==}
3486 case False{}:
3487 match b7:
3488 case True{}:
3489 {==}
3490 case False{}:
3491 {==}
3492 case False{}:
3493 match b6:
3494 case True{}:
3495 match b7:
3496 case True{}:
3497 {==}
3498 case False{}:
3499 {==}
3500 case False{}:
3501 match b7:
3502 case True{}:
3503 {==}
3504 case False{}:
3505 {==}
3506
3507def 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}:
3508 match b5:
3509 case True{}:
3510 match b6:
3511 case True{}:
3512 match b7:
3513 case True{}:
3514 {==}
3515 case False{}:
3516 {==}
3517 case False{}:
3518 match b7:
3519 case True{}:
3520 {==}
3521 case False{}:
3522 {==}
3523 case False{}:
3524 match b6:
3525 case True{}:
3526 match b7:
3527 case True{}:
3528 {==}
3529 case False{}:
3530 {==}
3531 case False{}:
3532 match b7:
3533 case True{}:
3534 {==}
3535 case False{}:
3536 {==}
3537
3538def 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}:
3539 match b5:
3540 case True{}:
3541 match b6:
3542 case True{}:
3543 match b7:
3544 case True{}:
3545 {==}
3546 case False{}:
3547 {==}
3548 case False{}:
3549 match b7:
3550 case True{}:
3551 {==}
3552 case False{}:
3553 {==}
3554 case False{}:
3555 match b6:
3556 case True{}:
3557 match b7:
3558 case True{}:
3559 {==}
3560 case False{}:
3561 {==}
3562 case False{}:
3563 match b7:
3564 case True{}:
3565 {==}
3566 case False{}:
3567 {==}
3568
3569def 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}:
3570 match b5:
3571 case True{}:
3572 match b6:
3573 case True{}:
3574 match b7:
3575 case True{}:
3576 {==}
3577 case False{}:
3578 {==}
3579 case False{}:
3580 match b7:
3581 case True{}:
3582 {==}
3583 case False{}:
3584 {==}
3585 case False{}:
3586 match b6:
3587 case True{}:
3588 match b7:
3589 case True{}:
3590 {==}
3591 case False{}:
3592 {==}
3593 case False{}:
3594 match b7:
3595 case True{}:
3596 {==}
3597 case False{}:
3598 {==}
3599
3600def 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}:
3601 match b5:
3602 case True{}:
3603 match b6:
3604 case True{}:
3605 match b7:
3606 case True{}:
3607 {==}
3608 case False{}:
3609 {==}
3610 case False{}:
3611 match b7:
3612 case True{}:
3613 {==}
3614 case False{}:
3615 {==}
3616 case False{}:
3617 match b6:
3618 case True{}:
3619 match b7:
3620 case True{}:
3621 {==}
3622 case False{}:
3623 {==}
3624 case False{}:
3625 match b7:
3626 case True{}:
3627 {==}
3628 case False{}:
3629 {==}
3630
3631def 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}:
3632 match b5:
3633 case True{}:
3634 match b6:
3635 case True{}:
3636 match b7:
3637 case True{}:
3638 {==}
3639 case False{}:
3640 {==}
3641 case False{}:
3642 match b7:
3643 case True{}:
3644 {==}
3645 case False{}:
3646 {==}
3647 case False{}:
3648 match b6:
3649 case True{}:
3650 match b7:
3651 case True{}:
3652 {==}
3653 case False{}:
3654 {==}
3655 case False{}:
3656 match b7:
3657 case True{}:
3658 {==}
3659 case False{}:
3660 {==}
3661
3662def 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}:
3663 match b5:
3664 case True{}:
3665 match b6:
3666 case True{}:
3667 match b7:
3668 case True{}:
3669 {==}
3670 case False{}:
3671 {==}
3672 case False{}:
3673 match b7:
3674 case True{}:
3675 {==}
3676 case False{}:
3677 {==}
3678 case False{}:
3679 match b6:
3680 case True{}:
3681 match b7:
3682 case True{}:
3683 {==}
3684 case False{}:
3685 {==}
3686 case False{}:
3687 match b7:
3688 case True{}:
3689 {==}
3690 case False{}:
3691 {==}
3692
3693def 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}:
3694 match b5:
3695 case True{}:
3696 match b6:
3697 case True{}:
3698 match b7:
3699 case True{}:
3700 {==}
3701 case False{}:
3702 {==}
3703 case False{}:
3704 match b7:
3705 case True{}:
3706 {==}
3707 case False{}:
3708 {==}
3709 case False{}:
3710 match b6:
3711 case True{}:
3712 match b7:
3713 case True{}:
3714 {==}
3715 case False{}:
3716 {==}
3717 case False{}:
3718 match b7:
3719 case True{}:
3720 {==}
3721 case False{}:
3722 {==}
3723
3724def 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}:
3725 match b5:
3726 case True{}:
3727 match b6:
3728 case True{}:
3729 match b7:
3730 case True{}:
3731 {==}
3732 case False{}:
3733 {==}
3734 case False{}:
3735 match b7:
3736 case True{}:
3737 {==}
3738 case False{}:
3739 {==}
3740 case False{}:
3741 match b6:
3742 case True{}:
3743 match b7:
3744 case True{}:
3745 {==}
3746 case False{}:
3747 {==}
3748 case False{}:
3749 match b7:
3750 case True{}:
3751 {==}
3752 case False{}:
3753 {==}
3754
3755def 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}:
3756 match b5:
3757 case True{}:
3758 match b6:
3759 case True{}:
3760 match b7:
3761 case True{}:
3762 {==}
3763 case False{}:
3764 {==}
3765 case False{}:
3766 match b7:
3767 case True{}:
3768 {==}
3769 case False{}:
3770 {==}
3771 case False{}:
3772 match b6:
3773 case True{}:
3774 match b7:
3775 case True{}:
3776 {==}
3777 case False{}:
3778 {==}
3779 case False{}:
3780 match b7:
3781 case True{}:
3782 {==}
3783 case False{}:
3784 {==}
3785
3786def 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}:
3787 match b5:
3788 case True{}:
3789 match b6:
3790 case True{}:
3791 match b7:
3792 case True{}:
3793 {==}
3794 case False{}:
3795 {==}
3796 case False{}:
3797 match b7:
3798 case True{}:
3799 {==}
3800 case False{}:
3801 {==}
3802 case False{}:
3803 match b6:
3804 case True{}:
3805 match b7:
3806 case True{}:
3807 {==}
3808 case False{}:
3809 {==}
3810 case False{}:
3811 match b7:
3812 case True{}:
3813 {==}
3814 case False{}:
3815 {==}
3816
3817def 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}:
3818 match b5:
3819 case True{}:
3820 match b6:
3821 case True{}:
3822 match b7:
3823 case True{}:
3824 {==}
3825 case False{}:
3826 {==}
3827 case False{}:
3828 match b7:
3829 case True{}:
3830 {==}
3831 case False{}:
3832 {==}
3833 case False{}:
3834 match b6:
3835 case True{}:
3836 match b7:
3837 case True{}:
3838 {==}
3839 case False{}:
3840 {==}
3841 case False{}:
3842 match b7:
3843 case True{}:
3844 {==}
3845 case False{}:
3846 {==}
3847
3848def 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}:
3849 match b5:
3850 case True{}:
3851 match b6:
3852 case True{}:
3853 match b7:
3854 case True{}:
3855 {==}
3856 case False{}:
3857 {==}
3858 case False{}:
3859 match b7:
3860 case True{}:
3861 {==}
3862 case False{}:
3863 {==}
3864 case False{}:
3865 match b6:
3866 case True{}:
3867 match b7:
3868 case True{}:
3869 {==}
3870 case False{}:
3871 {==}
3872 case False{}:
3873 match b7:
3874 case True{}:
3875 {==}
3876 case False{}:
3877 {==}
3878
3879def 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}:
3880 match b5:
3881 case True{}:
3882 match b6:
3883 case True{}:
3884 match b7:
3885 case True{}:
3886 {==}
3887 case False{}:
3888 {==}
3889 case False{}:
3890 match b7:
3891 case True{}:
3892 {==}
3893 case False{}:
3894 {==}
3895 case False{}:
3896 match b6:
3897 case True{}:
3898 match b7:
3899 case True{}:
3900 {==}
3901 case False{}:
3902 {==}
3903 case False{}:
3904 match b7:
3905 case True{}:
3906 {==}
3907 case False{}:
3908 {==}
3909
3910def 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}:
3911 match b5:
3912 case True{}:
3913 match b6:
3914 case True{}:
3915 match b7:
3916 case True{}:
3917 {==}
3918 case False{}:
3919 {==}
3920 case False{}:
3921 match b7:
3922 case True{}:
3923 {==}
3924 case False{}:
3925 {==}
3926 case False{}:
3927 match b6:
3928 case True{}:
3929 match b7:
3930 case True{}:
3931 {==}
3932 case False{}:
3933 {==}
3934 case False{}:
3935 match b7:
3936 case True{}:
3937 {==}
3938 case False{}:
3939 {==}
3940
3941def 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}:
3942 match b5:
3943 case True{}:
3944 match b6:
3945 case True{}:
3946 match b7:
3947 case True{}:
3948 {==}
3949 case False{}:
3950 {==}
3951 case False{}:
3952 match b7:
3953 case True{}:
3954 {==}
3955 case False{}:
3956 {==}
3957 case False{}:
3958 match b6:
3959 case True{}:
3960 match b7:
3961 case True{}:
3962 {==}
3963 case False{}:
3964 {==}
3965 case False{}:
3966 match b7:
3967 case True{}:
3968 {==}
3969 case False{}:
3970 {==}
3971
3972def 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}:
3973 match b5:
3974 case True{}:
3975 match b6:
3976 case True{}:
3977 match b7:
3978 case True{}:
3979 {==}
3980 case False{}:
3981 {==}
3982 case False{}:
3983 match b7:
3984 case True{}:
3985 {==}
3986 case False{}:
3987 {==}
3988 case False{}:
3989 match b6:
3990 case True{}:
3991 match b7:
3992 case True{}:
3993 {==}
3994 case False{}:
3995 {==}
3996 case False{}:
3997 match b7:
3998 case True{}:
3999 {==}
4000 case False{}:
4001 {==}
4002
4003def 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}:
4004 match b0:
4005 case True{}:
4006 match b1:
4007 case True{}:
4008 match b2:
4009 case True{}:
4010 match b3:
4011 case True{}:
4012 match b4:
4013 case True{}:
4014 exp_log_aes.s11111(b5, b6, b7)
4015 case False{}:
4016 exp_log_aes.s11110(b5, b6, b7)
4017 case False{}:
4018 match b4:
4019 case True{}:
4020 exp_log_aes.s11101(b5, b6, b7)
4021 case False{}:
4022 exp_log_aes.s11100(b5, b6, b7)
4023 case False{}:
4024 match b3:
4025 case True{}:
4026 match b4:
4027 case True{}:
4028 exp_log_aes.s11011(b5, b6, b7)
4029 case False{}:
4030 exp_log_aes.s11010(b5, b6, b7)
4031 case False{}:
4032 match b4:
4033 case True{}:
4034 exp_log_aes.s11001(b5, b6, b7)
4035 case False{}:
4036 exp_log_aes.s11000(b5, b6, b7)
4037 case False{}:
4038 match b2:
4039 case True{}:
4040 match b3:
4041 case True{}:
4042 match b4:
4043 case True{}:
4044 exp_log_aes.s10111(b5, b6, b7)
4045 case False{}:
4046 exp_log_aes.s10110(b5, b6, b7)
4047 case False{}:
4048 match b4:
4049 case True{}:
4050 exp_log_aes.s10101(b5, b6, b7)
4051 case False{}:
4052 exp_log_aes.s10100(b5, b6, b7)
4053 case False{}:
4054 match b3:
4055 case True{}:
4056 match b4:
4057 case True{}:
4058 exp_log_aes.s10011(b5, b6, b7)
4059 case False{}:
4060 exp_log_aes.s10010(b5, b6, b7)
4061 case False{}:
4062 match b4:
4063 case True{}:
4064 exp_log_aes.s10001(b5, b6, b7)
4065 case False{}:
4066 exp_log_aes.s10000(b5, b6, b7)
4067 case False{}:
4068 match b1:
4069 case True{}:
4070 match b2:
4071 case True{}:
4072 match b3:
4073 case True{}:
4074 match b4:
4075 case True{}:
4076 exp_log_aes.s01111(b5, b6, b7)
4077 case False{}:
4078 exp_log_aes.s01110(b5, b6, b7)
4079 case False{}:
4080 match b4:
4081 case True{}:
4082 exp_log_aes.s01101(b5, b6, b7)
4083 case False{}:
4084 exp_log_aes.s01100(b5, b6, b7)
4085 case False{}:
4086 match b3:
4087 case True{}:
4088 match b4:
4089 case True{}:
4090 exp_log_aes.s01011(b5, b6, b7)
4091 case False{}:
4092 exp_log_aes.s01010(b5, b6, b7)
4093 case False{}:
4094 match b4:
4095 case True{}:
4096 exp_log_aes.s01001(b5, b6, b7)
4097 case False{}:
4098 exp_log_aes.s01000(b5, b6, b7)
4099 case False{}:
4100 match b2:
4101 case True{}:
4102 match b3:
4103 case True{}:
4104 match b4:
4105 case True{}:
4106 exp_log_aes.s00111(b5, b6, b7)
4107 case False{}:
4108 exp_log_aes.s00110(b5, b6, b7)
4109 case False{}:
4110 match b4:
4111 case True{}:
4112 exp_log_aes.s00101(b5, b6, b7)
4113 case False{}:
4114 exp_log_aes.s00100(b5, b6, b7)
4115 case False{}:
4116 match b3:
4117 case True{}:
4118 match b4:
4119 case True{}:
4120 exp_log_aes.s00011(b5, b6, b7)
4121 case False{}:
4122 exp_log_aes.s00010(b5, b6, b7)
4123 case False{}:
4124 match b4:
4125 case True{}:
4126 exp_log_aes.s00001(b5, b6, b7)
4127 case False{}:
4128 exp_log_aes.s00000(b5, b6, b7)
4129
4130def 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}:
4131 match a:
4132 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
4133 %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}
4134 exp_log_aes.bits(b0, b1, b2, b3, b4, b5, b6, b7)
4135
4136def 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}:
4137 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), _)) == G.Gf8.elt(a) : U32}
4138 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.aes(), G.Gf8.log(G.Gf8.aes(), fixz(G.Gf8.elt(a)))) == _ : U32}
4139 exp_log_aes.core(a)
4140
4141def Laws.exp_log_aes(a, nz):
4142 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))
4143
4144def 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}:
4145 match b5:
4146 case True{}:
4147 match b6:
4148 case True{}:
4149 match b7:
4150 case True{}:
4151 {==}
4152 case False{}:
4153 {==}
4154 case False{}:
4155 match b7:
4156 case True{}:
4157 {==}
4158 case False{}:
4159 {==}
4160 case False{}:
4161 match b6:
4162 case True{}:
4163 match b7:
4164 case True{}:
4165 {==}
4166 case False{}:
4167 {==}
4168 case False{}:
4169 match b7:
4170 case True{}:
4171 {==}
4172 case False{}:
4173 {==}
4174
4175def 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}:
4176 match b5:
4177 case True{}:
4178 match b6:
4179 case True{}:
4180 match b7:
4181 case True{}:
4182 {==}
4183 case False{}:
4184 {==}
4185 case False{}:
4186 match b7:
4187 case True{}:
4188 {==}
4189 case False{}:
4190 {==}
4191 case False{}:
4192 match b6:
4193 case True{}:
4194 match b7:
4195 case True{}:
4196 {==}
4197 case False{}:
4198 {==}
4199 case False{}:
4200 match b7:
4201 case True{}:
4202 {==}
4203 case False{}:
4204 {==}
4205
4206def 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}:
4207 match b5:
4208 case True{}:
4209 match b6:
4210 case True{}:
4211 match b7:
4212 case True{}:
4213 {==}
4214 case False{}:
4215 {==}
4216 case False{}:
4217 match b7:
4218 case True{}:
4219 {==}
4220 case False{}:
4221 {==}
4222 case False{}:
4223 match b6:
4224 case True{}:
4225 match b7:
4226 case True{}:
4227 {==}
4228 case False{}:
4229 {==}
4230 case False{}:
4231 match b7:
4232 case True{}:
4233 {==}
4234 case False{}:
4235 {==}
4236
4237def 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}:
4238 match b5:
4239 case True{}:
4240 match b6:
4241 case True{}:
4242 match b7:
4243 case True{}:
4244 {==}
4245 case False{}:
4246 {==}
4247 case False{}:
4248 match b7:
4249 case True{}:
4250 {==}
4251 case False{}:
4252 {==}
4253 case False{}:
4254 match b6:
4255 case True{}:
4256 match b7:
4257 case True{}:
4258 {==}
4259 case False{}:
4260 {==}
4261 case False{}:
4262 match b7:
4263 case True{}:
4264 {==}
4265 case False{}:
4266 {==}
4267
4268def 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}:
4269 match b5:
4270 case True{}:
4271 match b6:
4272 case True{}:
4273 match b7:
4274 case True{}:
4275 {==}
4276 case False{}:
4277 {==}
4278 case False{}:
4279 match b7:
4280 case True{}:
4281 {==}
4282 case False{}:
4283 {==}
4284 case False{}:
4285 match b6:
4286 case True{}:
4287 match b7:
4288 case True{}:
4289 {==}
4290 case False{}:
4291 {==}
4292 case False{}:
4293 match b7:
4294 case True{}:
4295 {==}
4296 case False{}:
4297 {==}
4298
4299def 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}:
4300 match b5:
4301 case True{}:
4302 match b6:
4303 case True{}:
4304 match b7:
4305 case True{}:
4306 {==}
4307 case False{}:
4308 {==}
4309 case False{}:
4310 match b7:
4311 case True{}:
4312 {==}
4313 case False{}:
4314 {==}
4315 case False{}:
4316 match b6:
4317 case True{}:
4318 match b7:
4319 case True{}:
4320 {==}
4321 case False{}:
4322 {==}
4323 case False{}:
4324 match b7:
4325 case True{}:
4326 {==}
4327 case False{}:
4328 {==}
4329
4330def 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}:
4331 match b5:
4332 case True{}:
4333 match b6:
4334 case True{}:
4335 match b7:
4336 case True{}:
4337 {==}
4338 case False{}:
4339 {==}
4340 case False{}:
4341 match b7:
4342 case True{}:
4343 {==}
4344 case False{}:
4345 {==}
4346 case False{}:
4347 match b6:
4348 case True{}:
4349 match b7:
4350 case True{}:
4351 {==}
4352 case False{}:
4353 {==}
4354 case False{}:
4355 match b7:
4356 case True{}:
4357 {==}
4358 case False{}:
4359 {==}
4360
4361def 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}:
4362 match b5:
4363 case True{}:
4364 match b6:
4365 case True{}:
4366 match b7:
4367 case True{}:
4368 {==}
4369 case False{}:
4370 {==}
4371 case False{}:
4372 match b7:
4373 case True{}:
4374 {==}
4375 case False{}:
4376 {==}
4377 case False{}:
4378 match b6:
4379 case True{}:
4380 match b7:
4381 case True{}:
4382 {==}
4383 case False{}:
4384 {==}
4385 case False{}:
4386 match b7:
4387 case True{}:
4388 {==}
4389 case False{}:
4390 {==}
4391
4392def 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}:
4393 match b5:
4394 case True{}:
4395 match b6:
4396 case True{}:
4397 match b7:
4398 case True{}:
4399 {==}
4400 case False{}:
4401 {==}
4402 case False{}:
4403 match b7:
4404 case True{}:
4405 {==}
4406 case False{}:
4407 {==}
4408 case False{}:
4409 match b6:
4410 case True{}:
4411 match b7:
4412 case True{}:
4413 {==}
4414 case False{}:
4415 {==}
4416 case False{}:
4417 match b7:
4418 case True{}:
4419 {==}
4420 case False{}:
4421 {==}
4422
4423def 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}:
4424 match b5:
4425 case True{}:
4426 match b6:
4427 case True{}:
4428 match b7:
4429 case True{}:
4430 {==}
4431 case False{}:
4432 {==}
4433 case False{}:
4434 match b7:
4435 case True{}:
4436 {==}
4437 case False{}:
4438 {==}
4439 case False{}:
4440 match b6:
4441 case True{}:
4442 match b7:
4443 case True{}:
4444 {==}
4445 case False{}:
4446 {==}
4447 case False{}:
4448 match b7:
4449 case True{}:
4450 {==}
4451 case False{}:
4452 {==}
4453
4454def 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}:
4455 match b5:
4456 case True{}:
4457 match b6:
4458 case True{}:
4459 match b7:
4460 case True{}:
4461 {==}
4462 case False{}:
4463 {==}
4464 case False{}:
4465 match b7:
4466 case True{}:
4467 {==}
4468 case False{}:
4469 {==}
4470 case False{}:
4471 match b6:
4472 case True{}:
4473 match b7:
4474 case True{}:
4475 {==}
4476 case False{}:
4477 {==}
4478 case False{}:
4479 match b7:
4480 case True{}:
4481 {==}
4482 case False{}:
4483 {==}
4484
4485def 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}:
4486 match b5:
4487 case True{}:
4488 match b6:
4489 case True{}:
4490 match b7:
4491 case True{}:
4492 {==}
4493 case False{}:
4494 {==}
4495 case False{}:
4496 match b7:
4497 case True{}:
4498 {==}
4499 case False{}:
4500 {==}
4501 case False{}:
4502 match b6:
4503 case True{}:
4504 match b7:
4505 case True{}:
4506 {==}
4507 case False{}:
4508 {==}
4509 case False{}:
4510 match b7:
4511 case True{}:
4512 {==}
4513 case False{}:
4514 {==}
4515
4516def 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}:
4517 match b5:
4518 case True{}:
4519 match b6:
4520 case True{}:
4521 match b7:
4522 case True{}:
4523 {==}
4524 case False{}:
4525 {==}
4526 case False{}:
4527 match b7:
4528 case True{}:
4529 {==}
4530 case False{}:
4531 {==}
4532 case False{}:
4533 match b6:
4534 case True{}:
4535 match b7:
4536 case True{}:
4537 {==}
4538 case False{}:
4539 {==}
4540 case False{}:
4541 match b7:
4542 case True{}:
4543 {==}
4544 case False{}:
4545 {==}
4546
4547def 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}:
4548 match b5:
4549 case True{}:
4550 match b6:
4551 case True{}:
4552 match b7:
4553 case True{}:
4554 {==}
4555 case False{}:
4556 {==}
4557 case False{}:
4558 match b7:
4559 case True{}:
4560 {==}
4561 case False{}:
4562 {==}
4563 case False{}:
4564 match b6:
4565 case True{}:
4566 match b7:
4567 case True{}:
4568 {==}
4569 case False{}:
4570 {==}
4571 case False{}:
4572 match b7:
4573 case True{}:
4574 {==}
4575 case False{}:
4576 {==}
4577
4578def 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}:
4579 match b5:
4580 case True{}:
4581 match b6:
4582 case True{}:
4583 match b7:
4584 case True{}:
4585 {==}
4586 case False{}:
4587 {==}
4588 case False{}:
4589 match b7:
4590 case True{}:
4591 {==}
4592 case False{}:
4593 {==}
4594 case False{}:
4595 match b6:
4596 case True{}:
4597 match b7:
4598 case True{}:
4599 {==}
4600 case False{}:
4601 {==}
4602 case False{}:
4603 match b7:
4604 case True{}:
4605 {==}
4606 case False{}:
4607 {==}
4608
4609def 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}:
4610 match b5:
4611 case True{}:
4612 match b6:
4613 case True{}:
4614 match b7:
4615 case True{}:
4616 {==}
4617 case False{}:
4618 {==}
4619 case False{}:
4620 match b7:
4621 case True{}:
4622 {==}
4623 case False{}:
4624 {==}
4625 case False{}:
4626 match b6:
4627 case True{}:
4628 match b7:
4629 case True{}:
4630 {==}
4631 case False{}:
4632 {==}
4633 case False{}:
4634 match b7:
4635 case True{}:
4636 {==}
4637 case False{}:
4638 {==}
4639
4640def 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}:
4641 match b5:
4642 case True{}:
4643 match b6:
4644 case True{}:
4645 match b7:
4646 case True{}:
4647 {==}
4648 case False{}:
4649 {==}
4650 case False{}:
4651 match b7:
4652 case True{}:
4653 {==}
4654 case False{}:
4655 {==}
4656 case False{}:
4657 match b6:
4658 case True{}:
4659 match b7:
4660 case True{}:
4661 {==}
4662 case False{}:
4663 {==}
4664 case False{}:
4665 match b7:
4666 case True{}:
4667 {==}
4668 case False{}:
4669 {==}
4670
4671def 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}:
4672 match b5:
4673 case True{}:
4674 match b6:
4675 case True{}:
4676 match b7:
4677 case True{}:
4678 {==}
4679 case False{}:
4680 {==}
4681 case False{}:
4682 match b7:
4683 case True{}:
4684 {==}
4685 case False{}:
4686 {==}
4687 case False{}:
4688 match b6:
4689 case True{}:
4690 match b7:
4691 case True{}:
4692 {==}
4693 case False{}:
4694 {==}
4695 case False{}:
4696 match b7:
4697 case True{}:
4698 {==}
4699 case False{}:
4700 {==}
4701
4702def 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}:
4703 match b5:
4704 case True{}:
4705 match b6:
4706 case True{}:
4707 match b7:
4708 case True{}:
4709 {==}
4710 case False{}:
4711 {==}
4712 case False{}:
4713 match b7:
4714 case True{}:
4715 {==}
4716 case False{}:
4717 {==}
4718 case False{}:
4719 match b6:
4720 case True{}:
4721 match b7:
4722 case True{}:
4723 {==}
4724 case False{}:
4725 {==}
4726 case False{}:
4727 match b7:
4728 case True{}:
4729 {==}
4730 case False{}:
4731 {==}
4732
4733def 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}:
4734 match b5:
4735 case True{}:
4736 match b6:
4737 case True{}:
4738 match b7:
4739 case True{}:
4740 {==}
4741 case False{}:
4742 {==}
4743 case False{}:
4744 match b7:
4745 case True{}:
4746 {==}
4747 case False{}:
4748 {==}
4749 case False{}:
4750 match b6:
4751 case True{}:
4752 match b7:
4753 case True{}:
4754 {==}
4755 case False{}:
4756 {==}
4757 case False{}:
4758 match b7:
4759 case True{}:
4760 {==}
4761 case False{}:
4762 {==}
4763
4764def 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}:
4765 match b5:
4766 case True{}:
4767 match b6:
4768 case True{}:
4769 match b7:
4770 case True{}:
4771 {==}
4772 case False{}:
4773 {==}
4774 case False{}:
4775 match b7:
4776 case True{}:
4777 {==}
4778 case False{}:
4779 {==}
4780 case False{}:
4781 match b6:
4782 case True{}:
4783 match b7:
4784 case True{}:
4785 {==}
4786 case False{}:
4787 {==}
4788 case False{}:
4789 match b7:
4790 case True{}:
4791 {==}
4792 case False{}:
4793 {==}
4794
4795def 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}:
4796 match b5:
4797 case True{}:
4798 match b6:
4799 case True{}:
4800 match b7:
4801 case True{}:
4802 {==}
4803 case False{}:
4804 {==}
4805 case False{}:
4806 match b7:
4807 case True{}:
4808 {==}
4809 case False{}:
4810 {==}
4811 case False{}:
4812 match b6:
4813 case True{}:
4814 match b7:
4815 case True{}:
4816 {==}
4817 case False{}:
4818 {==}
4819 case False{}:
4820 match b7:
4821 case True{}:
4822 {==}
4823 case False{}:
4824 {==}
4825
4826def 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}:
4827 match b5:
4828 case True{}:
4829 match b6:
4830 case True{}:
4831 match b7:
4832 case True{}:
4833 {==}
4834 case False{}:
4835 {==}
4836 case False{}:
4837 match b7:
4838 case True{}:
4839 {==}
4840 case False{}:
4841 {==}
4842 case False{}:
4843 match b6:
4844 case True{}:
4845 match b7:
4846 case True{}:
4847 {==}
4848 case False{}:
4849 {==}
4850 case False{}:
4851 match b7:
4852 case True{}:
4853 {==}
4854 case False{}:
4855 {==}
4856
4857def 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}:
4858 match b5:
4859 case True{}:
4860 match b6:
4861 case True{}:
4862 match b7:
4863 case True{}:
4864 {==}
4865 case False{}:
4866 {==}
4867 case False{}:
4868 match b7:
4869 case True{}:
4870 {==}
4871 case False{}:
4872 {==}
4873 case False{}:
4874 match b6:
4875 case True{}:
4876 match b7:
4877 case True{}:
4878 {==}
4879 case False{}:
4880 {==}
4881 case False{}:
4882 match b7:
4883 case True{}:
4884 {==}
4885 case False{}:
4886 {==}
4887
4888def 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}:
4889 match b5:
4890 case True{}:
4891 match b6:
4892 case True{}:
4893 match b7:
4894 case True{}:
4895 {==}
4896 case False{}:
4897 {==}
4898 case False{}:
4899 match b7:
4900 case True{}:
4901 {==}
4902 case False{}:
4903 {==}
4904 case False{}:
4905 match b6:
4906 case True{}:
4907 match b7:
4908 case True{}:
4909 {==}
4910 case False{}:
4911 {==}
4912 case False{}:
4913 match b7:
4914 case True{}:
4915 {==}
4916 case False{}:
4917 {==}
4918
4919def 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}:
4920 match b5:
4921 case True{}:
4922 match b6:
4923 case True{}:
4924 match b7:
4925 case True{}:
4926 {==}
4927 case False{}:
4928 {==}
4929 case False{}:
4930 match b7:
4931 case True{}:
4932 {==}
4933 case False{}:
4934 {==}
4935 case False{}:
4936 match b6:
4937 case True{}:
4938 match b7:
4939 case True{}:
4940 {==}
4941 case False{}:
4942 {==}
4943 case False{}:
4944 match b7:
4945 case True{}:
4946 {==}
4947 case False{}:
4948 {==}
4949
4950def 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}:
4951 match b5:
4952 case True{}:
4953 match b6:
4954 case True{}:
4955 match b7:
4956 case True{}:
4957 {==}
4958 case False{}:
4959 {==}
4960 case False{}:
4961 match b7:
4962 case True{}:
4963 {==}
4964 case False{}:
4965 {==}
4966 case False{}:
4967 match b6:
4968 case True{}:
4969 match b7:
4970 case True{}:
4971 {==}
4972 case False{}:
4973 {==}
4974 case False{}:
4975 match b7:
4976 case True{}:
4977 {==}
4978 case False{}:
4979 {==}
4980
4981def 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}:
4982 match b5:
4983 case True{}:
4984 match b6:
4985 case True{}:
4986 match b7:
4987 case True{}:
4988 {==}
4989 case False{}:
4990 {==}
4991 case False{}:
4992 match b7:
4993 case True{}:
4994 {==}
4995 case False{}:
4996 {==}
4997 case False{}:
4998 match b6:
4999 case True{}:
5000 match b7:
5001 case True{}:
5002 {==}
5003 case False{}:
5004 {==}
5005 case False{}:
5006 match b7:
5007 case True{}:
5008 {==}
5009 case False{}:
5010 {==}
5011
5012def 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}:
5013 match b5:
5014 case True{}:
5015 match b6:
5016 case True{}:
5017 match b7:
5018 case True{}:
5019 {==}
5020 case False{}:
5021 {==}
5022 case False{}:
5023 match b7:
5024 case True{}:
5025 {==}
5026 case False{}:
5027 {==}
5028 case False{}:
5029 match b6:
5030 case True{}:
5031 match b7:
5032 case True{}:
5033 {==}
5034 case False{}:
5035 {==}
5036 case False{}:
5037 match b7:
5038 case True{}:
5039 {==}
5040 case False{}:
5041 {==}
5042
5043def 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}:
5044 match b5:
5045 case True{}:
5046 match b6:
5047 case True{}:
5048 match b7:
5049 case True{}:
5050 {==}
5051 case False{}:
5052 {==}
5053 case False{}:
5054 match b7:
5055 case True{}:
5056 {==}
5057 case False{}:
5058 {==}
5059 case False{}:
5060 match b6:
5061 case True{}:
5062 match b7:
5063 case True{}:
5064 {==}
5065 case False{}:
5066 {==}
5067 case False{}:
5068 match b7:
5069 case True{}:
5070 {==}
5071 case False{}:
5072 {==}
5073
5074def 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}:
5075 match b5:
5076 case True{}:
5077 match b6:
5078 case True{}:
5079 match b7:
5080 case True{}:
5081 {==}
5082 case False{}:
5083 {==}
5084 case False{}:
5085 match b7:
5086 case True{}:
5087 {==}
5088 case False{}:
5089 {==}
5090 case False{}:
5091 match b6:
5092 case True{}:
5093 match b7:
5094 case True{}:
5095 {==}
5096 case False{}:
5097 {==}
5098 case False{}:
5099 match b7:
5100 case True{}:
5101 {==}
5102 case False{}:
5103 {==}
5104
5105def 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}:
5106 match b5:
5107 case True{}:
5108 match b6:
5109 case True{}:
5110 match b7:
5111 case True{}:
5112 {==}
5113 case False{}:
5114 {==}
5115 case False{}:
5116 match b7:
5117 case True{}:
5118 {==}
5119 case False{}:
5120 {==}
5121 case False{}:
5122 match b6:
5123 case True{}:
5124 match b7:
5125 case True{}:
5126 {==}
5127 case False{}:
5128 {==}
5129 case False{}:
5130 match b7:
5131 case True{}:
5132 {==}
5133 case False{}:
5134 {==}
5135
5136def 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}:
5137 match b0:
5138 case True{}:
5139 match b1:
5140 case True{}:
5141 match b2:
5142 case True{}:
5143 match b3:
5144 case True{}:
5145 match b4:
5146 case True{}:
5147 mul_inv_rs.s11111(b5, b6, b7)
5148 case False{}:
5149 mul_inv_rs.s11110(b5, b6, b7)
5150 case False{}:
5151 match b4:
5152 case True{}:
5153 mul_inv_rs.s11101(b5, b6, b7)
5154 case False{}:
5155 mul_inv_rs.s11100(b5, b6, b7)
5156 case False{}:
5157 match b3:
5158 case True{}:
5159 match b4:
5160 case True{}:
5161 mul_inv_rs.s11011(b5, b6, b7)
5162 case False{}:
5163 mul_inv_rs.s11010(b5, b6, b7)
5164 case False{}:
5165 match b4:
5166 case True{}:
5167 mul_inv_rs.s11001(b5, b6, b7)
5168 case False{}:
5169 mul_inv_rs.s11000(b5, b6, b7)
5170 case False{}:
5171 match b2:
5172 case True{}:
5173 match b3:
5174 case True{}:
5175 match b4:
5176 case True{}:
5177 mul_inv_rs.s10111(b5, b6, b7)
5178 case False{}:
5179 mul_inv_rs.s10110(b5, b6, b7)
5180 case False{}:
5181 match b4:
5182 case True{}:
5183 mul_inv_rs.s10101(b5, b6, b7)
5184 case False{}:
5185 mul_inv_rs.s10100(b5, b6, b7)
5186 case False{}:
5187 match b3:
5188 case True{}:
5189 match b4:
5190 case True{}:
5191 mul_inv_rs.s10011(b5, b6, b7)
5192 case False{}:
5193 mul_inv_rs.s10010(b5, b6, b7)
5194 case False{}:
5195 match b4:
5196 case True{}:
5197 mul_inv_rs.s10001(b5, b6, b7)
5198 case False{}:
5199 mul_inv_rs.s10000(b5, b6, b7)
5200 case False{}:
5201 match b1:
5202 case True{}:
5203 match b2:
5204 case True{}:
5205 match b3:
5206 case True{}:
5207 match b4:
5208 case True{}:
5209 mul_inv_rs.s01111(b5, b6, b7)
5210 case False{}:
5211 mul_inv_rs.s01110(b5, b6, b7)
5212 case False{}:
5213 match b4:
5214 case True{}:
5215 mul_inv_rs.s01101(b5, b6, b7)
5216 case False{}:
5217 mul_inv_rs.s01100(b5, b6, b7)
5218 case False{}:
5219 match b3:
5220 case True{}:
5221 match b4:
5222 case True{}:
5223 mul_inv_rs.s01011(b5, b6, b7)
5224 case False{}:
5225 mul_inv_rs.s01010(b5, b6, b7)
5226 case False{}:
5227 match b4:
5228 case True{}:
5229 mul_inv_rs.s01001(b5, b6, b7)
5230 case False{}:
5231 mul_inv_rs.s01000(b5, b6, b7)
5232 case False{}:
5233 match b2:
5234 case True{}:
5235 match b3:
5236 case True{}:
5237 match b4:
5238 case True{}:
5239 mul_inv_rs.s00111(b5, b6, b7)
5240 case False{}:
5241 mul_inv_rs.s00110(b5, b6, b7)
5242 case False{}:
5243 match b4:
5244 case True{}:
5245 mul_inv_rs.s00101(b5, b6, b7)
5246 case False{}:
5247 mul_inv_rs.s00100(b5, b6, b7)
5248 case False{}:
5249 match b3:
5250 case True{}:
5251 match b4:
5252 case True{}:
5253 mul_inv_rs.s00011(b5, b6, b7)
5254 case False{}:
5255 mul_inv_rs.s00010(b5, b6, b7)
5256 case False{}:
5257 match b4:
5258 case True{}:
5259 mul_inv_rs.s00001(b5, b6, b7)
5260 case False{}:
5261 mul_inv_rs.s00000(b5, b6, b7)
5262
5263def 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}:
5264 match a:
5265 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
5266 %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}
5267 mul_inv_rs.bits(b0, b1, b2, b3, b4, b5, b6, b7)
5268
5269def 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}:
5270 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.rs(), _, G.Gf8.inv(G.Gf8.rs(), G.Gf8.elt(a))) == 1 : U32}
5271 %fix_nz(a, nz) : {G.Gf8.mul(G.Gf8.rs(), fixz(G.Gf8.elt(a)), G.Gf8.inv(G.Gf8.rs(), _)) == 1 : U32}
5272 mul_inv_rs.core(a)
5273
5274def Laws.mul_inv_rs(a, nz):
5275 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)))
5276
5277def 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}:
5278 match b5:
5279 case True{}:
5280 match b6:
5281 case True{}:
5282 match b7:
5283 case True{}:
5284 {==}
5285 case False{}:
5286 {==}
5287 case False{}:
5288 match b7:
5289 case True{}:
5290 {==}
5291 case False{}:
5292 {==}
5293 case False{}:
5294 match b6:
5295 case True{}:
5296 match b7:
5297 case True{}:
5298 {==}
5299 case False{}:
5300 {==}
5301 case False{}:
5302 match b7:
5303 case True{}:
5304 {==}
5305 case False{}:
5306 {==}
5307
5308def 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}:
5309 match b5:
5310 case True{}:
5311 match b6:
5312 case True{}:
5313 match b7:
5314 case True{}:
5315 {==}
5316 case False{}:
5317 {==}
5318 case False{}:
5319 match b7:
5320 case True{}:
5321 {==}
5322 case False{}:
5323 {==}
5324 case False{}:
5325 match b6:
5326 case True{}:
5327 match b7:
5328 case True{}:
5329 {==}
5330 case False{}:
5331 {==}
5332 case False{}:
5333 match b7:
5334 case True{}:
5335 {==}
5336 case False{}:
5337 {==}
5338
5339def 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}:
5340 match b5:
5341 case True{}:
5342 match b6:
5343 case True{}:
5344 match b7:
5345 case True{}:
5346 {==}
5347 case False{}:
5348 {==}
5349 case False{}:
5350 match b7:
5351 case True{}:
5352 {==}
5353 case False{}:
5354 {==}
5355 case False{}:
5356 match b6:
5357 case True{}:
5358 match b7:
5359 case True{}:
5360 {==}
5361 case False{}:
5362 {==}
5363 case False{}:
5364 match b7:
5365 case True{}:
5366 {==}
5367 case False{}:
5368 {==}
5369
5370def 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}:
5371 match b5:
5372 case True{}:
5373 match b6:
5374 case True{}:
5375 match b7:
5376 case True{}:
5377 {==}
5378 case False{}:
5379 {==}
5380 case False{}:
5381 match b7:
5382 case True{}:
5383 {==}
5384 case False{}:
5385 {==}
5386 case False{}:
5387 match b6:
5388 case True{}:
5389 match b7:
5390 case True{}:
5391 {==}
5392 case False{}:
5393 {==}
5394 case False{}:
5395 match b7:
5396 case True{}:
5397 {==}
5398 case False{}:
5399 {==}
5400
5401def 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}:
5402 match b5:
5403 case True{}:
5404 match b6:
5405 case True{}:
5406 match b7:
5407 case True{}:
5408 {==}
5409 case False{}:
5410 {==}
5411 case False{}:
5412 match b7:
5413 case True{}:
5414 {==}
5415 case False{}:
5416 {==}
5417 case False{}:
5418 match b6:
5419 case True{}:
5420 match b7:
5421 case True{}:
5422 {==}
5423 case False{}:
5424 {==}
5425 case False{}:
5426 match b7:
5427 case True{}:
5428 {==}
5429 case False{}:
5430 {==}
5431
5432def 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}:
5433 match b5:
5434 case True{}:
5435 match b6:
5436 case True{}:
5437 match b7:
5438 case True{}:
5439 {==}
5440 case False{}:
5441 {==}
5442 case False{}:
5443 match b7:
5444 case True{}:
5445 {==}
5446 case False{}:
5447 {==}
5448 case False{}:
5449 match b6:
5450 case True{}:
5451 match b7:
5452 case True{}:
5453 {==}
5454 case False{}:
5455 {==}
5456 case False{}:
5457 match b7:
5458 case True{}:
5459 {==}
5460 case False{}:
5461 {==}
5462
5463def 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}:
5464 match b5:
5465 case True{}:
5466 match b6:
5467 case True{}:
5468 match b7:
5469 case True{}:
5470 {==}
5471 case False{}:
5472 {==}
5473 case False{}:
5474 match b7:
5475 case True{}:
5476 {==}
5477 case False{}:
5478 {==}
5479 case False{}:
5480 match b6:
5481 case True{}:
5482 match b7:
5483 case True{}:
5484 {==}
5485 case False{}:
5486 {==}
5487 case False{}:
5488 match b7:
5489 case True{}:
5490 {==}
5491 case False{}:
5492 {==}
5493
5494def 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}:
5495 match b5:
5496 case True{}:
5497 match b6:
5498 case True{}:
5499 match b7:
5500 case True{}:
5501 {==}
5502 case False{}:
5503 {==}
5504 case False{}:
5505 match b7:
5506 case True{}:
5507 {==}
5508 case False{}:
5509 {==}
5510 case False{}:
5511 match b6:
5512 case True{}:
5513 match b7:
5514 case True{}:
5515 {==}
5516 case False{}:
5517 {==}
5518 case False{}:
5519 match b7:
5520 case True{}:
5521 {==}
5522 case False{}:
5523 {==}
5524
5525def 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}:
5526 match b5:
5527 case True{}:
5528 match b6:
5529 case True{}:
5530 match b7:
5531 case True{}:
5532 {==}
5533 case False{}:
5534 {==}
5535 case False{}:
5536 match b7:
5537 case True{}:
5538 {==}
5539 case False{}:
5540 {==}
5541 case False{}:
5542 match b6:
5543 case True{}:
5544 match b7:
5545 case True{}:
5546 {==}
5547 case False{}:
5548 {==}
5549 case False{}:
5550 match b7:
5551 case True{}:
5552 {==}
5553 case False{}:
5554 {==}
5555
5556def 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}:
5557 match b5:
5558 case True{}:
5559 match b6:
5560 case True{}:
5561 match b7:
5562 case True{}:
5563 {==}
5564 case False{}:
5565 {==}
5566 case False{}:
5567 match b7:
5568 case True{}:
5569 {==}
5570 case False{}:
5571 {==}
5572 case False{}:
5573 match b6:
5574 case True{}:
5575 match b7:
5576 case True{}:
5577 {==}
5578 case False{}:
5579 {==}
5580 case False{}:
5581 match b7:
5582 case True{}:
5583 {==}
5584 case False{}:
5585 {==}
5586
5587def 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}:
5588 match b5:
5589 case True{}:
5590 match b6:
5591 case True{}:
5592 match b7:
5593 case True{}:
5594 {==}
5595 case False{}:
5596 {==}
5597 case False{}:
5598 match b7:
5599 case True{}:
5600 {==}
5601 case False{}:
5602 {==}
5603 case False{}:
5604 match b6:
5605 case True{}:
5606 match b7:
5607 case True{}:
5608 {==}
5609 case False{}:
5610 {==}
5611 case False{}:
5612 match b7:
5613 case True{}:
5614 {==}
5615 case False{}:
5616 {==}
5617
5618def 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}:
5619 match b5:
5620 case True{}:
5621 match b6:
5622 case True{}:
5623 match b7:
5624 case True{}:
5625 {==}
5626 case False{}:
5627 {==}
5628 case False{}:
5629 match b7:
5630 case True{}:
5631 {==}
5632 case False{}:
5633 {==}
5634 case False{}:
5635 match b6:
5636 case True{}:
5637 match b7:
5638 case True{}:
5639 {==}
5640 case False{}:
5641 {==}
5642 case False{}:
5643 match b7:
5644 case True{}:
5645 {==}
5646 case False{}:
5647 {==}
5648
5649def 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}:
5650 match b5:
5651 case True{}:
5652 match b6:
5653 case True{}:
5654 match b7:
5655 case True{}:
5656 {==}
5657 case False{}:
5658 {==}
5659 case False{}:
5660 match b7:
5661 case True{}:
5662 {==}
5663 case False{}:
5664 {==}
5665 case False{}:
5666 match b6:
5667 case True{}:
5668 match b7:
5669 case True{}:
5670 {==}
5671 case False{}:
5672 {==}
5673 case False{}:
5674 match b7:
5675 case True{}:
5676 {==}
5677 case False{}:
5678 {==}
5679
5680def 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}:
5681 match b5:
5682 case True{}:
5683 match b6:
5684 case True{}:
5685 match b7:
5686 case True{}:
5687 {==}
5688 case False{}:
5689 {==}
5690 case False{}:
5691 match b7:
5692 case True{}:
5693 {==}
5694 case False{}:
5695 {==}
5696 case False{}:
5697 match b6:
5698 case True{}:
5699 match b7:
5700 case True{}:
5701 {==}
5702 case False{}:
5703 {==}
5704 case False{}:
5705 match b7:
5706 case True{}:
5707 {==}
5708 case False{}:
5709 {==}
5710
5711def 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}:
5712 match b5:
5713 case True{}:
5714 match b6:
5715 case True{}:
5716 match b7:
5717 case True{}:
5718 {==}
5719 case False{}:
5720 {==}
5721 case False{}:
5722 match b7:
5723 case True{}:
5724 {==}
5725 case False{}:
5726 {==}
5727 case False{}:
5728 match b6:
5729 case True{}:
5730 match b7:
5731 case True{}:
5732 {==}
5733 case False{}:
5734 {==}
5735 case False{}:
5736 match b7:
5737 case True{}:
5738 {==}
5739 case False{}:
5740 {==}
5741
5742def 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}:
5743 match b5:
5744 case True{}:
5745 match b6:
5746 case True{}:
5747 match b7:
5748 case True{}:
5749 {==}
5750 case False{}:
5751 {==}
5752 case False{}:
5753 match b7:
5754 case True{}:
5755 {==}
5756 case False{}:
5757 {==}
5758 case False{}:
5759 match b6:
5760 case True{}:
5761 match b7:
5762 case True{}:
5763 {==}
5764 case False{}:
5765 {==}
5766 case False{}:
5767 match b7:
5768 case True{}:
5769 {==}
5770 case False{}:
5771 {==}
5772
5773def 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}:
5774 match b5:
5775 case True{}:
5776 match b6:
5777 case True{}:
5778 match b7:
5779 case True{}:
5780 {==}
5781 case False{}:
5782 {==}
5783 case False{}:
5784 match b7:
5785 case True{}:
5786 {==}
5787 case False{}:
5788 {==}
5789 case False{}:
5790 match b6:
5791 case True{}:
5792 match b7:
5793 case True{}:
5794 {==}
5795 case False{}:
5796 {==}
5797 case False{}:
5798 match b7:
5799 case True{}:
5800 {==}
5801 case False{}:
5802 {==}
5803
5804def 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}:
5805 match b5:
5806 case True{}:
5807 match b6:
5808 case True{}:
5809 match b7:
5810 case True{}:
5811 {==}
5812 case False{}:
5813 {==}
5814 case False{}:
5815 match b7:
5816 case True{}:
5817 {==}
5818 case False{}:
5819 {==}
5820 case False{}:
5821 match b6:
5822 case True{}:
5823 match b7:
5824 case True{}:
5825 {==}
5826 case False{}:
5827 {==}
5828 case False{}:
5829 match b7:
5830 case True{}:
5831 {==}
5832 case False{}:
5833 {==}
5834
5835def 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}:
5836 match b5:
5837 case True{}:
5838 match b6:
5839 case True{}:
5840 match b7:
5841 case True{}:
5842 {==}
5843 case False{}:
5844 {==}
5845 case False{}:
5846 match b7:
5847 case True{}:
5848 {==}
5849 case False{}:
5850 {==}
5851 case False{}:
5852 match b6:
5853 case True{}:
5854 match b7:
5855 case True{}:
5856 {==}
5857 case False{}:
5858 {==}
5859 case False{}:
5860 match b7:
5861 case True{}:
5862 {==}
5863 case False{}:
5864 {==}
5865
5866def 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}:
5867 match b5:
5868 case True{}:
5869 match b6:
5870 case True{}:
5871 match b7:
5872 case True{}:
5873 {==}
5874 case False{}:
5875 {==}
5876 case False{}:
5877 match b7:
5878 case True{}:
5879 {==}
5880 case False{}:
5881 {==}
5882 case False{}:
5883 match b6:
5884 case True{}:
5885 match b7:
5886 case True{}:
5887 {==}
5888 case False{}:
5889 {==}
5890 case False{}:
5891 match b7:
5892 case True{}:
5893 {==}
5894 case False{}:
5895 {==}
5896
5897def 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}:
5898 match b5:
5899 case True{}:
5900 match b6:
5901 case True{}:
5902 match b7:
5903 case True{}:
5904 {==}
5905 case False{}:
5906 {==}
5907 case False{}:
5908 match b7:
5909 case True{}:
5910 {==}
5911 case False{}:
5912 {==}
5913 case False{}:
5914 match b6:
5915 case True{}:
5916 match b7:
5917 case True{}:
5918 {==}
5919 case False{}:
5920 {==}
5921 case False{}:
5922 match b7:
5923 case True{}:
5924 {==}
5925 case False{}:
5926 {==}
5927
5928def 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}:
5929 match b5:
5930 case True{}:
5931 match b6:
5932 case True{}:
5933 match b7:
5934 case True{}:
5935 {==}
5936 case False{}:
5937 {==}
5938 case False{}:
5939 match b7:
5940 case True{}:
5941 {==}
5942 case False{}:
5943 {==}
5944 case False{}:
5945 match b6:
5946 case True{}:
5947 match b7:
5948 case True{}:
5949 {==}
5950 case False{}:
5951 {==}
5952 case False{}:
5953 match b7:
5954 case True{}:
5955 {==}
5956 case False{}:
5957 {==}
5958
5959def 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}:
5960 match b5:
5961 case True{}:
5962 match b6:
5963 case True{}:
5964 match b7:
5965 case True{}:
5966 {==}
5967 case False{}:
5968 {==}
5969 case False{}:
5970 match b7:
5971 case True{}:
5972 {==}
5973 case False{}:
5974 {==}
5975 case False{}:
5976 match b6:
5977 case True{}:
5978 match b7:
5979 case True{}:
5980 {==}
5981 case False{}:
5982 {==}
5983 case False{}:
5984 match b7:
5985 case True{}:
5986 {==}
5987 case False{}:
5988 {==}
5989
5990def 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}:
5991 match b5:
5992 case True{}:
5993 match b6:
5994 case True{}:
5995 match b7:
5996 case True{}:
5997 {==}
5998 case False{}:
5999 {==}
6000 case False{}:
6001 match b7:
6002 case True{}:
6003 {==}
6004 case False{}:
6005 {==}
6006 case False{}:
6007 match b6:
6008 case True{}:
6009 match b7:
6010 case True{}:
6011 {==}
6012 case False{}:
6013 {==}
6014 case False{}:
6015 match b7:
6016 case True{}:
6017 {==}
6018 case False{}:
6019 {==}
6020
6021def 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}:
6022 match b5:
6023 case True{}:
6024 match b6:
6025 case True{}:
6026 match b7:
6027 case True{}:
6028 {==}
6029 case False{}:
6030 {==}
6031 case False{}:
6032 match b7:
6033 case True{}:
6034 {==}
6035 case False{}:
6036 {==}
6037 case False{}:
6038 match b6:
6039 case True{}:
6040 match b7:
6041 case True{}:
6042 {==}
6043 case False{}:
6044 {==}
6045 case False{}:
6046 match b7:
6047 case True{}:
6048 {==}
6049 case False{}:
6050 {==}
6051
6052def 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}:
6053 match b5:
6054 case True{}:
6055 match b6:
6056 case True{}:
6057 match b7:
6058 case True{}:
6059 {==}
6060 case False{}:
6061 {==}
6062 case False{}:
6063 match b7:
6064 case True{}:
6065 {==}
6066 case False{}:
6067 {==}
6068 case False{}:
6069 match b6:
6070 case True{}:
6071 match b7:
6072 case True{}:
6073 {==}
6074 case False{}:
6075 {==}
6076 case False{}:
6077 match b7:
6078 case True{}:
6079 {==}
6080 case False{}:
6081 {==}
6082
6083def 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}:
6084 match b5:
6085 case True{}:
6086 match b6:
6087 case True{}:
6088 match b7:
6089 case True{}:
6090 {==}
6091 case False{}:
6092 {==}
6093 case False{}:
6094 match b7:
6095 case True{}:
6096 {==}
6097 case False{}:
6098 {==}
6099 case False{}:
6100 match b6:
6101 case True{}:
6102 match b7:
6103 case True{}:
6104 {==}
6105 case False{}:
6106 {==}
6107 case False{}:
6108 match b7:
6109 case True{}:
6110 {==}
6111 case False{}:
6112 {==}
6113
6114def 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}:
6115 match b5:
6116 case True{}:
6117 match b6:
6118 case True{}:
6119 match b7:
6120 case True{}:
6121 {==}
6122 case False{}:
6123 {==}
6124 case False{}:
6125 match b7:
6126 case True{}:
6127 {==}
6128 case False{}:
6129 {==}
6130 case False{}:
6131 match b6:
6132 case True{}:
6133 match b7:
6134 case True{}:
6135 {==}
6136 case False{}:
6137 {==}
6138 case False{}:
6139 match b7:
6140 case True{}:
6141 {==}
6142 case False{}:
6143 {==}
6144
6145def 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}:
6146 match b5:
6147 case True{}:
6148 match b6:
6149 case True{}:
6150 match b7:
6151 case True{}:
6152 {==}
6153 case False{}:
6154 {==}
6155 case False{}:
6156 match b7:
6157 case True{}:
6158 {==}
6159 case False{}:
6160 {==}
6161 case False{}:
6162 match b6:
6163 case True{}:
6164 match b7:
6165 case True{}:
6166 {==}
6167 case False{}:
6168 {==}
6169 case False{}:
6170 match b7:
6171 case True{}:
6172 {==}
6173 case False{}:
6174 {==}
6175
6176def 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}:
6177 match b5:
6178 case True{}:
6179 match b6:
6180 case True{}:
6181 match b7:
6182 case True{}:
6183 {==}
6184 case False{}:
6185 {==}
6186 case False{}:
6187 match b7:
6188 case True{}:
6189 {==}
6190 case False{}:
6191 {==}
6192 case False{}:
6193 match b6:
6194 case True{}:
6195 match b7:
6196 case True{}:
6197 {==}
6198 case False{}:
6199 {==}
6200 case False{}:
6201 match b7:
6202 case True{}:
6203 {==}
6204 case False{}:
6205 {==}
6206
6207def 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}:
6208 match b5:
6209 case True{}:
6210 match b6:
6211 case True{}:
6212 match b7:
6213 case True{}:
6214 {==}
6215 case False{}:
6216 {==}
6217 case False{}:
6218 match b7:
6219 case True{}:
6220 {==}
6221 case False{}:
6222 {==}
6223 case False{}:
6224 match b6:
6225 case True{}:
6226 match b7:
6227 case True{}:
6228 {==}
6229 case False{}:
6230 {==}
6231 case False{}:
6232 match b7:
6233 case True{}:
6234 {==}
6235 case False{}:
6236 {==}
6237
6238def 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}:
6239 match b5:
6240 case True{}:
6241 match b6:
6242 case True{}:
6243 match b7:
6244 case True{}:
6245 {==}
6246 case False{}:
6247 {==}
6248 case False{}:
6249 match b7:
6250 case True{}:
6251 {==}
6252 case False{}:
6253 {==}
6254 case False{}:
6255 match b6:
6256 case True{}:
6257 match b7:
6258 case True{}:
6259 {==}
6260 case False{}:
6261 {==}
6262 case False{}:
6263 match b7:
6264 case True{}:
6265 {==}
6266 case False{}:
6267 {==}
6268
6269def 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}:
6270 match b0:
6271 case True{}:
6272 match b1:
6273 case True{}:
6274 match b2:
6275 case True{}:
6276 match b3:
6277 case True{}:
6278 match b4:
6279 case True{}:
6280 exp_log_rs.s11111(b5, b6, b7)
6281 case False{}:
6282 exp_log_rs.s11110(b5, b6, b7)
6283 case False{}:
6284 match b4:
6285 case True{}:
6286 exp_log_rs.s11101(b5, b6, b7)
6287 case False{}:
6288 exp_log_rs.s11100(b5, b6, b7)
6289 case False{}:
6290 match b3:
6291 case True{}:
6292 match b4:
6293 case True{}:
6294 exp_log_rs.s11011(b5, b6, b7)
6295 case False{}:
6296 exp_log_rs.s11010(b5, b6, b7)
6297 case False{}:
6298 match b4:
6299 case True{}:
6300 exp_log_rs.s11001(b5, b6, b7)
6301 case False{}:
6302 exp_log_rs.s11000(b5, b6, b7)
6303 case False{}:
6304 match b2:
6305 case True{}:
6306 match b3:
6307 case True{}:
6308 match b4:
6309 case True{}:
6310 exp_log_rs.s10111(b5, b6, b7)
6311 case False{}:
6312 exp_log_rs.s10110(b5, b6, b7)
6313 case False{}:
6314 match b4:
6315 case True{}:
6316 exp_log_rs.s10101(b5, b6, b7)
6317 case False{}:
6318 exp_log_rs.s10100(b5, b6, b7)
6319 case False{}:
6320 match b3:
6321 case True{}:
6322 match b4:
6323 case True{}:
6324 exp_log_rs.s10011(b5, b6, b7)
6325 case False{}:
6326 exp_log_rs.s10010(b5, b6, b7)
6327 case False{}:
6328 match b4:
6329 case True{}:
6330 exp_log_rs.s10001(b5, b6, b7)
6331 case False{}:
6332 exp_log_rs.s10000(b5, b6, b7)
6333 case False{}:
6334 match b1:
6335 case True{}:
6336 match b2:
6337 case True{}:
6338 match b3:
6339 case True{}:
6340 match b4:
6341 case True{}:
6342 exp_log_rs.s01111(b5, b6, b7)
6343 case False{}:
6344 exp_log_rs.s01110(b5, b6, b7)
6345 case False{}:
6346 match b4:
6347 case True{}:
6348 exp_log_rs.s01101(b5, b6, b7)
6349 case False{}:
6350 exp_log_rs.s01100(b5, b6, b7)
6351 case False{}:
6352 match b3:
6353 case True{}:
6354 match b4:
6355 case True{}:
6356 exp_log_rs.s01011(b5, b6, b7)
6357 case False{}:
6358 exp_log_rs.s01010(b5, b6, b7)
6359 case False{}:
6360 match b4:
6361 case True{}:
6362 exp_log_rs.s01001(b5, b6, b7)
6363 case False{}:
6364 exp_log_rs.s01000(b5, b6, b7)
6365 case False{}:
6366 match b2:
6367 case True{}:
6368 match b3:
6369 case True{}:
6370 match b4:
6371 case True{}:
6372 exp_log_rs.s00111(b5, b6, b7)
6373 case False{}:
6374 exp_log_rs.s00110(b5, b6, b7)
6375 case False{}:
6376 match b4:
6377 case True{}:
6378 exp_log_rs.s00101(b5, b6, b7)
6379 case False{}:
6380 exp_log_rs.s00100(b5, b6, b7)
6381 case False{}:
6382 match b3:
6383 case True{}:
6384 match b4:
6385 case True{}:
6386 exp_log_rs.s00011(b5, b6, b7)
6387 case False{}:
6388 exp_log_rs.s00010(b5, b6, b7)
6389 case False{}:
6390 match b4:
6391 case True{}:
6392 exp_log_rs.s00001(b5, b6, b7)
6393 case False{}:
6394 exp_log_rs.s00000(b5, b6, b7)
6395
6396def 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}:
6397 match a:
6398 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, WCon{+b5, WCon{+b6, WCon{+b7, +r}}}}}}}}}:
6399 %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}
6400 exp_log_rs.bits(b0, b1, b2, b3, b4, b5, b6, b7)
6401
6402def 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}:
6403 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), _)) == G.Gf8.elt(a) : U32}
6404 %fix_nz(a, nz) : {G.Gf8.exp(G.Gf8.rs(), G.Gf8.log(G.Gf8.rs(), fixz(G.Gf8.elt(a)))) == _ : U32}
6405 exp_log_rs.core(a)
6406
6407def Laws.exp_log_rs(a, nz):
6408 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))
6409
6410# vectors, by computation
6411def Laws.v_aes_mul():
6412 {==}
6413
6414def Laws.v_aes_mul13():
6415 {==}
6416
6417def Laws.v_aes_xtime():
6418 {==}
6419
6420def Laws.v_aes_inv():
6421 {==}
6422
6423def Laws.v_rs_x8():
6424 {==}
6425
6426def Laws.v_rs_order():
6427 {==}
6428
6429def Laws.v_div():
6430 {==}
6431
6432def Laws.v_tab_mul_aes():
6433 {==}
6434
6435def Laws.v_tab_inv_aes():
6436 {==}
6437
6438def Laws.v_tab_mul_rs():
6439 {==}
6440
6441def Laws.v_tab_zero():
6442 {==}
6443
6444# 7. GF(2^m): addition commutes (XOR, bit by bit); for the small named
6445# fields, products and inverses by cases on the element's m bits
6446
6447def word_xor_comm(+n: Nat, +a: Word(n), +b: Word(n)) -> {Word.xor(n, a, b) == Word.xor(n, b, a) : Word(n)}:
6448 match n:
6449 case 0n:
6450 {==}
6451 case 1n+p:
6452 match a b:
6453 case WCon{+x, +at} WCon{+y, +bt}:
6454 %bx_comm(x, y) : {WCon{Bool.xor(x, y), Word.xor(p, at, bt)} == WCon{_, Word.xor(p, bt, at)} : Word(1n+p)}
6455 %word_xor_comm(p, at, bt) : {WCon{Bool.xor(x, y), Word.xor(p, at, bt)} == WCon{Bool.xor(x, y), _} : Word(1n+p)}
6456 {==}
6457
6458def u32_xor_comm(+a: U32, +b: U32) -> {U32.xor(a, b) == U32.xor(b, a) : U32}:
6459 match a b:
6460 case U32{+x} U32{+y}:
6461 Equal.cong(Word(32n), U32, w => U32{w}, Word.xor(32n, x, y), Word.xor(32n, y, x), word_xor_comm(32n, x, y))
6462
6463def Laws.gfm_add_comm(f, a, b):
6464 Equal.cong(U32, U32, z => U32.and(M.Gfm.mask(f), z), U32.xor(a, b), U32.xor(b, a), u32_xor_comm(a, b))
6465
6466def word_and_zero(+n: Nat, +r: Word(n)) -> {Word.and(n, Word.zero(n), r) == Word.zero(n) : Word(n)}:
6467 match n:
6468 case 0n:
6469 {==}
6470 case 1n+p:
6471 match r:
6472 case WCon{+x, +rt}:
6473 %word_and_zero(p, rt) : {WCon{False{}, Word.and(p, Word.zero(p), rt)} == WCon{False{}, _} : Word(1n+p)}
6474 {==}
6475
6476def 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}:
6477 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))
6478
6479def 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}:
6480 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))
6481
6482def 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}:
6483 match b0:
6484 case True{}:
6485 match b1:
6486 case True{}:
6487 match b2:
6488 case True{}:
6489 match b3:
6490 case True{}:
6491 {==}
6492 case False{}:
6493 {==}
6494 case False{}:
6495 match b3:
6496 case True{}:
6497 {==}
6498 case False{}:
6499 {==}
6500 case False{}:
6501 match b2:
6502 case True{}:
6503 match b3:
6504 case True{}:
6505 {==}
6506 case False{}:
6507 {==}
6508 case False{}:
6509 match b3:
6510 case True{}:
6511 {==}
6512 case False{}:
6513 {==}
6514 case False{}:
6515 match b1:
6516 case True{}:
6517 match b2:
6518 case True{}:
6519 match b3:
6520 case True{}:
6521 {==}
6522 case False{}:
6523 {==}
6524 case False{}:
6525 match b3:
6526 case True{}:
6527 {==}
6528 case False{}:
6529 {==}
6530 case False{}:
6531 match b2:
6532 case True{}:
6533 match b3:
6534 case True{}:
6535 {==}
6536 case False{}:
6537 {==}
6538 case False{}:
6539 match b3:
6540 case True{}:
6541 {==}
6542 case False{}:
6543 {==}
6544
6545def 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}:
6546 match b0:
6547 case True{}:
6548 match b1:
6549 case True{}:
6550 match b2:
6551 case True{}:
6552 match b3:
6553 case True{}:
6554 {==}
6555 case False{}:
6556 {==}
6557 case False{}:
6558 match b3:
6559 case True{}:
6560 {==}
6561 case False{}:
6562 {==}
6563 case False{}:
6564 match b2:
6565 case True{}:
6566 match b3:
6567 case True{}:
6568 {==}
6569 case False{}:
6570 {==}
6571 case False{}:
6572 match b3:
6573 case True{}:
6574 {==}
6575 case False{}:
6576 {==}
6577 case False{}:
6578 match b1:
6579 case True{}:
6580 match b2:
6581 case True{}:
6582 match b3:
6583 case True{}:
6584 {==}
6585 case False{}:
6586 {==}
6587 case False{}:
6588 match b3:
6589 case True{}:
6590 {==}
6591 case False{}:
6592 {==}
6593 case False{}:
6594 match b2:
6595 case True{}:
6596 match b3:
6597 case True{}:
6598 {==}
6599 case False{}:
6600 {==}
6601 case False{}:
6602 match b3:
6603 case True{}:
6604 {==}
6605 case False{}:
6606 {==}
6607
6608def 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}:
6609 match b0:
6610 case True{}:
6611 match b1:
6612 case True{}:
6613 match b2:
6614 case True{}:
6615 match b3:
6616 case True{}:
6617 {==}
6618 case False{}:
6619 {==}
6620 case False{}:
6621 match b3:
6622 case True{}:
6623 {==}
6624 case False{}:
6625 {==}
6626 case False{}:
6627 match b2:
6628 case True{}:
6629 match b3:
6630 case True{}:
6631 {==}
6632 case False{}:
6633 {==}
6634 case False{}:
6635 match b3:
6636 case True{}:
6637 {==}
6638 case False{}:
6639 {==}
6640 case False{}:
6641 match b1:
6642 case True{}:
6643 match b2:
6644 case True{}:
6645 match b3:
6646 case True{}:
6647 {==}
6648 case False{}:
6649 {==}
6650 case False{}:
6651 match b3:
6652 case True{}:
6653 {==}
6654 case False{}:
6655 {==}
6656 case False{}:
6657 match b2:
6658 case True{}:
6659 match b3:
6660 case True{}:
6661 {==}
6662 case False{}:
6663 {==}
6664 case False{}:
6665 match b3:
6666 case True{}:
6667 {==}
6668 case False{}:
6669 {==}
6670
6671def 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}:
6672 match b0:
6673 case True{}:
6674 match b1:
6675 case True{}:
6676 match b2:
6677 case True{}:
6678 match b3:
6679 case True{}:
6680 {==}
6681 case False{}:
6682 {==}
6683 case False{}:
6684 match b3:
6685 case True{}:
6686 {==}
6687 case False{}:
6688 {==}
6689 case False{}:
6690 match b2:
6691 case True{}:
6692 match b3:
6693 case True{}:
6694 {==}
6695 case False{}:
6696 {==}
6697 case False{}:
6698 match b3:
6699 case True{}:
6700 {==}
6701 case False{}:
6702 {==}
6703 case False{}:
6704 match b1:
6705 case True{}:
6706 match b2:
6707 case True{}:
6708 match b3:
6709 case True{}:
6710 {==}
6711 case False{}:
6712 {==}
6713 case False{}:
6714 match b3:
6715 case True{}:
6716 {==}
6717 case False{}:
6718 {==}
6719 case False{}:
6720 match b2:
6721 case True{}:
6722 match b3:
6723 case True{}:
6724 {==}
6725 case False{}:
6726 {==}
6727 case False{}:
6728 match b3:
6729 case True{}:
6730 {==}
6731 case False{}:
6732 {==}
6733
6734def 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}:
6735 match b0:
6736 case True{}:
6737 match b1:
6738 case True{}:
6739 match b2:
6740 case True{}:
6741 match b3:
6742 case True{}:
6743 {==}
6744 case False{}:
6745 {==}
6746 case False{}:
6747 match b3:
6748 case True{}:
6749 {==}
6750 case False{}:
6751 {==}
6752 case False{}:
6753 match b2:
6754 case True{}:
6755 match b3:
6756 case True{}:
6757 {==}
6758 case False{}:
6759 {==}
6760 case False{}:
6761 match b3:
6762 case True{}:
6763 {==}
6764 case False{}:
6765 {==}
6766 case False{}:
6767 match b1:
6768 case True{}:
6769 match b2:
6770 case True{}:
6771 match b3:
6772 case True{}:
6773 {==}
6774 case False{}:
6775 {==}
6776 case False{}:
6777 match b3:
6778 case True{}:
6779 {==}
6780 case False{}:
6781 {==}
6782 case False{}:
6783 match b2:
6784 case True{}:
6785 match b3:
6786 case True{}:
6787 {==}
6788 case False{}:
6789 {==}
6790 case False{}:
6791 match b3:
6792 case True{}:
6793 {==}
6794 case False{}:
6795 {==}
6796
6797def 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}:
6798 match b0:
6799 case True{}:
6800 match b1:
6801 case True{}:
6802 match b2:
6803 case True{}:
6804 match b3:
6805 case True{}:
6806 {==}
6807 case False{}:
6808 {==}
6809 case False{}:
6810 match b3:
6811 case True{}:
6812 {==}
6813 case False{}:
6814 {==}
6815 case False{}:
6816 match b2:
6817 case True{}:
6818 match b3:
6819 case True{}:
6820 {==}
6821 case False{}:
6822 {==}
6823 case False{}:
6824 match b3:
6825 case True{}:
6826 {==}
6827 case False{}:
6828 {==}
6829 case False{}:
6830 match b1:
6831 case True{}:
6832 match b2:
6833 case True{}:
6834 match b3:
6835 case True{}:
6836 {==}
6837 case False{}:
6838 {==}
6839 case False{}:
6840 match b3:
6841 case True{}:
6842 {==}
6843 case False{}:
6844 {==}
6845 case False{}:
6846 match b2:
6847 case True{}:
6848 match b3:
6849 case True{}:
6850 {==}
6851 case False{}:
6852 {==}
6853 case False{}:
6854 match b3:
6855 case True{}:
6856 {==}
6857 case False{}:
6858 {==}
6859
6860def 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}:
6861 match b0:
6862 case True{}:
6863 match b1:
6864 case True{}:
6865 match b2:
6866 case True{}:
6867 match b3:
6868 case True{}:
6869 {==}
6870 case False{}:
6871 {==}
6872 case False{}:
6873 match b3:
6874 case True{}:
6875 {==}
6876 case False{}:
6877 {==}
6878 case False{}:
6879 match b2:
6880 case True{}:
6881 match b3:
6882 case True{}:
6883 {==}
6884 case False{}:
6885 {==}
6886 case False{}:
6887 match b3:
6888 case True{}:
6889 {==}
6890 case False{}:
6891 {==}
6892 case False{}:
6893 match b1:
6894 case True{}:
6895 match b2:
6896 case True{}:
6897 match b3:
6898 case True{}:
6899 {==}
6900 case False{}:
6901 {==}
6902 case False{}:
6903 match b3:
6904 case True{}:
6905 {==}
6906 case False{}:
6907 {==}
6908 case False{}:
6909 match b2:
6910 case True{}:
6911 match b3:
6912 case True{}:
6913 {==}
6914 case False{}:
6915 {==}
6916 case False{}:
6917 match b3:
6918 case True{}:
6919 {==}
6920 case False{}:
6921 {==}
6922
6923def 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}:
6924 match b0:
6925 case True{}:
6926 match b1:
6927 case True{}:
6928 match b2:
6929 case True{}:
6930 match b3:
6931 case True{}:
6932 {==}
6933 case False{}:
6934 {==}
6935 case False{}:
6936 match b3:
6937 case True{}:
6938 {==}
6939 case False{}:
6940 {==}
6941 case False{}:
6942 match b2:
6943 case True{}:
6944 match b3:
6945 case True{}:
6946 {==}
6947 case False{}:
6948 {==}
6949 case False{}:
6950 match b3:
6951 case True{}:
6952 {==}
6953 case False{}:
6954 {==}
6955 case False{}:
6956 match b1:
6957 case True{}:
6958 match b2:
6959 case True{}:
6960 match b3:
6961 case True{}:
6962 {==}
6963 case False{}:
6964 {==}
6965 case False{}:
6966 match b3:
6967 case True{}:
6968 {==}
6969 case False{}:
6970 {==}
6971 case False{}:
6972 match b2:
6973 case True{}:
6974 match b3:
6975 case True{}:
6976 {==}
6977 case False{}:
6978 {==}
6979 case False{}:
6980 match b3:
6981 case True{}:
6982 {==}
6983 case False{}:
6984 {==}
6985
6986def 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}:
6987 match b0:
6988 case True{}:
6989 match b1:
6990 case True{}:
6991 match b2:
6992 case True{}:
6993 match b3:
6994 case True{}:
6995 {==}
6996 case False{}:
6997 {==}
6998 case False{}:
6999 match b3:
7000 case True{}:
7001 {==}
7002 case False{}:
7003 {==}
7004 case False{}:
7005 match b2:
7006 case True{}:
7007 match b3:
7008 case True{}:
7009 {==}
7010 case False{}:
7011 {==}
7012 case False{}:
7013 match b3:
7014 case True{}:
7015 {==}
7016 case False{}:
7017 {==}
7018 case False{}:
7019 match b1:
7020 case True{}:
7021 match b2:
7022 case True{}:
7023 match b3:
7024 case True{}:
7025 {==}
7026 case False{}:
7027 {==}
7028 case False{}:
7029 match b3:
7030 case True{}:
7031 {==}
7032 case False{}:
7033 {==}
7034 case False{}:
7035 match b2:
7036 case True{}:
7037 match b3:
7038 case True{}:
7039 {==}
7040 case False{}:
7041 {==}
7042 case False{}:
7043 match b3:
7044 case True{}:
7045 {==}
7046 case False{}:
7047 {==}
7048
7049def 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}:
7050 match b0:
7051 case True{}:
7052 match b1:
7053 case True{}:
7054 match b2:
7055 case True{}:
7056 match b3:
7057 case True{}:
7058 {==}
7059 case False{}:
7060 {==}
7061 case False{}:
7062 match b3:
7063 case True{}:
7064 {==}
7065 case False{}:
7066 {==}
7067 case False{}:
7068 match b2:
7069 case True{}:
7070 match b3:
7071 case True{}:
7072 {==}
7073 case False{}:
7074 {==}
7075 case False{}:
7076 match b3:
7077 case True{}:
7078 {==}
7079 case False{}:
7080 {==}
7081 case False{}:
7082 match b1:
7083 case True{}:
7084 match b2:
7085 case True{}:
7086 match b3:
7087 case True{}:
7088 {==}
7089 case False{}:
7090 {==}
7091 case False{}:
7092 match b3:
7093 case True{}:
7094 {==}
7095 case False{}:
7096 {==}
7097 case False{}:
7098 match b2:
7099 case True{}:
7100 match b3:
7101 case True{}:
7102 {==}
7103 case False{}:
7104 {==}
7105 case False{}:
7106 match b3:
7107 case True{}:
7108 {==}
7109 case False{}:
7110 {==}
7111
7112def 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}:
7113 match b0:
7114 case True{}:
7115 match b1:
7116 case True{}:
7117 match b2:
7118 case True{}:
7119 match b3:
7120 case True{}:
7121 {==}
7122 case False{}:
7123 {==}
7124 case False{}:
7125 match b3:
7126 case True{}:
7127 {==}
7128 case False{}:
7129 {==}
7130 case False{}:
7131 match b2:
7132 case True{}:
7133 match b3:
7134 case True{}:
7135 {==}
7136 case False{}:
7137 {==}
7138 case False{}:
7139 match b3:
7140 case True{}:
7141 {==}
7142 case False{}:
7143 {==}
7144 case False{}:
7145 match b1:
7146 case True{}:
7147 match b2:
7148 case True{}:
7149 match b3:
7150 case True{}:
7151 {==}
7152 case False{}:
7153 {==}
7154 case False{}:
7155 match b3:
7156 case True{}:
7157 {==}
7158 case False{}:
7159 {==}
7160 case False{}:
7161 match b2:
7162 case True{}:
7163 match b3:
7164 case True{}:
7165 {==}
7166 case False{}:
7167 {==}
7168 case False{}:
7169 match b3:
7170 case True{}:
7171 {==}
7172 case False{}:
7173 {==}
7174
7175def 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}:
7176 match b0:
7177 case True{}:
7178 match b1:
7179 case True{}:
7180 match b2:
7181 case True{}:
7182 match b3:
7183 case True{}:
7184 {==}
7185 case False{}:
7186 {==}
7187 case False{}:
7188 match b3:
7189 case True{}:
7190 {==}
7191 case False{}:
7192 {==}
7193 case False{}:
7194 match b2:
7195 case True{}:
7196 match b3:
7197 case True{}:
7198 {==}
7199 case False{}:
7200 {==}
7201 case False{}:
7202 match b3:
7203 case True{}:
7204 {==}
7205 case False{}:
7206 {==}
7207 case False{}:
7208 match b1:
7209 case True{}:
7210 match b2:
7211 case True{}:
7212 match b3:
7213 case True{}:
7214 {==}
7215 case False{}:
7216 {==}
7217 case False{}:
7218 match b3:
7219 case True{}:
7220 {==}
7221 case False{}:
7222 {==}
7223 case False{}:
7224 match b2:
7225 case True{}:
7226 match b3:
7227 case True{}:
7228 {==}
7229 case False{}:
7230 {==}
7231 case False{}:
7232 match b3:
7233 case True{}:
7234 {==}
7235 case False{}:
7236 {==}
7237
7238def 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}:
7239 match b0:
7240 case True{}:
7241 match b1:
7242 case True{}:
7243 match b2:
7244 case True{}:
7245 match b3:
7246 case True{}:
7247 {==}
7248 case False{}:
7249 {==}
7250 case False{}:
7251 match b3:
7252 case True{}:
7253 {==}
7254 case False{}:
7255 {==}
7256 case False{}:
7257 match b2:
7258 case True{}:
7259 match b3:
7260 case True{}:
7261 {==}
7262 case False{}:
7263 {==}
7264 case False{}:
7265 match b3:
7266 case True{}:
7267 {==}
7268 case False{}:
7269 {==}
7270 case False{}:
7271 match b1:
7272 case True{}:
7273 match b2:
7274 case True{}:
7275 match b3:
7276 case True{}:
7277 {==}
7278 case False{}:
7279 {==}
7280 case False{}:
7281 match b3:
7282 case True{}:
7283 {==}
7284 case False{}:
7285 {==}
7286 case False{}:
7287 match b2:
7288 case True{}:
7289 match b3:
7290 case True{}:
7291 {==}
7292 case False{}:
7293 {==}
7294 case False{}:
7295 match b3:
7296 case True{}:
7297 {==}
7298 case False{}:
7299 {==}
7300
7301def 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}:
7302 match b0:
7303 case True{}:
7304 match b1:
7305 case True{}:
7306 match b2:
7307 case True{}:
7308 match b3:
7309 case True{}:
7310 {==}
7311 case False{}:
7312 {==}
7313 case False{}:
7314 match b3:
7315 case True{}:
7316 {==}
7317 case False{}:
7318 {==}
7319 case False{}:
7320 match b2:
7321 case True{}:
7322 match b3:
7323 case True{}:
7324 {==}
7325 case False{}:
7326 {==}
7327 case False{}:
7328 match b3:
7329 case True{}:
7330 {==}
7331 case False{}:
7332 {==}
7333 case False{}:
7334 match b1:
7335 case True{}:
7336 match b2:
7337 case True{}:
7338 match b3:
7339 case True{}:
7340 {==}
7341 case False{}:
7342 {==}
7343 case False{}:
7344 match b3:
7345 case True{}:
7346 {==}
7347 case False{}:
7348 {==}
7349 case False{}:
7350 match b2:
7351 case True{}:
7352 match b3:
7353 case True{}:
7354 {==}
7355 case False{}:
7356 {==}
7357 case False{}:
7358 match b3:
7359 case True{}:
7360 {==}
7361 case False{}:
7362 {==}
7363
7364def 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}:
7365 match b0:
7366 case True{}:
7367 match b1:
7368 case True{}:
7369 match b2:
7370 case True{}:
7371 match b3:
7372 case True{}:
7373 {==}
7374 case False{}:
7375 {==}
7376 case False{}:
7377 match b3:
7378 case True{}:
7379 {==}
7380 case False{}:
7381 {==}
7382 case False{}:
7383 match b2:
7384 case True{}:
7385 match b3:
7386 case True{}:
7387 {==}
7388 case False{}:
7389 {==}
7390 case False{}:
7391 match b3:
7392 case True{}:
7393 {==}
7394 case False{}:
7395 {==}
7396 case False{}:
7397 match b1:
7398 case True{}:
7399 match b2:
7400 case True{}:
7401 match b3:
7402 case True{}:
7403 {==}
7404 case False{}:
7405 {==}
7406 case False{}:
7407 match b3:
7408 case True{}:
7409 {==}
7410 case False{}:
7411 {==}
7412 case False{}:
7413 match b2:
7414 case True{}:
7415 match b3:
7416 case True{}:
7417 {==}
7418 case False{}:
7419 {==}
7420 case False{}:
7421 match b3:
7422 case True{}:
7423 {==}
7424 case False{}:
7425 {==}
7426
7427def 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}:
7428 match b0:
7429 case True{}:
7430 match b1:
7431 case True{}:
7432 match b2:
7433 case True{}:
7434 match b3:
7435 case True{}:
7436 {==}
7437 case False{}:
7438 {==}
7439 case False{}:
7440 match b3:
7441 case True{}:
7442 {==}
7443 case False{}:
7444 {==}
7445 case False{}:
7446 match b2:
7447 case True{}:
7448 match b3:
7449 case True{}:
7450 {==}
7451 case False{}:
7452 {==}
7453 case False{}:
7454 match b3:
7455 case True{}:
7456 {==}
7457 case False{}:
7458 {==}
7459 case False{}:
7460 match b1:
7461 case True{}:
7462 match b2:
7463 case True{}:
7464 match b3:
7465 case True{}:
7466 {==}
7467 case False{}:
7468 {==}
7469 case False{}:
7470 match b3:
7471 case True{}:
7472 {==}
7473 case False{}:
7474 {==}
7475 case False{}:
7476 match b2:
7477 case True{}:
7478 match b3:
7479 case True{}:
7480 {==}
7481 case False{}:
7482 {==}
7483 case False{}:
7484 match b3:
7485 case True{}:
7486 {==}
7487 case False{}:
7488 {==}
7489
7490def 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}:
7491 match a0:
7492 case True{}:
7493 match a1:
7494 case True{}:
7495 match a2:
7496 case True{}:
7497 match a3:
7498 case True{}:
7499 comm16.s1111(b0, b1, b2, b3)
7500 case False{}:
7501 comm16.s1110(b0, b1, b2, b3)
7502 case False{}:
7503 match a3:
7504 case True{}:
7505 comm16.s1101(b0, b1, b2, b3)
7506 case False{}:
7507 comm16.s1100(b0, b1, b2, b3)
7508 case False{}:
7509 match a2:
7510 case True{}:
7511 match a3:
7512 case True{}:
7513 comm16.s1011(b0, b1, b2, b3)
7514 case False{}:
7515 comm16.s1010(b0, b1, b2, b3)
7516 case False{}:
7517 match a3:
7518 case True{}:
7519 comm16.s1001(b0, b1, b2, b3)
7520 case False{}:
7521 comm16.s1000(b0, b1, b2, b3)
7522 case False{}:
7523 match a1:
7524 case True{}:
7525 match a2:
7526 case True{}:
7527 match a3:
7528 case True{}:
7529 comm16.s0111(b0, b1, b2, b3)
7530 case False{}:
7531 comm16.s0110(b0, b1, b2, b3)
7532 case False{}:
7533 match a3:
7534 case True{}:
7535 comm16.s0101(b0, b1, b2, b3)
7536 case False{}:
7537 comm16.s0100(b0, b1, b2, b3)
7538 case False{}:
7539 match a2:
7540 case True{}:
7541 match a3:
7542 case True{}:
7543 comm16.s0011(b0, b1, b2, b3)
7544 case False{}:
7545 comm16.s0010(b0, b1, b2, b3)
7546 case False{}:
7547 match a3:
7548 case True{}:
7549 comm16.s0001(b0, b1, b2, b3)
7550 case False{}:
7551 comm16.s0000(b0, b1, b2, b3)
7552
7553def 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}:
7554 match a b:
7555 case U32{WCon{+a0, WCon{+a1, WCon{+a2, WCon{+a3, +ra}}}}} U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, +rb}}}}}:
7556 %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}
7557 %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}
7558 %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}
7559 %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}
7560 comm16.bits(a0, a1, a2, a3, b0, b1, b2, b3)
7561
7562def Laws.gfm_mul_comm_gf16(a, b):
7563 comm16.core(a, b)
7564
7565# a nonzero element as itself, and 0 as 1
7566def fixm(+x: U32) -> U32:
7567 Bool.pick(U32, U32.is_eq(x, 0), 1, x)
7568
7569def fixm_nz(+x: U32, nz: {U32.is_eq(x, 0) == False{} : Bool}) -> {fixm(x) == x : U32}:
7570 %Equal.sym(Bool, U32.is_eq(x, 0), False{}, nz) : {Bool.pick(U32, _, 1, x) == x : U32}
7571 {==}
7572
7573def 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}:
7574 match b0:
7575 case True{}:
7576 match b1:
7577 case True{}:
7578 match b2:
7579 case True{}:
7580 match b3:
7581 case True{}:
7582 {==}
7583 case False{}:
7584 {==}
7585 case False{}:
7586 match b3:
7587 case True{}:
7588 {==}
7589 case False{}:
7590 {==}
7591 case False{}:
7592 match b2:
7593 case True{}:
7594 match b3:
7595 case True{}:
7596 {==}
7597 case False{}:
7598 {==}
7599 case False{}:
7600 match b3:
7601 case True{}:
7602 {==}
7603 case False{}:
7604 {==}
7605 case False{}:
7606 match b1:
7607 case True{}:
7608 match b2:
7609 case True{}:
7610 match b3:
7611 case True{}:
7612 {==}
7613 case False{}:
7614 {==}
7615 case False{}:
7616 match b3:
7617 case True{}:
7618 {==}
7619 case False{}:
7620 {==}
7621 case False{}:
7622 match b2:
7623 case True{}:
7624 match b3:
7625 case True{}:
7626 {==}
7627 case False{}:
7628 {==}
7629 case False{}:
7630 match b3:
7631 case True{}:
7632 {==}
7633 case False{}:
7634 {==}
7635
7636def 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}:
7637 inv16.s(b0, b1, b2, b3)
7638
7639def 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}:
7640 match a:
7641 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, +r}}}}}:
7642 %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}
7643 %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}
7644 inv16.bits(b0, b1, b2, b3)
7645
7646def 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}:
7647 %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}
7648 %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}
7649 inv16.core(a)
7650
7651def Laws.gfm_mul_inv_gf16(a, nz):
7652 inv16.lift(a, nz)
7653
7654def 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}:
7655 match b1:
7656 case True{}:
7657 match b2:
7658 case True{}:
7659 match b3:
7660 case True{}:
7661 match b4:
7662 case True{}:
7663 {==}
7664 case False{}:
7665 {==}
7666 case False{}:
7667 match b4:
7668 case True{}:
7669 {==}
7670 case False{}:
7671 {==}
7672 case False{}:
7673 match b3:
7674 case True{}:
7675 match b4:
7676 case True{}:
7677 {==}
7678 case False{}:
7679 {==}
7680 case False{}:
7681 match b4:
7682 case True{}:
7683 {==}
7684 case False{}:
7685 {==}
7686 case False{}:
7687 match b2:
7688 case True{}:
7689 match b3:
7690 case True{}:
7691 match b4:
7692 case True{}:
7693 {==}
7694 case False{}:
7695 {==}
7696 case False{}:
7697 match b4:
7698 case True{}:
7699 {==}
7700 case False{}:
7701 {==}
7702 case False{}:
7703 match b3:
7704 case True{}:
7705 match b4:
7706 case True{}:
7707 {==}
7708 case False{}:
7709 {==}
7710 case False{}:
7711 match b4:
7712 case True{}:
7713 {==}
7714 case False{}:
7715 {==}
7716
7717def 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}:
7718 match b1:
7719 case True{}:
7720 match b2:
7721 case True{}:
7722 match b3:
7723 case True{}:
7724 match b4:
7725 case True{}:
7726 {==}
7727 case False{}:
7728 {==}
7729 case False{}:
7730 match b4:
7731 case True{}:
7732 {==}
7733 case False{}:
7734 {==}
7735 case False{}:
7736 match b3:
7737 case True{}:
7738 match b4:
7739 case True{}:
7740 {==}
7741 case False{}:
7742 {==}
7743 case False{}:
7744 match b4:
7745 case True{}:
7746 {==}
7747 case False{}:
7748 {==}
7749 case False{}:
7750 match b2:
7751 case True{}:
7752 match b3:
7753 case True{}:
7754 match b4:
7755 case True{}:
7756 {==}
7757 case False{}:
7758 {==}
7759 case False{}:
7760 match b4:
7761 case True{}:
7762 {==}
7763 case False{}:
7764 {==}
7765 case False{}:
7766 match b3:
7767 case True{}:
7768 match b4:
7769 case True{}:
7770 {==}
7771 case False{}:
7772 {==}
7773 case False{}:
7774 match b4:
7775 case True{}:
7776 {==}
7777 case False{}:
7778 {==}
7779
7780def 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}:
7781 match b0:
7782 case True{}:
7783 inv32.s1(b1, b2, b3, b4)
7784 case False{}:
7785 inv32.s0(b1, b2, b3, b4)
7786
7787def 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}:
7788 match a:
7789 case U32{WCon{+b0, WCon{+b1, WCon{+b2, WCon{+b3, WCon{+b4, +r}}}}}}:
7790 %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}
7791 %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}
7792 inv32.bits(b0, b1, b2, b3, b4)
7793
7794def 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}:
7795 %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}
7796 %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}
7797 inv32.core(a)
7798
7799def Laws.gfm_mul_inv_gf32(a, nz):
7800 inv32.lift(a, nz)
7801
7802# vectors, by computation
7803def Laws.v_gcm_x1():
7804 {==}
7805
7806def Laws.v_gcm_ghash():
7807 {==}
7808
7809def Laws.v_cmac_k1():
7810 {==}
7811
7812def Laws.v_cmac_k2():
7813 {==}
7814
7815def Laws.v_gcm_mul_x():
7816 {==}
7817
7818def Laws.v_gcm_mul_x_value():
7819 {==}
7820
7821def Laws.v_be_mul_x():
7822 {==}
7823
7824def Laws.v_be_mul():
7825 {==}
7826
7827def Laws.v_xts_wrap():
7828 {==}
7829
7830def Laws.v_xts_double():
7831 {==}
7832
7833def Laws.v_gf128_octets():
7834 {==}
7835
7836def Laws.v_gf128_short():
7837 {==}
7838
7839def Laws.v_bch13_x13():
7840 {==}
7841
7842def Laws.v_bch13_order():
7843 {==}
7844
7845def Laws.v_bch13_mul():
7846 {==}
7847
7848def Laws.v_bch13_inv():
7849 {==}
7850
7851def Laws.v_bch13_log():
7852 {==}
7853
7854def Laws.v_bch14_mul():
7855 {==}
7856