1 import Base 2 import ../shape/core.bend as Shape 3 import ../shape/nat_proofs.bend as Nats 4 import ../shape/broadcast_proofs.bend as Broadcast 5 import ../storage/arith.bend as Arith 6 import ./layout.bend as Layout 7 import ./axis_spec.bend as Axis 8 import ./word_conversion.bend as Conversion 9 10 def 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 21 def 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 33 def 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 45 def 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 51 def 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 58 def 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 65 def 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 73 def 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 82 def 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 99 def 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 110 def 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 121 def 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 131 def 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 137 def 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 145 def 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 150 def 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 155 def 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 177 def 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 186 def 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 192 type 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 200 type 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, 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 209 def 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 215 def 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 226 type 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 229 def lookup_complete_step(-A: Data, -head: A, -tail: List<&2, A>, -index: Nat, rec: Selected) -> Selected tail, 1n+index>: 230 match rec: 231 case Selection{item, exact}: 232 Selection{item, exact} 233 234 def lookup_complete(-A: Data, +items: List<&2, A>, +index: Nat, bound: Shape.LT(index, List.length(&2, A, items))) -> Selected: 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 245 def 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 252 def 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 259 def 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 271 def 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 283 def 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 298 def 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 306 def 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))) 312 def lists_empty(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 0n : Nat}) -> ListFacts: 313 match items: 314 case Nil{}: 315 Lists{{==}, {==}, {==}, {==}, {==}, {==}} 316 case +x0 <> +tail: 317 Empty.absurd(ListFacts tail>, nat_clash(1n+List.length(&2, A, tail), 0n, length, {==})) 318 319 def 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 326 def 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 337 def lists_0(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 1n : Nat}) -> ListFacts: 338 match items: 339 case Nil{}: 340 Empty.absurd(ListFacts, nat_clash(0n, 1n, length, {==})) 341 case +x0 <> Nil{}: 342 Lists{{==}, {==}, {==}, {==}, {==}, {==}} 343 case +x0 <> +x1 <> +tail: 344 Empty.absurd(ListFacts x1 <> tail>, nat_clash(2n+List.length(&2, A, tail), 1n, length, {==})) 345 346 def 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 355 def 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 370 def lists_01(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 2n : Nat}) -> ListFacts: 371 match items: 372 case Nil{}: 373 Empty.absurd(ListFacts, nat_clash(0n, 2n, length, {==})) 374 case +x0 <> Nil{}: 375 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 2n, length, {==})) 376 case +x0 <> +x1 <> Nil{}: 377 Lists{{==}, {==}, {==}, {==}, {==}, {==}} 378 case +x0 <> +x1 <> +x2 <> +tail: 379 Empty.absurd(ListFacts x1 <> x2 <> tail>, nat_clash(3n+List.length(&2, A, tail), 2n, length, {==})) 380 381 def 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 392 def 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 411 def lists_10(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 2n : Nat}) -> ListFacts: 412 match items: 413 case Nil{}: 414 Empty.absurd(ListFacts, nat_clash(0n, 2n, length, {==})) 415 case +x0 <> Nil{}: 416 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 2n, length, {==})) 417 case +x0 <> +x1 <> Nil{}: 418 Lists{{==}, {==}, {==}, {==}, {==}, {==}} 419 case +x0 <> +x1 <> +x2 <> +tail: 420 Empty.absurd(ListFacts x1 <> x2 <> tail>, nat_clash(3n+List.length(&2, A, tail), 2n, length, {==})) 421 422 def 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 433 def 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 452 def lists_012(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts: 453 match items: 454 case Nil{}: 455 Empty.absurd(ListFacts, nat_clash(0n, 3n, length, {==})) 456 case +x0 <> Nil{}: 457 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 3n, length, {==})) 458 case +x0 <> +x1 <> Nil{}: 459 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==})) 464 465 def 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 478 def 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 501 def lists_021(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts: 502 match items: 503 case Nil{}: 504 Empty.absurd(ListFacts, nat_clash(0n, 3n, length, {==})) 505 case +x0 <> Nil{}: 506 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 3n, length, {==})) 507 case +x0 <> +x1 <> Nil{}: 508 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==})) 513 514 def 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 527 def 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 550 def lists_102(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts: 551 match items: 552 case Nil{}: 553 Empty.absurd(ListFacts, nat_clash(0n, 3n, length, {==})) 554 case +x0 <> Nil{}: 555 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 3n, length, {==})) 556 case +x0 <> +x1 <> Nil{}: 557 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==})) 562 563 def 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 576 def 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 599 def lists_120(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts: 600 match items: 601 case Nil{}: 602 Empty.absurd(ListFacts, nat_clash(0n, 3n, length, {==})) 603 case +x0 <> Nil{}: 604 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 3n, length, {==})) 605 case +x0 <> +x1 <> Nil{}: 606 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==})) 611 612 def 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 625 def 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 648 def lists_201(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts: 649 match items: 650 case Nil{}: 651 Empty.absurd(ListFacts, nat_clash(0n, 3n, length, {==})) 652 case +x0 <> Nil{}: 653 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 3n, length, {==})) 654 case +x0 <> +x1 <> Nil{}: 655 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==})) 660 661 def 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 674 def 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 697 def lists_210(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 3n : Nat}) -> ListFacts: 698 match items: 699 case Nil{}: 700 Empty.absurd(ListFacts, nat_clash(0n, 3n, length, {==})) 701 case +x0 <> Nil{}: 702 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 3n, length, {==})) 703 case +x0 <> +x1 <> Nil{}: 704 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> tail>, nat_clash(4n+List.length(&2, A, tail), 3n, length, {==})) 709 710 def 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 723 def 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 746 def lists_0123(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 747 match items: 748 case Nil{}: 749 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 750 case +x0 <> Nil{}: 751 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 752 case +x0 <> +x1 <> Nil{}: 753 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 754 case +x0 <> +x1 <> +x2 <> Nil{}: 755 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 760 761 def 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 776 def 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 803 def lists_0132(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 804 match items: 805 case Nil{}: 806 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 807 case +x0 <> Nil{}: 808 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 809 case +x0 <> +x1 <> Nil{}: 810 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 811 case +x0 <> +x1 <> +x2 <> Nil{}: 812 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 817 818 def 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 833 def 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 860 def lists_0213(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 861 match items: 862 case Nil{}: 863 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 864 case +x0 <> Nil{}: 865 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 866 case +x0 <> +x1 <> Nil{}: 867 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 868 case +x0 <> +x1 <> +x2 <> Nil{}: 869 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 874 875 def 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 890 def 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 917 def lists_0231(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 918 match items: 919 case Nil{}: 920 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 921 case +x0 <> Nil{}: 922 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 923 case +x0 <> +x1 <> Nil{}: 924 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 925 case +x0 <> +x1 <> +x2 <> Nil{}: 926 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 931 932 def 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 947 def 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 974 def lists_0312(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 975 match items: 976 case Nil{}: 977 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 978 case +x0 <> Nil{}: 979 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 980 case +x0 <> +x1 <> Nil{}: 981 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 982 case +x0 <> +x1 <> +x2 <> Nil{}: 983 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 988 989 def 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 1004 def 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 1031 def lists_0321(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1032 match items: 1033 case Nil{}: 1034 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1035 case +x0 <> Nil{}: 1036 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1037 case +x0 <> +x1 <> Nil{}: 1038 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1039 case +x0 <> +x1 <> +x2 <> Nil{}: 1040 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1045 1046 def 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 1061 def 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), 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 1088 def lists_1023(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1089 match items: 1090 case Nil{}: 1091 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1092 case +x0 <> Nil{}: 1093 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1094 case +x0 <> +x1 <> Nil{}: 1095 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1096 case +x0 <> +x1 <> +x2 <> Nil{}: 1097 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1102 1103 def 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 1118 def 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 1145 def lists_1032(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1146 match items: 1147 case Nil{}: 1148 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1149 case +x0 <> Nil{}: 1150 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1151 case +x0 <> +x1 <> Nil{}: 1152 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1153 case +x0 <> +x1 <> +x2 <> Nil{}: 1154 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1159 1160 def 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 1175 def 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 1202 def lists_1203(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1203 match items: 1204 case Nil{}: 1205 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1206 case +x0 <> Nil{}: 1207 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1208 case +x0 <> +x1 <> Nil{}: 1209 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1210 case +x0 <> +x1 <> +x2 <> Nil{}: 1211 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1216 1217 def 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 1232 def 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 1259 def lists_1230(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1260 match items: 1261 case Nil{}: 1262 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1263 case +x0 <> Nil{}: 1264 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1265 case +x0 <> +x1 <> Nil{}: 1266 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1267 case +x0 <> +x1 <> +x2 <> Nil{}: 1268 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1273 1274 def 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 1289 def 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 1316 def lists_1302(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1317 match items: 1318 case Nil{}: 1319 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1320 case +x0 <> Nil{}: 1321 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1322 case +x0 <> +x1 <> Nil{}: 1323 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1324 case +x0 <> +x1 <> +x2 <> Nil{}: 1325 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1330 1331 def 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 1346 def 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 1373 def lists_1320(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1374 match items: 1375 case Nil{}: 1376 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1377 case +x0 <> Nil{}: 1378 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1379 case +x0 <> +x1 <> Nil{}: 1380 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1381 case +x0 <> +x1 <> +x2 <> Nil{}: 1382 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1387 1388 def 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 1403 def 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), Bo 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 1430 def lists_2013(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1431 match items: 1432 case Nil{}: 1433 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1434 case +x0 <> Nil{}: 1435 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1436 case +x0 <> +x1 <> Nil{}: 1437 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1438 case +x0 <> +x1 <> +x2 <> Nil{}: 1439 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1444 1445 def 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 1460 def 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 1487 def lists_2031(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1488 match items: 1489 case Nil{}: 1490 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1491 case +x0 <> Nil{}: 1492 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1493 case +x0 <> +x1 <> Nil{}: 1494 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1495 case +x0 <> +x1 <> +x2 <> Nil{}: 1496 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1501 1502 def 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 1517 def 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 1544 def lists_2103(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1545 match items: 1546 case Nil{}: 1547 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1548 case +x0 <> Nil{}: 1549 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1550 case +x0 <> +x1 <> Nil{}: 1551 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1552 case +x0 <> +x1 <> +x2 <> Nil{}: 1553 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1558 1559 def 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 1574 def 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 1601 def lists_2130(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1602 match items: 1603 case Nil{}: 1604 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1605 case +x0 <> Nil{}: 1606 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1607 case +x0 <> +x1 <> Nil{}: 1608 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1609 case +x0 <> +x1 <> +x2 <> Nil{}: 1610 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1615 1616 def 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 1631 def 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), Bo 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 1658 def lists_2301(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1659 match items: 1660 case Nil{}: 1661 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1662 case +x0 <> Nil{}: 1663 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1664 case +x0 <> +x1 <> Nil{}: 1665 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1666 case +x0 <> +x1 <> +x2 <> Nil{}: 1667 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1672 1673 def 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 1688 def 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), Bo 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 1715 def lists_2310(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1716 match items: 1717 case Nil{}: 1718 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1719 case +x0 <> Nil{}: 1720 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1721 case +x0 <> +x1 <> Nil{}: 1722 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1723 case +x0 <> +x1 <> +x2 <> Nil{}: 1724 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1729 1730 def 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 1745 def 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), Bo 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 1772 def lists_3012(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1773 match items: 1774 case Nil{}: 1775 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1776 case +x0 <> Nil{}: 1777 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1778 case +x0 <> +x1 <> Nil{}: 1779 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1780 case +x0 <> +x1 <> +x2 <> Nil{}: 1781 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1786 1787 def 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 1802 def 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 1829 def lists_3021(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1830 match items: 1831 case Nil{}: 1832 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1833 case +x0 <> Nil{}: 1834 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1835 case +x0 <> +x1 <> Nil{}: 1836 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1837 case +x0 <> +x1 <> +x2 <> Nil{}: 1838 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1843 1844 def 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 1859 def 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), Bo 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 1886 def lists_3102(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1887 match items: 1888 case Nil{}: 1889 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1890 case +x0 <> Nil{}: 1891 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1892 case +x0 <> +x1 <> Nil{}: 1893 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1894 case +x0 <> +x1 <> +x2 <> Nil{}: 1895 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1900 1901 def 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 1916 def 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, 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 1943 def lists_3120(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: 1944 match items: 1945 case Nil{}: 1946 Empty.absurd(ListFacts, nat_clash(0n, 4n, length, {==})) 1947 case +x0 <> Nil{}: 1948 Empty.absurd(ListFacts Nil{}>, nat_clash(1n, 4n, length, {==})) 1949 case +x0 <> +x1 <> Nil{}: 1950 Empty.absurd(ListFacts x1 <> Nil{}>, nat_clash(2n, 4n, length, {==})) 1951 case +x0 <> +x1 <> +x2 <> Nil{}: 1952 Empty.absurd(ListFacts 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 x1 <> x2 <> x3 <> x4 <> tail>, nat_clash(5n+List.length(&2, A, tail), 4n, length, {==})) 1957 1958 def 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 1973 def 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), Bo 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 2000 def lists_3201(-A: Data, +items: List<&2, A>, length: {List.length(&2, A, items) == 4n : Nat}) -> ListFacts: Lines 1-2000 of 3107. More: https://jend.leeeet.dev/read.txt?path=bendtorch-core@0.1.0.0/src/tensor/axis_algebra.bend&start_line=2001