src/tensor/axis_algebra.bend
bendtorch-core@0.1.0.0 · 3,107 lines · 159 definitions
1import Base
2import bendtorch-core@0.1.0.0/src/shape/core.bend as Shape
3import bendtorch-core@0.1.0.0/src/shape/nat_proofs.bend as Nats
4import bendtorch-core@0.1.0.0/src/shape/broadcast_proofs.bend as Broadcast
5import bendtorch-core@0.1.0.0/src/storage/arith.bend as Arith
6import bendtorch-core@0.1.0.0/src/tensor/layout.bend as Layout
7import bendtorch-core@0.1.0.0/src/tensor/axis_spec.bend as Axis
8import bendtorch-core@0.1.0.0/src/tensor/word_conversion.bend as Conversion
9
10def lookup(+values: List<&2, U32>, +index: Nat) -> {Layout.lookup(values, index) == Axis.lookup(U32, values, index) : Maybe<&2, U32>}:
11 match values index:
12 case Nil{} 0n:
13 {==}
14 case Nil{} 1n+p:
15 {==}
16 case head <> tail 0n:
17 {==}
18 case head <> +tail 1n+p:
19 lookup(tail, p)
20
21def reorder_step(+head: Maybe<&2, U32>, +tail: Maybe<&2, List<&2, U32>>) ->
22 {Layout.reorder_head(value => Layout.reorder_tail(value, tail), head) == Axis.prepend(U32, head, tail) : Maybe<&2, List<&2, U32>>}:
23 match head tail:
24 case None{} None{}:
25 {==}
26 case None{} Some{items}:
27 {==}
28 case Some{value} None{}:
29 {==}
30 case Some{value} Some{items}:
31 {==}
32
33def reorder(+axes: List<&2, U32>, +values: List<&2, U32>) ->
34 {Layout.reorder(values, axes) == Axis.gather(U32, values, Shape.naturals(axes)) : Maybe<&2, List<&2, U32>>}:
35 match axes:
36 case Nil{}:
37 {==}
38 case +axis <> +tail:
39 %Equal.sym(Maybe<&2, U32>, Layout.lookup(values, U32.to_nat(axis)), Axis.lookup(U32, values, U32.to_nat(axis)), lookup(values, U32.to_nat(axis))) :
40 {Layout.reorder_head(value => Layout.reorder_tail(value, Layout.reorder(values, tail)), _) == Axis.prepend(U32, Axis.lookup(U32, values, U32.to_nat(axis)), Axis.gather(U32, values, Shape.naturals(tail))) : Maybe<&2, List<&2, U32>>}
41 %Equal.sym(Maybe<&2, List<&2, U32>>, Layout.reorder(values, tail), Axis.gather(U32, values, Shape.naturals(tail)), reorder(tail, values)) :
42 {Layout.reorder_head(value => Layout.reorder_tail(value, _), Axis.lookup(U32, values, U32.to_nat(axis))) == Axis.prepend(U32, Axis.lookup(U32, values, U32.to_nat(axis)), Axis.gather(U32, values, Shape.naturals(tail))) : Maybe<&2, List<&2, U32>>}
43 reorder_step(Axis.lookup(U32, values, U32.to_nat(axis)), Axis.gather(U32, values, Shape.naturals(tail)))
44
45def u32_eq(+a: U32, +b: U32) -> {U32.is_eq(a, b) == Nat.is_eq(U32.to_nat(a), U32.to_nat(b)) : Bool}:
46 match a b:
47 case U32{+x} U32{+y}:
48 Equal.sym(Bool, Cmp.is_eq(Nat.cmp(Word.to_nat(32n, x), Word.to_nat(32n, y))), Cmp.is_eq(Word.cmp(32n, x, y)),
49 Equal.cong(Cmp, Bool, Cmp.is_eq, Nat.cmp(Word.to_nat(32n, x), Word.to_nat(32n, y)), Word.cmp(32n, x, y), Arith.word_cmp(32n, x, y)))
50
51def lookup_empty(+index: Nat) -> {Axis.lookup(U32, Nil{}, index) == None{} : Maybe<&2, U32>}:
52 match index:
53 case 0n:
54 {==}
55 case 1n+p:
56 {==}
57
58def select_empty(+index: Maybe<&2, Nat>) -> {Axis.select(U32, Nil{}, index) == None{} : Maybe<&2, U32>}:
59 match index:
60 case None{}:
61 {==}
62 case Some{+value}:
63 lookup_empty(value)
64
65def select_next(-head: U32, +tail: List<&2, U32>, +index: Maybe<&2, Nat>) ->
66 {Axis.select(U32, head <> tail, Axis.position_next(index)) == Axis.select(U32, tail, index) : Maybe<&2, U32>}:
67 match index:
68 case None{}:
69 {==}
70 case Some{value}:
71 {==}
72
73def coordinate_step(+decision: Bool, +head: U32, +tail: List<&2, U32>, +index: Maybe<&2, Nat>) ->
74 {Bool.pick(Maybe<&2, U32>, decision, Some{head}, Axis.select(U32, tail, index)) ==
75 Axis.select(U32, head <> tail, Axis.position_decided(decision, index)) : Maybe<&2, U32>}:
76 match decision:
77 case True{}:
78 {==}
79 case False{}:
80 Equal.sym(Maybe<&2, U32>, Axis.select(U32, head <> tail, Axis.position_next(index)), Axis.select(U32, tail, index), select_next(head, tail, index))
81
82def coordinate_for(+axes: List<&2, U32>, +coordinates: List<&2, U32>, +axis: U32) ->
83 {Layout.coordinate_for(axes, coordinates, axis) == Axis.select(U32, coordinates, Axis.position(Shape.naturals(axes), U32.to_nat(axis))) : Maybe<&2, U32>}:
84 match axes coordinates:
85 case Nil{} Nil{}:
86 {==}
87 case Nil{} head <> tail:
88 {==}
89 case +head <> +tail Nil{}:
90 Equal.sym(Maybe<&2, U32>, Axis.select(U32, Nil{}, Axis.position(Shape.naturals(head <> tail), U32.to_nat(axis))), None{},
91 select_empty(Axis.position(Shape.naturals(head <> tail), U32.to_nat(axis))))
92 case +head <> +tail +value <> +rest:
93 %Equal.sym(Maybe<&2, U32>, Layout.coordinate_for(tail, rest, axis), Axis.select(U32, rest, Axis.position(Shape.naturals(tail), U32.to_nat(axis))), coordinate_for(tail, rest, axis)) :
94 {Bool.pick(Maybe<&2, U32>, U32.is_eq(head, axis), Some{value}, _) == Axis.select(U32, value <> rest, Axis.position(Shape.naturals(head <> tail), U32.to_nat(axis))) : Maybe<&2, U32>}
95 %Equal.sym(Bool, U32.is_eq(head, axis), Nat.is_eq(U32.to_nat(head), U32.to_nat(axis)), u32_eq(head, axis)) :
96 {Bool.pick(Maybe<&2, U32>, _, Some{value}, Axis.select(U32, rest, Axis.position(Shape.naturals(tail), U32.to_nat(axis)))) == Axis.select(U32, value <> rest, Axis.position(Shape.naturals(head <> tail), U32.to_nat(axis))) : Maybe<&2, U32>}
97 coordinate_step(Nat.is_eq(U32.to_nat(head), U32.to_nat(axis)), value, rest, Axis.position(Shape.naturals(tail), U32.to_nat(axis)))
98
99def contains(+axes: List<&2, U32>, +axis: U32) -> {Layout.contains(axis, axes) == Axis.contains(U32.to_nat(axis), Shape.naturals(axes)) : Bool}:
100 match axes:
101 case Nil{}:
102 {==}
103 case +head <> +tail:
104 %Equal.sym(Bool, U32.is_eq(axis, head), Nat.is_eq(U32.to_nat(axis), U32.to_nat(head)), u32_eq(axis, head)) :
105 {Bool.or(_, Layout.contains(axis, tail)) == Axis.contains(U32.to_nat(axis), Shape.naturals(head <> tail)) : Bool}
106 %Equal.sym(Bool, Layout.contains(axis, tail), Axis.contains(U32.to_nat(axis), Shape.naturals(tail)), contains(tail, axis)) :
107 {Bool.or(Nat.is_eq(U32.to_nat(axis), U32.to_nat(head)), _) == Axis.contains(U32.to_nat(axis), Shape.naturals(head <> tail)) : Bool}
108 {==}
109
110def unique(+axes: List<&2, U32>) -> {Layout.unique(axes) == Axis.unique(Shape.naturals(axes)) : Bool}:
111 match axes:
112 case Nil{}:
113 {==}
114 case +head <> +tail:
115 %Equal.sym(Bool, Layout.contains(head, tail), Axis.contains(U32.to_nat(head), Shape.naturals(tail)), contains(tail, head)) :
116 {Bool.and(Bool.not(_), Layout.unique(tail)) == Axis.unique(Shape.naturals(head <> tail)) : Bool}
117 %Equal.sym(Bool, Layout.unique(tail), Axis.unique(Shape.naturals(tail)), unique(tail)) :
118 {Bool.and(Bool.not(Axis.contains(U32.to_nat(head), Shape.naturals(tail))), _) == Axis.unique(Shape.naturals(head <> tail)) : Bool}
119 {==}
120
121def bounded(+axes: List<&2, U32>, +rank: U32) -> {Layout.bounded(axes, rank) == Axis.bounded(Shape.naturals(axes), U32.to_nat(rank)) : Bool}:
122 match axes:
123 case Nil{}:
124 {==}
125 case +head <> +tail:
126 %Arith.u32_lt(head, rank) : {Bool.and(_, Layout.bounded(tail, rank)) == Axis.bounded(Shape.naturals(head <> tail), U32.to_nat(rank)) : Bool}
127 %Equal.sym(Bool, Layout.bounded(tail, rank), Axis.bounded(Shape.naturals(tail), U32.to_nat(rank)), bounded(tail, rank)) :
128 {Bool.and(Nat.is_lt(U32.to_nat(head), U32.to_nat(rank)), _) == Axis.bounded(Shape.naturals(head <> tail), U32.to_nat(rank)) : Bool}
129 {==}
130
131def rank_exact(+shape: Shape.Shape) -> {U32.to_nat(Shape.rank(shape)) == Shape.rank_dimensions(Shape.dimensions(shape)) : Nat}:
132 match shape:
133 case Shape.SShape{+dims, size, exact, +rank_bound, capacity_bound}:
134 Conversion.natural_word_exact(Shape.rank_dimensions(dims), 4,
135 Equal.sym(Bool, True{}, Nat.is_le(Shape.rank_dimensions(dims), 4n), Nats.le_true(Shape.rank_dimensions(dims), 4n, rank_bound)))
136
137def valid(+shape: Shape.Shape, +axes: List<&2, U32>, accepted: {True{} == Layout.bijective(shape, axes) : Bool}) ->
138 {True{} == Axis.valid(Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes)) : Bool}:
139 %Shape.rank_naturals(axes) : {True{} == Bool.and(Nat.is_eq(_, Shape.rank_dimensions(Shape.dimensions(shape))), Bool.and(Axis.bounded(Shape.naturals(axes), Shape.rank_dimensions(Shape.dimensions(shape))), Axis.unique(Shape.naturals(axes)))) : Bool}
140 %unique(axes) : {True{} == Bool.and(Nat.is_eq(Shape.rank_dimensions(axes), Shape.rank_dimensions(Shape.dimensions(shape))), Bool.and(Axis.bounded(Shape.naturals(axes), Shape.rank_dimensions(Shape.dimensions(shape))), _)) : Bool}
141 %rank_exact(shape) : {True{} == Bool.and(Nat.is_eq(Shape.rank_dimensions(axes), Shape.rank_dimensions(Shape.dimensions(shape))), Bool.and(Axis.bounded(Shape.naturals(axes), _), Layout.unique(axes))) : Bool}
142 %bounded(axes, Shape.rank(shape)) : {True{} == Bool.and(Nat.is_eq(Shape.rank_dimensions(axes), Shape.rank_dimensions(Shape.dimensions(shape))), Bool.and(_, Layout.unique(axes))) : Bool}
143 accepted
144
145def add_comm(+a: Nat, +b: Nat) -> {Nat.add(a, b) == Nat.add(b, a) : Nat}:
146 %Broadcast.add_zero(b) : {Nat.add(a, _) == Nat.add(b, a) : Nat}
147 %Broadcast.add_zero(a) : {Nat.add(a, Nat.add(b, 0n)) == Nat.add(b, _) : Nat}
148 Nats.add_swap(a, b, 0n)
149
150def cursor_bound(+rank: Nat, +cursor: Nat, bound: Shape.LE(Nat.add(rank, cursor), 4n)) -> Shape.LE(cursor, 4n):
151 Nats.le_add_left(cursor, rank, 4n,
152 %add_comm(rank, cursor) : Shape.LE(_, 4n)
153 bound)
154
155def inverse_coordinates_go(+dimensions: List<&2, U32>, +axes: List<&2, U32>, +coordinates: List<&2, U32>, +cursor: Nat,
156 +bound: Shape.LE(Nat.add(Shape.rank_dimensions(dimensions), cursor), 4n)) ->
157 {Layout.inverse_coordinates(dimensions, axes, coordinates, U32.from_nat(cursor)) ==
158 Axis.scatter(U32, Shape.rank_dimensions(dimensions), Shape.naturals(axes), coordinates, cursor) : Maybe<&2, List<&2, U32>>}:
159 match dimensions:
160 case Nil{}:
161 {==}
162 case head <> +tail:
163 %Equal.sym(Maybe<&2, U32>, Layout.coordinate_for(axes, coordinates, U32.from_nat(cursor)),
164 Axis.select(U32, coordinates, Axis.position(Shape.naturals(axes), U32.to_nat(U32.from_nat(cursor)))), coordinate_for(axes, coordinates, U32.from_nat(cursor))) :
165 {Layout.reorder_head(value => Layout.reorder_tail(value, Layout.inverse_coordinates(tail, axes, coordinates, U32.inc(U32.from_nat(cursor)))), _) == Axis.scatter(U32, 1n+Shape.rank_dimensions(tail), Shape.naturals(axes), coordinates, cursor) : Maybe<&2, List<&2, U32>>}
166 %Equal.sym(Nat, U32.to_nat(U32.from_nat(cursor)), cursor, Conversion.natural_word_exact(cursor, 4,
167 Equal.sym(Bool, True{}, Nat.is_le(cursor, 4n), Nats.le_true(cursor, 4n, cursor_bound(1n+Shape.rank_dimensions(tail), cursor, bound))))) :
168 {Layout.reorder_head(value => Layout.reorder_tail(value, Layout.inverse_coordinates(tail, axes, coordinates, U32.inc(U32.from_nat(cursor)))), Axis.select(U32, coordinates, Axis.position(Shape.naturals(axes), _))) == Axis.scatter(U32, 1n+Shape.rank_dimensions(tail), Shape.naturals(axes), coordinates, cursor) : Maybe<&2, List<&2, U32>>}
169 %Equal.sym(Maybe<&2, List<&2, U32>>, Layout.inverse_coordinates(tail, axes, coordinates, U32.from_nat(1n+cursor)),
170 Axis.scatter(U32, Shape.rank_dimensions(tail), Shape.naturals(axes), coordinates, 1n+cursor),
171 inverse_coordinates_go(tail, axes, coordinates, 1n+cursor,
172 %Equal.sym(Nat, Nat.add(Shape.rank_dimensions(tail), 1n+cursor), 1n+Nat.add(Shape.rank_dimensions(tail), cursor), Arith.add_succ(Shape.rank_dimensions(tail), cursor)) : Shape.LE(_, 4n)
173 bound)) :
174 {Layout.reorder_head(value => Layout.reorder_tail(value, _), Axis.select(U32, coordinates, Axis.position(Shape.naturals(axes), cursor))) == Axis.scatter(U32, 1n+Shape.rank_dimensions(tail), Shape.naturals(axes), coordinates, cursor) : Maybe<&2, List<&2, U32>>}
175 reorder_step(Axis.select(U32, coordinates, Axis.position(Shape.naturals(axes), cursor)), Axis.scatter(U32, Shape.rank_dimensions(tail), Shape.naturals(axes), coordinates, 1n+cursor))
176
177def inverse_coordinates(+shape: Shape.Shape, +axes: List<&2, U32>, +coordinates: List<&2, U32>) ->
178 {Layout.inverse_coordinates(Shape.dimensions(shape), axes, coordinates, 0) ==
179 Axis.scatter(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), coordinates, 0n) : Maybe<&2, List<&2, U32>>}:
180 match shape:
181 case Shape.SShape{+dims, size, exact, +rank_bound, capacity_bound}:
182 inverse_coordinates_go(dims, axes, coordinates, 0n,
183 %Equal.sym(Nat, Nat.add(Shape.rank_dimensions(dims), 0n), Shape.rank_dimensions(dims), Broadcast.add_zero(Shape.rank_dimensions(dims))) : Shape.LE(_, 4n)
184 rank_bound)
185
186def nat_clash(+a: Nat, +b: Nat, equal: {a == b : Nat}, different: {False{} == Nat.is_eq(a, b) : Bool}) -> Empty:
187 Shape.clash(Equal.trans(Bool, True{}, Nat.is_eq(a, b), False{},
188 Equal.trans(Bool, True{}, Nat.is_eq(b, b), Nat.is_eq(a, b), Equal.sym(Bool, Nat.is_eq(b, b), True{}, Arith.eq_refl(b)),
189 Equal.cong(Nat, Bool, n => Nat.is_eq(n, b), b, a, Equal.sym(Nat, a, b, equal))),
190 Equal.sym(Bool, False{}, Nat.is_eq(a, b), different)))
191
192type ListFacts<-A: Data, -rank: Nat, -axes: List<&2, Nat>, -items: List<&2, A>> is Data:
193 Lists{selected: {Axis.gather(A, items, axes) == Some{Axis.order(A, items, axes)} : Maybe<&2, List<&2, A>>},
194 ranked: {List.length(&2, A, Axis.order(A, items, axes)) == rank : Nat},
195 scattered: {Axis.scatter(A, rank, axes, items, 0n) == Some{Axis.order(A, items, Axis.inverse_axes(rank, axes))} : Maybe<&2, List<&2, A>>},
196 restored: {Axis.order(A, Axis.order(A, items, axes), Axis.inverse_axes(rank, axes)) == items : List<&2, A>},
197 reverse_restored: {Axis.order(A, Axis.order(A, items, Axis.inverse_axes(rank, axes)), axes) == items : List<&2, A>},
198 scatter_restored: {Axis.scatter(A, rank, axes, Axis.order(A, items, axes), 0n) == Some{items} : Maybe<&2, List<&2, A>>}}
199
200type Facts<-rank: Nat, -axes: List<&2, Nat>> is Type:
201 Certified{inverse_valid: {True{} == Axis.valid(rank, Axis.inverse_axes(rank, axes)) : Bool},
202 inverse_selected: {Axis.inverse(rank, axes) == Some{Axis.inverse_axes(rank, axes)} : Maybe<&2, List<&2, Nat>>},
203 inverse_restored: {Axis.inverse_axes(rank, Axis.inverse_axes(rank, axes)) == axes : List<&2, Nat>},
204 lists: @-A: Data -> @+items: List<&2, A> -> @length: {List.length(&2, A, items) == rank : Nat} -> ListFacts<A, rank, axes, items>,
205 product: @+dims: List<&2, Nat> -> @length: {List.length(&2, Nat, dims) == rank : Nat} -> {Shape.numel(Axis.order(Nat, dims, axes)) == Shape.numel(dims) : Nat},
206 fit: @+dims: List<&2, Nat> -> @+coords: List<&2, Nat> -> @dl: {List.length(&2, Nat, dims) == rank : Nat} -> @cl: {List.length(&2, Nat, coords) == rank : Nat} ->
207 {Shape.fit(Axis.order(Nat, dims, axes), Axis.order(Nat, coords, axes)) == Shape.fit(dims, coords) : Bool}}
208
209def mul_swap(+a: Nat, +b: Nat, +c: Nat) -> {Nat.mul(a, Nat.mul(b, c)) == Nat.mul(b, Nat.mul(a, c)) : Nat}:
210 Equal.trans(Nat, Nat.mul(a, Nat.mul(b, c)), Nat.mul(Nat.mul(a, b), c), Nat.mul(b, Nat.mul(a, c)),
211 Equal.sym(Nat, Nat.mul(Nat.mul(a, b), c), Nat.mul(a, Nat.mul(b, c)), Nats.mul_assoc(a, b, c)),
212 Equal.trans(Nat, Nat.mul(Nat.mul(a, b), c), Nat.mul(Nat.mul(b, a), c), Nat.mul(b, Nat.mul(a, c)),
213 Equal.cong(Nat, Nat, n => Nat.mul(n, c), Nat.mul(a, b), Nat.mul(b, a), Nats.mul_comm(a, b)), Nats.mul_assoc(b, a, c)))
214
215def and_swap(+a: Bool, +b: Bool, +c: Bool) -> {Bool.and(a, Bool.and(b, c)) == Bool.and(b, Bool.and(a, c)) : Bool}:
216 match a b:
217 case False{} False{}:
218 {==}
219 case False{} True{}:
220 {==}
221 case True{} False{}:
222 {==}
223 case True{} True{}:
224 {==}
225
226type Selected<-A: Data, -items: List<&2, A>, -index: Nat> is Data:
227 Selection{item: A, exact: {Axis.lookup(A, items, index) == Some{item} : Maybe<&2, A>}}
228
229def lookup_complete_step(-A: Data, -head: A, -tail: List<&2, A>, -index: Nat, rec: Selected<A, tail, index>) -> Selected<A, head <> tail, 1n+index>:
230 match rec:
231 case Selection{item, exact}:
232 Selection{item, exact}
233
234def lookup_complete(-A: Data, +items: List<&2, A>, +index: Nat, bound: Shape.LT(index, List.length(&2, A, items))) -> Selected<A, items, index>:
235 match items index:
236 case Nil{} 0n:
237 match bound:
238 case Nil{} 1n+p:
239 match bound:
240 case +head <> tail 0n:
241 Selection{head, {==}}
242 case +head <> +tail 1n+p:
243 lookup_complete_step(A, head, tail, p, lookup_complete(A, tail, p, bound))
244
245def natural_value(result: Maybe<&2, U32>) -> Maybe<&2, Nat>:
246 match result:
247 case None{}:
248 None{}
249 case Some{word}:
250 Some{U32.to_nat(word)}
251
252def natural_values(result: Maybe<&2, List<&2, U32>>) -> Maybe<&2, List<&2, Nat>>:
253 match result:
254 case None{}:
255 None{}
256 case Some{words}:
257 Some{Shape.naturals(words)}
258
259def lookup_naturals(+items: List<&2, U32>, +index: Nat) ->
260 {natural_value(Axis.lookup(U32, items, index)) == Axis.lookup(Nat, Shape.naturals(items), index) : Maybe<&2, Nat>}:
261 match items index:
262 case Nil{} 0n:
263 {==}
264 case Nil{} 1n+p:
265 {==}
266 case head <> tail 0n:
267 {==}
268 case head <> +tail 1n+p:
269 lookup_naturals(tail, p)
270
271def prepend_naturals(+head: Maybe<&2, U32>, +tail: Maybe<&2, List<&2, U32>>) ->
272 {natural_values(Axis.prepend(U32, head, tail)) == Axis.prepend(Nat, natural_value(head), natural_values(tail)) : Maybe<&2, List<&2, Nat>>}:
273 match head tail:
274 case None{} None{}:
275 {==}
276 case None{} Some{items}:
277 {==}
278 case Some{value} None{}:
279 {==}
280 case Some{value} Some{items}:
281 {==}
282
283def gather_naturals(+axes: List<&2, Nat>, +items: List<&2, U32>) ->
284 {natural_values(Axis.gather(U32, items, axes)) == Axis.gather(Nat, Shape.naturals(items), axes) : Maybe<&2, List<&2, Nat>>}:
285 match axes:
286 case Nil{}:
287 {==}
288 case +head <> +tail:
289 %Equal.sym(Maybe<&2, List<&2, Nat>>, natural_values(Axis.prepend(U32, Axis.lookup(U32, items, head), Axis.gather(U32, items, tail))),
290 Axis.prepend(Nat, natural_value(Axis.lookup(U32, items, head)), natural_values(Axis.gather(U32, items, tail))), prepend_naturals(Axis.lookup(U32, items, head), Axis.gather(U32, items, tail))) :
291 {_ == Axis.prepend(Nat, Axis.lookup(Nat, Shape.naturals(items), head), Axis.gather(Nat, Shape.naturals(items), tail)) : Maybe<&2, List<&2, Nat>>}
292 %Equal.sym(Maybe<&2, Nat>, natural_value(Axis.lookup(U32, items, head)), Axis.lookup(Nat, Shape.naturals(items), head), lookup_naturals(items, head)) :
293 {Axis.prepend(Nat, _, natural_values(Axis.gather(U32, items, tail))) == Axis.gather(Nat, Shape.naturals(items), head <> tail) : Maybe<&2, List<&2, Nat>>}
294 %Equal.sym(Maybe<&2, List<&2, Nat>>, natural_values(Axis.gather(U32, items, tail)), Axis.gather(Nat, Shape.naturals(items), tail), gather_naturals(tail, items)) :
295 {Axis.prepend(Nat, Axis.lookup(Nat, Shape.naturals(items), head), _) == Axis.gather(Nat, Shape.naturals(items), head <> tail) : Maybe<&2, List<&2, Nat>>}
296 {==}
297
298def values_naturals(+result: Maybe<&2, List<&2, U32>>) ->
299 {Shape.naturals(Axis.values(U32, result)) == Axis.values(Nat, natural_values(result)) : List<&2, Nat>}:
300 match result:
301 case None{}:
302 {==}
303 case Some{items}:
304 {==}
305
306def order_naturals(+axes: List<&2, Nat>, +items: List<&2, U32>) ->
307 {Shape.naturals(Axis.order(U32, items, axes)) == Axis.order(Nat, Shape.naturals(items), axes) : List<&2, Nat>}:
308 Equal.trans(List<&2, Nat>, Shape.naturals(Axis.order(U32, items, axes)), Axis.values(Nat, natural_values(Axis.gather(U32, items, axes))),
309 Axis.order(Nat, Shape.naturals(items), axes), values_naturals(Axis.gather(U32, items, axes)),
310 Equal.cong(Maybe<&2, List<&2, Nat>>, List<&2, Nat>, result => Axis.values(Nat, result), natural_values(Axis.gather(U32, items, axes)),
311 Axis.gather(Nat, Shape.naturals(items), axes), gather_naturals(axes, items)))
312def lists_empty(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 0n : Nat}) -> ListFacts<A, 0n, Nil{}, items>:
313 match items:
314 case Nil{}:
315 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
316 case +x0 <> +tail:
317 Empty.absurd(ListFacts<A, 0n, Nil{}, x0 <> tail>, nat_clash(1n+List.length(&2, A, tail), 0n, length, {==}))
318
319def product_empty(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 0n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, Nil{})) == Shape.numel(dims) : Nat}:
320 match dims:
321 case Nil{}:
322 {==}
323 case +x0 <> +tail:
324 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> tail, Nil{})) == Shape.numel(x0 <> tail) : Nat}, nat_clash(1n+List.length(&2, Nat, tail), 0n, length, {==}))
325
326def fit_empty(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 0n : Nat}, cl: {List.length(&2, Nat, coords) == 0n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, Nil{}), Axis.order(Nat, coords, Nil{})) == Shape.fit(dims, coords) : Bool}:
327 match dims:
328 case Nil{}:
329 match coords:
330 case Nil{}:
331 {==}
332 case +c0 <> +ct:
333 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, Nil{}), Axis.order(Nat, c0 <> ct, Nil{})) == Shape.fit(Nil{}, c0 <> ct) : Bool}, nat_clash(1n+List.length(&2, Nat, ct), 0n, cl, {==}))
334 case +d0 <> +dt:
335 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> dt, Nil{}), Axis.order(Nat, coords, Nil{})) == Shape.fit(d0 <> dt, coords) : Bool}, nat_clash(1n+List.length(&2, Nat, dt), 0n, dl, {==}))
336
337def lists_0(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 1n : Nat}) -> ListFacts<A, 1n, [0n], items>:
338 match items:
339 case Nil{}:
340 Empty.absurd(ListFacts<A, 1n, [0n], Nil{}>, nat_clash(0n, 1n, length, {==}))
341 case +x0 <> Nil{}:
342 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
343 case +x0 <> +x1 <> +tail:
344 Empty.absurd(ListFacts<A, 1n, [0n], x0 <> x1 <> tail>, nat_clash(2n+List.length(&2, A, tail), 1n, length, {==}))
345
346def product_0(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 1n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n])) == Shape.numel(dims) : Nat}:
347 match dims:
348 case Nil{}:
349 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 1n, length, {==}))
350 case +x0 <> Nil{}:
351 {==}
352 case +x0 <> +x1 <> +tail:
353 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> tail, [0n])) == Shape.numel(x0 <> x1 <> tail) : Nat}, nat_clash(2n+List.length(&2, Nat, tail), 1n, length, {==}))
354
355def fit_0(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 1n : Nat}, cl: {List.length(&2, Nat, coords) == 1n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n]), Axis.order(Nat, coords, [0n])) == Shape.fit(dims, coords) : Bool}:
356 match dims:
357 case Nil{}:
358 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n]), Axis.order(Nat, coords, [0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 1n, dl, {==}))
359 case +d0 <> Nil{}:
360 match coords:
361 case Nil{}:
362 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n]), Axis.order(Nat, Nil{}, [0n])) == Shape.fit(d0 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 1n, cl, {==}))
363 case +c0 <> Nil{}:
364 {==}
365 case +c0 <> +c1 <> +ct:
366 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n]), Axis.order(Nat, c0 <> c1 <> ct, [0n])) == Shape.fit(d0 <> Nil{}, c0 <> c1 <> ct) : Bool}, nat_clash(2n+List.length(&2, Nat, ct), 1n, cl, {==}))
367 case +d0 <> +d1 <> +dt:
368 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> dt, [0n]), Axis.order(Nat, coords, [0n])) == Shape.fit(d0 <> d1 <> dt, coords) : Bool}, nat_clash(2n+List.length(&2, Nat, dt), 1n, dl, {==}))
369
370def lists_01(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 2n : Nat}) -> ListFacts<A, 2n, [0n, 1n], items>:
371 match items:
372 case Nil{}:
373 Empty.absurd(ListFacts<A, 2n, [0n, 1n], Nil{}>, nat_clash(0n, 2n, length, {==}))
374 case +x0 <> Nil{}:
375 Empty.absurd(ListFacts<A, 2n, [0n, 1n], x0 <> Nil{}>, nat_clash(1n, 2n, length, {==}))
376 case +x0 <> +x1 <> Nil{}:
377 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
378 case +x0 <> +x1 <> +x2 <> +tail:
379 Empty.absurd(ListFacts<A, 2n, [0n, 1n], x0 <> x1 <> x2 <> tail>, nat_clash(3n+List.length(&2, A, tail), 2n, length, {==}))
380
381def product_01(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 2n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 1n])) == Shape.numel(dims) : Nat}:
382 match dims:
383 case Nil{}:
384 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 2n, length, {==}))
385 case +x0 <> Nil{}:
386 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 2n, length, {==}))
387 case +x0 <> +x1 <> Nil{}:
388 {==}
389 case +x0 <> +x1 <> +x2 <> +tail:
390 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> tail, [0n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> tail) : Nat}, nat_clash(3n+List.length(&2, Nat, tail), 2n, length, {==}))
391
392def fit_01(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 2n : Nat}, cl: {List.length(&2, Nat, coords) == 2n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 1n]), Axis.order(Nat, coords, [0n, 1n])) == Shape.fit(dims, coords) : Bool}:
393 match dims:
394 case Nil{}:
395 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 1n]), Axis.order(Nat, coords, [0n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 2n, dl, {==}))
396 case +d0 <> Nil{}:
397 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 1n]), Axis.order(Nat, coords, [0n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 2n, dl, {==}))
398 case +d0 <> +d1 <> Nil{}:
399 match coords:
400 case Nil{}:
401 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 1n]), Axis.order(Nat, Nil{}, [0n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 2n, cl, {==}))
402 case +c0 <> Nil{}:
403 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 1n]), Axis.order(Nat, c0 <> Nil{}, [0n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 2n, cl, {==}))
404 case +c0 <> +c1 <> Nil{}:
405 {==}
406 case +c0 <> +c1 <> +c2 <> +ct:
407 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> ct, [0n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, c0 <> c1 <> c2 <> ct) : Bool}, nat_clash(3n+List.length(&2, Nat, ct), 2n, cl, {==}))
408 case +d0 <> +d1 <> +d2 <> +dt:
409 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> dt, [0n, 1n]), Axis.order(Nat, coords, [0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> dt, coords) : Bool}, nat_clash(3n+List.length(&2, Nat, dt), 2n, dl, {==}))
410
411def lists_10(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 2n : Nat}) -> ListFacts<A, 2n, [1n, 0n], items>:
412 match items:
413 case Nil{}:
414 Empty.absurd(ListFacts<A, 2n, [1n, 0n], Nil{}>, nat_clash(0n, 2n, length, {==}))
415 case +x0 <> Nil{}:
416 Empty.absurd(ListFacts<A, 2n, [1n, 0n], x0 <> Nil{}>, nat_clash(1n, 2n, length, {==}))
417 case +x0 <> +x1 <> Nil{}:
418 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
419 case +x0 <> +x1 <> +x2 <> +tail:
420 Empty.absurd(ListFacts<A, 2n, [1n, 0n], x0 <> x1 <> x2 <> tail>, nat_clash(3n+List.length(&2, A, tail), 2n, length, {==}))
421
422def product_10(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 2n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 0n])) == Shape.numel(dims) : Nat}:
423 match dims:
424 case Nil{}:
425 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 2n, length, {==}))
426 case +x0 <> Nil{}:
427 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 2n, length, {==}))
428 case +x0 <> +x1 <> Nil{}:
429 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x1, 1n)), Nat.mul(x0, Nat.mul(x1, 1n)), mul_swap(x1, x0, 1n), {==})
430 case +x0 <> +x1 <> +x2 <> +tail:
431 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> tail, [1n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> tail) : Nat}, nat_clash(3n+List.length(&2, Nat, tail), 2n, length, {==}))
432
433def fit_10(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 2n : Nat}, cl: {List.length(&2, Nat, coords) == 2n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 0n]), Axis.order(Nat, coords, [1n, 0n])) == Shape.fit(dims, coords) : Bool}:
434 match dims:
435 case Nil{}:
436 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 0n]), Axis.order(Nat, coords, [1n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 2n, dl, {==}))
437 case +d0 <> Nil{}:
438 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 0n]), Axis.order(Nat, coords, [1n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 2n, dl, {==}))
439 case +d0 <> +d1 <> Nil{}:
440 match coords:
441 case Nil{}:
442 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 0n]), Axis.order(Nat, Nil{}, [1n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 2n, cl, {==}))
443 case +c0 <> Nil{}:
444 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 0n]), Axis.order(Nat, c0 <> Nil{}, [1n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 2n, cl, {==}))
445 case +c0 <> +c1 <> Nil{}:
446 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), True{}), {==})
447 case +c0 <> +c1 <> +c2 <> +ct:
448 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> ct, [1n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, c0 <> c1 <> c2 <> ct) : Bool}, nat_clash(3n+List.length(&2, Nat, ct), 2n, cl, {==}))
449 case +d0 <> +d1 <> +d2 <> +dt:
450 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> dt, [1n, 0n]), Axis.order(Nat, coords, [1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> dt, coords) : Bool}, nat_clash(3n+List.length(&2, Nat, dt), 2n, dl, {==}))
451
452def lists_012(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts<A, 3n, [0n, 1n, 2n], items>:
453 match items:
454 case Nil{}:
455 Empty.absurd(ListFacts<A, 3n, [0n, 1n, 2n], Nil{}>, nat_clash(0n, 3n, length, {==}))
456 case +x0 <> Nil{}:
457 Empty.absurd(ListFacts<A, 3n, [0n, 1n, 2n], x0 <> Nil{}>, nat_clash(1n, 3n, length, {==}))
458 case +x0 <> +x1 <> Nil{}:
459 Empty.absurd(ListFacts<A, 3n, [0n, 1n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 3n, length, {==}))
460 case +x0 <> +x1 <> +x2 <> Nil{}:
461 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
462 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
463 Empty.absurd(ListFacts<A, 3n, [0n, 1n, 2n], x0 <> x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==}))
464
465def product_012(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 3n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 1n, 2n])) == Shape.numel(dims) : Nat}:
466 match dims:
467 case Nil{}:
468 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 1n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 3n, length, {==}))
469 case +x0 <> Nil{}:
470 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 1n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 3n, length, {==}))
471 case +x0 <> +x1 <> Nil{}:
472 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 1n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 3n, length, {==}))
473 case +x0 <> +x1 <> +x2 <> Nil{}:
474 {==}
475 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
476 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> tail, [0n, 1n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> tail) : Nat}, nat_clash(4n+List.length(&2, Nat, tail), 3n, length, {==}))
477
478def fit_012(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 3n : Nat}, cl: {List.length(&2, Nat, coords) == 3n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 1n, 2n]), Axis.order(Nat, coords, [0n, 1n, 2n])) == Shape.fit(dims, coords) : Bool}:
479 match dims:
480 case Nil{}:
481 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 1n, 2n]), Axis.order(Nat, coords, [0n, 1n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 3n, dl, {==}))
482 case +d0 <> Nil{}:
483 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 1n, 2n]), Axis.order(Nat, coords, [0n, 1n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 3n, dl, {==}))
484 case +d0 <> +d1 <> Nil{}:
485 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 1n, 2n]), Axis.order(Nat, coords, [0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 3n, dl, {==}))
486 case +d0 <> +d1 <> +d2 <> Nil{}:
487 match coords:
488 case Nil{}:
489 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 1n, 2n]), Axis.order(Nat, Nil{}, [0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 3n, cl, {==}))
490 case +c0 <> Nil{}:
491 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 1n, 2n]), Axis.order(Nat, c0 <> Nil{}, [0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 3n, cl, {==}))
492 case +c0 <> +c1 <> Nil{}:
493 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 3n, cl, {==}))
494 case +c0 <> +c1 <> +c2 <> Nil{}:
495 {==}
496 case +c0 <> +c1 <> +c2 <> +c3 <> +ct:
497 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> ct, [0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> c2 <> c3 <> ct) : Bool}, nat_clash(4n+List.length(&2, Nat, ct), 3n, cl, {==}))
498 case +d0 <> +d1 <> +d2 <> +d3 <> +dt:
499 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> dt, [0n, 1n, 2n]), Axis.order(Nat, coords, [0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> dt, coords) : Bool}, nat_clash(4n+List.length(&2, Nat, dt), 3n, dl, {==}))
500
501def lists_021(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts<A, 3n, [0n, 2n, 1n], items>:
502 match items:
503 case Nil{}:
504 Empty.absurd(ListFacts<A, 3n, [0n, 2n, 1n], Nil{}>, nat_clash(0n, 3n, length, {==}))
505 case +x0 <> Nil{}:
506 Empty.absurd(ListFacts<A, 3n, [0n, 2n, 1n], x0 <> Nil{}>, nat_clash(1n, 3n, length, {==}))
507 case +x0 <> +x1 <> Nil{}:
508 Empty.absurd(ListFacts<A, 3n, [0n, 2n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 3n, length, {==}))
509 case +x0 <> +x1 <> +x2 <> Nil{}:
510 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
511 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
512 Empty.absurd(ListFacts<A, 3n, [0n, 2n, 1n], x0 <> x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==}))
513
514def product_021(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 3n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 2n, 1n])) == Shape.numel(dims) : Nat}:
515 match dims:
516 case Nil{}:
517 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 2n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 3n, length, {==}))
518 case +x0 <> Nil{}:
519 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 2n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 3n, length, {==}))
520 case +x0 <> +x1 <> Nil{}:
521 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 2n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 3n, length, {==}))
522 case +x0 <> +x1 <> +x2 <> Nil{}:
523 Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), {==})
524 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
525 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> tail, [0n, 2n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> tail) : Nat}, nat_clash(4n+List.length(&2, Nat, tail), 3n, length, {==}))
526
527def fit_021(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 3n : Nat}, cl: {List.length(&2, Nat, coords) == 3n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 2n, 1n]), Axis.order(Nat, coords, [0n, 2n, 1n])) == Shape.fit(dims, coords) : Bool}:
528 match dims:
529 case Nil{}:
530 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 2n, 1n]), Axis.order(Nat, coords, [0n, 2n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 3n, dl, {==}))
531 case +d0 <> Nil{}:
532 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 2n, 1n]), Axis.order(Nat, coords, [0n, 2n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 3n, dl, {==}))
533 case +d0 <> +d1 <> Nil{}:
534 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 2n, 1n]), Axis.order(Nat, coords, [0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 3n, dl, {==}))
535 case +d0 <> +d1 <> +d2 <> Nil{}:
536 match coords:
537 case Nil{}:
538 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 2n, 1n]), Axis.order(Nat, Nil{}, [0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 3n, cl, {==}))
539 case +c0 <> Nil{}:
540 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 2n, 1n]), Axis.order(Nat, c0 <> Nil{}, [0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 3n, cl, {==}))
541 case +c0 <> +c1 <> Nil{}:
542 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 3n, cl, {==}))
543 case +c0 <> +c1 <> +c2 <> Nil{}:
544 Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), {==})
545 case +c0 <> +c1 <> +c2 <> +c3 <> +ct:
546 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> ct, [0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> c2 <> c3 <> ct) : Bool}, nat_clash(4n+List.length(&2, Nat, ct), 3n, cl, {==}))
547 case +d0 <> +d1 <> +d2 <> +d3 <> +dt:
548 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> dt, [0n, 2n, 1n]), Axis.order(Nat, coords, [0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> dt, coords) : Bool}, nat_clash(4n+List.length(&2, Nat, dt), 3n, dl, {==}))
549
550def lists_102(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts<A, 3n, [1n, 0n, 2n], items>:
551 match items:
552 case Nil{}:
553 Empty.absurd(ListFacts<A, 3n, [1n, 0n, 2n], Nil{}>, nat_clash(0n, 3n, length, {==}))
554 case +x0 <> Nil{}:
555 Empty.absurd(ListFacts<A, 3n, [1n, 0n, 2n], x0 <> Nil{}>, nat_clash(1n, 3n, length, {==}))
556 case +x0 <> +x1 <> Nil{}:
557 Empty.absurd(ListFacts<A, 3n, [1n, 0n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 3n, length, {==}))
558 case +x0 <> +x1 <> +x2 <> Nil{}:
559 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
560 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
561 Empty.absurd(ListFacts<A, 3n, [1n, 0n, 2n], x0 <> x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==}))
562
563def product_102(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 3n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 0n, 2n])) == Shape.numel(dims) : Nat}:
564 match dims:
565 case Nil{}:
566 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 0n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 3n, length, {==}))
567 case +x0 <> Nil{}:
568 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 0n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 3n, length, {==}))
569 case +x0 <> +x1 <> Nil{}:
570 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 0n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 3n, length, {==}))
571 case +x0 <> +x1 <> +x2 <> Nil{}:
572 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), mul_swap(x1, x0, Nat.mul(x2, 1n)), {==})
573 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
574 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> tail, [1n, 0n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> tail) : Nat}, nat_clash(4n+List.length(&2, Nat, tail), 3n, length, {==}))
575
576def fit_102(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 3n : Nat}, cl: {List.length(&2, Nat, coords) == 3n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 0n, 2n]), Axis.order(Nat, coords, [1n, 0n, 2n])) == Shape.fit(dims, coords) : Bool}:
577 match dims:
578 case Nil{}:
579 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 0n, 2n]), Axis.order(Nat, coords, [1n, 0n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 3n, dl, {==}))
580 case +d0 <> Nil{}:
581 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 0n, 2n]), Axis.order(Nat, coords, [1n, 0n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 3n, dl, {==}))
582 case +d0 <> +d1 <> Nil{}:
583 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 0n, 2n]), Axis.order(Nat, coords, [1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 3n, dl, {==}))
584 case +d0 <> +d1 <> +d2 <> Nil{}:
585 match coords:
586 case Nil{}:
587 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 0n, 2n]), Axis.order(Nat, Nil{}, [1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 3n, cl, {==}))
588 case +c0 <> Nil{}:
589 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 0n, 2n]), Axis.order(Nat, c0 <> Nil{}, [1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 3n, cl, {==}))
590 case +c0 <> +c1 <> Nil{}:
591 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 3n, cl, {==}))
592 case +c0 <> +c1 <> +c2 <> Nil{}:
593 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})), {==})
594 case +c0 <> +c1 <> +c2 <> +c3 <> +ct:
595 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> ct, [1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> c2 <> c3 <> ct) : Bool}, nat_clash(4n+List.length(&2, Nat, ct), 3n, cl, {==}))
596 case +d0 <> +d1 <> +d2 <> +d3 <> +dt:
597 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> dt, [1n, 0n, 2n]), Axis.order(Nat, coords, [1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> dt, coords) : Bool}, nat_clash(4n+List.length(&2, Nat, dt), 3n, dl, {==}))
598
599def lists_120(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts<A, 3n, [1n, 2n, 0n], items>:
600 match items:
601 case Nil{}:
602 Empty.absurd(ListFacts<A, 3n, [1n, 2n, 0n], Nil{}>, nat_clash(0n, 3n, length, {==}))
603 case +x0 <> Nil{}:
604 Empty.absurd(ListFacts<A, 3n, [1n, 2n, 0n], x0 <> Nil{}>, nat_clash(1n, 3n, length, {==}))
605 case +x0 <> +x1 <> Nil{}:
606 Empty.absurd(ListFacts<A, 3n, [1n, 2n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 3n, length, {==}))
607 case +x0 <> +x1 <> +x2 <> Nil{}:
608 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
609 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
610 Empty.absurd(ListFacts<A, 3n, [1n, 2n, 0n], x0 <> x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==}))
611
612def product_120(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 3n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 2n, 0n])) == Shape.numel(dims) : Nat}:
613 match dims:
614 case Nil{}:
615 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 2n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 3n, length, {==}))
616 case +x0 <> Nil{}:
617 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 2n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 3n, length, {==}))
618 case +x0 <> +x1 <> Nil{}:
619 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 2n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 3n, length, {==}))
620 case +x0 <> +x1 <> +x2 <> Nil{}:
621 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x2, Nat.mul(x0, 1n))), Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.cong(Nat, Nat, value => Nat.mul(x1, value), Nat.mul(x2, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x2, 1n)), mul_swap(x2, x0, 1n)), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), mul_swap(x1, x0, Nat.mul(x2, 1n)), {==}))
622 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
623 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> tail, [1n, 2n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> tail) : Nat}, nat_clash(4n+List.length(&2, Nat, tail), 3n, length, {==}))
624
625def fit_120(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 3n : Nat}, cl: {List.length(&2, Nat, coords) == 3n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 2n, 0n]), Axis.order(Nat, coords, [1n, 2n, 0n])) == Shape.fit(dims, coords) : Bool}:
626 match dims:
627 case Nil{}:
628 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 2n, 0n]), Axis.order(Nat, coords, [1n, 2n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 3n, dl, {==}))
629 case +d0 <> Nil{}:
630 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 2n, 0n]), Axis.order(Nat, coords, [1n, 2n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 3n, dl, {==}))
631 case +d0 <> +d1 <> Nil{}:
632 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 2n, 0n]), Axis.order(Nat, coords, [1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 3n, dl, {==}))
633 case +d0 <> +d1 <> +d2 <> Nil{}:
634 match coords:
635 case Nil{}:
636 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 2n, 0n]), Axis.order(Nat, Nil{}, [1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 3n, cl, {==}))
637 case +c0 <> Nil{}:
638 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 2n, 0n]), Axis.order(Nat, c0 <> Nil{}, [1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 3n, cl, {==}))
639 case +c0 <> +c1 <> Nil{}:
640 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 3n, cl, {==}))
641 case +c0 <> +c1 <> +c2 <> Nil{}:
642 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})), {==}))
643 case +c0 <> +c1 <> +c2 <> +c3 <> +ct:
644 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> ct, [1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> c2 <> c3 <> ct) : Bool}, nat_clash(4n+List.length(&2, Nat, ct), 3n, cl, {==}))
645 case +d0 <> +d1 <> +d2 <> +d3 <> +dt:
646 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> dt, [1n, 2n, 0n]), Axis.order(Nat, coords, [1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> dt, coords) : Bool}, nat_clash(4n+List.length(&2, Nat, dt), 3n, dl, {==}))
647
648def lists_201(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts<A, 3n, [2n, 0n, 1n], items>:
649 match items:
650 case Nil{}:
651 Empty.absurd(ListFacts<A, 3n, [2n, 0n, 1n], Nil{}>, nat_clash(0n, 3n, length, {==}))
652 case +x0 <> Nil{}:
653 Empty.absurd(ListFacts<A, 3n, [2n, 0n, 1n], x0 <> Nil{}>, nat_clash(1n, 3n, length, {==}))
654 case +x0 <> +x1 <> Nil{}:
655 Empty.absurd(ListFacts<A, 3n, [2n, 0n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 3n, length, {==}))
656 case +x0 <> +x1 <> +x2 <> Nil{}:
657 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
658 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
659 Empty.absurd(ListFacts<A, 3n, [2n, 0n, 1n], x0 <> x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==}))
660
661def product_201(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 3n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 0n, 1n])) == Shape.numel(dims) : Nat}:
662 match dims:
663 case Nil{}:
664 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 0n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 3n, length, {==}))
665 case +x0 <> Nil{}:
666 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 0n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 3n, length, {==}))
667 case +x0 <> +x1 <> Nil{}:
668 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 0n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 3n, length, {==}))
669 case +x0 <> +x1 <> +x2 <> Nil{}:
670 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), mul_swap(x2, x0, Nat.mul(x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), {==}))
671 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
672 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> tail, [2n, 0n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> tail) : Nat}, nat_clash(4n+List.length(&2, Nat, tail), 3n, length, {==}))
673
674def fit_201(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 3n : Nat}, cl: {List.length(&2, Nat, coords) == 3n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 0n, 1n]), Axis.order(Nat, coords, [2n, 0n, 1n])) == Shape.fit(dims, coords) : Bool}:
675 match dims:
676 case Nil{}:
677 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 0n, 1n]), Axis.order(Nat, coords, [2n, 0n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 3n, dl, {==}))
678 case +d0 <> Nil{}:
679 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 0n, 1n]), Axis.order(Nat, coords, [2n, 0n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 3n, dl, {==}))
680 case +d0 <> +d1 <> Nil{}:
681 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 0n, 1n]), Axis.order(Nat, coords, [2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 3n, dl, {==}))
682 case +d0 <> +d1 <> +d2 <> Nil{}:
683 match coords:
684 case Nil{}:
685 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 0n, 1n]), Axis.order(Nat, Nil{}, [2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 3n, cl, {==}))
686 case +c0 <> Nil{}:
687 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 0n, 1n]), Axis.order(Nat, c0 <> Nil{}, [2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 3n, cl, {==}))
688 case +c0 <> +c1 <> Nil{}:
689 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 3n, cl, {==}))
690 case +c0 <> +c1 <> +c2 <> Nil{}:
691 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), {==}))
692 case +c0 <> +c1 <> +c2 <> +c3 <> +ct:
693 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> ct, [2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> c2 <> c3 <> ct) : Bool}, nat_clash(4n+List.length(&2, Nat, ct), 3n, cl, {==}))
694 case +d0 <> +d1 <> +d2 <> +d3 <> +dt:
695 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> dt, [2n, 0n, 1n]), Axis.order(Nat, coords, [2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> dt, coords) : Bool}, nat_clash(4n+List.length(&2, Nat, dt), 3n, dl, {==}))
696
697def lists_210(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts<A, 3n, [2n, 1n, 0n], items>:
698 match items:
699 case Nil{}:
700 Empty.absurd(ListFacts<A, 3n, [2n, 1n, 0n], Nil{}>, nat_clash(0n, 3n, length, {==}))
701 case +x0 <> Nil{}:
702 Empty.absurd(ListFacts<A, 3n, [2n, 1n, 0n], x0 <> Nil{}>, nat_clash(1n, 3n, length, {==}))
703 case +x0 <> +x1 <> Nil{}:
704 Empty.absurd(ListFacts<A, 3n, [2n, 1n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 3n, length, {==}))
705 case +x0 <> +x1 <> +x2 <> Nil{}:
706 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
707 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
708 Empty.absurd(ListFacts<A, 3n, [2n, 1n, 0n], x0 <> x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==}))
709
710def product_210(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 3n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 1n, 0n])) == Shape.numel(dims) : Nat}:
711 match dims:
712 case Nil{}:
713 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 1n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 3n, length, {==}))
714 case +x0 <> Nil{}:
715 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 1n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 3n, length, {==}))
716 case +x0 <> +x1 <> Nil{}:
717 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 1n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 3n, length, {==}))
718 case +x0 <> +x1 <> +x2 <> Nil{}:
719 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x1, Nat.mul(x0, 1n))), Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.cong(Nat, Nat, value => Nat.mul(x2, value), Nat.mul(x1, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x1, 1n)), mul_swap(x1, x0, 1n)), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), mul_swap(x2, x0, Nat.mul(x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), {==})))
720 case +x0 <> +x1 <> +x2 <> +x3 <> +tail:
721 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> tail, [2n, 1n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> tail) : Nat}, nat_clash(4n+List.length(&2, Nat, tail), 3n, length, {==}))
722
723def fit_210(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 3n : Nat}, cl: {List.length(&2, Nat, coords) == 3n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 1n, 0n]), Axis.order(Nat, coords, [2n, 1n, 0n])) == Shape.fit(dims, coords) : Bool}:
724 match dims:
725 case Nil{}:
726 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 1n, 0n]), Axis.order(Nat, coords, [2n, 1n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 3n, dl, {==}))
727 case +d0 <> Nil{}:
728 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 1n, 0n]), Axis.order(Nat, coords, [2n, 1n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 3n, dl, {==}))
729 case +d0 <> +d1 <> Nil{}:
730 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 1n, 0n]), Axis.order(Nat, coords, [2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 3n, dl, {==}))
731 case +d0 <> +d1 <> +d2 <> Nil{}:
732 match coords:
733 case Nil{}:
734 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 1n, 0n]), Axis.order(Nat, Nil{}, [2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 3n, cl, {==}))
735 case +c0 <> Nil{}:
736 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 1n, 0n]), Axis.order(Nat, c0 <> Nil{}, [2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 3n, cl, {==}))
737 case +c0 <> +c1 <> Nil{}:
738 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 3n, cl, {==}))
739 case +c0 <> +c1 <> +c2 <> Nil{}:
740 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{}))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), value), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), {==})))
741 case +c0 <> +c1 <> +c2 <> +c3 <> +ct:
742 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> ct, [2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, c0 <> c1 <> c2 <> c3 <> ct) : Bool}, nat_clash(4n+List.length(&2, Nat, ct), 3n, cl, {==}))
743 case +d0 <> +d1 <> +d2 <> +d3 <> +dt:
744 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> dt, [2n, 1n, 0n]), Axis.order(Nat, coords, [2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> dt, coords) : Bool}, nat_clash(4n+List.length(&2, Nat, dt), 3n, dl, {==}))
745
746def lists_0123(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [0n, 1n, 2n, 3n], items>:
747 match items:
748 case Nil{}:
749 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 2n, 3n], Nil{}>, nat_clash(0n, 4n, length, {==}))
750 case +x0 <> Nil{}:
751 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 2n, 3n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
752 case +x0 <> +x1 <> Nil{}:
753 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 2n, 3n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
754 case +x0 <> +x1 <> +x2 <> Nil{}:
755 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 2n, 3n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
756 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
757 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
758 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
759 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 2n, 3n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
760
761def product_0123(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 1n, 2n, 3n])) == Shape.numel(dims) : Nat}:
762 match dims:
763 case Nil{}:
764 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 1n, 2n, 3n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
765 case +x0 <> Nil{}:
766 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 1n, 2n, 3n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
767 case +x0 <> +x1 <> Nil{}:
768 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 1n, 2n, 3n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
769 case +x0 <> +x1 <> +x2 <> Nil{}:
770 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [0n, 1n, 2n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
771 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
772 {==}
773 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
774 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [0n, 1n, 2n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
775
776def fit_0123(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 1n, 2n, 3n]), Axis.order(Nat, coords, [0n, 1n, 2n, 3n])) == Shape.fit(dims, coords) : Bool}:
777 match dims:
778 case Nil{}:
779 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, coords, [0n, 1n, 2n, 3n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
780 case +d0 <> Nil{}:
781 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, coords, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
782 case +d0 <> +d1 <> Nil{}:
783 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, coords, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
784 case +d0 <> +d1 <> +d2 <> Nil{}:
785 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, coords, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
786 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
787 match coords:
788 case Nil{}:
789 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, Nil{}, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
790 case +c0 <> Nil{}:
791 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, c0 <> Nil{}, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
792 case +c0 <> +c1 <> Nil{}:
793 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
794 case +c0 <> +c1 <> +c2 <> Nil{}:
795 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
796 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
797 {==}
798 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
799 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 2n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
800 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
801 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [0n, 1n, 2n, 3n]), Axis.order(Nat, coords, [0n, 1n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
802
803def lists_0132(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [0n, 1n, 3n, 2n], items>:
804 match items:
805 case Nil{}:
806 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 3n, 2n], Nil{}>, nat_clash(0n, 4n, length, {==}))
807 case +x0 <> Nil{}:
808 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 3n, 2n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
809 case +x0 <> +x1 <> Nil{}:
810 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 3n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
811 case +x0 <> +x1 <> +x2 <> Nil{}:
812 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 3n, 2n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
813 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
814 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
815 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
816 Empty.absurd(ListFacts<A, 4n, [0n, 1n, 3n, 2n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
817
818def product_0132(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 1n, 3n, 2n])) == Shape.numel(dims) : Nat}:
819 match dims:
820 case Nil{}:
821 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 1n, 3n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
822 case +x0 <> Nil{}:
823 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 1n, 3n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
824 case +x0 <> +x1 <> Nil{}:
825 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 1n, 3n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
826 case +x0 <> +x1 <> +x2 <> Nil{}:
827 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [0n, 1n, 3n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
828 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
829 Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==})
830 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
831 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [0n, 1n, 3n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
832
833def fit_0132(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 1n, 3n, 2n]), Axis.order(Nat, coords, [0n, 1n, 3n, 2n])) == Shape.fit(dims, coords) : Bool}:
834 match dims:
835 case Nil{}:
836 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, coords, [0n, 1n, 3n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
837 case +d0 <> Nil{}:
838 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, coords, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
839 case +d0 <> +d1 <> Nil{}:
840 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, coords, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
841 case +d0 <> +d1 <> +d2 <> Nil{}:
842 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, coords, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
843 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
844 match coords:
845 case Nil{}:
846 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, Nil{}, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
847 case +c0 <> Nil{}:
848 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, c0 <> Nil{}, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
849 case +c0 <> +c1 <> Nil{}:
850 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
851 case +c0 <> +c1 <> +c2 <> Nil{}:
852 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
853 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
854 Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==})
855 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
856 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 1n, 3n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
857 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
858 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [0n, 1n, 3n, 2n]), Axis.order(Nat, coords, [0n, 1n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
859
860def lists_0213(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [0n, 2n, 1n, 3n], items>:
861 match items:
862 case Nil{}:
863 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 1n, 3n], Nil{}>, nat_clash(0n, 4n, length, {==}))
864 case +x0 <> Nil{}:
865 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 1n, 3n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
866 case +x0 <> +x1 <> Nil{}:
867 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 1n, 3n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
868 case +x0 <> +x1 <> +x2 <> Nil{}:
869 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 1n, 3n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
870 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
871 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
872 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
873 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 1n, 3n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
874
875def product_0213(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 2n, 1n, 3n])) == Shape.numel(dims) : Nat}:
876 match dims:
877 case Nil{}:
878 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 2n, 1n, 3n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
879 case +x0 <> Nil{}:
880 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 2n, 1n, 3n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
881 case +x0 <> +x1 <> Nil{}:
882 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 2n, 1n, 3n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
883 case +x0 <> +x1 <> +x2 <> Nil{}:
884 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [0n, 2n, 1n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
885 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
886 Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==})
887 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
888 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [0n, 2n, 1n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
889
890def fit_0213(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 2n, 1n, 3n]), Axis.order(Nat, coords, [0n, 2n, 1n, 3n])) == Shape.fit(dims, coords) : Bool}:
891 match dims:
892 case Nil{}:
893 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, coords, [0n, 2n, 1n, 3n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
894 case +d0 <> Nil{}:
895 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, coords, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
896 case +d0 <> +d1 <> Nil{}:
897 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, coords, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
898 case +d0 <> +d1 <> +d2 <> Nil{}:
899 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, coords, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
900 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
901 match coords:
902 case Nil{}:
903 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, Nil{}, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
904 case +c0 <> Nil{}:
905 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, c0 <> Nil{}, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
906 case +c0 <> +c1 <> Nil{}:
907 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
908 case +c0 <> +c1 <> +c2 <> Nil{}:
909 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
910 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
911 Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==})
912 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
913 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 1n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
914 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
915 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [0n, 2n, 1n, 3n]), Axis.order(Nat, coords, [0n, 2n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
916
917def lists_0231(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [0n, 2n, 3n, 1n], items>:
918 match items:
919 case Nil{}:
920 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 3n, 1n], Nil{}>, nat_clash(0n, 4n, length, {==}))
921 case +x0 <> Nil{}:
922 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 3n, 1n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
923 case +x0 <> +x1 <> Nil{}:
924 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 3n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
925 case +x0 <> +x1 <> +x2 <> Nil{}:
926 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 3n, 1n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
927 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
928 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
929 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
930 Empty.absurd(ListFacts<A, 4n, [0n, 2n, 3n, 1n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
931
932def product_0231(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 2n, 3n, 1n])) == Shape.numel(dims) : Nat}:
933 match dims:
934 case Nil{}:
935 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 2n, 3n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
936 case +x0 <> Nil{}:
937 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 2n, 3n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
938 case +x0 <> +x1 <> Nil{}:
939 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 2n, 3n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
940 case +x0 <> +x1 <> +x2 <> Nil{}:
941 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [0n, 2n, 3n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
942 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
943 Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x2, value)), Nat.mul(x3, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x3, 1n)), mul_swap(x3, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==}))
944 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
945 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [0n, 2n, 3n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
946
947def fit_0231(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 2n, 3n, 1n]), Axis.order(Nat, coords, [0n, 2n, 3n, 1n])) == Shape.fit(dims, coords) : Bool}:
948 match dims:
949 case Nil{}:
950 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, coords, [0n, 2n, 3n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
951 case +d0 <> Nil{}:
952 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, coords, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
953 case +d0 <> +d1 <> Nil{}:
954 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, coords, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
955 case +d0 <> +d1 <> +d2 <> Nil{}:
956 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, coords, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
957 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
958 match coords:
959 case Nil{}:
960 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, Nil{}, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
961 case +c0 <> Nil{}:
962 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, c0 <> Nil{}, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
963 case +c0 <> +c1 <> Nil{}:
964 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
965 case +c0 <> +c1 <> +c2 <> Nil{}:
966 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
967 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
968 Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==}))
969 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
970 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 2n, 3n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
971 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
972 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [0n, 2n, 3n, 1n]), Axis.order(Nat, coords, [0n, 2n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
973
974def lists_0312(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [0n, 3n, 1n, 2n], items>:
975 match items:
976 case Nil{}:
977 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 1n, 2n], Nil{}>, nat_clash(0n, 4n, length, {==}))
978 case +x0 <> Nil{}:
979 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 1n, 2n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
980 case +x0 <> +x1 <> Nil{}:
981 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 1n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
982 case +x0 <> +x1 <> +x2 <> Nil{}:
983 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 1n, 2n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
984 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
985 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
986 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
987 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 1n, 2n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
988
989def product_0312(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 3n, 1n, 2n])) == Shape.numel(dims) : Nat}:
990 match dims:
991 case Nil{}:
992 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 3n, 1n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
993 case +x0 <> Nil{}:
994 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 3n, 1n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
995 case +x0 <> +x1 <> Nil{}:
996 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 3n, 1n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
997 case +x0 <> +x1 <> +x2 <> Nil{}:
998 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [0n, 3n, 1n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
999 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1000 Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==}))
1001 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1002 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [0n, 3n, 1n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1003
1004def fit_0312(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 3n, 1n, 2n]), Axis.order(Nat, coords, [0n, 3n, 1n, 2n])) == Shape.fit(dims, coords) : Bool}:
1005 match dims:
1006 case Nil{}:
1007 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, coords, [0n, 3n, 1n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1008 case +d0 <> Nil{}:
1009 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, coords, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1010 case +d0 <> +d1 <> Nil{}:
1011 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, coords, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1012 case +d0 <> +d1 <> +d2 <> Nil{}:
1013 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, coords, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1014 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1015 match coords:
1016 case Nil{}:
1017 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, Nil{}, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1018 case +c0 <> Nil{}:
1019 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, c0 <> Nil{}, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1020 case +c0 <> +c1 <> Nil{}:
1021 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1022 case +c0 <> +c1 <> +c2 <> Nil{}:
1023 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1024 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1025 Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==}))
1026 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1027 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1028 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1029 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [0n, 3n, 1n, 2n]), Axis.order(Nat, coords, [0n, 3n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1030
1031def lists_0321(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [0n, 3n, 2n, 1n], items>:
1032 match items:
1033 case Nil{}:
1034 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 2n, 1n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1035 case +x0 <> Nil{}:
1036 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 2n, 1n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1037 case +x0 <> +x1 <> Nil{}:
1038 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 2n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1039 case +x0 <> +x1 <> +x2 <> Nil{}:
1040 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 2n, 1n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1041 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1042 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1043 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1044 Empty.absurd(ListFacts<A, 4n, [0n, 3n, 2n, 1n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1045
1046def product_0321(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [0n, 3n, 2n, 1n])) == Shape.numel(dims) : Nat}:
1047 match dims:
1048 case Nil{}:
1049 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [0n, 3n, 2n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1050 case +x0 <> Nil{}:
1051 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [0n, 3n, 2n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1052 case +x0 <> +x1 <> Nil{}:
1053 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [0n, 3n, 2n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1054 case +x0 <> +x1 <> +x2 <> Nil{}:
1055 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [0n, 3n, 2n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1056 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1057 Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x3, value)), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==})))
1058 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1059 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [0n, 3n, 2n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1060
1061def fit_0321(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [0n, 3n, 2n, 1n]), Axis.order(Nat, coords, [0n, 3n, 2n, 1n])) == Shape.fit(dims, coords) : Bool}:
1062 match dims:
1063 case Nil{}:
1064 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, coords, [0n, 3n, 2n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1065 case +d0 <> Nil{}:
1066 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, coords, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1067 case +d0 <> +d1 <> Nil{}:
1068 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, coords, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1069 case +d0 <> +d1 <> +d2 <> Nil{}:
1070 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, coords, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1071 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1072 match coords:
1073 case Nil{}:
1074 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, Nil{}, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1075 case +c0 <> Nil{}:
1076 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, c0 <> Nil{}, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1077 case +c0 <> +c1 <> Nil{}:
1078 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1079 case +c0 <> +c1 <> +c2 <> Nil{}:
1080 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1081 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1082 Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), value)), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==})))
1083 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1084 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [0n, 3n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1085 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1086 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [0n, 3n, 2n, 1n]), Axis.order(Nat, coords, [0n, 3n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1087
1088def lists_1023(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [1n, 0n, 2n, 3n], items>:
1089 match items:
1090 case Nil{}:
1091 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 2n, 3n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1092 case +x0 <> Nil{}:
1093 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 2n, 3n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1094 case +x0 <> +x1 <> Nil{}:
1095 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 2n, 3n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1096 case +x0 <> +x1 <> +x2 <> Nil{}:
1097 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 2n, 3n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1098 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1099 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1100 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1101 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 2n, 3n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1102
1103def product_1023(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 0n, 2n, 3n])) == Shape.numel(dims) : Nat}:
1104 match dims:
1105 case Nil{}:
1106 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 0n, 2n, 3n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1107 case +x0 <> Nil{}:
1108 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 0n, 2n, 3n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1109 case +x0 <> +x1 <> Nil{}:
1110 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 0n, 2n, 3n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1111 case +x0 <> +x1 <> +x2 <> Nil{}:
1112 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [1n, 0n, 2n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1113 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1114 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x1, x0, Nat.mul(x2, Nat.mul(x3, 1n))), {==})
1115 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1116 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [1n, 0n, 2n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1117
1118def fit_1023(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 0n, 2n, 3n]), Axis.order(Nat, coords, [1n, 0n, 2n, 3n])) == Shape.fit(dims, coords) : Bool}:
1119 match dims:
1120 case Nil{}:
1121 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, coords, [1n, 0n, 2n, 3n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1122 case +d0 <> Nil{}:
1123 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, coords, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1124 case +d0 <> +d1 <> Nil{}:
1125 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, coords, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1126 case +d0 <> +d1 <> +d2 <> Nil{}:
1127 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, coords, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1128 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1129 match coords:
1130 case Nil{}:
1131 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, Nil{}, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1132 case +c0 <> Nil{}:
1133 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, c0 <> Nil{}, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1134 case +c0 <> +c1 <> Nil{}:
1135 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1136 case +c0 <> +c1 <> +c2 <> Nil{}:
1137 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1138 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1139 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), {==})
1140 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1141 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 2n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1142 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1143 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [1n, 0n, 2n, 3n]), Axis.order(Nat, coords, [1n, 0n, 2n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1144
1145def lists_1032(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [1n, 0n, 3n, 2n], items>:
1146 match items:
1147 case Nil{}:
1148 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 3n, 2n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1149 case +x0 <> Nil{}:
1150 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 3n, 2n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1151 case +x0 <> +x1 <> Nil{}:
1152 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 3n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1153 case +x0 <> +x1 <> +x2 <> Nil{}:
1154 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 3n, 2n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1155 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1156 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1157 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1158 Empty.absurd(ListFacts<A, 4n, [1n, 0n, 3n, 2n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1159
1160def product_1032(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 0n, 3n, 2n])) == Shape.numel(dims) : Nat}:
1161 match dims:
1162 case Nil{}:
1163 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 0n, 3n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1164 case +x0 <> Nil{}:
1165 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 0n, 3n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1166 case +x0 <> +x1 <> Nil{}:
1167 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 0n, 3n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1168 case +x0 <> +x1 <> +x2 <> Nil{}:
1169 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [1n, 0n, 3n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1170 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1171 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x1, x0, Nat.mul(x3, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==}))
1172 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1173 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [1n, 0n, 3n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1174
1175def fit_1032(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 0n, 3n, 2n]), Axis.order(Nat, coords, [1n, 0n, 3n, 2n])) == Shape.fit(dims, coords) : Bool}:
1176 match dims:
1177 case Nil{}:
1178 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, coords, [1n, 0n, 3n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1179 case +d0 <> Nil{}:
1180 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, coords, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1181 case +d0 <> +d1 <> Nil{}:
1182 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, coords, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1183 case +d0 <> +d1 <> +d2 <> Nil{}:
1184 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, coords, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1185 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1186 match coords:
1187 case Nil{}:
1188 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, Nil{}, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1189 case +c0 <> Nil{}:
1190 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, c0 <> Nil{}, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1191 case +c0 <> +c1 <> Nil{}:
1192 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1193 case +c0 <> +c1 <> +c2 <> Nil{}:
1194 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1195 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1196 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==}))
1197 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1198 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 0n, 3n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1199 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1200 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [1n, 0n, 3n, 2n]), Axis.order(Nat, coords, [1n, 0n, 3n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1201
1202def lists_1203(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [1n, 2n, 0n, 3n], items>:
1203 match items:
1204 case Nil{}:
1205 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 0n, 3n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1206 case +x0 <> Nil{}:
1207 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 0n, 3n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1208 case +x0 <> +x1 <> Nil{}:
1209 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 0n, 3n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1210 case +x0 <> +x1 <> +x2 <> Nil{}:
1211 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 0n, 3n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1212 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1213 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1214 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1215 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 0n, 3n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1216
1217def product_1203(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 2n, 0n, 3n])) == Shape.numel(dims) : Nat}:
1218 match dims:
1219 case Nil{}:
1220 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 2n, 0n, 3n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1221 case +x0 <> Nil{}:
1222 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 2n, 0n, 3n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1223 case +x0 <> +x1 <> Nil{}:
1224 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 2n, 0n, 3n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1225 case +x0 <> +x1 <> +x2 <> Nil{}:
1226 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [1n, 2n, 0n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1227 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1228 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, 1n)))), Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x1, value), Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, 1n))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x0, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x1, x0, Nat.mul(x2, Nat.mul(x3, 1n))), {==}))
1229 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1230 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [1n, 2n, 0n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1231
1232def fit_1203(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 2n, 0n, 3n]), Axis.order(Nat, coords, [1n, 2n, 0n, 3n])) == Shape.fit(dims, coords) : Bool}:
1233 match dims:
1234 case Nil{}:
1235 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, coords, [1n, 2n, 0n, 3n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1236 case +d0 <> Nil{}:
1237 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, coords, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1238 case +d0 <> +d1 <> Nil{}:
1239 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, coords, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1240 case +d0 <> +d1 <> +d2 <> Nil{}:
1241 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, coords, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1242 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1243 match coords:
1244 case Nil{}:
1245 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, Nil{}, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1246 case +c0 <> Nil{}:
1247 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, c0 <> Nil{}, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1248 case +c0 <> +c1 <> Nil{}:
1249 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1250 case +c0 <> +c1 <> +c2 <> Nil{}:
1251 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1252 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1253 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), {==}))
1254 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1255 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 0n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1256 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1257 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [1n, 2n, 0n, 3n]), Axis.order(Nat, coords, [1n, 2n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1258
1259def lists_1230(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [1n, 2n, 3n, 0n], items>:
1260 match items:
1261 case Nil{}:
1262 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 3n, 0n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1263 case +x0 <> Nil{}:
1264 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 3n, 0n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1265 case +x0 <> +x1 <> Nil{}:
1266 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 3n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1267 case +x0 <> +x1 <> +x2 <> Nil{}:
1268 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 3n, 0n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1269 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1270 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1271 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1272 Empty.absurd(ListFacts<A, 4n, [1n, 2n, 3n, 0n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1273
1274def product_1230(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 2n, 3n, 0n])) == Shape.numel(dims) : Nat}:
1275 match dims:
1276 case Nil{}:
1277 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 2n, 3n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1278 case +x0 <> Nil{}:
1279 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 2n, 3n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1280 case +x0 <> +x1 <> Nil{}:
1281 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 2n, 3n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1282 case +x0 <> +x1 <> +x2 <> Nil{}:
1283 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [1n, 2n, 3n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1284 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1285 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, Nat.mul(x0, 1n)))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x1, Nat.mul(x2, value)), Nat.mul(x3, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x3, 1n)), mul_swap(x3, x0, 1n)), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, 1n)))), Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x1, value), Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, 1n))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x0, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x1, x0, Nat.mul(x2, Nat.mul(x3, 1n))), {==})))
1286 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1287 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [1n, 2n, 3n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1288
1289def fit_1230(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 2n, 3n, 0n]), Axis.order(Nat, coords, [1n, 2n, 3n, 0n])) == Shape.fit(dims, coords) : Bool}:
1290 match dims:
1291 case Nil{}:
1292 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, coords, [1n, 2n, 3n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1293 case +d0 <> Nil{}:
1294 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, coords, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1295 case +d0 <> +d1 <> Nil{}:
1296 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, coords, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1297 case +d0 <> +d1 <> +d2 <> Nil{}:
1298 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, coords, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1299 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1300 match coords:
1301 case Nil{}:
1302 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, Nil{}, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1303 case +c0 <> Nil{}:
1304 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, c0 <> Nil{}, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1305 case +c0 <> +c1 <> Nil{}:
1306 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1307 case +c0 <> +c1 <> +c2 <> Nil{}:
1308 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1309 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1310 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), True{})))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), {==})))
1311 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1312 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 2n, 3n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1313 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1314 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [1n, 2n, 3n, 0n]), Axis.order(Nat, coords, [1n, 2n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1315
1316def lists_1302(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [1n, 3n, 0n, 2n], items>:
1317 match items:
1318 case Nil{}:
1319 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 0n, 2n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1320 case +x0 <> Nil{}:
1321 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 0n, 2n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1322 case +x0 <> +x1 <> Nil{}:
1323 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 0n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1324 case +x0 <> +x1 <> +x2 <> Nil{}:
1325 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 0n, 2n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1326 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1327 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1328 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1329 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 0n, 2n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1330
1331def product_1302(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 3n, 0n, 2n])) == Shape.numel(dims) : Nat}:
1332 match dims:
1333 case Nil{}:
1334 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 3n, 0n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1335 case +x0 <> Nil{}:
1336 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 3n, 0n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1337 case +x0 <> +x1 <> Nil{}:
1338 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 3n, 0n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1339 case +x0 <> +x1 <> +x2 <> Nil{}:
1340 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [1n, 3n, 0n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1341 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1342 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, 1n)))), Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x1, value), Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x0, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x1, x0, Nat.mul(x3, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==})))
1343 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1344 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [1n, 3n, 0n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1345
1346def fit_1302(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 3n, 0n, 2n]), Axis.order(Nat, coords, [1n, 3n, 0n, 2n])) == Shape.fit(dims, coords) : Bool}:
1347 match dims:
1348 case Nil{}:
1349 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, coords, [1n, 3n, 0n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1350 case +d0 <> Nil{}:
1351 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, coords, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1352 case +d0 <> +d1 <> Nil{}:
1353 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, coords, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1354 case +d0 <> +d1 <> +d2 <> Nil{}:
1355 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, coords, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1356 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1357 match coords:
1358 case Nil{}:
1359 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, Nil{}, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1360 case +c0 <> Nil{}:
1361 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, c0 <> Nil{}, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1362 case +c0 <> +c1 <> Nil{}:
1363 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1364 case +c0 <> +c1 <> +c2 <> Nil{}:
1365 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1366 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1367 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==})))
1368 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1369 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1370 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1371 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [1n, 3n, 0n, 2n]), Axis.order(Nat, coords, [1n, 3n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1372
1373def lists_1320(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [1n, 3n, 2n, 0n], items>:
1374 match items:
1375 case Nil{}:
1376 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 2n, 0n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1377 case +x0 <> Nil{}:
1378 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 2n, 0n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1379 case +x0 <> +x1 <> Nil{}:
1380 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 2n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1381 case +x0 <> +x1 <> +x2 <> Nil{}:
1382 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 2n, 0n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1383 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1384 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1385 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1386 Empty.absurd(ListFacts<A, 4n, [1n, 3n, 2n, 0n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1387
1388def product_1320(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [1n, 3n, 2n, 0n])) == Shape.numel(dims) : Nat}:
1389 match dims:
1390 case Nil{}:
1391 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [1n, 3n, 2n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1392 case +x0 <> Nil{}:
1393 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [1n, 3n, 2n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1394 case +x0 <> +x1 <> Nil{}:
1395 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [1n, 3n, 2n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1396 case +x0 <> +x1 <> +x2 <> Nil{}:
1397 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [1n, 3n, 2n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1398 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1399 Equal.trans(Nat, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, Nat.mul(x0, 1n)))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x1, Nat.mul(x3, value)), Nat.mul(x2, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x2, 1n)), mul_swap(x2, x0, 1n)), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, 1n)))), Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x1, value), Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x0, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x1, x0, Nat.mul(x3, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==}))))
1400 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1401 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [1n, 3n, 2n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1402
1403def fit_1320(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [1n, 3n, 2n, 0n]), Axis.order(Nat, coords, [1n, 3n, 2n, 0n])) == Shape.fit(dims, coords) : Bool}:
1404 match dims:
1405 case Nil{}:
1406 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, coords, [1n, 3n, 2n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1407 case +d0 <> Nil{}:
1408 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, coords, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1409 case +d0 <> +d1 <> Nil{}:
1410 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, coords, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1411 case +d0 <> +d1 <> +d2 <> Nil{}:
1412 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, coords, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1413 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1414 match coords:
1415 case Nil{}:
1416 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, Nil{}, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1417 case +c0 <> Nil{}:
1418 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, c0 <> Nil{}, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1419 case +c0 <> +c1 <> Nil{}:
1420 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1421 case +c0 <> +c1 <> +c2 <> Nil{}:
1422 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1423 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1424 Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), True{})))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), value)), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c1, d1), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==}))))
1425 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1426 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [1n, 3n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1427 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1428 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [1n, 3n, 2n, 0n]), Axis.order(Nat, coords, [1n, 3n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1429
1430def lists_2013(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [2n, 0n, 1n, 3n], items>:
1431 match items:
1432 case Nil{}:
1433 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 1n, 3n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1434 case +x0 <> Nil{}:
1435 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 1n, 3n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1436 case +x0 <> +x1 <> Nil{}:
1437 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 1n, 3n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1438 case +x0 <> +x1 <> +x2 <> Nil{}:
1439 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 1n, 3n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1440 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1441 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1442 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1443 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 1n, 3n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1444
1445def product_2013(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 0n, 1n, 3n])) == Shape.numel(dims) : Nat}:
1446 match dims:
1447 case Nil{}:
1448 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 0n, 1n, 3n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1449 case +x0 <> Nil{}:
1450 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 0n, 1n, 3n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1451 case +x0 <> +x1 <> Nil{}:
1452 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 0n, 1n, 3n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1453 case +x0 <> +x1 <> +x2 <> Nil{}:
1454 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [2n, 0n, 1n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1455 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1456 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x2, x0, Nat.mul(x1, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==}))
1457 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1458 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [2n, 0n, 1n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1459
1460def fit_2013(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 0n, 1n, 3n]), Axis.order(Nat, coords, [2n, 0n, 1n, 3n])) == Shape.fit(dims, coords) : Bool}:
1461 match dims:
1462 case Nil{}:
1463 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, coords, [2n, 0n, 1n, 3n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1464 case +d0 <> Nil{}:
1465 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, coords, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1466 case +d0 <> +d1 <> Nil{}:
1467 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, coords, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1468 case +d0 <> +d1 <> +d2 <> Nil{}:
1469 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, coords, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1470 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1471 match coords:
1472 case Nil{}:
1473 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, Nil{}, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1474 case +c0 <> Nil{}:
1475 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, c0 <> Nil{}, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1476 case +c0 <> +c1 <> Nil{}:
1477 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1478 case +c0 <> +c1 <> +c2 <> Nil{}:
1479 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1480 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1481 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==}))
1482 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1483 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 1n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1484 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1485 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [2n, 0n, 1n, 3n]), Axis.order(Nat, coords, [2n, 0n, 1n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1486
1487def lists_2031(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [2n, 0n, 3n, 1n], items>:
1488 match items:
1489 case Nil{}:
1490 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 3n, 1n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1491 case +x0 <> Nil{}:
1492 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 3n, 1n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1493 case +x0 <> +x1 <> Nil{}:
1494 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 3n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1495 case +x0 <> +x1 <> +x2 <> Nil{}:
1496 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 3n, 1n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1497 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1498 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1499 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1500 Empty.absurd(ListFacts<A, 4n, [2n, 0n, 3n, 1n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1501
1502def product_2031(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 0n, 3n, 1n])) == Shape.numel(dims) : Nat}:
1503 match dims:
1504 case Nil{}:
1505 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 0n, 3n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1506 case +x0 <> Nil{}:
1507 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 0n, 3n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1508 case +x0 <> +x1 <> Nil{}:
1509 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 0n, 3n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1510 case +x0 <> +x1 <> +x2 <> Nil{}:
1511 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [2n, 0n, 3n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1512 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1513 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x2, x0, Nat.mul(x3, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x2, value)), Nat.mul(x3, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x3, 1n)), mul_swap(x3, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==})))
1514 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1515 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [2n, 0n, 3n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1516
1517def fit_2031(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 0n, 3n, 1n]), Axis.order(Nat, coords, [2n, 0n, 3n, 1n])) == Shape.fit(dims, coords) : Bool}:
1518 match dims:
1519 case Nil{}:
1520 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, coords, [2n, 0n, 3n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1521 case +d0 <> Nil{}:
1522 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, coords, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1523 case +d0 <> +d1 <> Nil{}:
1524 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, coords, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1525 case +d0 <> +d1 <> +d2 <> Nil{}:
1526 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, coords, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1527 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1528 match coords:
1529 case Nil{}:
1530 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, Nil{}, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1531 case +c0 <> Nil{}:
1532 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, c0 <> Nil{}, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1533 case +c0 <> +c1 <> Nil{}:
1534 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1535 case +c0 <> +c1 <> +c2 <> Nil{}:
1536 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1537 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1538 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==})))
1539 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1540 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 0n, 3n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1541 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1542 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [2n, 0n, 3n, 1n]), Axis.order(Nat, coords, [2n, 0n, 3n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1543
1544def lists_2103(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [2n, 1n, 0n, 3n], items>:
1545 match items:
1546 case Nil{}:
1547 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 0n, 3n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1548 case +x0 <> Nil{}:
1549 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 0n, 3n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1550 case +x0 <> +x1 <> Nil{}:
1551 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 0n, 3n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1552 case +x0 <> +x1 <> +x2 <> Nil{}:
1553 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 0n, 3n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1554 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1555 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1556 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1557 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 0n, 3n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1558
1559def product_2103(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 1n, 0n, 3n])) == Shape.numel(dims) : Nat}:
1560 match dims:
1561 case Nil{}:
1562 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 1n, 0n, 3n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1563 case +x0 <> Nil{}:
1564 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 1n, 0n, 3n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1565 case +x0 <> +x1 <> Nil{}:
1566 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 1n, 0n, 3n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1567 case +x0 <> +x1 <> +x2 <> Nil{}:
1568 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [2n, 1n, 0n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1569 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1570 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, 1n)))), Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x2, value), Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n))), mul_swap(x1, x0, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x2, x0, Nat.mul(x1, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==})))
1571 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1572 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [2n, 1n, 0n, 3n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1573
1574def fit_2103(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 1n, 0n, 3n]), Axis.order(Nat, coords, [2n, 1n, 0n, 3n])) == Shape.fit(dims, coords) : Bool}:
1575 match dims:
1576 case Nil{}:
1577 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, coords, [2n, 1n, 0n, 3n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1578 case +d0 <> Nil{}:
1579 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, coords, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1580 case +d0 <> +d1 <> Nil{}:
1581 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, coords, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1582 case +d0 <> +d1 <> +d2 <> Nil{}:
1583 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, coords, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1584 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1585 match coords:
1586 case Nil{}:
1587 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, Nil{}, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1588 case +c0 <> Nil{}:
1589 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, c0 <> Nil{}, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1590 case +c0 <> +c1 <> Nil{}:
1591 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1592 case +c0 <> +c1 <> +c2 <> Nil{}:
1593 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1594 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1595 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), value), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==})))
1596 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1597 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 0n, 3n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1598 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1599 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [2n, 1n, 0n, 3n]), Axis.order(Nat, coords, [2n, 1n, 0n, 3n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1600
1601def lists_2130(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [2n, 1n, 3n, 0n], items>:
1602 match items:
1603 case Nil{}:
1604 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 3n, 0n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1605 case +x0 <> Nil{}:
1606 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 3n, 0n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1607 case +x0 <> +x1 <> Nil{}:
1608 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 3n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1609 case +x0 <> +x1 <> +x2 <> Nil{}:
1610 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 3n, 0n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1611 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1612 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1613 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1614 Empty.absurd(ListFacts<A, 4n, [2n, 1n, 3n, 0n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1615
1616def product_2130(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 1n, 3n, 0n])) == Shape.numel(dims) : Nat}:
1617 match dims:
1618 case Nil{}:
1619 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 1n, 3n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1620 case +x0 <> Nil{}:
1621 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 1n, 3n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1622 case +x0 <> +x1 <> Nil{}:
1623 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 1n, 3n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1624 case +x0 <> +x1 <> +x2 <> Nil{}:
1625 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [2n, 1n, 3n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1626 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1627 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, Nat.mul(x0, 1n)))), Nat.mul(x2, Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x2, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x3, 1n)), mul_swap(x3, x0, 1n)), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, 1n)))), Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x2, value), Nat.mul(x1, Nat.mul(x0, Nat.mul(x3, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n))), mul_swap(x1, x0, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x2, x0, Nat.mul(x1, Nat.mul(x3, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==}))))
1628 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1629 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [2n, 1n, 3n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1630
1631def fit_2130(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 1n, 3n, 0n]), Axis.order(Nat, coords, [2n, 1n, 3n, 0n])) == Shape.fit(dims, coords) : Bool}:
1632 match dims:
1633 case Nil{}:
1634 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, coords, [2n, 1n, 3n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1635 case +d0 <> Nil{}:
1636 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, coords, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1637 case +d0 <> +d1 <> Nil{}:
1638 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, coords, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1639 case +d0 <> +d1 <> +d2 <> Nil{}:
1640 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, coords, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1641 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1642 match coords:
1643 case Nil{}:
1644 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, Nil{}, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1645 case +c0 <> Nil{}:
1646 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, c0 <> Nil{}, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1647 case +c0 <> +c1 <> Nil{}:
1648 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1649 case +c0 <> +c1 <> +c2 <> Nil{}:
1650 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1651 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1652 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), True{})))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), value), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==}))))
1653 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1654 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 1n, 3n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1655 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1656 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [2n, 1n, 3n, 0n]), Axis.order(Nat, coords, [2n, 1n, 3n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1657
1658def lists_2301(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [2n, 3n, 0n, 1n], items>:
1659 match items:
1660 case Nil{}:
1661 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 0n, 1n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1662 case +x0 <> Nil{}:
1663 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 0n, 1n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1664 case +x0 <> +x1 <> Nil{}:
1665 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 0n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1666 case +x0 <> +x1 <> +x2 <> Nil{}:
1667 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 0n, 1n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1668 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1669 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1670 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1671 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 0n, 1n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1672
1673def product_2301(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 3n, 0n, 1n])) == Shape.numel(dims) : Nat}:
1674 match dims:
1675 case Nil{}:
1676 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 3n, 0n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1677 case +x0 <> Nil{}:
1678 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 3n, 0n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1679 case +x0 <> +x1 <> Nil{}:
1680 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 3n, 0n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1681 case +x0 <> +x1 <> +x2 <> Nil{}:
1682 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [2n, 3n, 0n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1683 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1684 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, 1n)))), Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x2, value), Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n))), mul_swap(x3, x0, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x2, x0, Nat.mul(x3, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x2, value)), Nat.mul(x3, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x3, 1n)), mul_swap(x3, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==}))))
1685 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1686 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [2n, 3n, 0n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1687
1688def fit_2301(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 3n, 0n, 1n]), Axis.order(Nat, coords, [2n, 3n, 0n, 1n])) == Shape.fit(dims, coords) : Bool}:
1689 match dims:
1690 case Nil{}:
1691 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, coords, [2n, 3n, 0n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1692 case +d0 <> Nil{}:
1693 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, coords, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1694 case +d0 <> +d1 <> Nil{}:
1695 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, coords, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1696 case +d0 <> +d1 <> +d2 <> Nil{}:
1697 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, coords, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1698 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1699 match coords:
1700 case Nil{}:
1701 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, Nil{}, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1702 case +c0 <> Nil{}:
1703 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, c0 <> Nil{}, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1704 case +c0 <> +c1 <> Nil{}:
1705 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1706 case +c0 <> +c1 <> +c2 <> Nil{}:
1707 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1708 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1709 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==}))))
1710 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1711 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1712 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1713 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [2n, 3n, 0n, 1n]), Axis.order(Nat, coords, [2n, 3n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1714
1715def lists_2310(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [2n, 3n, 1n, 0n], items>:
1716 match items:
1717 case Nil{}:
1718 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 1n, 0n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1719 case +x0 <> Nil{}:
1720 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 1n, 0n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1721 case +x0 <> +x1 <> Nil{}:
1722 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 1n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1723 case +x0 <> +x1 <> +x2 <> Nil{}:
1724 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 1n, 0n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1725 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1726 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1727 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1728 Empty.absurd(ListFacts<A, 4n, [2n, 3n, 1n, 0n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1729
1730def product_2310(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [2n, 3n, 1n, 0n])) == Shape.numel(dims) : Nat}:
1731 match dims:
1732 case Nil{}:
1733 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [2n, 3n, 1n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1734 case +x0 <> Nil{}:
1735 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [2n, 3n, 1n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1736 case +x0 <> +x1 <> Nil{}:
1737 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [2n, 3n, 1n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1738 case +x0 <> +x1 <> +x2 <> Nil{}:
1739 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [2n, 3n, 1n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1740 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1741 Equal.trans(Nat, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, Nat.mul(x0, 1n)))), Nat.mul(x2, Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x2, Nat.mul(x3, value)), Nat.mul(x1, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x1, 1n)), mul_swap(x1, x0, 1n)), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, 1n)))), Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x2, value), Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n))), mul_swap(x3, x0, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x2, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x2, x0, Nat.mul(x3, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x3, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x2, value)), Nat.mul(x3, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x3, 1n)), mul_swap(x3, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x2, Nat.mul(x1, Nat.mul(x3, 1n))), Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n))), mul_swap(x2, x1, Nat.mul(x3, 1n))), {==})))))
1742 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1743 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [2n, 3n, 1n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1744
1745def fit_2310(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [2n, 3n, 1n, 0n]), Axis.order(Nat, coords, [2n, 3n, 1n, 0n])) == Shape.fit(dims, coords) : Bool}:
1746 match dims:
1747 case Nil{}:
1748 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, coords, [2n, 3n, 1n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1749 case +d0 <> Nil{}:
1750 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, coords, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1751 case +d0 <> +d1 <> Nil{}:
1752 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, coords, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1753 case +d0 <> +d1 <> +d2 <> Nil{}:
1754 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, coords, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1755 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1756 match coords:
1757 case Nil{}:
1758 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, Nil{}, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1759 case +c0 <> Nil{}:
1760 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, c0 <> Nil{}, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1761 case +c0 <> +c1 <> Nil{}:
1762 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1763 case +c0 <> +c1 <> +c2 <> Nil{}:
1764 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1765 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1766 Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{})))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), value)), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c2, d2), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), True{}))), {==})))))
1767 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1768 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [2n, 3n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1769 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1770 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [2n, 3n, 1n, 0n]), Axis.order(Nat, coords, [2n, 3n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1771
1772def lists_3012(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [3n, 0n, 1n, 2n], items>:
1773 match items:
1774 case Nil{}:
1775 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 1n, 2n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1776 case +x0 <> Nil{}:
1777 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 1n, 2n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1778 case +x0 <> +x1 <> Nil{}:
1779 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 1n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1780 case +x0 <> +x1 <> +x2 <> Nil{}:
1781 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 1n, 2n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1782 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1783 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1784 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1785 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 1n, 2n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1786
1787def product_3012(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [3n, 0n, 1n, 2n])) == Shape.numel(dims) : Nat}:
1788 match dims:
1789 case Nil{}:
1790 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [3n, 0n, 1n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1791 case +x0 <> Nil{}:
1792 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [3n, 0n, 1n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1793 case +x0 <> +x1 <> Nil{}:
1794 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [3n, 0n, 1n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1795 case +x0 <> +x1 <> +x2 <> Nil{}:
1796 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [3n, 0n, 1n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1797 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1798 Equal.trans(Nat, Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x3, x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==})))
1799 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1800 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [3n, 0n, 1n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1801
1802def fit_3012(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [3n, 0n, 1n, 2n]), Axis.order(Nat, coords, [3n, 0n, 1n, 2n])) == Shape.fit(dims, coords) : Bool}:
1803 match dims:
1804 case Nil{}:
1805 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, coords, [3n, 0n, 1n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1806 case +d0 <> Nil{}:
1807 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, coords, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1808 case +d0 <> +d1 <> Nil{}:
1809 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, coords, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1810 case +d0 <> +d1 <> +d2 <> Nil{}:
1811 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, coords, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1812 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1813 match coords:
1814 case Nil{}:
1815 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, Nil{}, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1816 case +c0 <> Nil{}:
1817 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, c0 <> Nil{}, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1818 case +c0 <> +c1 <> Nil{}:
1819 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1820 case +c0 <> +c1 <> +c2 <> Nil{}:
1821 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1822 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1823 Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==})))
1824 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1825 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 1n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1826 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1827 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [3n, 0n, 1n, 2n]), Axis.order(Nat, coords, [3n, 0n, 1n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1828
1829def lists_3021(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [3n, 0n, 2n, 1n], items>:
1830 match items:
1831 case Nil{}:
1832 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 2n, 1n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1833 case +x0 <> Nil{}:
1834 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 2n, 1n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1835 case +x0 <> +x1 <> Nil{}:
1836 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 2n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1837 case +x0 <> +x1 <> +x2 <> Nil{}:
1838 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 2n, 1n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1839 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1840 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1841 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1842 Empty.absurd(ListFacts<A, 4n, [3n, 0n, 2n, 1n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1843
1844def product_3021(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [3n, 0n, 2n, 1n])) == Shape.numel(dims) : Nat}:
1845 match dims:
1846 case Nil{}:
1847 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [3n, 0n, 2n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1848 case +x0 <> Nil{}:
1849 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [3n, 0n, 2n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1850 case +x0 <> +x1 <> Nil{}:
1851 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [3n, 0n, 2n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1852 case +x0 <> +x1 <> +x2 <> Nil{}:
1853 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [3n, 0n, 2n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1854 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1855 Equal.trans(Nat, Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x3, x0, Nat.mul(x2, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x3, value)), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==}))))
1856 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1857 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [3n, 0n, 2n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1858
1859def fit_3021(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [3n, 0n, 2n, 1n]), Axis.order(Nat, coords, [3n, 0n, 2n, 1n])) == Shape.fit(dims, coords) : Bool}:
1860 match dims:
1861 case Nil{}:
1862 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, coords, [3n, 0n, 2n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1863 case +d0 <> Nil{}:
1864 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, coords, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1865 case +d0 <> +d1 <> Nil{}:
1866 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, coords, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1867 case +d0 <> +d1 <> +d2 <> Nil{}:
1868 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, coords, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1869 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1870 match coords:
1871 case Nil{}:
1872 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, Nil{}, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1873 case +c0 <> Nil{}:
1874 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, c0 <> Nil{}, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1875 case +c0 <> +c1 <> Nil{}:
1876 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1877 case +c0 <> +c1 <> +c2 <> Nil{}:
1878 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1879 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1880 Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), value)), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==}))))
1881 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1882 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 0n, 2n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1883 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1884 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [3n, 0n, 2n, 1n]), Axis.order(Nat, coords, [3n, 0n, 2n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1885
1886def lists_3102(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [3n, 1n, 0n, 2n], items>:
1887 match items:
1888 case Nil{}:
1889 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 0n, 2n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1890 case +x0 <> Nil{}:
1891 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 0n, 2n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1892 case +x0 <> +x1 <> Nil{}:
1893 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 0n, 2n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1894 case +x0 <> +x1 <> +x2 <> Nil{}:
1895 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 0n, 2n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1896 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1897 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1898 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1899 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 0n, 2n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1900
1901def product_3102(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [3n, 1n, 0n, 2n])) == Shape.numel(dims) : Nat}:
1902 match dims:
1903 case Nil{}:
1904 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [3n, 1n, 0n, 2n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1905 case +x0 <> Nil{}:
1906 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [3n, 1n, 0n, 2n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1907 case +x0 <> +x1 <> Nil{}:
1908 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [3n, 1n, 0n, 2n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1909 case +x0 <> +x1 <> +x2 <> Nil{}:
1910 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [3n, 1n, 0n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1911 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1912 Equal.trans(Nat, Nat.mul(x3, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n)))), Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x3, value), Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), mul_swap(x1, x0, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x3, x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==}))))
1913 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1914 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [3n, 1n, 0n, 2n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1915
1916def fit_3102(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [3n, 1n, 0n, 2n]), Axis.order(Nat, coords, [3n, 1n, 0n, 2n])) == Shape.fit(dims, coords) : Bool}:
1917 match dims:
1918 case Nil{}:
1919 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, coords, [3n, 1n, 0n, 2n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1920 case +d0 <> Nil{}:
1921 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, coords, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1922 case +d0 <> +d1 <> Nil{}:
1923 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, coords, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1924 case +d0 <> +d1 <> +d2 <> Nil{}:
1925 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, coords, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1926 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1927 match coords:
1928 case Nil{}:
1929 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, Nil{}, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1930 case +c0 <> Nil{}:
1931 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, c0 <> Nil{}, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1932 case +c0 <> +c1 <> Nil{}:
1933 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1934 case +c0 <> +c1 <> +c2 <> Nil{}:
1935 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1936 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1937 Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c3, d3), value), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==}))))
1938 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1939 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 0n, 2n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1940 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1941 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [3n, 1n, 0n, 2n]), Axis.order(Nat, coords, [3n, 1n, 0n, 2n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1942
1943def lists_3120(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [3n, 1n, 2n, 0n], items>:
1944 match items:
1945 case Nil{}:
1946 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 2n, 0n], Nil{}>, nat_clash(0n, 4n, length, {==}))
1947 case +x0 <> Nil{}:
1948 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 2n, 0n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
1949 case +x0 <> +x1 <> Nil{}:
1950 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 2n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
1951 case +x0 <> +x1 <> +x2 <> Nil{}:
1952 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 2n, 0n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
1953 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1954 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
1955 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1956 Empty.absurd(ListFacts<A, 4n, [3n, 1n, 2n, 0n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
1957
1958def product_3120(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [3n, 1n, 2n, 0n])) == Shape.numel(dims) : Nat}:
1959 match dims:
1960 case Nil{}:
1961 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [3n, 1n, 2n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
1962 case +x0 <> Nil{}:
1963 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [3n, 1n, 2n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
1964 case +x0 <> +x1 <> Nil{}:
1965 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [3n, 1n, 2n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
1966 case +x0 <> +x1 <> +x2 <> Nil{}:
1967 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [3n, 1n, 2n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
1968 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
1969 Equal.trans(Nat, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, Nat.mul(x0, 1n)))), Nat.mul(x3, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x3, Nat.mul(x1, value)), Nat.mul(x2, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x2, 1n)), mul_swap(x2, x0, 1n)), Equal.trans(Nat, Nat.mul(x3, Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n)))), Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x3, value), Nat.mul(x1, Nat.mul(x0, Nat.mul(x2, 1n))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n))), mul_swap(x1, x0, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x3, Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x3, x0, Nat.mul(x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==})))))
1970 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
1971 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [3n, 1n, 2n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
1972
1973def fit_3120(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [3n, 1n, 2n, 0n]), Axis.order(Nat, coords, [3n, 1n, 2n, 0n])) == Shape.fit(dims, coords) : Bool}:
1974 match dims:
1975 case Nil{}:
1976 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, coords, [3n, 1n, 2n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
1977 case +d0 <> Nil{}:
1978 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, coords, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
1979 case +d0 <> +d1 <> Nil{}:
1980 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, coords, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
1981 case +d0 <> +d1 <> +d2 <> Nil{}:
1982 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, coords, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
1983 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
1984 match coords:
1985 case Nil{}:
1986 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, Nil{}, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
1987 case +c0 <> Nil{}:
1988 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, c0 <> Nil{}, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
1989 case +c0 <> +c1 <> Nil{}:
1990 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
1991 case +c0 <> +c1 <> +c2 <> Nil{}:
1992 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
1993 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
1994 Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), True{})))), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c3, d3), value), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==})))))
1995 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
1996 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 1n, 2n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
1997 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
1998 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [3n, 1n, 2n, 0n]), Axis.order(Nat, coords, [3n, 1n, 2n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
1999
2000def lists_3201(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [3n, 2n, 0n, 1n], items>:
2001 match items:
2002 case Nil{}:
2003 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 0n, 1n], Nil{}>, nat_clash(0n, 4n, length, {==}))
2004 case +x0 <> Nil{}:
2005 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 0n, 1n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
2006 case +x0 <> +x1 <> Nil{}:
2007 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 0n, 1n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
2008 case +x0 <> +x1 <> +x2 <> Nil{}:
2009 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 0n, 1n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
2010 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
2011 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
2012 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
2013 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 0n, 1n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
2014
2015def product_3201(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [3n, 2n, 0n, 1n])) == Shape.numel(dims) : Nat}:
2016 match dims:
2017 case Nil{}:
2018 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [3n, 2n, 0n, 1n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
2019 case +x0 <> Nil{}:
2020 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [3n, 2n, 0n, 1n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
2021 case +x0 <> +x1 <> Nil{}:
2022 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [3n, 2n, 0n, 1n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
2023 case +x0 <> +x1 <> +x2 <> Nil{}:
2024 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [3n, 2n, 0n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
2025 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
2026 Equal.trans(Nat, Nat.mul(x3, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n)))), Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x3, value), Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), mul_swap(x2, x0, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x3, x0, Nat.mul(x2, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x3, value)), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==})))))
2027 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
2028 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [3n, 2n, 0n, 1n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
2029
2030def fit_3201(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [3n, 2n, 0n, 1n]), Axis.order(Nat, coords, [3n, 2n, 0n, 1n])) == Shape.fit(dims, coords) : Bool}:
2031 match dims:
2032 case Nil{}:
2033 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, coords, [3n, 2n, 0n, 1n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
2034 case +d0 <> Nil{}:
2035 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, coords, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
2036 case +d0 <> +d1 <> Nil{}:
2037 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, coords, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
2038 case +d0 <> +d1 <> +d2 <> Nil{}:
2039 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, coords, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
2040 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
2041 match coords:
2042 case Nil{}:
2043 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, Nil{}, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
2044 case +c0 <> Nil{}:
2045 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, c0 <> Nil{}, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
2046 case +c0 <> +c1 <> Nil{}:
2047 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
2048 case +c0 <> +c1 <> +c2 <> Nil{}:
2049 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
2050 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
2051 Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c3, d3), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), value)), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==})))))
2052 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
2053 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 0n, 1n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
2054 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
2055 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [3n, 2n, 0n, 1n]), Axis.order(Nat, coords, [3n, 2n, 0n, 1n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
2056
2057def lists_3210(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts<A, 4n, [3n, 2n, 1n, 0n], items>:
2058 match items:
2059 case Nil{}:
2060 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 1n, 0n], Nil{}>, nat_clash(0n, 4n, length, {==}))
2061 case +x0 <> Nil{}:
2062 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 1n, 0n], x0 <> Nil{}>, nat_clash(1n, 4n, length, {==}))
2063 case +x0 <> +x1 <> Nil{}:
2064 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 1n, 0n], x0 <> x1 <> Nil{}>, nat_clash(2n, 4n, length, {==}))
2065 case +x0 <> +x1 <> +x2 <> Nil{}:
2066 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 1n, 0n], x0 <> x1 <> x2 <> Nil{}>, nat_clash(3n, 4n, length, {==}))
2067 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
2068 Lists{{==}, {==}, {==}, {==}, {==}, {==}}
2069 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
2070 Empty.absurd(ListFacts<A, 4n, [3n, 2n, 1n, 0n], x0 <> x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==}))
2071
2072def product_3210(+dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == 4n : Nat}) -> {Shape.numel(Axis.order(Nat, dims, [3n, 2n, 1n, 0n])) == Shape.numel(dims) : Nat}:
2073 match dims:
2074 case Nil{}:
2075 Empty.absurd({Shape.numel(Axis.order(Nat, Nil{}, [3n, 2n, 1n, 0n])) == Shape.numel(Nil{}) : Nat}, nat_clash(0n, 4n, length, {==}))
2076 case +x0 <> Nil{}:
2077 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> Nil{}, [3n, 2n, 1n, 0n])) == Shape.numel(x0 <> Nil{}) : Nat}, nat_clash(1n, 4n, length, {==}))
2078 case +x0 <> +x1 <> Nil{}:
2079 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> Nil{}, [3n, 2n, 1n, 0n])) == Shape.numel(x0 <> x1 <> Nil{}) : Nat}, nat_clash(2n, 4n, length, {==}))
2080 case +x0 <> +x1 <> +x2 <> Nil{}:
2081 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> Nil{}, [3n, 2n, 1n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> Nil{}) : Nat}, nat_clash(3n, 4n, length, {==}))
2082 case +x0 <> +x1 <> +x2 <> +x3 <> Nil{}:
2083 Equal.trans(Nat, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, Nat.mul(x0, 1n)))), Nat.mul(x3, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x3, Nat.mul(x2, value)), Nat.mul(x1, Nat.mul(x0, 1n)), Nat.mul(x0, Nat.mul(x1, 1n)), mul_swap(x1, x0, 1n)), Equal.trans(Nat, Nat.mul(x3, Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n)))), Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x3, value), Nat.mul(x2, Nat.mul(x0, Nat.mul(x1, 1n))), Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n))), mul_swap(x2, x0, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x3, Nat.mul(x0, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), mul_swap(x3, x0, Nat.mul(x2, Nat.mul(x1, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x2, Nat.mul(x1, 1n)))), Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x3, value)), Nat.mul(x2, Nat.mul(x1, 1n)), Nat.mul(x1, Nat.mul(x2, 1n)), mul_swap(x2, x1, 1n)), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, value), Nat.mul(x3, Nat.mul(x1, Nat.mul(x2, 1n))), Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n))), mul_swap(x3, x1, Nat.mul(x2, 1n))), Equal.trans(Nat, Nat.mul(x0, Nat.mul(x1, Nat.mul(x3, Nat.mul(x2, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Nat.mul(x0, Nat.mul(x1, Nat.mul(x2, Nat.mul(x3, 1n)))), Equal.cong(Nat, Nat, value => Nat.mul(x0, Nat.mul(x1, value)), Nat.mul(x3, Nat.mul(x2, 1n)), Nat.mul(x2, Nat.mul(x3, 1n)), mul_swap(x3, x2, 1n)), {==}))))))
2084 case +x0 <> +x1 <> +x2 <> +x3 <> +x4 <> +tail:
2085 Empty.absurd({Shape.numel(Axis.order(Nat, x0 <> x1 <> x2 <> x3 <> x4 <> tail, [3n, 2n, 1n, 0n])) == Shape.numel(x0 <> x1 <> x2 <> x3 <> x4 <> tail) : Nat}, nat_clash(5n+List.length(&2, Nat, tail), 4n, length, {==}))
2086
2087def fit_3210(+dims: List<&2, Nat>, +coords: List<&2, Nat>, dl: {List.length(&2, Nat, dims) == 4n : Nat}, cl: {List.length(&2, Nat, coords) == 4n : Nat}) -> {Shape.fit(Axis.order(Nat, dims, [3n, 2n, 1n, 0n]), Axis.order(Nat, coords, [3n, 2n, 1n, 0n])) == Shape.fit(dims, coords) : Bool}:
2088 match dims:
2089 case Nil{}:
2090 Empty.absurd({Shape.fit(Axis.order(Nat, Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, coords, [3n, 2n, 1n, 0n])) == Shape.fit(Nil{}, coords) : Bool}, nat_clash(0n, 4n, dl, {==}))
2091 case +d0 <> Nil{}:
2092 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, coords, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> Nil{}, coords) : Bool}, nat_clash(1n, 4n, dl, {==}))
2093 case +d0 <> +d1 <> Nil{}:
2094 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, coords, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> Nil{}, coords) : Bool}, nat_clash(2n, 4n, dl, {==}))
2095 case +d0 <> +d1 <> +d2 <> Nil{}:
2096 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, coords, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> Nil{}, coords) : Bool}, nat_clash(3n, 4n, dl, {==}))
2097 case +d0 <> +d1 <> +d2 <> +d3 <> Nil{}:
2098 match coords:
2099 case Nil{}:
2100 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, Nil{}, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, Nil{}) : Bool}, nat_clash(0n, 4n, cl, {==}))
2101 case +c0 <> Nil{}:
2102 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, c0 <> Nil{}, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> Nil{}) : Bool}, nat_clash(1n, 4n, cl, {==}))
2103 case +c0 <> +c1 <> Nil{}:
2104 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> Nil{}, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> Nil{}) : Bool}, nat_clash(2n, 4n, cl, {==}))
2105 case +c0 <> +c1 <> +c2 <> Nil{}:
2106 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> Nil{}, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> Nil{}) : Bool}, nat_clash(3n, 4n, cl, {==}))
2107 case +c0 <> +c1 <> +c2 <> +c3 <> Nil{}:
2108 Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{})))), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), value)), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c0, d0), True{})), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})), and_swap(Nat.is_lt(c1, d1), Nat.is_lt(c0, d0), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c3, d3), value), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), value)), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c1, d1), True{})), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})), and_swap(Nat.is_lt(c2, d2), Nat.is_lt(c1, d1), True{})), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), value), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{}))), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), True{}))), Equal.trans(Bool, Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})))), Equal.cong(Bool, Bool, value => Bool.and(Nat.is_lt(c0, d0), Bool.and(Nat.is_lt(c1, d1), value)), Bool.and(Nat.is_lt(c3, d3), Bool.and(Nat.is_lt(c2, d2), True{})), Bool.and(Nat.is_lt(c2, d2), Bool.and(Nat.is_lt(c3, d3), True{})), and_swap(Nat.is_lt(c3, d3), Nat.is_lt(c2, d2), True{})), {==}))))))
2109 case +c0 <> +c1 <> +c2 <> +c3 <> +c4 <> +ct:
2110 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> Nil{}, [3n, 2n, 1n, 0n]), Axis.order(Nat, c0 <> c1 <> c2 <> c3 <> c4 <> ct, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> Nil{}, c0 <> c1 <> c2 <> c3 <> c4 <> ct) : Bool}, nat_clash(5n+List.length(&2, Nat, ct), 4n, cl, {==}))
2111 case +d0 <> +d1 <> +d2 <> +d3 <> +d4 <> +dt:
2112 Empty.absurd({Shape.fit(Axis.order(Nat, d0 <> d1 <> d2 <> d3 <> d4 <> dt, [3n, 2n, 1n, 0n]), Axis.order(Nat, coords, [3n, 2n, 1n, 0n])) == Shape.fit(d0 <> d1 <> d2 <> d3 <> d4 <> dt, coords) : Bool}, nat_clash(5n+List.length(&2, Nat, dt), 4n, dl, {==}))
2113
2114def facts_0(+axes: List<&2, Nat>, accepted: {True{} == Axis.valid(0n, axes) : Bool}) -> Facts<0n, axes>:
2115 match axes:
2116 case Nil{}:
2117 Certified{{==}, {==}, {==}, A => items => length => lists_empty(A, items, length),
2118 dims => length => product_empty(dims, length), dims => coords => dl => cl => fit_empty(dims, coords, dl, cl)}
2119 case +a0 <> +tail:
2120 Empty.absurd(Facts<0n, a0 <> tail>, Shape.clash(accepted))
2121
2122def facts_1(+axes: List<&2, Nat>, accepted: {True{} == Axis.valid(1n, axes) : Bool}) -> Facts<1n, axes>:
2123 match axes:
2124 case Nil{}:
2125 Empty.absurd(Facts<1n, Nil{}>, Shape.clash(accepted))
2126 case 0n <> Nil{}:
2127 Certified{{==}, {==}, {==}, A => items => length => lists_0(A, items, length),
2128 dims => length => product_0(dims, length), dims => coords => dl => cl => fit_0(dims, coords, dl, cl)}
2129 case (1n+p) <> Nil{}:
2130 Empty.absurd(Facts<1n, (1n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(1n+p, 1n), Axis.bounded(Nil{}, 1n), Arith.and_left(Axis.bounded((1n+p) <> Nil{}, 1n), Axis.unique((1n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(1n, (1n+p) <> Nil{}), accepted)))))
2131 case +a0 <> +a1 <> +tail:
2132 Empty.absurd(Facts<1n, a0 <> a1 <> tail>, Shape.clash(accepted))
2133
2134def facts_2(+axes: List<&2, Nat>, accepted: {True{} == Axis.valid(2n, axes) : Bool}) -> Facts<2n, axes>:
2135 match axes:
2136 case Nil{}:
2137 Empty.absurd(Facts<2n, Nil{}>, Shape.clash(accepted))
2138 case +a0 <> Nil{}:
2139 Empty.absurd(Facts<2n, a0 <> Nil{}>, Shape.clash(accepted))
2140 case 0n <> 0n <> Nil{}:
2141 Empty.absurd(Facts<2n, [0n, 0n]>, Shape.clash(accepted))
2142 case 0n <> 1n <> Nil{}:
2143 Certified{{==}, {==}, {==}, A => items => length => lists_01(A, items, length),
2144 dims => length => product_01(dims, length), dims => coords => dl => cl => fit_01(dims, coords, dl, cl)}
2145 case 0n <> (2n+p) <> Nil{}:
2146 Empty.absurd(Facts<2n, 0n <> (2n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(2n+p, 2n), Axis.bounded(Nil{}, 2n), Arith.and_left(Axis.bounded(0n <> (2n+p) <> Nil{}, 2n), Axis.unique(0n <> (2n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(2n, 0n <> (2n+p) <> Nil{}), accepted)))))
2147 case 1n <> 0n <> Nil{}:
2148 Certified{{==}, {==}, {==}, A => items => length => lists_10(A, items, length),
2149 dims => length => product_10(dims, length), dims => coords => dl => cl => fit_10(dims, coords, dl, cl)}
2150 case 1n <> 1n <> Nil{}:
2151 Empty.absurd(Facts<2n, [1n, 1n]>, Shape.clash(accepted))
2152 case 1n <> (2n+p) <> Nil{}:
2153 Empty.absurd(Facts<2n, 1n <> (2n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(2n+p, 2n), Axis.bounded(Nil{}, 2n), Arith.and_left(Axis.bounded(1n <> (2n+p) <> Nil{}, 2n), Axis.unique(1n <> (2n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(2n, 1n <> (2n+p) <> Nil{}), accepted)))))
2154 case (2n+p) <> a0 <> Nil{}:
2155 Empty.absurd(Facts<2n, (2n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(2n+p, 2n), Axis.bounded(a0 <> Nil{}, 2n), Arith.and_left(Axis.bounded((2n+p) <> a0 <> Nil{}, 2n), Axis.unique((2n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(2n, (2n+p) <> a0 <> Nil{}), accepted)))))
2156 case +a0 <> +a1 <> +a2 <> +tail:
2157 Empty.absurd(Facts<2n, a0 <> a1 <> a2 <> tail>, Shape.clash(accepted))
2158
2159def facts_3(+axes: List<&2, Nat>, accepted: {True{} == Axis.valid(3n, axes) : Bool}) -> Facts<3n, axes>:
2160 match axes:
2161 case Nil{}:
2162 Empty.absurd(Facts<3n, Nil{}>, Shape.clash(accepted))
2163 case +a0 <> Nil{}:
2164 Empty.absurd(Facts<3n, a0 <> Nil{}>, Shape.clash(accepted))
2165 case +a0 <> +a1 <> Nil{}:
2166 Empty.absurd(Facts<3n, a0 <> a1 <> Nil{}>, Shape.clash(accepted))
2167 case 0n <> 0n <> 0n <> Nil{}:
2168 Empty.absurd(Facts<3n, [0n, 0n, 0n]>, Shape.clash(accepted))
2169 case 0n <> 0n <> 1n <> Nil{}:
2170 Empty.absurd(Facts<3n, [0n, 0n, 1n]>, Shape.clash(accepted))
2171 case 0n <> 0n <> 2n <> Nil{}:
2172 Empty.absurd(Facts<3n, [0n, 0n, 2n]>, Shape.clash(accepted))
2173 case 0n <> 0n <> (3n+p) <> Nil{}:
2174 Empty.absurd(Facts<3n, 0n <> 0n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(0n <> 0n <> (3n+p) <> Nil{}, 3n), Axis.unique(0n <> 0n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 0n <> 0n <> (3n+p) <> Nil{}), accepted)))))
2175 case 0n <> 1n <> 0n <> Nil{}:
2176 Empty.absurd(Facts<3n, [0n, 1n, 0n]>, Shape.clash(accepted))
2177 case 0n <> 1n <> 1n <> Nil{}:
2178 Empty.absurd(Facts<3n, [0n, 1n, 1n]>, Shape.clash(accepted))
2179 case 0n <> 1n <> 2n <> Nil{}:
2180 Certified{{==}, {==}, {==}, A => items => length => lists_012(A, items, length),
2181 dims => length => product_012(dims, length), dims => coords => dl => cl => fit_012(dims, coords, dl, cl)}
2182 case 0n <> 1n <> (3n+p) <> Nil{}:
2183 Empty.absurd(Facts<3n, 0n <> 1n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(0n <> 1n <> (3n+p) <> Nil{}, 3n), Axis.unique(0n <> 1n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 0n <> 1n <> (3n+p) <> Nil{}), accepted)))))
2184 case 0n <> 2n <> 0n <> Nil{}:
2185 Empty.absurd(Facts<3n, [0n, 2n, 0n]>, Shape.clash(accepted))
2186 case 0n <> 2n <> 1n <> Nil{}:
2187 Certified{{==}, {==}, {==}, A => items => length => lists_021(A, items, length),
2188 dims => length => product_021(dims, length), dims => coords => dl => cl => fit_021(dims, coords, dl, cl)}
2189 case 0n <> 2n <> 2n <> Nil{}:
2190 Empty.absurd(Facts<3n, [0n, 2n, 2n]>, Shape.clash(accepted))
2191 case 0n <> 2n <> (3n+p) <> Nil{}:
2192 Empty.absurd(Facts<3n, 0n <> 2n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(0n <> 2n <> (3n+p) <> Nil{}, 3n), Axis.unique(0n <> 2n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 0n <> 2n <> (3n+p) <> Nil{}), accepted)))))
2193 case 0n <> (3n+p) <> a0 <> Nil{}:
2194 Empty.absurd(Facts<3n, 0n <> (3n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(a0 <> Nil{}, 3n), Arith.and_left(Axis.bounded(0n <> (3n+p) <> a0 <> Nil{}, 3n), Axis.unique(0n <> (3n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 0n <> (3n+p) <> a0 <> Nil{}), accepted)))))
2195 case 1n <> 0n <> 0n <> Nil{}:
2196 Empty.absurd(Facts<3n, [1n, 0n, 0n]>, Shape.clash(accepted))
2197 case 1n <> 0n <> 1n <> Nil{}:
2198 Empty.absurd(Facts<3n, [1n, 0n, 1n]>, Shape.clash(accepted))
2199 case 1n <> 0n <> 2n <> Nil{}:
2200 Certified{{==}, {==}, {==}, A => items => length => lists_102(A, items, length),
2201 dims => length => product_102(dims, length), dims => coords => dl => cl => fit_102(dims, coords, dl, cl)}
2202 case 1n <> 0n <> (3n+p) <> Nil{}:
2203 Empty.absurd(Facts<3n, 1n <> 0n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(1n <> 0n <> (3n+p) <> Nil{}, 3n), Axis.unique(1n <> 0n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 1n <> 0n <> (3n+p) <> Nil{}), accepted)))))
2204 case 1n <> 1n <> 0n <> Nil{}:
2205 Empty.absurd(Facts<3n, [1n, 1n, 0n]>, Shape.clash(accepted))
2206 case 1n <> 1n <> 1n <> Nil{}:
2207 Empty.absurd(Facts<3n, [1n, 1n, 1n]>, Shape.clash(accepted))
2208 case 1n <> 1n <> 2n <> Nil{}:
2209 Empty.absurd(Facts<3n, [1n, 1n, 2n]>, Shape.clash(accepted))
2210 case 1n <> 1n <> (3n+p) <> Nil{}:
2211 Empty.absurd(Facts<3n, 1n <> 1n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(1n <> 1n <> (3n+p) <> Nil{}, 3n), Axis.unique(1n <> 1n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 1n <> 1n <> (3n+p) <> Nil{}), accepted)))))
2212 case 1n <> 2n <> 0n <> Nil{}:
2213 Certified{{==}, {==}, {==}, A => items => length => lists_120(A, items, length),
2214 dims => length => product_120(dims, length), dims => coords => dl => cl => fit_120(dims, coords, dl, cl)}
2215 case 1n <> 2n <> 1n <> Nil{}:
2216 Empty.absurd(Facts<3n, [1n, 2n, 1n]>, Shape.clash(accepted))
2217 case 1n <> 2n <> 2n <> Nil{}:
2218 Empty.absurd(Facts<3n, [1n, 2n, 2n]>, Shape.clash(accepted))
2219 case 1n <> 2n <> (3n+p) <> Nil{}:
2220 Empty.absurd(Facts<3n, 1n <> 2n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(1n <> 2n <> (3n+p) <> Nil{}, 3n), Axis.unique(1n <> 2n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 1n <> 2n <> (3n+p) <> Nil{}), accepted)))))
2221 case 1n <> (3n+p) <> a0 <> Nil{}:
2222 Empty.absurd(Facts<3n, 1n <> (3n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(a0 <> Nil{}, 3n), Arith.and_left(Axis.bounded(1n <> (3n+p) <> a0 <> Nil{}, 3n), Axis.unique(1n <> (3n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 1n <> (3n+p) <> a0 <> Nil{}), accepted)))))
2223 case 2n <> 0n <> 0n <> Nil{}:
2224 Empty.absurd(Facts<3n, [2n, 0n, 0n]>, Shape.clash(accepted))
2225 case 2n <> 0n <> 1n <> Nil{}:
2226 Certified{{==}, {==}, {==}, A => items => length => lists_201(A, items, length),
2227 dims => length => product_201(dims, length), dims => coords => dl => cl => fit_201(dims, coords, dl, cl)}
2228 case 2n <> 0n <> 2n <> Nil{}:
2229 Empty.absurd(Facts<3n, [2n, 0n, 2n]>, Shape.clash(accepted))
2230 case 2n <> 0n <> (3n+p) <> Nil{}:
2231 Empty.absurd(Facts<3n, 2n <> 0n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(2n <> 0n <> (3n+p) <> Nil{}, 3n), Axis.unique(2n <> 0n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 2n <> 0n <> (3n+p) <> Nil{}), accepted)))))
2232 case 2n <> 1n <> 0n <> Nil{}:
2233 Certified{{==}, {==}, {==}, A => items => length => lists_210(A, items, length),
2234 dims => length => product_210(dims, length), dims => coords => dl => cl => fit_210(dims, coords, dl, cl)}
2235 case 2n <> 1n <> 1n <> Nil{}:
2236 Empty.absurd(Facts<3n, [2n, 1n, 1n]>, Shape.clash(accepted))
2237 case 2n <> 1n <> 2n <> Nil{}:
2238 Empty.absurd(Facts<3n, [2n, 1n, 2n]>, Shape.clash(accepted))
2239 case 2n <> 1n <> (3n+p) <> Nil{}:
2240 Empty.absurd(Facts<3n, 2n <> 1n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(2n <> 1n <> (3n+p) <> Nil{}, 3n), Axis.unique(2n <> 1n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 2n <> 1n <> (3n+p) <> Nil{}), accepted)))))
2241 case 2n <> 2n <> 0n <> Nil{}:
2242 Empty.absurd(Facts<3n, [2n, 2n, 0n]>, Shape.clash(accepted))
2243 case 2n <> 2n <> 1n <> Nil{}:
2244 Empty.absurd(Facts<3n, [2n, 2n, 1n]>, Shape.clash(accepted))
2245 case 2n <> 2n <> 2n <> Nil{}:
2246 Empty.absurd(Facts<3n, [2n, 2n, 2n]>, Shape.clash(accepted))
2247 case 2n <> 2n <> (3n+p) <> Nil{}:
2248 Empty.absurd(Facts<3n, 2n <> 2n <> (3n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(Nil{}, 3n), Arith.and_left(Axis.bounded(2n <> 2n <> (3n+p) <> Nil{}, 3n), Axis.unique(2n <> 2n <> (3n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 2n <> 2n <> (3n+p) <> Nil{}), accepted)))))
2249 case 2n <> (3n+p) <> a0 <> Nil{}:
2250 Empty.absurd(Facts<3n, 2n <> (3n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(a0 <> Nil{}, 3n), Arith.and_left(Axis.bounded(2n <> (3n+p) <> a0 <> Nil{}, 3n), Axis.unique(2n <> (3n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, 2n <> (3n+p) <> a0 <> Nil{}), accepted)))))
2251 case (3n+p) <> a0 <> a1 <> Nil{}:
2252 Empty.absurd(Facts<3n, (3n+p) <> a0 <> a1 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(3n+p, 3n), Axis.bounded(a0 <> a1 <> Nil{}, 3n), Arith.and_left(Axis.bounded((3n+p) <> a0 <> a1 <> Nil{}, 3n), Axis.unique((3n+p) <> a0 <> a1 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(3n, (3n+p) <> a0 <> a1 <> Nil{}), accepted)))))
2253 case +a0 <> +a1 <> +a2 <> +a3 <> +tail:
2254 Empty.absurd(Facts<3n, a0 <> a1 <> a2 <> a3 <> tail>, Shape.clash(accepted))
2255
2256def facts_4(+axes: List<&2, Nat>, accepted: {True{} == Axis.valid(4n, axes) : Bool}) -> Facts<4n, axes>:
2257 match axes:
2258 case Nil{}:
2259 Empty.absurd(Facts<4n, Nil{}>, Shape.clash(accepted))
2260 case +a0 <> Nil{}:
2261 Empty.absurd(Facts<4n, a0 <> Nil{}>, Shape.clash(accepted))
2262 case +a0 <> +a1 <> Nil{}:
2263 Empty.absurd(Facts<4n, a0 <> a1 <> Nil{}>, Shape.clash(accepted))
2264 case +a0 <> +a1 <> +a2 <> Nil{}:
2265 Empty.absurd(Facts<4n, a0 <> a1 <> a2 <> Nil{}>, Shape.clash(accepted))
2266 case 0n <> 0n <> 0n <> 0n <> Nil{}:
2267 Empty.absurd(Facts<4n, [0n, 0n, 0n, 0n]>, Shape.clash(accepted))
2268 case 0n <> 0n <> 0n <> 1n <> Nil{}:
2269 Empty.absurd(Facts<4n, [0n, 0n, 0n, 1n]>, Shape.clash(accepted))
2270 case 0n <> 0n <> 0n <> 2n <> Nil{}:
2271 Empty.absurd(Facts<4n, [0n, 0n, 0n, 2n]>, Shape.clash(accepted))
2272 case 0n <> 0n <> 0n <> 3n <> Nil{}:
2273 Empty.absurd(Facts<4n, [0n, 0n, 0n, 3n]>, Shape.clash(accepted))
2274 case 0n <> 0n <> 0n <> (4n+p) <> Nil{}:
2275 Empty.absurd(Facts<4n, 0n <> 0n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 0n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 0n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 0n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2276 case 0n <> 0n <> 1n <> 0n <> Nil{}:
2277 Empty.absurd(Facts<4n, [0n, 0n, 1n, 0n]>, Shape.clash(accepted))
2278 case 0n <> 0n <> 1n <> 1n <> Nil{}:
2279 Empty.absurd(Facts<4n, [0n, 0n, 1n, 1n]>, Shape.clash(accepted))
2280 case 0n <> 0n <> 1n <> 2n <> Nil{}:
2281 Empty.absurd(Facts<4n, [0n, 0n, 1n, 2n]>, Shape.clash(accepted))
2282 case 0n <> 0n <> 1n <> 3n <> Nil{}:
2283 Empty.absurd(Facts<4n, [0n, 0n, 1n, 3n]>, Shape.clash(accepted))
2284 case 0n <> 0n <> 1n <> (4n+p) <> Nil{}:
2285 Empty.absurd(Facts<4n, 0n <> 0n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 0n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 0n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 0n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2286 case 0n <> 0n <> 2n <> 0n <> Nil{}:
2287 Empty.absurd(Facts<4n, [0n, 0n, 2n, 0n]>, Shape.clash(accepted))
2288 case 0n <> 0n <> 2n <> 1n <> Nil{}:
2289 Empty.absurd(Facts<4n, [0n, 0n, 2n, 1n]>, Shape.clash(accepted))
2290 case 0n <> 0n <> 2n <> 2n <> Nil{}:
2291 Empty.absurd(Facts<4n, [0n, 0n, 2n, 2n]>, Shape.clash(accepted))
2292 case 0n <> 0n <> 2n <> 3n <> Nil{}:
2293 Empty.absurd(Facts<4n, [0n, 0n, 2n, 3n]>, Shape.clash(accepted))
2294 case 0n <> 0n <> 2n <> (4n+p) <> Nil{}:
2295 Empty.absurd(Facts<4n, 0n <> 0n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 0n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 0n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 0n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2296 case 0n <> 0n <> 3n <> 0n <> Nil{}:
2297 Empty.absurd(Facts<4n, [0n, 0n, 3n, 0n]>, Shape.clash(accepted))
2298 case 0n <> 0n <> 3n <> 1n <> Nil{}:
2299 Empty.absurd(Facts<4n, [0n, 0n, 3n, 1n]>, Shape.clash(accepted))
2300 case 0n <> 0n <> 3n <> 2n <> Nil{}:
2301 Empty.absurd(Facts<4n, [0n, 0n, 3n, 2n]>, Shape.clash(accepted))
2302 case 0n <> 0n <> 3n <> 3n <> Nil{}:
2303 Empty.absurd(Facts<4n, [0n, 0n, 3n, 3n]>, Shape.clash(accepted))
2304 case 0n <> 0n <> 3n <> (4n+p) <> Nil{}:
2305 Empty.absurd(Facts<4n, 0n <> 0n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 0n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 0n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 0n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2306 case 0n <> 0n <> (4n+p) <> a0 <> Nil{}:
2307 Empty.absurd(Facts<4n, 0n <> 0n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 0n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(0n <> 0n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 0n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2308 case 0n <> 1n <> 0n <> 0n <> Nil{}:
2309 Empty.absurd(Facts<4n, [0n, 1n, 0n, 0n]>, Shape.clash(accepted))
2310 case 0n <> 1n <> 0n <> 1n <> Nil{}:
2311 Empty.absurd(Facts<4n, [0n, 1n, 0n, 1n]>, Shape.clash(accepted))
2312 case 0n <> 1n <> 0n <> 2n <> Nil{}:
2313 Empty.absurd(Facts<4n, [0n, 1n, 0n, 2n]>, Shape.clash(accepted))
2314 case 0n <> 1n <> 0n <> 3n <> Nil{}:
2315 Empty.absurd(Facts<4n, [0n, 1n, 0n, 3n]>, Shape.clash(accepted))
2316 case 0n <> 1n <> 0n <> (4n+p) <> Nil{}:
2317 Empty.absurd(Facts<4n, 0n <> 1n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 1n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 1n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 1n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2318 case 0n <> 1n <> 1n <> 0n <> Nil{}:
2319 Empty.absurd(Facts<4n, [0n, 1n, 1n, 0n]>, Shape.clash(accepted))
2320 case 0n <> 1n <> 1n <> 1n <> Nil{}:
2321 Empty.absurd(Facts<4n, [0n, 1n, 1n, 1n]>, Shape.clash(accepted))
2322 case 0n <> 1n <> 1n <> 2n <> Nil{}:
2323 Empty.absurd(Facts<4n, [0n, 1n, 1n, 2n]>, Shape.clash(accepted))
2324 case 0n <> 1n <> 1n <> 3n <> Nil{}:
2325 Empty.absurd(Facts<4n, [0n, 1n, 1n, 3n]>, Shape.clash(accepted))
2326 case 0n <> 1n <> 1n <> (4n+p) <> Nil{}:
2327 Empty.absurd(Facts<4n, 0n <> 1n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 1n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 1n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 1n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2328 case 0n <> 1n <> 2n <> 0n <> Nil{}:
2329 Empty.absurd(Facts<4n, [0n, 1n, 2n, 0n]>, Shape.clash(accepted))
2330 case 0n <> 1n <> 2n <> 1n <> Nil{}:
2331 Empty.absurd(Facts<4n, [0n, 1n, 2n, 1n]>, Shape.clash(accepted))
2332 case 0n <> 1n <> 2n <> 2n <> Nil{}:
2333 Empty.absurd(Facts<4n, [0n, 1n, 2n, 2n]>, Shape.clash(accepted))
2334 case 0n <> 1n <> 2n <> 3n <> Nil{}:
2335 Certified{{==}, {==}, {==}, A => items => length => lists_0123(A, items, length),
2336 dims => length => product_0123(dims, length), dims => coords => dl => cl => fit_0123(dims, coords, dl, cl)}
2337 case 0n <> 1n <> 2n <> (4n+p) <> Nil{}:
2338 Empty.absurd(Facts<4n, 0n <> 1n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 1n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 1n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 1n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2339 case 0n <> 1n <> 3n <> 0n <> Nil{}:
2340 Empty.absurd(Facts<4n, [0n, 1n, 3n, 0n]>, Shape.clash(accepted))
2341 case 0n <> 1n <> 3n <> 1n <> Nil{}:
2342 Empty.absurd(Facts<4n, [0n, 1n, 3n, 1n]>, Shape.clash(accepted))
2343 case 0n <> 1n <> 3n <> 2n <> Nil{}:
2344 Certified{{==}, {==}, {==}, A => items => length => lists_0132(A, items, length),
2345 dims => length => product_0132(dims, length), dims => coords => dl => cl => fit_0132(dims, coords, dl, cl)}
2346 case 0n <> 1n <> 3n <> 3n <> Nil{}:
2347 Empty.absurd(Facts<4n, [0n, 1n, 3n, 3n]>, Shape.clash(accepted))
2348 case 0n <> 1n <> 3n <> (4n+p) <> Nil{}:
2349 Empty.absurd(Facts<4n, 0n <> 1n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 1n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 1n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 1n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2350 case 0n <> 1n <> (4n+p) <> a0 <> Nil{}:
2351 Empty.absurd(Facts<4n, 0n <> 1n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 1n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(0n <> 1n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 1n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2352 case 0n <> 2n <> 0n <> 0n <> Nil{}:
2353 Empty.absurd(Facts<4n, [0n, 2n, 0n, 0n]>, Shape.clash(accepted))
2354 case 0n <> 2n <> 0n <> 1n <> Nil{}:
2355 Empty.absurd(Facts<4n, [0n, 2n, 0n, 1n]>, Shape.clash(accepted))
2356 case 0n <> 2n <> 0n <> 2n <> Nil{}:
2357 Empty.absurd(Facts<4n, [0n, 2n, 0n, 2n]>, Shape.clash(accepted))
2358 case 0n <> 2n <> 0n <> 3n <> Nil{}:
2359 Empty.absurd(Facts<4n, [0n, 2n, 0n, 3n]>, Shape.clash(accepted))
2360 case 0n <> 2n <> 0n <> (4n+p) <> Nil{}:
2361 Empty.absurd(Facts<4n, 0n <> 2n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 2n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 2n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 2n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2362 case 0n <> 2n <> 1n <> 0n <> Nil{}:
2363 Empty.absurd(Facts<4n, [0n, 2n, 1n, 0n]>, Shape.clash(accepted))
2364 case 0n <> 2n <> 1n <> 1n <> Nil{}:
2365 Empty.absurd(Facts<4n, [0n, 2n, 1n, 1n]>, Shape.clash(accepted))
2366 case 0n <> 2n <> 1n <> 2n <> Nil{}:
2367 Empty.absurd(Facts<4n, [0n, 2n, 1n, 2n]>, Shape.clash(accepted))
2368 case 0n <> 2n <> 1n <> 3n <> Nil{}:
2369 Certified{{==}, {==}, {==}, A => items => length => lists_0213(A, items, length),
2370 dims => length => product_0213(dims, length), dims => coords => dl => cl => fit_0213(dims, coords, dl, cl)}
2371 case 0n <> 2n <> 1n <> (4n+p) <> Nil{}:
2372 Empty.absurd(Facts<4n, 0n <> 2n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 2n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 2n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 2n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2373 case 0n <> 2n <> 2n <> 0n <> Nil{}:
2374 Empty.absurd(Facts<4n, [0n, 2n, 2n, 0n]>, Shape.clash(accepted))
2375 case 0n <> 2n <> 2n <> 1n <> Nil{}:
2376 Empty.absurd(Facts<4n, [0n, 2n, 2n, 1n]>, Shape.clash(accepted))
2377 case 0n <> 2n <> 2n <> 2n <> Nil{}:
2378 Empty.absurd(Facts<4n, [0n, 2n, 2n, 2n]>, Shape.clash(accepted))
2379 case 0n <> 2n <> 2n <> 3n <> Nil{}:
2380 Empty.absurd(Facts<4n, [0n, 2n, 2n, 3n]>, Shape.clash(accepted))
2381 case 0n <> 2n <> 2n <> (4n+p) <> Nil{}:
2382 Empty.absurd(Facts<4n, 0n <> 2n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 2n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 2n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 2n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2383 case 0n <> 2n <> 3n <> 0n <> Nil{}:
2384 Empty.absurd(Facts<4n, [0n, 2n, 3n, 0n]>, Shape.clash(accepted))
2385 case 0n <> 2n <> 3n <> 1n <> Nil{}:
2386 Certified{{==}, {==}, {==}, A => items => length => lists_0231(A, items, length),
2387 dims => length => product_0231(dims, length), dims => coords => dl => cl => fit_0231(dims, coords, dl, cl)}
2388 case 0n <> 2n <> 3n <> 2n <> Nil{}:
2389 Empty.absurd(Facts<4n, [0n, 2n, 3n, 2n]>, Shape.clash(accepted))
2390 case 0n <> 2n <> 3n <> 3n <> Nil{}:
2391 Empty.absurd(Facts<4n, [0n, 2n, 3n, 3n]>, Shape.clash(accepted))
2392 case 0n <> 2n <> 3n <> (4n+p) <> Nil{}:
2393 Empty.absurd(Facts<4n, 0n <> 2n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 2n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 2n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 2n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2394 case 0n <> 2n <> (4n+p) <> a0 <> Nil{}:
2395 Empty.absurd(Facts<4n, 0n <> 2n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 2n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(0n <> 2n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 2n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2396 case 0n <> 3n <> 0n <> 0n <> Nil{}:
2397 Empty.absurd(Facts<4n, [0n, 3n, 0n, 0n]>, Shape.clash(accepted))
2398 case 0n <> 3n <> 0n <> 1n <> Nil{}:
2399 Empty.absurd(Facts<4n, [0n, 3n, 0n, 1n]>, Shape.clash(accepted))
2400 case 0n <> 3n <> 0n <> 2n <> Nil{}:
2401 Empty.absurd(Facts<4n, [0n, 3n, 0n, 2n]>, Shape.clash(accepted))
2402 case 0n <> 3n <> 0n <> 3n <> Nil{}:
2403 Empty.absurd(Facts<4n, [0n, 3n, 0n, 3n]>, Shape.clash(accepted))
2404 case 0n <> 3n <> 0n <> (4n+p) <> Nil{}:
2405 Empty.absurd(Facts<4n, 0n <> 3n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 3n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 3n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 3n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2406 case 0n <> 3n <> 1n <> 0n <> Nil{}:
2407 Empty.absurd(Facts<4n, [0n, 3n, 1n, 0n]>, Shape.clash(accepted))
2408 case 0n <> 3n <> 1n <> 1n <> Nil{}:
2409 Empty.absurd(Facts<4n, [0n, 3n, 1n, 1n]>, Shape.clash(accepted))
2410 case 0n <> 3n <> 1n <> 2n <> Nil{}:
2411 Certified{{==}, {==}, {==}, A => items => length => lists_0312(A, items, length),
2412 dims => length => product_0312(dims, length), dims => coords => dl => cl => fit_0312(dims, coords, dl, cl)}
2413 case 0n <> 3n <> 1n <> 3n <> Nil{}:
2414 Empty.absurd(Facts<4n, [0n, 3n, 1n, 3n]>, Shape.clash(accepted))
2415 case 0n <> 3n <> 1n <> (4n+p) <> Nil{}:
2416 Empty.absurd(Facts<4n, 0n <> 3n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 3n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 3n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 3n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2417 case 0n <> 3n <> 2n <> 0n <> Nil{}:
2418 Empty.absurd(Facts<4n, [0n, 3n, 2n, 0n]>, Shape.clash(accepted))
2419 case 0n <> 3n <> 2n <> 1n <> Nil{}:
2420 Certified{{==}, {==}, {==}, A => items => length => lists_0321(A, items, length),
2421 dims => length => product_0321(dims, length), dims => coords => dl => cl => fit_0321(dims, coords, dl, cl)}
2422 case 0n <> 3n <> 2n <> 2n <> Nil{}:
2423 Empty.absurd(Facts<4n, [0n, 3n, 2n, 2n]>, Shape.clash(accepted))
2424 case 0n <> 3n <> 2n <> 3n <> Nil{}:
2425 Empty.absurd(Facts<4n, [0n, 3n, 2n, 3n]>, Shape.clash(accepted))
2426 case 0n <> 3n <> 2n <> (4n+p) <> Nil{}:
2427 Empty.absurd(Facts<4n, 0n <> 3n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 3n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 3n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 3n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2428 case 0n <> 3n <> 3n <> 0n <> Nil{}:
2429 Empty.absurd(Facts<4n, [0n, 3n, 3n, 0n]>, Shape.clash(accepted))
2430 case 0n <> 3n <> 3n <> 1n <> Nil{}:
2431 Empty.absurd(Facts<4n, [0n, 3n, 3n, 1n]>, Shape.clash(accepted))
2432 case 0n <> 3n <> 3n <> 2n <> Nil{}:
2433 Empty.absurd(Facts<4n, [0n, 3n, 3n, 2n]>, Shape.clash(accepted))
2434 case 0n <> 3n <> 3n <> 3n <> Nil{}:
2435 Empty.absurd(Facts<4n, [0n, 3n, 3n, 3n]>, Shape.clash(accepted))
2436 case 0n <> 3n <> 3n <> (4n+p) <> Nil{}:
2437 Empty.absurd(Facts<4n, 0n <> 3n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 3n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(0n <> 3n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 3n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2438 case 0n <> 3n <> (4n+p) <> a0 <> Nil{}:
2439 Empty.absurd(Facts<4n, 0n <> 3n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> 3n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(0n <> 3n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> 3n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2440 case 0n <> (4n+p) <> a0 <> a1 <> Nil{}:
2441 Empty.absurd(Facts<4n, 0n <> (4n+p) <> a0 <> a1 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> a1 <> Nil{}, 4n), Arith.and_left(Axis.bounded(0n <> (4n+p) <> a0 <> a1 <> Nil{}, 4n), Axis.unique(0n <> (4n+p) <> a0 <> a1 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 0n <> (4n+p) <> a0 <> a1 <> Nil{}), accepted)))))
2442 case 1n <> 0n <> 0n <> 0n <> Nil{}:
2443 Empty.absurd(Facts<4n, [1n, 0n, 0n, 0n]>, Shape.clash(accepted))
2444 case 1n <> 0n <> 0n <> 1n <> Nil{}:
2445 Empty.absurd(Facts<4n, [1n, 0n, 0n, 1n]>, Shape.clash(accepted))
2446 case 1n <> 0n <> 0n <> 2n <> Nil{}:
2447 Empty.absurd(Facts<4n, [1n, 0n, 0n, 2n]>, Shape.clash(accepted))
2448 case 1n <> 0n <> 0n <> 3n <> Nil{}:
2449 Empty.absurd(Facts<4n, [1n, 0n, 0n, 3n]>, Shape.clash(accepted))
2450 case 1n <> 0n <> 0n <> (4n+p) <> Nil{}:
2451 Empty.absurd(Facts<4n, 1n <> 0n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 0n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 0n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 0n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2452 case 1n <> 0n <> 1n <> 0n <> Nil{}:
2453 Empty.absurd(Facts<4n, [1n, 0n, 1n, 0n]>, Shape.clash(accepted))
2454 case 1n <> 0n <> 1n <> 1n <> Nil{}:
2455 Empty.absurd(Facts<4n, [1n, 0n, 1n, 1n]>, Shape.clash(accepted))
2456 case 1n <> 0n <> 1n <> 2n <> Nil{}:
2457 Empty.absurd(Facts<4n, [1n, 0n, 1n, 2n]>, Shape.clash(accepted))
2458 case 1n <> 0n <> 1n <> 3n <> Nil{}:
2459 Empty.absurd(Facts<4n, [1n, 0n, 1n, 3n]>, Shape.clash(accepted))
2460 case 1n <> 0n <> 1n <> (4n+p) <> Nil{}:
2461 Empty.absurd(Facts<4n, 1n <> 0n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 0n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 0n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 0n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2462 case 1n <> 0n <> 2n <> 0n <> Nil{}:
2463 Empty.absurd(Facts<4n, [1n, 0n, 2n, 0n]>, Shape.clash(accepted))
2464 case 1n <> 0n <> 2n <> 1n <> Nil{}:
2465 Empty.absurd(Facts<4n, [1n, 0n, 2n, 1n]>, Shape.clash(accepted))
2466 case 1n <> 0n <> 2n <> 2n <> Nil{}:
2467 Empty.absurd(Facts<4n, [1n, 0n, 2n, 2n]>, Shape.clash(accepted))
2468 case 1n <> 0n <> 2n <> 3n <> Nil{}:
2469 Certified{{==}, {==}, {==}, A => items => length => lists_1023(A, items, length),
2470 dims => length => product_1023(dims, length), dims => coords => dl => cl => fit_1023(dims, coords, dl, cl)}
2471 case 1n <> 0n <> 2n <> (4n+p) <> Nil{}:
2472 Empty.absurd(Facts<4n, 1n <> 0n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 0n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 0n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 0n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2473 case 1n <> 0n <> 3n <> 0n <> Nil{}:
2474 Empty.absurd(Facts<4n, [1n, 0n, 3n, 0n]>, Shape.clash(accepted))
2475 case 1n <> 0n <> 3n <> 1n <> Nil{}:
2476 Empty.absurd(Facts<4n, [1n, 0n, 3n, 1n]>, Shape.clash(accepted))
2477 case 1n <> 0n <> 3n <> 2n <> Nil{}:
2478 Certified{{==}, {==}, {==}, A => items => length => lists_1032(A, items, length),
2479 dims => length => product_1032(dims, length), dims => coords => dl => cl => fit_1032(dims, coords, dl, cl)}
2480 case 1n <> 0n <> 3n <> 3n <> Nil{}:
2481 Empty.absurd(Facts<4n, [1n, 0n, 3n, 3n]>, Shape.clash(accepted))
2482 case 1n <> 0n <> 3n <> (4n+p) <> Nil{}:
2483 Empty.absurd(Facts<4n, 1n <> 0n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 0n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 0n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 0n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2484 case 1n <> 0n <> (4n+p) <> a0 <> Nil{}:
2485 Empty.absurd(Facts<4n, 1n <> 0n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 0n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(1n <> 0n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 0n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2486 case 1n <> 1n <> 0n <> 0n <> Nil{}:
2487 Empty.absurd(Facts<4n, [1n, 1n, 0n, 0n]>, Shape.clash(accepted))
2488 case 1n <> 1n <> 0n <> 1n <> Nil{}:
2489 Empty.absurd(Facts<4n, [1n, 1n, 0n, 1n]>, Shape.clash(accepted))
2490 case 1n <> 1n <> 0n <> 2n <> Nil{}:
2491 Empty.absurd(Facts<4n, [1n, 1n, 0n, 2n]>, Shape.clash(accepted))
2492 case 1n <> 1n <> 0n <> 3n <> Nil{}:
2493 Empty.absurd(Facts<4n, [1n, 1n, 0n, 3n]>, Shape.clash(accepted))
2494 case 1n <> 1n <> 0n <> (4n+p) <> Nil{}:
2495 Empty.absurd(Facts<4n, 1n <> 1n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 1n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 1n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 1n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2496 case 1n <> 1n <> 1n <> 0n <> Nil{}:
2497 Empty.absurd(Facts<4n, [1n, 1n, 1n, 0n]>, Shape.clash(accepted))
2498 case 1n <> 1n <> 1n <> 1n <> Nil{}:
2499 Empty.absurd(Facts<4n, [1n, 1n, 1n, 1n]>, Shape.clash(accepted))
2500 case 1n <> 1n <> 1n <> 2n <> Nil{}:
2501 Empty.absurd(Facts<4n, [1n, 1n, 1n, 2n]>, Shape.clash(accepted))
2502 case 1n <> 1n <> 1n <> 3n <> Nil{}:
2503 Empty.absurd(Facts<4n, [1n, 1n, 1n, 3n]>, Shape.clash(accepted))
2504 case 1n <> 1n <> 1n <> (4n+p) <> Nil{}:
2505 Empty.absurd(Facts<4n, 1n <> 1n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 1n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 1n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 1n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2506 case 1n <> 1n <> 2n <> 0n <> Nil{}:
2507 Empty.absurd(Facts<4n, [1n, 1n, 2n, 0n]>, Shape.clash(accepted))
2508 case 1n <> 1n <> 2n <> 1n <> Nil{}:
2509 Empty.absurd(Facts<4n, [1n, 1n, 2n, 1n]>, Shape.clash(accepted))
2510 case 1n <> 1n <> 2n <> 2n <> Nil{}:
2511 Empty.absurd(Facts<4n, [1n, 1n, 2n, 2n]>, Shape.clash(accepted))
2512 case 1n <> 1n <> 2n <> 3n <> Nil{}:
2513 Empty.absurd(Facts<4n, [1n, 1n, 2n, 3n]>, Shape.clash(accepted))
2514 case 1n <> 1n <> 2n <> (4n+p) <> Nil{}:
2515 Empty.absurd(Facts<4n, 1n <> 1n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 1n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 1n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 1n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2516 case 1n <> 1n <> 3n <> 0n <> Nil{}:
2517 Empty.absurd(Facts<4n, [1n, 1n, 3n, 0n]>, Shape.clash(accepted))
2518 case 1n <> 1n <> 3n <> 1n <> Nil{}:
2519 Empty.absurd(Facts<4n, [1n, 1n, 3n, 1n]>, Shape.clash(accepted))
2520 case 1n <> 1n <> 3n <> 2n <> Nil{}:
2521 Empty.absurd(Facts<4n, [1n, 1n, 3n, 2n]>, Shape.clash(accepted))
2522 case 1n <> 1n <> 3n <> 3n <> Nil{}:
2523 Empty.absurd(Facts<4n, [1n, 1n, 3n, 3n]>, Shape.clash(accepted))
2524 case 1n <> 1n <> 3n <> (4n+p) <> Nil{}:
2525 Empty.absurd(Facts<4n, 1n <> 1n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 1n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 1n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 1n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2526 case 1n <> 1n <> (4n+p) <> a0 <> Nil{}:
2527 Empty.absurd(Facts<4n, 1n <> 1n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 1n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(1n <> 1n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 1n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2528 case 1n <> 2n <> 0n <> 0n <> Nil{}:
2529 Empty.absurd(Facts<4n, [1n, 2n, 0n, 0n]>, Shape.clash(accepted))
2530 case 1n <> 2n <> 0n <> 1n <> Nil{}:
2531 Empty.absurd(Facts<4n, [1n, 2n, 0n, 1n]>, Shape.clash(accepted))
2532 case 1n <> 2n <> 0n <> 2n <> Nil{}:
2533 Empty.absurd(Facts<4n, [1n, 2n, 0n, 2n]>, Shape.clash(accepted))
2534 case 1n <> 2n <> 0n <> 3n <> Nil{}:
2535 Certified{{==}, {==}, {==}, A => items => length => lists_1203(A, items, length),
2536 dims => length => product_1203(dims, length), dims => coords => dl => cl => fit_1203(dims, coords, dl, cl)}
2537 case 1n <> 2n <> 0n <> (4n+p) <> Nil{}:
2538 Empty.absurd(Facts<4n, 1n <> 2n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 2n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 2n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 2n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2539 case 1n <> 2n <> 1n <> 0n <> Nil{}:
2540 Empty.absurd(Facts<4n, [1n, 2n, 1n, 0n]>, Shape.clash(accepted))
2541 case 1n <> 2n <> 1n <> 1n <> Nil{}:
2542 Empty.absurd(Facts<4n, [1n, 2n, 1n, 1n]>, Shape.clash(accepted))
2543 case 1n <> 2n <> 1n <> 2n <> Nil{}:
2544 Empty.absurd(Facts<4n, [1n, 2n, 1n, 2n]>, Shape.clash(accepted))
2545 case 1n <> 2n <> 1n <> 3n <> Nil{}:
2546 Empty.absurd(Facts<4n, [1n, 2n, 1n, 3n]>, Shape.clash(accepted))
2547 case 1n <> 2n <> 1n <> (4n+p) <> Nil{}:
2548 Empty.absurd(Facts<4n, 1n <> 2n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 2n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 2n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 2n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2549 case 1n <> 2n <> 2n <> 0n <> Nil{}:
2550 Empty.absurd(Facts<4n, [1n, 2n, 2n, 0n]>, Shape.clash(accepted))
2551 case 1n <> 2n <> 2n <> 1n <> Nil{}:
2552 Empty.absurd(Facts<4n, [1n, 2n, 2n, 1n]>, Shape.clash(accepted))
2553 case 1n <> 2n <> 2n <> 2n <> Nil{}:
2554 Empty.absurd(Facts<4n, [1n, 2n, 2n, 2n]>, Shape.clash(accepted))
2555 case 1n <> 2n <> 2n <> 3n <> Nil{}:
2556 Empty.absurd(Facts<4n, [1n, 2n, 2n, 3n]>, Shape.clash(accepted))
2557 case 1n <> 2n <> 2n <> (4n+p) <> Nil{}:
2558 Empty.absurd(Facts<4n, 1n <> 2n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 2n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 2n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 2n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2559 case 1n <> 2n <> 3n <> 0n <> Nil{}:
2560 Certified{{==}, {==}, {==}, A => items => length => lists_1230(A, items, length),
2561 dims => length => product_1230(dims, length), dims => coords => dl => cl => fit_1230(dims, coords, dl, cl)}
2562 case 1n <> 2n <> 3n <> 1n <> Nil{}:
2563 Empty.absurd(Facts<4n, [1n, 2n, 3n, 1n]>, Shape.clash(accepted))
2564 case 1n <> 2n <> 3n <> 2n <> Nil{}:
2565 Empty.absurd(Facts<4n, [1n, 2n, 3n, 2n]>, Shape.clash(accepted))
2566 case 1n <> 2n <> 3n <> 3n <> Nil{}:
2567 Empty.absurd(Facts<4n, [1n, 2n, 3n, 3n]>, Shape.clash(accepted))
2568 case 1n <> 2n <> 3n <> (4n+p) <> Nil{}:
2569 Empty.absurd(Facts<4n, 1n <> 2n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 2n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 2n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 2n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2570 case 1n <> 2n <> (4n+p) <> a0 <> Nil{}:
2571 Empty.absurd(Facts<4n, 1n <> 2n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 2n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(1n <> 2n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 2n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2572 case 1n <> 3n <> 0n <> 0n <> Nil{}:
2573 Empty.absurd(Facts<4n, [1n, 3n, 0n, 0n]>, Shape.clash(accepted))
2574 case 1n <> 3n <> 0n <> 1n <> Nil{}:
2575 Empty.absurd(Facts<4n, [1n, 3n, 0n, 1n]>, Shape.clash(accepted))
2576 case 1n <> 3n <> 0n <> 2n <> Nil{}:
2577 Certified{{==}, {==}, {==}, A => items => length => lists_1302(A, items, length),
2578 dims => length => product_1302(dims, length), dims => coords => dl => cl => fit_1302(dims, coords, dl, cl)}
2579 case 1n <> 3n <> 0n <> 3n <> Nil{}:
2580 Empty.absurd(Facts<4n, [1n, 3n, 0n, 3n]>, Shape.clash(accepted))
2581 case 1n <> 3n <> 0n <> (4n+p) <> Nil{}:
2582 Empty.absurd(Facts<4n, 1n <> 3n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 3n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 3n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 3n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2583 case 1n <> 3n <> 1n <> 0n <> Nil{}:
2584 Empty.absurd(Facts<4n, [1n, 3n, 1n, 0n]>, Shape.clash(accepted))
2585 case 1n <> 3n <> 1n <> 1n <> Nil{}:
2586 Empty.absurd(Facts<4n, [1n, 3n, 1n, 1n]>, Shape.clash(accepted))
2587 case 1n <> 3n <> 1n <> 2n <> Nil{}:
2588 Empty.absurd(Facts<4n, [1n, 3n, 1n, 2n]>, Shape.clash(accepted))
2589 case 1n <> 3n <> 1n <> 3n <> Nil{}:
2590 Empty.absurd(Facts<4n, [1n, 3n, 1n, 3n]>, Shape.clash(accepted))
2591 case 1n <> 3n <> 1n <> (4n+p) <> Nil{}:
2592 Empty.absurd(Facts<4n, 1n <> 3n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 3n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 3n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 3n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2593 case 1n <> 3n <> 2n <> 0n <> Nil{}:
2594 Certified{{==}, {==}, {==}, A => items => length => lists_1320(A, items, length),
2595 dims => length => product_1320(dims, length), dims => coords => dl => cl => fit_1320(dims, coords, dl, cl)}
2596 case 1n <> 3n <> 2n <> 1n <> Nil{}:
2597 Empty.absurd(Facts<4n, [1n, 3n, 2n, 1n]>, Shape.clash(accepted))
2598 case 1n <> 3n <> 2n <> 2n <> Nil{}:
2599 Empty.absurd(Facts<4n, [1n, 3n, 2n, 2n]>, Shape.clash(accepted))
2600 case 1n <> 3n <> 2n <> 3n <> Nil{}:
2601 Empty.absurd(Facts<4n, [1n, 3n, 2n, 3n]>, Shape.clash(accepted))
2602 case 1n <> 3n <> 2n <> (4n+p) <> Nil{}:
2603 Empty.absurd(Facts<4n, 1n <> 3n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 3n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 3n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 3n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2604 case 1n <> 3n <> 3n <> 0n <> Nil{}:
2605 Empty.absurd(Facts<4n, [1n, 3n, 3n, 0n]>, Shape.clash(accepted))
2606 case 1n <> 3n <> 3n <> 1n <> Nil{}:
2607 Empty.absurd(Facts<4n, [1n, 3n, 3n, 1n]>, Shape.clash(accepted))
2608 case 1n <> 3n <> 3n <> 2n <> Nil{}:
2609 Empty.absurd(Facts<4n, [1n, 3n, 3n, 2n]>, Shape.clash(accepted))
2610 case 1n <> 3n <> 3n <> 3n <> Nil{}:
2611 Empty.absurd(Facts<4n, [1n, 3n, 3n, 3n]>, Shape.clash(accepted))
2612 case 1n <> 3n <> 3n <> (4n+p) <> Nil{}:
2613 Empty.absurd(Facts<4n, 1n <> 3n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 3n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(1n <> 3n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 3n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2614 case 1n <> 3n <> (4n+p) <> a0 <> Nil{}:
2615 Empty.absurd(Facts<4n, 1n <> 3n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> 3n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(1n <> 3n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> 3n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2616 case 1n <> (4n+p) <> a0 <> a1 <> Nil{}:
2617 Empty.absurd(Facts<4n, 1n <> (4n+p) <> a0 <> a1 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> a1 <> Nil{}, 4n), Arith.and_left(Axis.bounded(1n <> (4n+p) <> a0 <> a1 <> Nil{}, 4n), Axis.unique(1n <> (4n+p) <> a0 <> a1 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 1n <> (4n+p) <> a0 <> a1 <> Nil{}), accepted)))))
2618 case 2n <> 0n <> 0n <> 0n <> Nil{}:
2619 Empty.absurd(Facts<4n, [2n, 0n, 0n, 0n]>, Shape.clash(accepted))
2620 case 2n <> 0n <> 0n <> 1n <> Nil{}:
2621 Empty.absurd(Facts<4n, [2n, 0n, 0n, 1n]>, Shape.clash(accepted))
2622 case 2n <> 0n <> 0n <> 2n <> Nil{}:
2623 Empty.absurd(Facts<4n, [2n, 0n, 0n, 2n]>, Shape.clash(accepted))
2624 case 2n <> 0n <> 0n <> 3n <> Nil{}:
2625 Empty.absurd(Facts<4n, [2n, 0n, 0n, 3n]>, Shape.clash(accepted))
2626 case 2n <> 0n <> 0n <> (4n+p) <> Nil{}:
2627 Empty.absurd(Facts<4n, 2n <> 0n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 0n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 0n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 0n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2628 case 2n <> 0n <> 1n <> 0n <> Nil{}:
2629 Empty.absurd(Facts<4n, [2n, 0n, 1n, 0n]>, Shape.clash(accepted))
2630 case 2n <> 0n <> 1n <> 1n <> Nil{}:
2631 Empty.absurd(Facts<4n, [2n, 0n, 1n, 1n]>, Shape.clash(accepted))
2632 case 2n <> 0n <> 1n <> 2n <> Nil{}:
2633 Empty.absurd(Facts<4n, [2n, 0n, 1n, 2n]>, Shape.clash(accepted))
2634 case 2n <> 0n <> 1n <> 3n <> Nil{}:
2635 Certified{{==}, {==}, {==}, A => items => length => lists_2013(A, items, length),
2636 dims => length => product_2013(dims, length), dims => coords => dl => cl => fit_2013(dims, coords, dl, cl)}
2637 case 2n <> 0n <> 1n <> (4n+p) <> Nil{}:
2638 Empty.absurd(Facts<4n, 2n <> 0n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 0n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 0n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 0n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2639 case 2n <> 0n <> 2n <> 0n <> Nil{}:
2640 Empty.absurd(Facts<4n, [2n, 0n, 2n, 0n]>, Shape.clash(accepted))
2641 case 2n <> 0n <> 2n <> 1n <> Nil{}:
2642 Empty.absurd(Facts<4n, [2n, 0n, 2n, 1n]>, Shape.clash(accepted))
2643 case 2n <> 0n <> 2n <> 2n <> Nil{}:
2644 Empty.absurd(Facts<4n, [2n, 0n, 2n, 2n]>, Shape.clash(accepted))
2645 case 2n <> 0n <> 2n <> 3n <> Nil{}:
2646 Empty.absurd(Facts<4n, [2n, 0n, 2n, 3n]>, Shape.clash(accepted))
2647 case 2n <> 0n <> 2n <> (4n+p) <> Nil{}:
2648 Empty.absurd(Facts<4n, 2n <> 0n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 0n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 0n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 0n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2649 case 2n <> 0n <> 3n <> 0n <> Nil{}:
2650 Empty.absurd(Facts<4n, [2n, 0n, 3n, 0n]>, Shape.clash(accepted))
2651 case 2n <> 0n <> 3n <> 1n <> Nil{}:
2652 Certified{{==}, {==}, {==}, A => items => length => lists_2031(A, items, length),
2653 dims => length => product_2031(dims, length), dims => coords => dl => cl => fit_2031(dims, coords, dl, cl)}
2654 case 2n <> 0n <> 3n <> 2n <> Nil{}:
2655 Empty.absurd(Facts<4n, [2n, 0n, 3n, 2n]>, Shape.clash(accepted))
2656 case 2n <> 0n <> 3n <> 3n <> Nil{}:
2657 Empty.absurd(Facts<4n, [2n, 0n, 3n, 3n]>, Shape.clash(accepted))
2658 case 2n <> 0n <> 3n <> (4n+p) <> Nil{}:
2659 Empty.absurd(Facts<4n, 2n <> 0n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 0n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 0n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 0n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2660 case 2n <> 0n <> (4n+p) <> a0 <> Nil{}:
2661 Empty.absurd(Facts<4n, 2n <> 0n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 0n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(2n <> 0n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 0n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2662 case 2n <> 1n <> 0n <> 0n <> Nil{}:
2663 Empty.absurd(Facts<4n, [2n, 1n, 0n, 0n]>, Shape.clash(accepted))
2664 case 2n <> 1n <> 0n <> 1n <> Nil{}:
2665 Empty.absurd(Facts<4n, [2n, 1n, 0n, 1n]>, Shape.clash(accepted))
2666 case 2n <> 1n <> 0n <> 2n <> Nil{}:
2667 Empty.absurd(Facts<4n, [2n, 1n, 0n, 2n]>, Shape.clash(accepted))
2668 case 2n <> 1n <> 0n <> 3n <> Nil{}:
2669 Certified{{==}, {==}, {==}, A => items => length => lists_2103(A, items, length),
2670 dims => length => product_2103(dims, length), dims => coords => dl => cl => fit_2103(dims, coords, dl, cl)}
2671 case 2n <> 1n <> 0n <> (4n+p) <> Nil{}:
2672 Empty.absurd(Facts<4n, 2n <> 1n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 1n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 1n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 1n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2673 case 2n <> 1n <> 1n <> 0n <> Nil{}:
2674 Empty.absurd(Facts<4n, [2n, 1n, 1n, 0n]>, Shape.clash(accepted))
2675 case 2n <> 1n <> 1n <> 1n <> Nil{}:
2676 Empty.absurd(Facts<4n, [2n, 1n, 1n, 1n]>, Shape.clash(accepted))
2677 case 2n <> 1n <> 1n <> 2n <> Nil{}:
2678 Empty.absurd(Facts<4n, [2n, 1n, 1n, 2n]>, Shape.clash(accepted))
2679 case 2n <> 1n <> 1n <> 3n <> Nil{}:
2680 Empty.absurd(Facts<4n, [2n, 1n, 1n, 3n]>, Shape.clash(accepted))
2681 case 2n <> 1n <> 1n <> (4n+p) <> Nil{}:
2682 Empty.absurd(Facts<4n, 2n <> 1n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 1n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 1n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 1n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2683 case 2n <> 1n <> 2n <> 0n <> Nil{}:
2684 Empty.absurd(Facts<4n, [2n, 1n, 2n, 0n]>, Shape.clash(accepted))
2685 case 2n <> 1n <> 2n <> 1n <> Nil{}:
2686 Empty.absurd(Facts<4n, [2n, 1n, 2n, 1n]>, Shape.clash(accepted))
2687 case 2n <> 1n <> 2n <> 2n <> Nil{}:
2688 Empty.absurd(Facts<4n, [2n, 1n, 2n, 2n]>, Shape.clash(accepted))
2689 case 2n <> 1n <> 2n <> 3n <> Nil{}:
2690 Empty.absurd(Facts<4n, [2n, 1n, 2n, 3n]>, Shape.clash(accepted))
2691 case 2n <> 1n <> 2n <> (4n+p) <> Nil{}:
2692 Empty.absurd(Facts<4n, 2n <> 1n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 1n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 1n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 1n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2693 case 2n <> 1n <> 3n <> 0n <> Nil{}:
2694 Certified{{==}, {==}, {==}, A => items => length => lists_2130(A, items, length),
2695 dims => length => product_2130(dims, length), dims => coords => dl => cl => fit_2130(dims, coords, dl, cl)}
2696 case 2n <> 1n <> 3n <> 1n <> Nil{}:
2697 Empty.absurd(Facts<4n, [2n, 1n, 3n, 1n]>, Shape.clash(accepted))
2698 case 2n <> 1n <> 3n <> 2n <> Nil{}:
2699 Empty.absurd(Facts<4n, [2n, 1n, 3n, 2n]>, Shape.clash(accepted))
2700 case 2n <> 1n <> 3n <> 3n <> Nil{}:
2701 Empty.absurd(Facts<4n, [2n, 1n, 3n, 3n]>, Shape.clash(accepted))
2702 case 2n <> 1n <> 3n <> (4n+p) <> Nil{}:
2703 Empty.absurd(Facts<4n, 2n <> 1n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 1n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 1n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 1n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2704 case 2n <> 1n <> (4n+p) <> a0 <> Nil{}:
2705 Empty.absurd(Facts<4n, 2n <> 1n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 1n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(2n <> 1n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 1n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2706 case 2n <> 2n <> 0n <> 0n <> Nil{}:
2707 Empty.absurd(Facts<4n, [2n, 2n, 0n, 0n]>, Shape.clash(accepted))
2708 case 2n <> 2n <> 0n <> 1n <> Nil{}:
2709 Empty.absurd(Facts<4n, [2n, 2n, 0n, 1n]>, Shape.clash(accepted))
2710 case 2n <> 2n <> 0n <> 2n <> Nil{}:
2711 Empty.absurd(Facts<4n, [2n, 2n, 0n, 2n]>, Shape.clash(accepted))
2712 case 2n <> 2n <> 0n <> 3n <> Nil{}:
2713 Empty.absurd(Facts<4n, [2n, 2n, 0n, 3n]>, Shape.clash(accepted))
2714 case 2n <> 2n <> 0n <> (4n+p) <> Nil{}:
2715 Empty.absurd(Facts<4n, 2n <> 2n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 2n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 2n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 2n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2716 case 2n <> 2n <> 1n <> 0n <> Nil{}:
2717 Empty.absurd(Facts<4n, [2n, 2n, 1n, 0n]>, Shape.clash(accepted))
2718 case 2n <> 2n <> 1n <> 1n <> Nil{}:
2719 Empty.absurd(Facts<4n, [2n, 2n, 1n, 1n]>, Shape.clash(accepted))
2720 case 2n <> 2n <> 1n <> 2n <> Nil{}:
2721 Empty.absurd(Facts<4n, [2n, 2n, 1n, 2n]>, Shape.clash(accepted))
2722 case 2n <> 2n <> 1n <> 3n <> Nil{}:
2723 Empty.absurd(Facts<4n, [2n, 2n, 1n, 3n]>, Shape.clash(accepted))
2724 case 2n <> 2n <> 1n <> (4n+p) <> Nil{}:
2725 Empty.absurd(Facts<4n, 2n <> 2n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 2n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 2n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 2n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2726 case 2n <> 2n <> 2n <> 0n <> Nil{}:
2727 Empty.absurd(Facts<4n, [2n, 2n, 2n, 0n]>, Shape.clash(accepted))
2728 case 2n <> 2n <> 2n <> 1n <> Nil{}:
2729 Empty.absurd(Facts<4n, [2n, 2n, 2n, 1n]>, Shape.clash(accepted))
2730 case 2n <> 2n <> 2n <> 2n <> Nil{}:
2731 Empty.absurd(Facts<4n, [2n, 2n, 2n, 2n]>, Shape.clash(accepted))
2732 case 2n <> 2n <> 2n <> 3n <> Nil{}:
2733 Empty.absurd(Facts<4n, [2n, 2n, 2n, 3n]>, Shape.clash(accepted))
2734 case 2n <> 2n <> 2n <> (4n+p) <> Nil{}:
2735 Empty.absurd(Facts<4n, 2n <> 2n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 2n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 2n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 2n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2736 case 2n <> 2n <> 3n <> 0n <> Nil{}:
2737 Empty.absurd(Facts<4n, [2n, 2n, 3n, 0n]>, Shape.clash(accepted))
2738 case 2n <> 2n <> 3n <> 1n <> Nil{}:
2739 Empty.absurd(Facts<4n, [2n, 2n, 3n, 1n]>, Shape.clash(accepted))
2740 case 2n <> 2n <> 3n <> 2n <> Nil{}:
2741 Empty.absurd(Facts<4n, [2n, 2n, 3n, 2n]>, Shape.clash(accepted))
2742 case 2n <> 2n <> 3n <> 3n <> Nil{}:
2743 Empty.absurd(Facts<4n, [2n, 2n, 3n, 3n]>, Shape.clash(accepted))
2744 case 2n <> 2n <> 3n <> (4n+p) <> Nil{}:
2745 Empty.absurd(Facts<4n, 2n <> 2n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 2n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 2n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 2n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2746 case 2n <> 2n <> (4n+p) <> a0 <> Nil{}:
2747 Empty.absurd(Facts<4n, 2n <> 2n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 2n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(2n <> 2n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 2n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2748 case 2n <> 3n <> 0n <> 0n <> Nil{}:
2749 Empty.absurd(Facts<4n, [2n, 3n, 0n, 0n]>, Shape.clash(accepted))
2750 case 2n <> 3n <> 0n <> 1n <> Nil{}:
2751 Certified{{==}, {==}, {==}, A => items => length => lists_2301(A, items, length),
2752 dims => length => product_2301(dims, length), dims => coords => dl => cl => fit_2301(dims, coords, dl, cl)}
2753 case 2n <> 3n <> 0n <> 2n <> Nil{}:
2754 Empty.absurd(Facts<4n, [2n, 3n, 0n, 2n]>, Shape.clash(accepted))
2755 case 2n <> 3n <> 0n <> 3n <> Nil{}:
2756 Empty.absurd(Facts<4n, [2n, 3n, 0n, 3n]>, Shape.clash(accepted))
2757 case 2n <> 3n <> 0n <> (4n+p) <> Nil{}:
2758 Empty.absurd(Facts<4n, 2n <> 3n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 3n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 3n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 3n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2759 case 2n <> 3n <> 1n <> 0n <> Nil{}:
2760 Certified{{==}, {==}, {==}, A => items => length => lists_2310(A, items, length),
2761 dims => length => product_2310(dims, length), dims => coords => dl => cl => fit_2310(dims, coords, dl, cl)}
2762 case 2n <> 3n <> 1n <> 1n <> Nil{}:
2763 Empty.absurd(Facts<4n, [2n, 3n, 1n, 1n]>, Shape.clash(accepted))
2764 case 2n <> 3n <> 1n <> 2n <> Nil{}:
2765 Empty.absurd(Facts<4n, [2n, 3n, 1n, 2n]>, Shape.clash(accepted))
2766 case 2n <> 3n <> 1n <> 3n <> Nil{}:
2767 Empty.absurd(Facts<4n, [2n, 3n, 1n, 3n]>, Shape.clash(accepted))
2768 case 2n <> 3n <> 1n <> (4n+p) <> Nil{}:
2769 Empty.absurd(Facts<4n, 2n <> 3n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 3n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 3n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 3n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2770 case 2n <> 3n <> 2n <> 0n <> Nil{}:
2771 Empty.absurd(Facts<4n, [2n, 3n, 2n, 0n]>, Shape.clash(accepted))
2772 case 2n <> 3n <> 2n <> 1n <> Nil{}:
2773 Empty.absurd(Facts<4n, [2n, 3n, 2n, 1n]>, Shape.clash(accepted))
2774 case 2n <> 3n <> 2n <> 2n <> Nil{}:
2775 Empty.absurd(Facts<4n, [2n, 3n, 2n, 2n]>, Shape.clash(accepted))
2776 case 2n <> 3n <> 2n <> 3n <> Nil{}:
2777 Empty.absurd(Facts<4n, [2n, 3n, 2n, 3n]>, Shape.clash(accepted))
2778 case 2n <> 3n <> 2n <> (4n+p) <> Nil{}:
2779 Empty.absurd(Facts<4n, 2n <> 3n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 3n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 3n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 3n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2780 case 2n <> 3n <> 3n <> 0n <> Nil{}:
2781 Empty.absurd(Facts<4n, [2n, 3n, 3n, 0n]>, Shape.clash(accepted))
2782 case 2n <> 3n <> 3n <> 1n <> Nil{}:
2783 Empty.absurd(Facts<4n, [2n, 3n, 3n, 1n]>, Shape.clash(accepted))
2784 case 2n <> 3n <> 3n <> 2n <> Nil{}:
2785 Empty.absurd(Facts<4n, [2n, 3n, 3n, 2n]>, Shape.clash(accepted))
2786 case 2n <> 3n <> 3n <> 3n <> Nil{}:
2787 Empty.absurd(Facts<4n, [2n, 3n, 3n, 3n]>, Shape.clash(accepted))
2788 case 2n <> 3n <> 3n <> (4n+p) <> Nil{}:
2789 Empty.absurd(Facts<4n, 2n <> 3n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 3n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(2n <> 3n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 3n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2790 case 2n <> 3n <> (4n+p) <> a0 <> Nil{}:
2791 Empty.absurd(Facts<4n, 2n <> 3n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> 3n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(2n <> 3n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> 3n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2792 case 2n <> (4n+p) <> a0 <> a1 <> Nil{}:
2793 Empty.absurd(Facts<4n, 2n <> (4n+p) <> a0 <> a1 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> a1 <> Nil{}, 4n), Arith.and_left(Axis.bounded(2n <> (4n+p) <> a0 <> a1 <> Nil{}, 4n), Axis.unique(2n <> (4n+p) <> a0 <> a1 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 2n <> (4n+p) <> a0 <> a1 <> Nil{}), accepted)))))
2794 case 3n <> 0n <> 0n <> 0n <> Nil{}:
2795 Empty.absurd(Facts<4n, [3n, 0n, 0n, 0n]>, Shape.clash(accepted))
2796 case 3n <> 0n <> 0n <> 1n <> Nil{}:
2797 Empty.absurd(Facts<4n, [3n, 0n, 0n, 1n]>, Shape.clash(accepted))
2798 case 3n <> 0n <> 0n <> 2n <> Nil{}:
2799 Empty.absurd(Facts<4n, [3n, 0n, 0n, 2n]>, Shape.clash(accepted))
2800 case 3n <> 0n <> 0n <> 3n <> Nil{}:
2801 Empty.absurd(Facts<4n, [3n, 0n, 0n, 3n]>, Shape.clash(accepted))
2802 case 3n <> 0n <> 0n <> (4n+p) <> Nil{}:
2803 Empty.absurd(Facts<4n, 3n <> 0n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 0n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 0n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 0n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2804 case 3n <> 0n <> 1n <> 0n <> Nil{}:
2805 Empty.absurd(Facts<4n, [3n, 0n, 1n, 0n]>, Shape.clash(accepted))
2806 case 3n <> 0n <> 1n <> 1n <> Nil{}:
2807 Empty.absurd(Facts<4n, [3n, 0n, 1n, 1n]>, Shape.clash(accepted))
2808 case 3n <> 0n <> 1n <> 2n <> Nil{}:
2809 Certified{{==}, {==}, {==}, A => items => length => lists_3012(A, items, length),
2810 dims => length => product_3012(dims, length), dims => coords => dl => cl => fit_3012(dims, coords, dl, cl)}
2811 case 3n <> 0n <> 1n <> 3n <> Nil{}:
2812 Empty.absurd(Facts<4n, [3n, 0n, 1n, 3n]>, Shape.clash(accepted))
2813 case 3n <> 0n <> 1n <> (4n+p) <> Nil{}:
2814 Empty.absurd(Facts<4n, 3n <> 0n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 0n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 0n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 0n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2815 case 3n <> 0n <> 2n <> 0n <> Nil{}:
2816 Empty.absurd(Facts<4n, [3n, 0n, 2n, 0n]>, Shape.clash(accepted))
2817 case 3n <> 0n <> 2n <> 1n <> Nil{}:
2818 Certified{{==}, {==}, {==}, A => items => length => lists_3021(A, items, length),
2819 dims => length => product_3021(dims, length), dims => coords => dl => cl => fit_3021(dims, coords, dl, cl)}
2820 case 3n <> 0n <> 2n <> 2n <> Nil{}:
2821 Empty.absurd(Facts<4n, [3n, 0n, 2n, 2n]>, Shape.clash(accepted))
2822 case 3n <> 0n <> 2n <> 3n <> Nil{}:
2823 Empty.absurd(Facts<4n, [3n, 0n, 2n, 3n]>, Shape.clash(accepted))
2824 case 3n <> 0n <> 2n <> (4n+p) <> Nil{}:
2825 Empty.absurd(Facts<4n, 3n <> 0n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 0n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 0n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 0n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2826 case 3n <> 0n <> 3n <> 0n <> Nil{}:
2827 Empty.absurd(Facts<4n, [3n, 0n, 3n, 0n]>, Shape.clash(accepted))
2828 case 3n <> 0n <> 3n <> 1n <> Nil{}:
2829 Empty.absurd(Facts<4n, [3n, 0n, 3n, 1n]>, Shape.clash(accepted))
2830 case 3n <> 0n <> 3n <> 2n <> Nil{}:
2831 Empty.absurd(Facts<4n, [3n, 0n, 3n, 2n]>, Shape.clash(accepted))
2832 case 3n <> 0n <> 3n <> 3n <> Nil{}:
2833 Empty.absurd(Facts<4n, [3n, 0n, 3n, 3n]>, Shape.clash(accepted))
2834 case 3n <> 0n <> 3n <> (4n+p) <> Nil{}:
2835 Empty.absurd(Facts<4n, 3n <> 0n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 0n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 0n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 0n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2836 case 3n <> 0n <> (4n+p) <> a0 <> Nil{}:
2837 Empty.absurd(Facts<4n, 3n <> 0n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 0n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(3n <> 0n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 0n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2838 case 3n <> 1n <> 0n <> 0n <> Nil{}:
2839 Empty.absurd(Facts<4n, [3n, 1n, 0n, 0n]>, Shape.clash(accepted))
2840 case 3n <> 1n <> 0n <> 1n <> Nil{}:
2841 Empty.absurd(Facts<4n, [3n, 1n, 0n, 1n]>, Shape.clash(accepted))
2842 case 3n <> 1n <> 0n <> 2n <> Nil{}:
2843 Certified{{==}, {==}, {==}, A => items => length => lists_3102(A, items, length),
2844 dims => length => product_3102(dims, length), dims => coords => dl => cl => fit_3102(dims, coords, dl, cl)}
2845 case 3n <> 1n <> 0n <> 3n <> Nil{}:
2846 Empty.absurd(Facts<4n, [3n, 1n, 0n, 3n]>, Shape.clash(accepted))
2847 case 3n <> 1n <> 0n <> (4n+p) <> Nil{}:
2848 Empty.absurd(Facts<4n, 3n <> 1n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 1n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 1n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 1n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2849 case 3n <> 1n <> 1n <> 0n <> Nil{}:
2850 Empty.absurd(Facts<4n, [3n, 1n, 1n, 0n]>, Shape.clash(accepted))
2851 case 3n <> 1n <> 1n <> 1n <> Nil{}:
2852 Empty.absurd(Facts<4n, [3n, 1n, 1n, 1n]>, Shape.clash(accepted))
2853 case 3n <> 1n <> 1n <> 2n <> Nil{}:
2854 Empty.absurd(Facts<4n, [3n, 1n, 1n, 2n]>, Shape.clash(accepted))
2855 case 3n <> 1n <> 1n <> 3n <> Nil{}:
2856 Empty.absurd(Facts<4n, [3n, 1n, 1n, 3n]>, Shape.clash(accepted))
2857 case 3n <> 1n <> 1n <> (4n+p) <> Nil{}:
2858 Empty.absurd(Facts<4n, 3n <> 1n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 1n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 1n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 1n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2859 case 3n <> 1n <> 2n <> 0n <> Nil{}:
2860 Certified{{==}, {==}, {==}, A => items => length => lists_3120(A, items, length),
2861 dims => length => product_3120(dims, length), dims => coords => dl => cl => fit_3120(dims, coords, dl, cl)}
2862 case 3n <> 1n <> 2n <> 1n <> Nil{}:
2863 Empty.absurd(Facts<4n, [3n, 1n, 2n, 1n]>, Shape.clash(accepted))
2864 case 3n <> 1n <> 2n <> 2n <> Nil{}:
2865 Empty.absurd(Facts<4n, [3n, 1n, 2n, 2n]>, Shape.clash(accepted))
2866 case 3n <> 1n <> 2n <> 3n <> Nil{}:
2867 Empty.absurd(Facts<4n, [3n, 1n, 2n, 3n]>, Shape.clash(accepted))
2868 case 3n <> 1n <> 2n <> (4n+p) <> Nil{}:
2869 Empty.absurd(Facts<4n, 3n <> 1n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 1n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 1n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 1n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2870 case 3n <> 1n <> 3n <> 0n <> Nil{}:
2871 Empty.absurd(Facts<4n, [3n, 1n, 3n, 0n]>, Shape.clash(accepted))
2872 case 3n <> 1n <> 3n <> 1n <> Nil{}:
2873 Empty.absurd(Facts<4n, [3n, 1n, 3n, 1n]>, Shape.clash(accepted))
2874 case 3n <> 1n <> 3n <> 2n <> Nil{}:
2875 Empty.absurd(Facts<4n, [3n, 1n, 3n, 2n]>, Shape.clash(accepted))
2876 case 3n <> 1n <> 3n <> 3n <> Nil{}:
2877 Empty.absurd(Facts<4n, [3n, 1n, 3n, 3n]>, Shape.clash(accepted))
2878 case 3n <> 1n <> 3n <> (4n+p) <> Nil{}:
2879 Empty.absurd(Facts<4n, 3n <> 1n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 1n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 1n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 1n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2880 case 3n <> 1n <> (4n+p) <> a0 <> Nil{}:
2881 Empty.absurd(Facts<4n, 3n <> 1n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 1n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(3n <> 1n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 1n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2882 case 3n <> 2n <> 0n <> 0n <> Nil{}:
2883 Empty.absurd(Facts<4n, [3n, 2n, 0n, 0n]>, Shape.clash(accepted))
2884 case 3n <> 2n <> 0n <> 1n <> Nil{}:
2885 Certified{{==}, {==}, {==}, A => items => length => lists_3201(A, items, length),
2886 dims => length => product_3201(dims, length), dims => coords => dl => cl => fit_3201(dims, coords, dl, cl)}
2887 case 3n <> 2n <> 0n <> 2n <> Nil{}:
2888 Empty.absurd(Facts<4n, [3n, 2n, 0n, 2n]>, Shape.clash(accepted))
2889 case 3n <> 2n <> 0n <> 3n <> Nil{}:
2890 Empty.absurd(Facts<4n, [3n, 2n, 0n, 3n]>, Shape.clash(accepted))
2891 case 3n <> 2n <> 0n <> (4n+p) <> Nil{}:
2892 Empty.absurd(Facts<4n, 3n <> 2n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 2n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 2n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 2n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2893 case 3n <> 2n <> 1n <> 0n <> Nil{}:
2894 Certified{{==}, {==}, {==}, A => items => length => lists_3210(A, items, length),
2895 dims => length => product_3210(dims, length), dims => coords => dl => cl => fit_3210(dims, coords, dl, cl)}
2896 case 3n <> 2n <> 1n <> 1n <> Nil{}:
2897 Empty.absurd(Facts<4n, [3n, 2n, 1n, 1n]>, Shape.clash(accepted))
2898 case 3n <> 2n <> 1n <> 2n <> Nil{}:
2899 Empty.absurd(Facts<4n, [3n, 2n, 1n, 2n]>, Shape.clash(accepted))
2900 case 3n <> 2n <> 1n <> 3n <> Nil{}:
2901 Empty.absurd(Facts<4n, [3n, 2n, 1n, 3n]>, Shape.clash(accepted))
2902 case 3n <> 2n <> 1n <> (4n+p) <> Nil{}:
2903 Empty.absurd(Facts<4n, 3n <> 2n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 2n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 2n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 2n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2904 case 3n <> 2n <> 2n <> 0n <> Nil{}:
2905 Empty.absurd(Facts<4n, [3n, 2n, 2n, 0n]>, Shape.clash(accepted))
2906 case 3n <> 2n <> 2n <> 1n <> Nil{}:
2907 Empty.absurd(Facts<4n, [3n, 2n, 2n, 1n]>, Shape.clash(accepted))
2908 case 3n <> 2n <> 2n <> 2n <> Nil{}:
2909 Empty.absurd(Facts<4n, [3n, 2n, 2n, 2n]>, Shape.clash(accepted))
2910 case 3n <> 2n <> 2n <> 3n <> Nil{}:
2911 Empty.absurd(Facts<4n, [3n, 2n, 2n, 3n]>, Shape.clash(accepted))
2912 case 3n <> 2n <> 2n <> (4n+p) <> Nil{}:
2913 Empty.absurd(Facts<4n, 3n <> 2n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 2n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 2n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 2n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2914 case 3n <> 2n <> 3n <> 0n <> Nil{}:
2915 Empty.absurd(Facts<4n, [3n, 2n, 3n, 0n]>, Shape.clash(accepted))
2916 case 3n <> 2n <> 3n <> 1n <> Nil{}:
2917 Empty.absurd(Facts<4n, [3n, 2n, 3n, 1n]>, Shape.clash(accepted))
2918 case 3n <> 2n <> 3n <> 2n <> Nil{}:
2919 Empty.absurd(Facts<4n, [3n, 2n, 3n, 2n]>, Shape.clash(accepted))
2920 case 3n <> 2n <> 3n <> 3n <> Nil{}:
2921 Empty.absurd(Facts<4n, [3n, 2n, 3n, 3n]>, Shape.clash(accepted))
2922 case 3n <> 2n <> 3n <> (4n+p) <> Nil{}:
2923 Empty.absurd(Facts<4n, 3n <> 2n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 2n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 2n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 2n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2924 case 3n <> 2n <> (4n+p) <> a0 <> Nil{}:
2925 Empty.absurd(Facts<4n, 3n <> 2n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 2n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(3n <> 2n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 2n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2926 case 3n <> 3n <> 0n <> 0n <> Nil{}:
2927 Empty.absurd(Facts<4n, [3n, 3n, 0n, 0n]>, Shape.clash(accepted))
2928 case 3n <> 3n <> 0n <> 1n <> Nil{}:
2929 Empty.absurd(Facts<4n, [3n, 3n, 0n, 1n]>, Shape.clash(accepted))
2930 case 3n <> 3n <> 0n <> 2n <> Nil{}:
2931 Empty.absurd(Facts<4n, [3n, 3n, 0n, 2n]>, Shape.clash(accepted))
2932 case 3n <> 3n <> 0n <> 3n <> Nil{}:
2933 Empty.absurd(Facts<4n, [3n, 3n, 0n, 3n]>, Shape.clash(accepted))
2934 case 3n <> 3n <> 0n <> (4n+p) <> Nil{}:
2935 Empty.absurd(Facts<4n, 3n <> 3n <> 0n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 3n <> 0n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 3n <> 0n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 3n <> 0n <> (4n+p) <> Nil{}), accepted)))))
2936 case 3n <> 3n <> 1n <> 0n <> Nil{}:
2937 Empty.absurd(Facts<4n, [3n, 3n, 1n, 0n]>, Shape.clash(accepted))
2938 case 3n <> 3n <> 1n <> 1n <> Nil{}:
2939 Empty.absurd(Facts<4n, [3n, 3n, 1n, 1n]>, Shape.clash(accepted))
2940 case 3n <> 3n <> 1n <> 2n <> Nil{}:
2941 Empty.absurd(Facts<4n, [3n, 3n, 1n, 2n]>, Shape.clash(accepted))
2942 case 3n <> 3n <> 1n <> 3n <> Nil{}:
2943 Empty.absurd(Facts<4n, [3n, 3n, 1n, 3n]>, Shape.clash(accepted))
2944 case 3n <> 3n <> 1n <> (4n+p) <> Nil{}:
2945 Empty.absurd(Facts<4n, 3n <> 3n <> 1n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 3n <> 1n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 3n <> 1n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 3n <> 1n <> (4n+p) <> Nil{}), accepted)))))
2946 case 3n <> 3n <> 2n <> 0n <> Nil{}:
2947 Empty.absurd(Facts<4n, [3n, 3n, 2n, 0n]>, Shape.clash(accepted))
2948 case 3n <> 3n <> 2n <> 1n <> Nil{}:
2949 Empty.absurd(Facts<4n, [3n, 3n, 2n, 1n]>, Shape.clash(accepted))
2950 case 3n <> 3n <> 2n <> 2n <> Nil{}:
2951 Empty.absurd(Facts<4n, [3n, 3n, 2n, 2n]>, Shape.clash(accepted))
2952 case 3n <> 3n <> 2n <> 3n <> Nil{}:
2953 Empty.absurd(Facts<4n, [3n, 3n, 2n, 3n]>, Shape.clash(accepted))
2954 case 3n <> 3n <> 2n <> (4n+p) <> Nil{}:
2955 Empty.absurd(Facts<4n, 3n <> 3n <> 2n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 3n <> 2n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 3n <> 2n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 3n <> 2n <> (4n+p) <> Nil{}), accepted)))))
2956 case 3n <> 3n <> 3n <> 0n <> Nil{}:
2957 Empty.absurd(Facts<4n, [3n, 3n, 3n, 0n]>, Shape.clash(accepted))
2958 case 3n <> 3n <> 3n <> 1n <> Nil{}:
2959 Empty.absurd(Facts<4n, [3n, 3n, 3n, 1n]>, Shape.clash(accepted))
2960 case 3n <> 3n <> 3n <> 2n <> Nil{}:
2961 Empty.absurd(Facts<4n, [3n, 3n, 3n, 2n]>, Shape.clash(accepted))
2962 case 3n <> 3n <> 3n <> 3n <> Nil{}:
2963 Empty.absurd(Facts<4n, [3n, 3n, 3n, 3n]>, Shape.clash(accepted))
2964 case 3n <> 3n <> 3n <> (4n+p) <> Nil{}:
2965 Empty.absurd(Facts<4n, 3n <> 3n <> 3n <> (4n+p) <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 3n <> 3n <> (4n+p) <> Nil{}, 4n), Axis.unique(3n <> 3n <> 3n <> (4n+p) <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 3n <> 3n <> (4n+p) <> Nil{}), accepted)))))
2966 case 3n <> 3n <> (4n+p) <> a0 <> Nil{}:
2967 Empty.absurd(Facts<4n, 3n <> 3n <> (4n+p) <> a0 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> 3n <> (4n+p) <> a0 <> Nil{}, 4n), Axis.unique(3n <> 3n <> (4n+p) <> a0 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> 3n <> (4n+p) <> a0 <> Nil{}), accepted)))))
2968 case 3n <> (4n+p) <> a0 <> a1 <> Nil{}:
2969 Empty.absurd(Facts<4n, 3n <> (4n+p) <> a0 <> a1 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> a1 <> Nil{}, 4n), Arith.and_left(Axis.bounded(3n <> (4n+p) <> a0 <> a1 <> Nil{}, 4n), Axis.unique(3n <> (4n+p) <> a0 <> a1 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, 3n <> (4n+p) <> a0 <> a1 <> Nil{}), accepted)))))
2970 case (4n+p) <> a0 <> a1 <> a2 <> Nil{}:
2971 Empty.absurd(Facts<4n, (4n+p) <> a0 <> a1 <> a2 <> Nil{}>, Arith.lt_zero(p, Arith.and_left(Nat.is_lt(4n+p, 4n), Axis.bounded(a0 <> a1 <> a2 <> Nil{}, 4n), Arith.and_left(Axis.bounded((4n+p) <> a0 <> a1 <> a2 <> Nil{}, 4n), Axis.unique((4n+p) <> a0 <> a1 <> a2 <> Nil{}), Equal.sym(Bool, True{}, Axis.valid(4n, (4n+p) <> a0 <> a1 <> a2 <> Nil{}), accepted)))))
2972 case +a0 <> +a1 <> +a2 <> +a3 <> +a4 <> +tail:
2973 Empty.absurd(Facts<4n, a0 <> a1 <> a2 <> a3 <> a4 <> tail>, Shape.clash(accepted))
2974
2975def facts(+rank: Nat, +axes: List<&2, Nat>, bound: Shape.LE(rank, 4n), accepted: {True{} == Axis.valid(rank, axes) : Bool}) -> Facts<rank, axes>:
2976 match rank:
2977 case 0n:
2978 facts_0(axes, accepted)
2979 case 1n+rankp:
2980 match rankp:
2981 case 0n:
2982 facts_1(axes, accepted)
2983 case 1n+rankpp:
2984 match rankpp:
2985 case 0n:
2986 facts_2(axes, accepted)
2987 case 1n+rankppp:
2988 match rankppp:
2989 case 0n:
2990 facts_3(axes, accepted)
2991 case 1n+rankpppp:
2992 match rankpppp:
2993 case 0n:
2994 facts_4(axes, accepted)
2995 case 1n+rankppppp:
2996 match bound:
2997
2998def facts_lists(-A: Data, -rank: Nat, -axes: List<&2, Nat>, +items: List<&2, A>, length: {List.length(&2, A, items) == rank : Nat}, certificate: Facts<rank, axes>) -> ListFacts<A, rank, axes, items>:
2999 Certified{iv, iselected, irestored, lists, product, fit} = certificate
3000 lists(A, items, length)
3001
3002def facts_product(-rank: Nat, -axes: List<&2, Nat>, +dims: List<&2, Nat>, length: {List.length(&2, Nat, dims) == rank : Nat}, certificate: Facts<rank, axes>) ->
3003 {Shape.numel(Axis.order(Nat, dims, axes)) == Shape.numel(dims) : Nat}:
3004 Certified{iv, iselected, irestored, lists, product, fit} = certificate
3005 product(dims, length)
3006
3007def facts_inverse_valid(-rank: Nat, -axes: List<&2, Nat>, certificate: Facts<rank, axes>) -> {True{} == Axis.valid(rank, Axis.inverse_axes(rank, axes)) : Bool}:
3008 Certified{iv, iselected, irestored, lists, product, fit} = certificate
3009 iv
3010
3011def selected(-A: Data, -rank: Nat, -axes: List<&2, Nat>, -items: List<&2, A>, certificate: ListFacts<A, rank, axes, items>) ->
3012 {Axis.gather(A, items, axes) == Some{Axis.order(A, items, axes)} : Maybe<&2, List<&2, A>>}:
3013 match certificate:
3014 case Lists{selected, ranked, scattered, restored, reverse_restored, scatter_restored}:
3015 selected
3016
3017def ranked(-A: Data, -rank: Nat, -axes: List<&2, Nat>, -items: List<&2, A>, certificate: ListFacts<A, rank, axes, items>) ->
3018 {List.length(&2, A, Axis.order(A, items, axes)) == rank : Nat}:
3019 match certificate:
3020 case Lists{selected, ranked, scattered, restored, reverse_restored, scatter_restored}:
3021 ranked
3022
3023def scattered(-A: Data, -rank: Nat, -axes: List<&2, Nat>, -items: List<&2, A>, certificate: ListFacts<A, rank, axes, items>) ->
3024 {Axis.scatter(A, rank, axes, items, 0n) == Some{Axis.order(A, items, Axis.inverse_axes(rank, axes))} : Maybe<&2, List<&2, A>>}:
3025 match certificate:
3026 case Lists{selected, ranked, scattered, restored, reverse_restored, scatter_restored}:
3027 scattered
3028
3029def restored(-A: Data, -rank: Nat, -axes: List<&2, Nat>, -items: List<&2, A>, certificate: ListFacts<A, rank, axes, items>) ->
3030 {Axis.order(A, Axis.order(A, items, axes), Axis.inverse_axes(rank, axes)) == items : List<&2, A>}:
3031 match certificate:
3032 case Lists{selected, ranked, scattered, restored, reverse_restored, scatter_restored}:
3033 restored
3034
3035def scatter_restored(-A: Data, -rank: Nat, -axes: List<&2, Nat>, -items: List<&2, A>, certificate: ListFacts<A, rank, axes, items>) ->
3036 {Axis.scatter(A, rank, axes, Axis.order(A, items, axes), 0n) == Some{items} : Maybe<&2, List<&2, A>>}:
3037 match certificate:
3038 case Lists{selected, ranked, scattered, restored, reverse_restored, scatter_restored}:
3039 scatter_restored
3040
3041def shape_facts(+shape: Shape.Shape, +axes: List<&2, U32>, accepted: {True{} == Layout.bijective(shape, axes) : Bool}) ->
3042 Facts<Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes)>:
3043 match shape:
3044 case Shape.SShape{+dims, +size, +exact, +rank_bound, +capacity_bound}:
3045 facts(Shape.rank_dimensions(dims), Shape.naturals(axes), rank_bound, valid(Shape.SShape{dims, size, exact, rank_bound, capacity_bound}, axes, accepted))
3046
3047def word_length(+items: List<&2, U32>) -> {List.length(&2, U32, items) == Shape.rank_dimensions(items) : Nat}:
3048 match items:
3049 case Nil{}:
3050 {==}
3051 case head <> +tail:
3052 Equal.cong(Nat, Nat, n => 1n+n, List.length(&2, U32, tail), Shape.rank_dimensions(tail), word_length(tail))
3053
3054def permutation_complete(+shape: Shape.Shape, +axes: List<&2, U32>, accepted: {True{} == Layout.bijective(shape, axes) : Bool}) ->
3055 {Layout.reorder(Shape.dimensions(shape), axes) == Some{Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))} : Maybe<&2, List<&2, U32>>}:
3056 certificate = facts_lists(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), Shape.dimensions(shape), word_length(Shape.dimensions(shape)), shape_facts(shape, axes, accepted))
3057 Equal.trans(Maybe<&2, List<&2, U32>>, Layout.reorder(Shape.dimensions(shape), axes), Axis.gather(U32, Shape.dimensions(shape), Shape.naturals(axes)),
3058 Some{Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))}, reorder(axes, Shape.dimensions(shape)), selected(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), Shape.dimensions(shape), certificate))
3059
3060def permutation_rank(+shape: Shape.Shape, +axes: List<&2, U32>, accepted: {True{} == Layout.bijective(shape, axes) : Bool}) ->
3061 {Shape.rank_dimensions(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))) == Shape.rank_dimensions(Shape.dimensions(shape)) : Nat}:
3062 certificate = facts_lists(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), Shape.dimensions(shape), word_length(Shape.dimensions(shape)), shape_facts(shape, axes, accepted))
3063 Equal.trans(Nat, Shape.rank_dimensions(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))), List.length(&2, U32, Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))),
3064 Shape.rank_dimensions(Shape.dimensions(shape)), Equal.sym(Nat, List.length(&2, U32, Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))),
3065 Shape.rank_dimensions(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))), word_length(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes)))), ranked(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), Shape.dimensions(shape), certificate))
3066
3067def permutation_product(+shape: Shape.Shape, +axes: List<&2, U32>, accepted: {True{} == Layout.bijective(shape, axes) : Bool}) ->
3068 {Shape.logical_numel(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))) == Shape.logical_numel(Shape.dimensions(shape)) : Nat}:
3069 Equal.trans(Nat, Shape.logical_numel(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))),
3070 Shape.numel(Axis.order(Nat, Shape.naturals(Shape.dimensions(shape)), Shape.naturals(axes))), Shape.logical_numel(Shape.dimensions(shape)),
3071 Equal.cong(List<&2, Nat>, Nat, dims => Shape.numel(dims), Shape.naturals(Axis.order(U32, Shape.dimensions(shape), Shape.naturals(axes))),
3072 Axis.order(Nat, Shape.naturals(Shape.dimensions(shape)), Shape.naturals(axes)), order_naturals(Shape.naturals(axes), Shape.dimensions(shape))),
3073 facts_product(Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), Shape.naturals(Shape.dimensions(shape)), Equal.sym(Nat, Shape.rank_dimensions(Shape.dimensions(shape)), List.length(&2, Nat, Shape.naturals(Shape.dimensions(shape))), Shape.rank_naturals(Shape.dimensions(shape))), shape_facts(shape, axes, accepted)))
3074
3075def scatter_complete(+shape: Shape.Shape, +axes: List<&2, U32>, +coords: List<&2, U32>,
3076 accepted: {True{} == Layout.bijective(shape, axes) : Bool}, length: {Shape.rank_dimensions(coords) == Shape.rank_dimensions(Shape.dimensions(shape)) : Nat}) ->
3077 {Layout.inverse_coordinates(Shape.dimensions(shape), axes, coords, 0) ==
3078 Some{Axis.order(U32, coords, Axis.inverse_axes(Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes)))} : Maybe<&2, List<&2, U32>>}:
3079 certificate = facts_lists(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), coords,
3080 Equal.trans(Nat, List.length(&2, U32, coords), Shape.rank_dimensions(coords), Shape.rank_dimensions(Shape.dimensions(shape)), word_length(coords), length), shape_facts(shape, axes, accepted))
3081 Equal.trans(Maybe<&2, List<&2, U32>>, Layout.inverse_coordinates(Shape.dimensions(shape), axes, coords, 0),
3082 Axis.scatter(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), coords, 0n),
3083 Some{Axis.order(U32, coords, Axis.inverse_axes(Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes)))}, inverse_coordinates(shape, axes, coords), scattered(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), coords, certificate))
3084
3085def scatter_gather(+shape: Shape.Shape, +axes: List<&2, U32>, +coords: List<&2, U32>,
3086 accepted: {True{} == Layout.bijective(shape, axes) : Bool}, length: {Shape.rank_dimensions(coords) == Shape.rank_dimensions(Shape.dimensions(shape)) : Nat}) ->
3087 {Layout.inverse_coordinates(Shape.dimensions(shape), axes, Axis.order(U32, coords, Shape.naturals(axes)), 0) == Some{coords} : Maybe<&2, List<&2, U32>>}:
3088 certificate = facts_lists(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), coords,
3089 Equal.trans(Nat, List.length(&2, U32, coords), Shape.rank_dimensions(coords), Shape.rank_dimensions(Shape.dimensions(shape)), word_length(coords), length), shape_facts(shape, axes, accepted))
3090 Equal.trans(Maybe<&2, List<&2, U32>>, Layout.inverse_coordinates(Shape.dimensions(shape), axes, Axis.order(U32, coords, Shape.naturals(axes)), 0),
3091 Axis.scatter(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), Axis.order(U32, coords, Shape.naturals(axes)), 0n), Some{coords},
3092 inverse_coordinates(shape, axes, Axis.order(U32, coords, Shape.naturals(axes))), scatter_restored(U32, Shape.rank_dimensions(Shape.dimensions(shape)), Shape.naturals(axes), coords, certificate))
3093
3094def inverse_valid(+rank: Nat, +axes: List<&2, Nat>, bound: Shape.LE(rank, 4n), accepted: {True{} == Axis.valid(rank, axes) : Bool}) ->
3095 {True{} == Axis.valid(rank, Axis.inverse_axes(rank, axes)) : Bool}:
3096 facts_inverse_valid(rank, axes, facts(rank, axes, bound, accepted))
3097
3098def inverse_composition(-A: Data, +rank: Nat, +axes: List<&2, Nat>, +items: List<&2, A>, bound: Shape.LE(rank, 4n),
3099 accepted: {True{} == Axis.valid(rank, axes) : Bool}, length: {List.length(&2, A, items) == rank : Nat}) ->
3100 {Axis.order(A, Axis.order(A, items, axes), Axis.inverse_axes(rank, axes)) == items : List<&2, A>}:
3101 restored(A, rank, axes, items, facts_lists(A, rank, axes, items, length, facts(rank, axes, bound, accepted)))
3102
3103def inverse_scatter_composition(-A: Data, +rank: Nat, +axes: List<&2, Nat>, +items: List<&2, A>, +bound: Shape.LE(rank, 4n),
3104 +accepted: {True{} == Axis.valid(rank, axes) : Bool}, length: {List.length(&2, A, items) == rank : Nat}) ->
3105 {Axis.scatter(A, rank, Axis.inverse_axes(rank, axes), Axis.order(A, items, Axis.inverse_axes(rank, axes)), 0n) == Some{items} : Maybe<&2, List<&2, A>>}:
3106 scatter_restored(A, rank, Axis.inverse_axes(rank, axes), items,
3107 facts_lists(A, rank, Axis.inverse_axes(rank, axes), items, length, facts(rank, Axis.inverse_axes(rank, axes), bound, inverse_valid(rank, axes, bound, accepted))))