url stringclasses 147 values | commit stringclasses 147 values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | case zero => {
rewrite [H] at LE;
simp at LE;
rewrite [LE];
simp;
} | x y n : ℕ
LE : x ≤ pred n
H : n = zero
⊢ x * y ≤ zero * y - y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
LE : x ≤ pred n
H : n = zero
⊢ x * y ≤ zero * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | case succ n' => {
simp at LE;
rewrite [H] at LE;
simp at LE;
sorry; } | x y n : ℕ
LE : x ≤ pred n
n' : ℕ
H : n = succ n'
⊢ x * y ≤ succ n' * y - y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
LE : x ≤ pred n
n' : ℕ
H : n = succ n'
⊢ x * y ≤ succ n' * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | rewrite [H] at LE | x y n : ℕ
LE : x ≤ pred n
H : n = zero
⊢ x * y ≤ zero * y - y | x y n : ℕ
LE : x ≤ pred zero
H : n = zero
⊢ x * y ≤ zero * y - y | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
LE : x ≤ pred n
H : n = zero
⊢ x * y ≤ zero * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | simp at LE | x y n : ℕ
LE : x ≤ pred zero
H : n = zero
⊢ x * y ≤ zero * y - y | x y n : ℕ
H : n = zero
LE : x = 0
⊢ x * y ≤ zero * y - y | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
LE : x ≤ pred zero
H : n = zero
⊢ x * y ≤ zero * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | rewrite [LE] | x y n : ℕ
H : n = zero
LE : x = 0
⊢ x * y ≤ zero * y - y | x y n : ℕ
H : n = zero
LE : x = 0
⊢ 0 * y ≤ zero * y - y | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
H : n = zero
LE : x = 0
⊢ x * y ≤ zero * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | simp | x y n : ℕ
H : n = zero
LE : x = 0
⊢ 0 * y ≤ zero * y - y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
H : n = zero
LE : x = 0
⊢ 0 * y ≤ zero * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | rewrite [H] at LE | x y n : ℕ
LE : x ≤ pred n
n' : ℕ
H : n = succ n'
⊢ x * y ≤ succ n' * y - y | x y n n' : ℕ
LE : x ≤ pred (succ n')
H : n = succ n'
⊢ x * y ≤ succ n' * y - y | Please generate a tactic in lean4 to solve the state.
STATE:
x y n : ℕ
LE : x ≤ pred n
n' : ℕ
H : n = succ n'
⊢ x * y ≤ succ n' * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | simp at LE | x y n n' : ℕ
LE : x ≤ pred (succ n')
H : n = succ n'
⊢ x * y ≤ succ n' * y - y | x y n n' : ℕ
LE : x ≤ n'
H : n = succ n'
⊢ x * y ≤ succ n' * y - y | Please generate a tactic in lean4 to solve the state.
STATE:
x y n n' : ℕ
LE : x ≤ pred (succ n')
H : n = succ n'
⊢ x * y ≤ succ n' * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.le_mul_pred | [596, 1] | [610, 2] | sorry | x y n n' : ℕ
LE : x ≤ n'
H : n = succ n'
⊢ x * y ≤ succ n' * y - y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y n n' : ℕ
LE : x ≤ n'
H : n = succ n'
⊢ x * y ≤ succ n' * y - y
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.NonEmpty.empty_absurd | [654, 1] | [656, 2] | cases CONTRA | α : Type
CONTRA : NonEmpty []
⊢ False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
CONTRA : NonEmpty []
⊢ False
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | TensorIndex'.empty_dims_is_empty | [659, 1] | [661, 2] | cases index | index : TensorIndex' []
⊢ index = Empty | case Empty
⊢ Empty = Empty | Please generate a tactic in lean4 to solve the state.
STATE:
index : TensorIndex' []
⊢ index = Empty
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | TensorIndex'.empty_dims_is_empty | [659, 1] | [661, 2] | simp | case Empty
⊢ Empty = Empty | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Empty
⊢ Empty = Empty
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | intros a b | ⊢ ∀ (a b : ℕ), a < b ↔ b > a | a b : ℕ
⊢ a < b ↔ b > a | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (a b : ℕ), a < b ↔ b > a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | constructor | a b : ℕ
⊢ a < b ↔ b > a | case mp
a b : ℕ
⊢ a < b → b > a
case mpr
a b : ℕ
⊢ b > a → a < b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
⊢ a < b ↔ b > a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | case mp => {
intros A_LT_B;
simp [GT.gt]; exact A_LT_B;
} | a b : ℕ
⊢ a < b → b > a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
⊢ a < b → b > a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | case mpr => {
intros B_GT_A;
simp [GT.gt] at B_GT_A;
exact B_GT_A;
} | a b : ℕ
⊢ b > a → a < b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
⊢ b > a → a < b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | intros A_LT_B | a b : ℕ
⊢ a < b → b > a | a b : ℕ
A_LT_B : a < b
⊢ b > a | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
⊢ a < b → b > a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | simp [GT.gt] | a b : ℕ
A_LT_B : a < b
⊢ b > a | a b : ℕ
A_LT_B : a < b
⊢ a < b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
A_LT_B : a < b
⊢ b > a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | exact A_LT_B | a b : ℕ
A_LT_B : a < b
⊢ a < b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
A_LT_B : a < b
⊢ a < b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | intros B_GT_A | a b : ℕ
⊢ b > a → a < b | a b : ℕ
B_GT_A : b > a
⊢ a < b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
⊢ b > a → a < b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | simp [GT.gt] at B_GT_A | a b : ℕ
B_GT_A : b > a
⊢ a < b | a b : ℕ
B_GT_A : a < b
⊢ a < b | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
B_GT_A : b > a
⊢ a < b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.lt_iff_gt | [671, 1] | [682, 2] | exact B_GT_A | a b : ℕ
B_GT_A : a < b
⊢ a < b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : ℕ
B_GT_A : a < b
⊢ a < b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | shapeProd_cons_prod | [719, 1] | [721, 2] | simp [Nat.mul_assoc] | x y : ℕ
zs : List ℕ
⊢ shapeProd (x :: y :: zs) = shapeProd (x * y :: zs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x y : ℕ
zs : List ℕ
⊢ shapeProd (x :: y :: zs) = shapeProd (x * y :: zs)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | intros a | ⊢ ∀ (a b : ℕ), a ≠ 0 → b ≠ 0 → a * b ≠ 0 | a : ℕ
⊢ ∀ (b : ℕ), a ≠ 0 → b ≠ 0 → a * b ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (a b : ℕ), a ≠ 0 → b ≠ 0 → a * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | induction a | a : ℕ
⊢ ∀ (b : ℕ), a ≠ 0 → b ≠ 0 → a * b ≠ 0 | case zero
⊢ ∀ (b : ℕ), zero ≠ 0 → b ≠ 0 → zero * b ≠ 0
case succ
n✝ : ℕ
n_ih✝ : ∀ (b : ℕ), n✝ ≠ 0 → b ≠ 0 → n✝ * b ≠ 0
⊢ ∀ (b : ℕ), succ n✝ ≠ 0 → b ≠ 0 → succ n✝ * b ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a : ℕ
⊢ ∀ (b : ℕ), a ≠ 0 → b ≠ 0 → a * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | case zero => {
intros b A_NEQ_ZERO; simp [A_NEQ_ZERO]; contradiction;
} | ⊢ ∀ (b : ℕ), zero ≠ 0 → b ≠ 0 → zero * b ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (b : ℕ), zero ≠ 0 → b ≠ 0 → zero * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | case succ a' IH => {
intros b;
induction b;
case zero => {
intros A B;
simp at B;
}
case succ b' IH' => {
intros A B;
simp [Nat.mul];
}
} | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ ∀ (b : ℕ), succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ ∀ (b : ℕ), succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | intros b A_NEQ_ZERO | ⊢ ∀ (b : ℕ), zero ≠ 0 → b ≠ 0 → zero * b ≠ 0 | b : ℕ
A_NEQ_ZERO : zero ≠ 0
⊢ b ≠ 0 → zero * b ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ ∀ (b : ℕ), zero ≠ 0 → b ≠ 0 → zero * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | simp [A_NEQ_ZERO] | b : ℕ
A_NEQ_ZERO : zero ≠ 0
⊢ b ≠ 0 → zero * b ≠ 0 | b : ℕ
A_NEQ_ZERO : zero ≠ 0
⊢ 0 < b → False | Please generate a tactic in lean4 to solve the state.
STATE:
b : ℕ
A_NEQ_ZERO : zero ≠ 0
⊢ b ≠ 0 → zero * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | contradiction | b : ℕ
A_NEQ_ZERO : zero ≠ 0
⊢ 0 < b → False | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
b : ℕ
A_NEQ_ZERO : zero ≠ 0
⊢ 0 < b → False
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | intros b | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ ∀ (b : ℕ), succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0 | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b : ℕ
⊢ succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ ∀ (b : ℕ), succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | induction b | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b : ℕ
⊢ succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0 | case zero
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ succ a' ≠ 0 → zero ≠ 0 → succ a' * zero ≠ 0
case succ
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
n✝ : ℕ
n_ih✝ : succ a' ≠ 0 → n✝ ≠ 0 → succ a' * n✝ ≠ 0
⊢ succ a' ≠ 0 → succ n✝ ≠ 0 → succ a' * succ n✝ ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b : ℕ
⊢ succ a' ≠ 0 → b ≠ 0 → succ a' * b ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | case zero => {
intros A B;
simp at B;
} | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ succ a' ≠ 0 → zero ≠ 0 → succ a' * zero ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ succ a' ≠ 0 → zero ≠ 0 → succ a' * zero ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | case succ b' IH' => {
intros A B;
simp [Nat.mul];
} | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
⊢ succ a' ≠ 0 → succ b' ≠ 0 → succ a' * succ b' ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
⊢ succ a' ≠ 0 → succ b' ≠ 0 → succ a' * succ b' ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | intros A B | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ succ a' ≠ 0 → zero ≠ 0 → succ a' * zero ≠ 0 | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
A : succ a' ≠ 0
B : zero ≠ 0
⊢ succ a' * zero ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
⊢ succ a' ≠ 0 → zero ≠ 0 → succ a' * zero ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | simp at B | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
A : succ a' ≠ 0
B : zero ≠ 0
⊢ succ a' * zero ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
A : succ a' ≠ 0
B : zero ≠ 0
⊢ succ a' * zero ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | intros A B | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
⊢ succ a' ≠ 0 → succ b' ≠ 0 → succ a' * succ b' ≠ 0 | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
A : succ a' ≠ 0
B : succ b' ≠ 0
⊢ succ a' * succ b' ≠ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
⊢ succ a' ≠ 0 → succ b' ≠ 0 → succ a' * succ b' ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Nat.mul_of_nonzero_is_nonzero | [728, 1] | [747, 2] | simp [Nat.mul] | a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
A : succ a' ≠ 0
B : succ b' ≠ 0
⊢ succ a' * succ b' ≠ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a' : ℕ
IH : ∀ (b : ℕ), a' ≠ 0 → b ≠ 0 → a' * b ≠ 0
b' : ℕ
IH' : succ a' ≠ 0 → b' ≠ 0 → succ a' * b' ≠ 0
A : succ a' ≠ 0
B : succ b' ≠ 0
⊢ succ a' * succ b' ≠ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | induction xs | α : Type u_1
xs : List α
⊢ ∀ (ix bound : ℕ) (H : ix + List.length xs = bound), List.length xs = List.length (zipFlatIndexGo xs ix bound H) | case nil
α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + List.length [] = bound), List.length [] = List.length (zipFlatIndexGo [] ix bound H)
case cons
α : Type u_1
head✝ : α
tail✝ : List α
tail_ih✝ :
∀ (ix bound : ℕ) (H : ix + List.length tail✝ = bound),
List.length tail✝ = List.length (zipFlatIndexGo tail✝ ix bound H)
⊢ ∀ (ix bound : ℕ) (H : ix + List.length (head✝ :: tail✝) = bound),
List.length (head✝ :: tail✝) = List.length (zipFlatIndexGo (head✝ :: tail✝) ix bound H) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ ∀ (ix bound : ℕ) (H : ix + List.length xs = bound), List.length xs = List.length (zipFlatIndexGo xs ix bound H)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | case nil => {
intros; unfold zipFlatIndexGo; rfl;
} | α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + List.length [] = bound), List.length [] = List.length (zipFlatIndexGo [] ix bound H) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + List.length [] = bound), List.length [] = List.length (zipFlatIndexGo [] ix bound H)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | case cons x xs' IND => {
intros ix bound H;
simp [zipFlatIndexGo];
apply IND;
} | α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
⊢ ∀ (ix bound : ℕ) (H : ix + List.length (x :: xs') = bound),
List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
⊢ ∀ (ix bound : ℕ) (H : ix + List.length (x :: xs') = bound),
List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | intros | α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + List.length [] = bound), List.length [] = List.length (zipFlatIndexGo [] ix bound H) | α : Type u_1
ix✝ bound✝ : ℕ
H✝ : ix✝ + List.length [] = bound✝
⊢ List.length [] = List.length (zipFlatIndexGo [] ix✝ bound✝ H✝) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + List.length [] = bound), List.length [] = List.length (zipFlatIndexGo [] ix bound H)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | unfold zipFlatIndexGo | α : Type u_1
ix✝ bound✝ : ℕ
H✝ : ix✝ + List.length [] = bound✝
⊢ List.length [] = List.length (zipFlatIndexGo [] ix✝ bound✝ H✝) | α : Type u_1
ix✝ bound✝ : ℕ
H✝ : ix✝ + List.length [] = bound✝
⊢ List.length [] = List.length [] | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
ix✝ bound✝ : ℕ
H✝ : ix✝ + List.length [] = bound✝
⊢ List.length [] = List.length (zipFlatIndexGo [] ix✝ bound✝ H✝)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | rfl | α : Type u_1
ix✝ bound✝ : ℕ
H✝ : ix✝ + List.length [] = bound✝
⊢ List.length [] = List.length [] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
ix✝ bound✝ : ℕ
H✝ : ix✝ + List.length [] = bound✝
⊢ List.length [] = List.length []
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | intros ix bound H | α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
⊢ ∀ (ix bound : ℕ) (H : ix + List.length (x :: xs') = bound),
List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H) | α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
ix bound : ℕ
H : ix + List.length (x :: xs') = bound
⊢ List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
⊢ ∀ (ix bound : ℕ) (H : ix + List.length (x :: xs') = bound),
List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | simp [zipFlatIndexGo] | α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
ix bound : ℕ
H : ix + List.length (x :: xs') = bound
⊢ List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H) | α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
ix bound : ℕ
H : ix + List.length (x :: xs') = bound
⊢ List.length xs' = List.length (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + List.length xs' = bound)) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
ix bound : ℕ
H : ix + List.length (x :: xs') = bound
⊢ List.length (x :: xs') = List.length (zipFlatIndexGo (x :: xs') ix bound H)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | zip_flat_index_go_length | [777, 1] | [788, 2] | apply IND | α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
ix bound : ℕ
H : ix + List.length (x :: xs') = bound
⊢ List.length xs' = List.length (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + List.length xs' = bound)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND : ∀ (ix bound : ℕ) (H : ix + List.length xs' = bound), List.length xs' = List.length (zipFlatIndexGo xs' ix bound H)
ix bound : ℕ
H : ix + List.length (x :: xs') = bound
⊢ List.length xs' = List.length (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + List.length xs' = bound))
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | rewrite [<- H] | α : Type ?u.95188
xs : List α
ix bound : ℕ
H : ix + length xs = bound
deltaIx : ℕ
GETIX : deltaIx < length xs
⊢ ix + deltaIx < bound | α : Type ?u.95188
xs : List α
ix bound : ℕ
H : ix + length xs = bound
deltaIx : ℕ
GETIX : deltaIx < length xs
⊢ ix + deltaIx < ix + length xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type ?u.95188
xs : List α
ix bound : ℕ
H : ix + length xs = bound
deltaIx : ℕ
GETIX : deltaIx < length xs
⊢ ix + deltaIx < bound
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp [Nat.add_lt_add_left, GETIX] | α : Type ?u.95188
xs : List α
ix bound : ℕ
H : ix + length xs = bound
deltaIx : ℕ
GETIX : deltaIx < length xs
⊢ ix + deltaIx < ix + length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type ?u.95188
xs : List α
ix bound : ℕ
H : ix + length xs = bound
deltaIx : ℕ
GETIX : deltaIx < length xs
⊢ ix + deltaIx < ix + length xs
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | intros xs | α : Type u_1
⊢ ∀ (xs : List α) (ix bound : ℕ) (H : ix + length xs = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs),
getF (zipFlatIndexGo xs ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs ix bound H)) =
(getF xs deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | α : Type u_1
xs : List α
⊢ ∀ (ix bound : ℕ) (H : ix + length xs = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs),
getF (zipFlatIndexGo xs ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs ix bound H)) =
(getF xs deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (xs : List α) (ix bound : ℕ) (H : ix + length xs = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs),
getF (zipFlatIndexGo xs ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs ix bound H)) =
(getF xs deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | induction xs | α : Type u_1
xs : List α
⊢ ∀ (ix bound : ℕ) (H : ix + length xs = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs),
getF (zipFlatIndexGo xs ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs ix bound H)) =
(getF xs deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | case nil
α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + length [] = bound) (deltaIx : ℕ) (GETIX : deltaIx < length []),
getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
case cons
α : Type u_1
head✝ : α
tail✝ : List α
tail_ih✝ :
∀ (ix bound : ℕ) (H : ix + length tail✝ = bound) (deltaIx : ℕ) (GETIX : deltaIx < length tail✝),
getF (zipFlatIndexGo tail✝ ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo tail✝ ix bound H)) =
(getF tail✝ deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
⊢ ∀ (ix bound : ℕ) (H : ix + length (head✝ :: tail✝) = bound) (deltaIx : ℕ) (GETIX : deltaIx < length (head✝ :: tail✝)),
getF (zipFlatIndexGo (head✝ :: tail✝) ix bound H) deltaIx
(_ : deltaIx < length (zipFlatIndexGo (head✝ :: tail✝) ix bound H)) =
(getF (head✝ :: tail✝) deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ ∀ (ix bound : ℕ) (H : ix + length xs = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs),
getF (zipFlatIndexGo xs ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs ix bound H)) =
(getF xs deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | case nil => {
intros ix bound H deltaIx GETIX;
simp [List.length, Nat.not_lt_zero] at GETIX;
} | α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + length [] = bound) (deltaIx : ℕ) (GETIX : deltaIx < length []),
getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + length [] = bound) (deltaIx : ℕ) (GETIX : deltaIx < length []),
getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | case cons x xs' IND => {
intros ix bound H deltaIx GETIX; cases deltaIx;
case zero => {
simp;
simp [zipFlatIndexGo, List.getF]
}
case succ deltaIx' => {
simp [zipFlatIndexGo];
simp [List.getF];
rewrite [IND];
simp [Nat.add_assoc, Nat.add_one, Nat.succ_add, Nat.add_succ];
simp at GETIX;
apply Nat.lt_of_succ_lt_succ;
exact GETIX;
}
} | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
⊢ ∀ (ix bound : ℕ) (H : ix + length (x :: xs') = bound) (deltaIx : ℕ) (GETIX : deltaIx < length (x :: xs')),
getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
⊢ ∀ (ix bound : ℕ) (H : ix + length (x :: xs') = bound) (deltaIx : ℕ) (GETIX : deltaIx < length (x :: xs')),
getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | intros ix bound H deltaIx GETIX | α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + length [] = bound) (deltaIx : ℕ) (GETIX : deltaIx < length []),
getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | α : Type u_1
ix bound : ℕ
H : ix + length [] = bound
deltaIx : ℕ
GETIX : deltaIx < length []
⊢ getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
⊢ ∀ (ix bound : ℕ) (H : ix + length [] = bound) (deltaIx : ℕ) (GETIX : deltaIx < length []),
getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp [List.length, Nat.not_lt_zero] at GETIX | α : Type u_1
ix bound : ℕ
H : ix + length [] = bound
deltaIx : ℕ
GETIX : deltaIx < length []
⊢ getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
ix bound : ℕ
H : ix + length [] = bound
deltaIx : ℕ
GETIX : deltaIx < length []
⊢ getF (zipFlatIndexGo [] ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo [] ix bound H)) =
(getF [] deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | intros ix bound H deltaIx GETIX | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
⊢ ∀ (ix bound : ℕ) (H : ix + length (x :: xs') = bound) (deltaIx : ℕ) (GETIX : deltaIx < length (x :: xs')),
getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx : ℕ
GETIX : deltaIx < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
⊢ ∀ (ix bound : ℕ) (H : ix + length (x :: xs') = bound) (deltaIx : ℕ) (GETIX : deltaIx < length (x :: xs')),
getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | cases deltaIx | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx : ℕ
GETIX : deltaIx < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) }) | case zero
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) Nat.zero (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') Nat.zero GETIX, { ix := ix + Nat.zero, h_ix_inbound := (_ : ix + Nat.zero < bound) })
case succ
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
n✝ : ℕ
GETIX : Nat.succ n✝ < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) (Nat.succ n✝)
(_ : Nat.succ n✝ < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') (Nat.succ n✝) GETIX, { ix := ix + Nat.succ n✝, h_ix_inbound := (_ : ix + Nat.succ n✝ < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx : ℕ
GETIX : deltaIx < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | case zero => {
simp;
simp [zipFlatIndexGo, List.getF]
} | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) Nat.zero (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') Nat.zero GETIX, { ix := ix + Nat.zero, h_ix_inbound := (_ : ix + Nat.zero < bound) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) Nat.zero (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') Nat.zero GETIX, { ix := ix + Nat.zero, h_ix_inbound := (_ : ix + Nat.zero < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | case succ deltaIx' => {
simp [zipFlatIndexGo];
simp [List.getF];
rewrite [IND];
simp [Nat.add_assoc, Nat.add_one, Nat.succ_add, Nat.add_succ];
simp at GETIX;
apply Nat.lt_of_succ_lt_succ;
exact GETIX;
} | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) (Nat.succ deltaIx')
(_ : Nat.succ deltaIx' < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) (Nat.succ deltaIx')
(_ : Nat.succ deltaIx' < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) Nat.zero (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') Nat.zero GETIX, { ix := ix + Nat.zero, h_ix_inbound := (_ : ix + Nat.zero < bound) }) | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) 0 (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') 0 GETIX, { ix := ix, h_ix_inbound := (_ : ix < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) Nat.zero (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') Nat.zero GETIX, { ix := ix + Nat.zero, h_ix_inbound := (_ : ix + Nat.zero < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp [zipFlatIndexGo, List.getF] | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) 0 (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') 0 GETIX, { ix := ix, h_ix_inbound := (_ : ix < bound) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
GETIX : Nat.zero < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) 0 (_ : Nat.zero < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') 0 GETIX, { ix := ix, h_ix_inbound := (_ : ix < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp [zipFlatIndexGo] | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) (Nat.succ deltaIx')
(_ : Nat.succ deltaIx' < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) }) | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF
((x, { ix := ix, h_ix_inbound := (_ : ix < bound) }) ::
zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))
(Nat.succ deltaIx')
(_ :
Nat.succ deltaIx' <
length
((x, { ix := ix, h_ix_inbound := (_ : ix < bound) }) ::
zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo (x :: xs') ix bound H) (Nat.succ deltaIx')
(_ : Nat.succ deltaIx' < length (zipFlatIndexGo (x :: xs') ix bound H)) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp [List.getF] | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF
((x, { ix := ix, h_ix_inbound := (_ : ix < bound) }) ::
zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))
(Nat.succ deltaIx')
(_ :
Nat.succ deltaIx' <
length
((x, { ix := ix, h_ix_inbound := (_ : ix < bound) }) ::
zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) }) | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound)) deltaIx'
(_ : deltaIx' < length (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))) =
(getF xs' deltaIx' (_ : deltaIx' < length xs'),
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF
((x, { ix := ix, h_ix_inbound := (_ : ix < bound) }) ::
zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))
(Nat.succ deltaIx')
(_ :
Nat.succ deltaIx' <
length
((x, { ix := ix, h_ix_inbound := (_ : ix < bound) }) ::
zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))) =
(getF (x :: xs') (Nat.succ deltaIx') GETIX,
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | rewrite [IND] | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound)) deltaIx'
(_ : deltaIx' < length (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))) =
(getF xs' deltaIx' (_ : deltaIx' < length xs'),
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) }) | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ (getF xs' deltaIx' ?GETIX, { ix := ix + 1 + deltaIx', h_ix_inbound := (_ : ix + 1 + deltaIx' < bound) }) =
(getF xs' deltaIx' (_ : deltaIx' < length xs'),
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ deltaIx' < length xs' | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ getF (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound)) deltaIx'
(_ : deltaIx' < length (zipFlatIndexGo xs' (ix + 1) bound (_ : ix + 1 + length xs' = bound))) =
(getF xs' deltaIx' (_ : deltaIx' < length xs'),
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp [Nat.add_assoc, Nat.add_one, Nat.succ_add, Nat.add_succ] | α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ (getF xs' deltaIx' ?GETIX, { ix := ix + 1 + deltaIx', h_ix_inbound := (_ : ix + 1 + deltaIx' < bound) }) =
(getF xs' deltaIx' (_ : deltaIx' < length xs'),
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ deltaIx' < length xs' | case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ deltaIx' < length xs' | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ (getF xs' deltaIx' ?GETIX, { ix := ix + 1 + deltaIx', h_ix_inbound := (_ : ix + 1 + deltaIx' < bound) }) =
(getF xs' deltaIx' (_ : deltaIx' < length xs'),
{ ix := ix + Nat.succ deltaIx', h_ix_inbound := (_ : ix + Nat.succ deltaIx' < bound) })
case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ deltaIx' < length xs'
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | simp at GETIX | case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ deltaIx' < length xs' | case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < Nat.succ (length xs')
⊢ deltaIx' < length xs' | Please generate a tactic in lean4 to solve the state.
STATE:
case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < length (x :: xs')
⊢ deltaIx' < length xs'
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | apply Nat.lt_of_succ_lt_succ | case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < Nat.succ (length xs')
⊢ deltaIx' < length xs' | case GETIX.a
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < Nat.succ (length xs')
⊢ Nat.succ deltaIx' < Nat.succ (length xs') | Please generate a tactic in lean4 to solve the state.
STATE:
case GETIX
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < Nat.succ (length xs')
⊢ deltaIx' < length xs'
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_go_get | [795, 1] | [824, 2] | exact GETIX | case GETIX.a
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < Nat.succ (length xs')
⊢ Nat.succ deltaIx' < Nat.succ (length xs') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case GETIX.a
α : Type u_1
x : α
xs' : List α
IND :
∀ (ix bound : ℕ) (H : ix + length xs' = bound) (deltaIx : ℕ) (GETIX : deltaIx < length xs'),
getF (zipFlatIndexGo xs' ix bound H) deltaIx (_ : deltaIx < length (zipFlatIndexGo xs' ix bound H)) =
(getF xs' deltaIx GETIX, { ix := ix + deltaIx, h_ix_inbound := (_ : ix + deltaIx < bound) })
ix bound : ℕ
H : ix + length (x :: xs') = bound
deltaIx' : ℕ
GETIX : Nat.succ deltaIx' < Nat.succ (length xs')
⊢ Nat.succ deltaIx' < Nat.succ (length xs')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.length_zip_flat_index | [833, 1] | [836, 2] | apply Eq.symm | α : Type u_1
xs : List α
⊢ length (zipFlatIndex xs) = length xs | case h
α : Type u_1
xs : List α
⊢ length xs = length (zipFlatIndex xs) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
⊢ length (zipFlatIndex xs) = length xs
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.length_zip_flat_index | [833, 1] | [836, 2] | apply zip_flat_index_go_length | case h
α : Type u_1
xs : List α
⊢ length xs = length (zipFlatIndex xs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
xs : List α
⊢ length xs = length (zipFlatIndex xs)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | simp | α : Type ?u.103966
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length (zipFlatIndex xs) | α : Type ?u.103966
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type ?u.103966
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length (zipFlatIndex xs)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | apply GETIX | α : Type ?u.103966
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type ?u.103966
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length xs
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | simp[zipFlatIndex] | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getF (zipFlatIndex xs) getIx (_ : getIx < length (zipFlatIndex xs)) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX }) | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getF (zipFlatIndex xs) getIx (_ : getIx < length (zipFlatIndex xs)) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | have RHS : { ix := getIx, h_ix_inbound := GETIX : TensorFlatIndex (xs.length) } = {ix := 0 + getIx, h_ix_inbound := by { simp; apply GETIX } : TensorFlatIndex (xs.length)} := by {
simp;
} | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX }) | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
RHS : { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | rewrite [RHS] | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
RHS : { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX }) | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
RHS : { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
RHS : { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := getIx, h_ix_inbound := GETIX })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | apply List.zip_flat_index_go_get (xs := xs) (ix := 0) (bound := List.length xs) (deltaIx := getIx) (GETIX := GETIX) | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
RHS : { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
RHS : { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
⊢ getF (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs)) getIx
(_ : getIx < length (zipFlatIndexGo xs 0 (length xs) (_ : 0 + length xs = length xs))) =
(getF xs getIx GETIX, { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) })
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | simp | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ 0 + getIx < length xs | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length xs | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ 0 + getIx < length xs
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | apply GETIX | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length xs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ getIx < length xs
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.zip_flat_index_get | [839, 1] | [847, 2] | simp | α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
xs : List α
getIx : ℕ
GETIX : getIx < length xs
⊢ { ix := getIx, h_ix_inbound := GETIX } = { ix := 0 + getIx, h_ix_inbound := (_ : 0 + getIx < length xs) }
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | intros h | M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
results : List β
⊢ (∀ (a : α), fM a = pure (f a)) → mapM.loop fM l results = pure (reverse results ++ map f l) | M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
results : List β
h : ∀ (a : α), fM a = pure (f a)
⊢ mapM.loop fM l results = pure (reverse results ++ map f l) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
results : List β
⊢ (∀ (a : α), fM a = pure (f a)) → mapM.loop fM l results = pure (reverse results ++ map f l)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | revert results | M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
results : List β
h : ∀ (a : α), fM a = pure (f a)
⊢ mapM.loop fM l results = pure (reverse results ++ map f l) | M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
⊢ ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
results : List β
h : ∀ (a : α), fM a = pure (f a)
⊢ mapM.loop fM l results = pure (reverse results ++ map f l)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | induction l with
| nil => intros results; simp [map];
| cons a l ih =>
intros results
simp [mapM.loop, map, h, ih, reverse_cons, append_assoc] | M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
⊢ ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
⊢ ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | intros results | case nil
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
⊢ ∀ (results : List β), mapM.loop fM [] results = pure (reverse results ++ map f []) | case nil
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
results : List β
⊢ mapM.loop fM [] results = pure (reverse results ++ map f []) | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
⊢ ∀ (results : List β), mapM.loop fM [] results = pure (reverse results ++ map f [])
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | simp [map] | case nil
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
results : List β
⊢ mapM.loop fM [] results = pure (reverse results ++ map f []) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
results : List β
⊢ mapM.loop fM [] results = pure (reverse results ++ map f [])
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | intros results | case cons
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
a : α
l : List α
ih : ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l)
⊢ ∀ (results : List β), mapM.loop fM (a :: l) results = pure (reverse results ++ map f (a :: l)) | case cons
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
a : α
l : List α
ih : ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l)
results : List β
⊢ mapM.loop fM (a :: l) results = pure (reverse results ++ map f (a :: l)) | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
a : α
l : List α
ih : ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l)
⊢ ∀ (results : List β), mapM.loop fM (a :: l) results = pure (reverse results ++ map f (a :: l))
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_loop_map | [874, 1] | [884, 63] | simp [mapM.loop, map, h, ih, reverse_cons, append_assoc] | case cons
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
a : α
l : List α
ih : ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l)
results : List β
⊢ mapM.loop fM (a :: l) results = pure (reverse results ++ map f (a :: l)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
f : α → β
fM : α → M β
h : ∀ (a : α), fM a = pure (f a)
a : α
l : List α
ih : ∀ (results : List β), mapM.loop fM l results = pure (reverse results ++ map f l)
results : List β
⊢ mapM.loop fM (a :: l) results = pure (reverse results ++ map f (a :: l))
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | List.mapM_map | [886, 1] | [889, 27] | apply List.mapM_loop_map | M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
⊢ (∀ (a : α), fM a = pure (f a)) → mapM fM l = pure (map f l) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad M
inst✝ : LawfulMonad M
l : List α
f : α → β
fM : α → M β
⊢ (∀ (a : α), fM a = pure (f a)) → mapM fM l = pure (map f l)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Tensor1D.mapM_map | [891, 1] | [899, 32] | intros h | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
⊢ (∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)) →
mapMWithFlatIndex v fM = pure (mapWithFlatIndex v f) | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ mapMWithFlatIndex v fM = pure (mapWithFlatIndex v f) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
⊢ (∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)) →
mapMWithFlatIndex v fM = pure (mapWithFlatIndex v f)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Tensor1D.mapM_map | [891, 1] | [899, 32] | unfold mapWithFlatIndex | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ mapMWithFlatIndex v fM = pure (mapWithFlatIndex v f) | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ mapMWithFlatIndex v fM =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) } | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ mapMWithFlatIndex v fM = pure (mapWithFlatIndex v f)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Tensor1D.mapM_map | [891, 1] | [899, 32] | unfold mapMWithFlatIndex | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ mapMWithFlatIndex v fM =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) } | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ (do
let data ←
List.mapM
(fun x =>
match x with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)
let temp : Tensor1D :=
{ size0 := List.length data, data := data, h_data_size := (_ : List.length data = List.length data) }
pure temp) =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) } | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ mapMWithFlatIndex v fM =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) }
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Tensor1D.mapM_map | [891, 1] | [899, 32] | rw [List.mapM_map] | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ (do
let data ←
List.mapM
(fun x =>
match x with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)
let temp : Tensor1D :=
{ size0 := List.length data, data := data, h_data_size := (_ : List.length data = List.length data) }
pure temp) =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) } | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ (do
let data ← pure (List.map ?f (List.zipFlatIndex v.data))
let temp : Tensor1D :=
{ size0 := List.length data, data := data, h_data_size := (_ : List.length data = List.length data) }
pure temp) =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) }
case f
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ FinInt 32 × TensorFlatIndex (List.length v.data) → FinInt 32
case a
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ ∀ (a : FinInt 32 × TensorFlatIndex (List.length v.data)),
(match a with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val) =
pure (?f a) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ (do
let data ←
List.mapM
(fun x =>
match x with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)
let temp : Tensor1D :=
{ size0 := List.length data, data := data, h_data_size := (_ : List.length data = List.length data) }
pure temp) =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) }
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Tensor1D.mapM_map | [891, 1] | [899, 32] | . simp [v.h_data_size]; rfl | M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ (do
let data ← pure (List.map ?f (List.zipFlatIndex v.data))
let temp : Tensor1D :=
{ size0 := List.length data, data := data, h_data_size := (_ : List.length data = List.length data) }
pure temp) =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) }
case f
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ FinInt 32 × TensorFlatIndex (List.length v.data) → FinInt 32
case a
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ ∀ (a : FinInt 32 × TensorFlatIndex (List.length v.data)),
(match a with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val) =
pure (?f a) | case a
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ ∀ (a : FinInt 32 × TensorFlatIndex (List.length v.data)),
(match a with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val) =
pure (f ((_ : List.length v.data = v.size0) ▸ a.snd) a.fst) | Please generate a tactic in lean4 to solve the state.
STATE:
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ (do
let data ← pure (List.map ?f (List.zipFlatIndex v.data))
let temp : Tensor1D :=
{ size0 := List.length data, data := data, h_data_size := (_ : List.length data = List.length data) }
pure temp) =
pure
{ size0 := v.size0,
data :=
List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data),
h_data_size :=
(_ :
List.length
(List.map
(fun x =>
match x with
| (val, ix) => f ((_ : List.length v.data = v.size0) ▸ ix) val)
(List.zipFlatIndex v.data)) =
v.size0) }
case f
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ FinInt 32 × TensorFlatIndex (List.length v.data) → FinInt 32
case a
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ ∀ (a : FinInt 32 × TensorFlatIndex (List.length v.data)),
(match a with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val) =
pure (?f a)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/KDTensor.lean | Tensor1D.mapM_map | [891, 1] | [899, 32] | . intros a; cases a; simp [h] | case a
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ ∀ (a : FinInt 32 × TensorFlatIndex (List.length v.data)),
(match a with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val) =
pure (f ((_ : List.length v.data = v.size0) ▸ a.snd) a.fst) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
M : Type → Type
inst✝¹ : Monad M
inst✝ : LawfulMonad M
v : Tensor1D
f : TensorFlatIndex v.size0 → FinInt 32 → FinInt 32
fM : TensorFlatIndex v.size0 → FinInt 32 → M (FinInt 32)
h : ∀ (flat_index : TensorFlatIndex v.size0) (val : FinInt 32), fM flat_index val = pure (f flat_index val)
⊢ ∀ (a : FinInt 32 × TensorFlatIndex (List.length v.data)),
(match a with
| (val, ix) => fM ((_ : List.length v.data = v.size0) ▸ ix) val) =
pure (f ((_ : List.length v.data = v.size0) ▸ a.snd) a.fst)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | playground/tactic.lean | testSuccess | [80, 1] | [83, 7] | intros a b c d e | ⊢ Nat → ∀ (bint : Int), Nat → ∀ (dint : Int), Int → bint = dint | a : Nat
b : Int
c : Nat
d e : Int
⊢ b = d | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ Nat → ∀ (bint : Int), Nat → ∀ (dint : Int), Int → bint = dint
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | playground/tactic.lean | testGoalNotEqualityMustFail | [85, 1] | [87, 10] | intros a b c | ⊢ Nat → Int → Nat → Nat | a : Nat
b : Int
c : Nat
⊢ Nat | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ Nat → Int → Nat → Nat
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.sub_add_assoc | [21, 1] | [22, 64] | simp [Int.sub_eq_add_neg, Int.add_assoc, Int.add_comm (-m) k] | n m k : ℤ
⊢ n - m + k = n + (k - m) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m k : ℤ
⊢ n - m + k = n + (k - m)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.sub_assoc | [24, 1] | [25, 67] | simp [Int.sub_eq_add_neg, Int.add_assoc, Int.add_comm (-m) (-k)] | n m k : ℤ
⊢ n - m - k = n - k - m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m k : ℤ
⊢ n - m - k = n - k - m
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.add_sub | [27, 1] | [29, 39] | rw [Int.sub_eq_add_neg, Int.add_comm m (-n), ←Int.add_assoc,
Int.add_right_neg, Int.zero_add] | n m : ℤ
⊢ n + (m - n) = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : ℤ
⊢ n + (m - n) = m
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.sub_add_dist | [31, 1] | [33, 48] | rw [Int.sub_eq_add_neg, Int.neg_add, ←Int.add_assoc,
←Int.sub_eq_add_neg, ←Int.sub_eq_add_neg] | n m p : ℤ
⊢ n - (m + p) = n - m - p | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m p : ℤ
⊢ n - (m + p) = n - m - p
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_two | [39, 1] | [44, 22] | have h: (2:Int) = 1 + 1 := rfl | n : ℤ
⊢ n * 2 = n + n | n : ℤ
h : 2 = 1 + 1
⊢ n * 2 = n + n | Please generate a tactic in lean4 to solve the state.
STATE:
n : ℤ
⊢ n * 2 = n + n
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.