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/Arith.lean | Int.mul_two | [39, 1] | [44, 22] | rw [h] | n : β€
h : 2 = 1 + 1
β’ n * 2 = n + n | n : β€
h : 2 = 1 + 1
β’ n * (1 + 1) = n + n | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
h : 2 = 1 + 1
β’ n * 2 = n + n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_two | [39, 1] | [44, 22] | rw [Int.mul_add] | n : β€
h : 2 = 1 + 1
β’ n * (1 + 1) = n + n | n : β€
h : 2 = 1 + 1
β’ n * 1 + n * 1 = n + n | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
h : 2 = 1 + 1
β’ n * (1 + 1) = n + n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_two | [39, 1] | [44, 22] | simp [Int.mul_one] | n : β€
h : 2 = 1 + 1
β’ n * 1 + n * 1 = n + n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
h : 2 = 1 + 1
β’ n * 1 + n * 1 = n + n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_zero | [48, 1] | [48, 45] | rfl | n : β€
β’ n ^ 0 = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
β’ n ^ 0 = 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_succ | [50, 1] | [50, 64] | rfl | n : β€
m : β
β’ n ^ (m + 1) = n ^ m * n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
m : β
β’ n ^ (m + 1) = n ^ m * n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.two_pow_ge | [52, 1] | [53, 8] | sorry | n : β
β’ 2 ^ n β₯ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
β’ 2 ^ n β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.two_pow_pos | [55, 1] | [56, 8] | sorry | n : β
β’ 2 ^ n > 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
β’ 2 ^ n > 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.one_le_two_pow | [58, 1] | [59, 8] | sorry | n : β
β’ 1 β€ 2 ^ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
β’ 1 β€ 2 ^ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.one_lt_two_pow | [61, 1] | [62, 8] | sorry | n : β
β’ n > 0 β 1 < 2 ^ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
β’ n > 0 β 1 < 2 ^ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mod_bounds | [64, 1] | [65, 8] | sorry | a b : β€
β’ a β₯ 0 β a < b β a % b = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β€
β’ a β₯ 0 β a < b β a % b = a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mod_mod | [67, 1] | [68, 8] | sorry | a b : β€
β’ a % b % b = a % b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β€
β’ a % b % b = a % b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mod_ge_neg | [70, 1] | [71, 8] | sorry | a b : β€
β’ a % b β₯ -b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β€
β’ a % b β₯ -b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mod_ge | [73, 1] | [74, 8] | sorry | a b : β€
β’ a β₯ 0 β a % b β₯ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β€
β’ a β₯ 0 β a % b β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mod_lt | [76, 1] | [77, 8] | sorry | a b : β€
β’ b > 0 β a % b < b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β€
β’ b > 0 β a % b < b
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.add_mod_right | [79, 1] | [80, 8] | sorry | x z : β€
β’ z > 0 β x β₯ 0 β (x + z) % z = x % z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x z : β€
β’ z > 0 β x β₯ 0 β (x + z) % z = x % z
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.add_mod_left | [82, 1] | [83, 8] | sorry | x z : β€
β’ z > 0 β x β₯ 0 β (z + x) % z = x % z | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
x z : β€
β’ z > 0 β x β₯ 0 β (z + x) % z = x % z
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.ge_zero_eq_nonneg | [90, 1] | [91, 30] | simp [GE.ge, LE.le, Int.le] | n : β€
β’ n β₯ 0 β NonNeg n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
β’ n β₯ 0 β NonNeg n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.zero_ge_neg | [93, 1] | [94, 43] | simp [GE.ge, LE.le, Int.le, Int.neg_neg] | n : β€
β’ n β₯ 0 β 0 β₯ -n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
β’ n β₯ 0 β 0 β₯ -n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.add_ge_zero | [98, 1] | [98, 70] | sorry | n m : β€
β’ n β₯ 0 β m β₯ 0 β n + m β₯ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
β’ n β₯ 0 β m β₯ 0 β n + m β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.le_succ | [105, 1] | [107, 14] | suffices NonNeg 1 by simp [LE.le, Int.le, add_sub_assoc, add_sub]; trivial | n : β€
β’ n β€ n + 1 | n : β€
β’ NonNeg 1 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
β’ n β€ n + 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.le_succ | [105, 1] | [107, 14] | constructor | n : β€
β’ NonNeg 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
β’ NonNeg 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.le_succ | [105, 1] | [107, 14] | simp [LE.le, Int.le, add_sub_assoc, add_sub] | n : β€
this : NonNeg 1
β’ n β€ n + 1 | n : β€
this : NonNeg 1
β’ NonNeg 1 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
this : NonNeg 1
β’ n β€ n + 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.le_succ | [105, 1] | [107, 14] | trivial | n : β€
this : NonNeg 1
β’ NonNeg 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
this : NonNeg 1
β’ NonNeg 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.succ_le_succ | [109, 1] | [110, 8] | sorry | n m : β€
β’ n β€ m β n + 1 β€ m + 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
β’ n β€ m β n + 1 β€ m + 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.ge_trans | [112, 1] | [115, 23] | simp [GE.ge] | n k m : β€
β’ n β₯ m β m β₯ k β n β₯ k | n k m : β€
β’ m β€ n β k β€ m β k β€ n | Please generate a tactic in lean4 to solve the state.
STATE:
n k m : β€
β’ n β₯ m β m β₯ k β n β₯ k
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.ge_trans | [112, 1] | [115, 23] | intros hβ hβ | n k m : β€
β’ m β€ n β k β€ m β k β€ n | n k m : β€
hβ : m β€ n
hβ : k β€ m
β’ k β€ n | Please generate a tactic in lean4 to solve the state.
STATE:
n k m : β€
β’ m β€ n β k β€ m β k β€ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.ge_trans | [112, 1] | [115, 23] | apply le_trans hβ hβ | n k m : β€
hβ : m β€ n
hβ : k β€ m
β’ k β€ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n k m : β€
hβ : m β€ n
hβ : k β€ m
β’ k β€ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.lt_add_right | [117, 1] | [118, 8] | sorry | n m : β€
β’ m > 0 β n < n + m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
β’ m > 0 β n < n + m
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_ge_zero | [120, 1] | [123, 34] | rw [Int.ge_zero_eq_nonneg, Int.ge_zero_eq_nonneg, Int.ge_zero_eq_nonneg] | n m : β€
β’ n β₯ 0 β m β₯ 0 β n * m β₯ 0 | n m : β€
β’ NonNeg n β NonNeg m β NonNeg (n * m) | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
β’ n β₯ 0 β m β₯ 0 β n * m β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_ge_zero | [120, 1] | [123, 34] | intros hn hm | n m : β€
β’ NonNeg n β NonNeg m β NonNeg (n * m) | n m : β€
hn : NonNeg n
hm : NonNeg m
β’ NonNeg (n * m) | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
β’ NonNeg n β NonNeg m β NonNeg (n * m)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_ge_zero | [120, 1] | [123, 34] | cases hn | n m : β€
hn : NonNeg n
hm : NonNeg m
β’ NonNeg (n * m) | case mk
m : β€
hm : NonNeg m
nβ : β
β’ NonNeg (ofNat nβ * m) | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
hn : NonNeg n
hm : NonNeg m
β’ NonNeg (n * m)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_ge_zero | [120, 1] | [123, 34] | cases hm | case mk
m : β€
hm : NonNeg m
nβ : β
β’ NonNeg (ofNat nβ * m) | case mk.mk
nβΒΉ nβ : β
β’ NonNeg (ofNat nβΒΉ * ofNat nβ) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
m : β€
hm : NonNeg m
nβ : β
β’ NonNeg (ofNat nβ * m)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_ge_zero | [120, 1] | [123, 34] | constructor | case mk.mk
nβΒΉ nβ : β
β’ NonNeg (ofNat nβΒΉ * ofNat nβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.mk
nβΒΉ nβ : β
β’ NonNeg (ofNat nβΒΉ * ofNat nβ)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.mul_gt_zero | [125, 1] | [126, 8] | sorry | n m : β€
β’ n > 0 β m > 0 β n * m > 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β€
β’ n > 0 β m > 0 β n * m > 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_ge_zero | [128, 1] | [131, 50] | revert n | n : β€
m : β
β’ n β₯ 0 β n ^ m β₯ 0 | m : β
β’ β (n : β€), n β₯ 0 β n ^ m β₯ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
m : β
β’ n β₯ 0 β n ^ m β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_ge_zero | [128, 1] | [131, 50] | induction m <;> intros n h <;> simp | m : β
β’ β (n : β€), n β₯ 0 β n ^ m β₯ 0 | case succ
nβ : β
n_ihβ : β (n : β€), n β₯ 0 β n ^ nβ β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ Nat.succ nβ | Please generate a tactic in lean4 to solve the state.
STATE:
m : β
β’ β (n : β€), n β₯ 0 β n ^ m β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_ge_zero | [128, 1] | [131, 50] | case succ acc ih =>
simp [pow_succ]; apply mul_ge_zero (ih _ h) h | acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ Nat.succ acc | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ Nat.succ acc
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_ge_zero | [128, 1] | [131, 50] | simp [pow_succ] | acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ Nat.succ acc | acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ acc * n | Please generate a tactic in lean4 to solve the state.
STATE:
acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ Nat.succ acc
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_ge_zero | [128, 1] | [131, 50] | apply mul_ge_zero (ih _ h) h | acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ acc * n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
acc : β
ih : β (n : β€), n β₯ 0 β n ^ acc β₯ 0
n : β€
h : n β₯ 0
β’ 0 β€ n ^ acc * n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_gt_zero | [133, 1] | [136, 50] | revert n | n : β€
m : β
β’ n > 0 β n ^ m > 0 | m : β
β’ β (n : β€), n > 0 β n ^ m > 0 | Please generate a tactic in lean4 to solve the state.
STATE:
n : β€
m : β
β’ n > 0 β n ^ m > 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_gt_zero | [133, 1] | [136, 50] | induction m <;> intros n h <;> simp | m : β
β’ β (n : β€), n > 0 β n ^ m > 0 | case succ
nβ : β
n_ihβ : β (n : β€), n > 0 β n ^ nβ > 0
n : β€
h : n > 0
β’ 0 < n ^ Nat.succ nβ | Please generate a tactic in lean4 to solve the state.
STATE:
m : β
β’ β (n : β€), n > 0 β n ^ m > 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_gt_zero | [133, 1] | [136, 50] | case succ acc ih =>
simp [pow_succ]; apply mul_gt_zero (ih _ h) h | acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ Nat.succ acc | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ Nat.succ acc
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_gt_zero | [133, 1] | [136, 50] | simp [pow_succ] | acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ Nat.succ acc | acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ acc * n | Please generate a tactic in lean4 to solve the state.
STATE:
acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ Nat.succ acc
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.pow_gt_zero | [133, 1] | [136, 50] | apply mul_gt_zero (ih _ h) h | acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ acc * n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
acc : β
ih : β (n : β€), n > 0 β n ^ acc > 0
n : β€
h : n > 0
β’ 0 < n ^ acc * n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Int.lt_add_lt_left | [138, 1] | [139, 8] | sorry | 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.ge_add_ge_right | [141, 1] | [142, 8] | sorry | n m k : β€
β’ n β₯ m β n + k β₯ m + k | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m k : β€
β’ n β₯ m β n + k β₯ m + k
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Nat.minus_plus_one | [150, 1] | [151, 26] | cases a | a : β
h : a > 0
β’ a - 1 + 1 = a | case zero
h : zero > 0
β’ zero - 1 + 1 = zero
case succ
nβ : β
h : succ nβ > 0
β’ succ nβ - 1 + 1 = succ nβ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β
h : a > 0
β’ a - 1 + 1 = a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Nat.minus_plus_one | [150, 1] | [151, 26] | simp at h | case zero
h : zero > 0
β’ zero - 1 + 1 = zero
case succ
nβ : β
h : succ nβ > 0
β’ succ nβ - 1 + 1 = succ nβ | case succ
nβ : β
h : succ nβ > 0
β’ succ nβ - 1 + 1 = succ nβ | Please generate a tactic in lean4 to solve the state.
STATE:
case zero
h : zero > 0
β’ zero - 1 + 1 = zero
case succ
nβ : β
h : succ nβ > 0
β’ succ nβ - 1 + 1 = succ nβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/Arith.lean | Nat.minus_plus_one | [150, 1] | [151, 26] | rfl | case succ
nβ : β
h : succ nβ > 0
β’ succ nβ - 1 + 1 = succ nβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case succ
nβ : β
h : succ nβ > 0
β’ succ nβ - 1 + 1 = succ nβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_remap_bound | [22, 1] | [26, 8] | intro i h | n m : β
β’ β (i : β), i < n * m β transpose_remap n m i < n * m | n m i : β
h : i < n * m
β’ transpose_remap n m i < n * m | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β
β’ β (i : β), i < n * m β transpose_remap n m i < n * m
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_remap_bound | [22, 1] | [26, 8] | simp [transpose_remap] | n m i : β
h : i < n * m
β’ transpose_remap n m i < n * m | n m i : β
h : i < n * m
β’ m * (i % n) + i / n < n * m | Please generate a tactic in lean4 to solve the state.
STATE:
n m i : β
h : i < n * m
β’ transpose_remap n m i < n * m
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_remap_bound | [22, 1] | [26, 8] | sorry | n m i : β
h : i < n * m
β’ m * (i % n) + i / n < n * m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m i : β
h : i < n * m
β’ m * (i % n) + i / n < n * m
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_remap_involutive | [28, 1] | [31, 8] | simp [transpose_remap, Function.comp] | n m : β
β’ β (i : β), transpose_remap m n (transpose_remap n m i) = i | n m : β
β’ β (i : β), n * ((m * (i % n) + i / n) % m) + (m * (i % n) + i / n) / m = i | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β
β’ β (i : β), transpose_remap m n (transpose_remap n m i) = i
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_remap_involutive | [28, 1] | [31, 8] | intro i | n m : β
β’ β (i : β), n * ((m * (i % n) + i / n) % m) + (m * (i % n) + i / n) / m = i | n m i : β
β’ n * ((m * (i % n) + i / n) % m) + (m * (i % n) + i / n) / m = i | Please generate a tactic in lean4 to solve the state.
STATE:
n m : β
β’ β (i : β), n * ((m * (i % n) + i / n) % m) + (m * (i % n) + i / n) / m = i
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_remap_involutive | [28, 1] | [31, 8] | sorry | n m i : β
β’ n * ((m * (i % n) + i / n) % m) + (m * (i % n) + i / n) / m = i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m i : β
β’ n * ((m * (i % n) + i / n) % m) + (m * (i % n) + i / n) / m = i
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | Function.comp_assoc | [50, 1] | [52, 20] | funext x | Ξ± : Sort u_1
Ξ² : Sort u_2
Ξ³ : Sort u_3
Ξ΄ : Sort u_4
f : Ξ± β Ξ²
g : Ξ² β Ξ³
h : Ξ³ β Ξ΄
β’ (h β g) β f = h β g β f | case h
Ξ± : Sort u_1
Ξ² : Sort u_2
Ξ³ : Sort u_3
Ξ΄ : Sort u_4
f : Ξ± β Ξ²
g : Ξ² β Ξ³
h : Ξ³ β Ξ΄
x : Ξ±
β’ comp (h β g) f x = comp h (g β f) x | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Sort u_1
Ξ² : Sort u_2
Ξ³ : Sort u_3
Ξ΄ : Sort u_4
f : Ξ± β Ξ²
g : Ξ² β Ξ³
h : Ξ³ β Ξ΄
β’ (h β g) β f = h β g β f
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | Function.comp_assoc | [50, 1] | [52, 20] | simp | case h
Ξ± : Sort u_1
Ξ² : Sort u_2
Ξ³ : Sort u_3
Ξ΄ : Sort u_4
f : Ξ± β Ξ²
g : Ξ² β Ξ³
h : Ξ³ β Ξ΄
x : Ξ±
β’ comp (h β g) f x = comp h (g β f) x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Sort u_1
Ξ² : Sort u_2
Ξ³ : Sort u_3
Ξ΄ : Sort u_4
f : Ξ± β Ξ²
g : Ξ² β Ξ³
h : Ξ³ β Ξ΄
x : Ξ±
β’ comp (h β g) f x = comp h (g β f) x
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_involutive | [54, 1] | [62, 38] | intro t | Ξ± n : β
m : MLIR.AST.MLIRTy
β’ β (t : Matrix Ξ± n m), transpose (transpose t) = t | Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ transpose (transpose t) = t | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± n : β
m : MLIR.AST.MLIRTy
β’ β (t : Matrix Ξ± n m), transpose (transpose t) = t
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_involutive | [54, 1] | [62, 38] | simp [transpose] | Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ transpose (transpose t) = t | Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ {
toTensor :=
{ shape := [Ξ±, n],
data :=
List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))),
h_data_size :=
(_ :
List.length
(List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)))) =
shapeProd [Ξ±, n]) },
h_refines :=
(_ :
shapeRefines
{ shape := [Ξ±, n],
data :=
List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data))),
h_data_size :=
(_ :
List.length
(List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)))) =
shapeProd [Ξ±, n]) }.shape
[MLIR.AST.Dimension.Known Ξ±, MLIR.AST.Dimension.Known n] =
true) } =
t | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ transpose (transpose t) = t
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_involutive | [54, 1] | [62, 38] | apply RankedTensor.eq_of_fields_eq <;> simp | Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ {
toTensor :=
{ shape := [Ξ±, n],
data :=
List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))),
h_data_size :=
(_ :
List.length
(List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)))) =
shapeProd [Ξ±, n]) },
h_refines :=
(_ :
shapeRefines
{ shape := [Ξ±, n],
data :=
List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data))),
h_data_size :=
(_ :
List.length
(List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)))) =
shapeProd [Ξ±, n]) }.shape
[MLIR.AST.Dimension.Known Ξ±, MLIR.AST.Dimension.Known n] =
true) } =
t | case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ [Ξ±, n] = t.toTensor.shape
case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))) =
t.toTensor.data | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ {
toTensor :=
{ shape := [Ξ±, n],
data :=
List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))),
h_data_size :=
(_ :
List.length
(List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)))) =
shapeProd [Ξ±, n]) },
h_refines :=
(_ :
shapeRefines
{ shape := [Ξ±, n],
data :=
List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data))),
h_data_size :=
(_ :
List.length
(List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β
transpose_remap Ξ± n i < List.length t.toTensor.data)))) =
shapeProd [Ξ±, n]) }.shape
[MLIR.AST.Dimension.Known Ξ±, MLIR.AST.Dimension.Known n] =
true) } =
t
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_involutive | [54, 1] | [62, 38] | . rw [βdim_known_project_eq _ t.h_refines] <;> simp | case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ [Ξ±, n] = t.toTensor.shape
case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))) =
t.toTensor.data | case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))) =
t.toTensor.data | Please generate a tactic in lean4 to solve the state.
STATE:
case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ [Ξ±, n] = t.toTensor.shape
case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))) =
t.toTensor.data
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ToyModel.lean | transpose_involutive | [54, 1] | [62, 38] | . simp [List.remap_remap]
apply List.extF <;> simp
simp [transpose_remap_involutive] | case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))) =
t.toTensor.data | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
Ξ± n : β
m : MLIR.AST.MLIRTy
t : Matrix Ξ± n m
β’ List.remap
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ : β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))
(transpose_remap n Ξ±)
(_ :
β (n_1 : β),
n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β), i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data)) β
transpose_remap n Ξ± n_1 <
List.length
(List.remap t.toTensor.data (transpose_remap Ξ± n)
(_ :
β (i : β),
i < List.length t.toTensor.data β transpose_remap Ξ± n i < List.length t.toTensor.data))) =
t.toTensor.data
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.id_map | [8, 1] | [13, 34] | simp [Functor.map] | E : Type β Type
R : Type
t : Fitree E R
β’ id <$> t = t | E : Type β Type
R : Type
t : Fitree E R
β’ bind t (ret β id) = t | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
R : Type
t : Fitree E R
β’ id <$> t = t
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.id_map | [8, 1] | [13, 34] | induction t with
| Ret _ => rfl
| Vis _ _ ih => simp [bind, ih] | E : Type β Type
R : Type
t : Fitree E R
β’ bind t (ret β id) = t | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
R : Type
t : Fitree E R
β’ bind t (ret β id) = t
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.id_map | [8, 1] | [13, 34] | rfl | case Ret
E : Type β Type
R : Type
rβ : R
β’ bind (Ret rβ) (ret β id) = Ret rβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Ret
E : Type β Type
R : Type
rβ : R
β’ bind (Ret rβ) (ret β id) = Ret rβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.id_map | [8, 1] | [13, 34] | simp [bind, ih] | case Vis
E : Type β Type
R Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E R
ih : β (a : Tβ), bind (kβ a) (ret β id) = kβ a
β’ bind (Vis eβ kβ) (ret β id) = Vis eβ kβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
E : Type β Type
R Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E R
ih : β (a : Tβ), bind (kβ a) (ret β id) = kβ a
β’ bind (Vis eβ kβ) (ret β id) = Vis eβ kβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.comp_map | [15, 1] | [20, 34] | simp [Functor.map] | Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
t : Fitree E Rβ
β’ (g β f) <$> t = g <$> f <$> t | Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
t : Fitree E Rβ
β’ bind t (ret β g β f) = bind t fun x => ret (g (f x)) | Please generate a tactic in lean4 to solve the state.
STATE:
Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
t : Fitree E Rβ
β’ (g β f) <$> t = g <$> f <$> t
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.comp_map | [15, 1] | [20, 34] | induction t with
| Ret _ => rfl
| Vis _ _ ih => simp [bind, ih] | Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
t : Fitree E Rβ
β’ bind t (ret β g β f) = bind t fun x => ret (g (f x)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
t : Fitree E Rβ
β’ bind t (ret β g β f) = bind t fun x => ret (g (f x))
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.comp_map | [15, 1] | [20, 34] | rfl | case Ret
Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
rβ : Rβ
β’ bind (Ret rβ) (ret β g β f) = bind (Ret rβ) fun x => ret (g (f x)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Ret
Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
rβ : Rβ
β’ bind (Ret rβ) (ret β g β f) = bind (Ret rβ) fun x => ret (g (f x))
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.comp_map | [15, 1] | [20, 34] | simp [bind, ih] | case Vis
Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), bind (kβ a) (ret β g β f) = bind (kβ a) fun x => ret (g (f x))
β’ bind (Vis eβ kβ) (ret β g β f) = bind (Vis eβ kβ) fun x => ret (g (f x)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
Rβ Rβ Rβ : Type
E : Type β Type
f : Rβ β Rβ
g : Rβ β Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), bind (kβ a) (ret β g β f) = bind (kβ a) fun x => ret (g (f x))
β’ bind (Vis eβ kβ) (ret β g β f) = bind (Vis eβ kβ) fun x => ret (g (f x))
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | simp [SeqLeft.seqLeft, Seq.seq] | E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (SeqLeft.seqLeft tβ fun x => tβ) = Seq.seq (Function.const Rβ <$> tβ) fun x => tβ | E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (bind tβ fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> tβ) fun y => bind tβ (ret β y) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (SeqLeft.seqLeft tβ fun x => tβ) = Seq.seq (Function.const Rβ <$> tβ) fun x => tβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | induction tβ with
| Ret _ => rfl
| Vis _ _ ih => simp [bind]; funext _; simp [ih]; sorry | E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (bind tβ fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> tβ) fun y => bind tβ (ret β y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (bind tβ fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> tβ) fun y => bind tβ (ret β y)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | rfl | case Ret
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
rβ : Rβ
β’ (bind (Ret rβ) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> Ret rβ) fun y => bind tβ (ret β y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Ret
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
rβ : Rβ
β’ (bind (Ret rβ) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> Ret rβ) fun y => bind tβ (ret β y)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | simp [bind] | case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
β’ (bind (Vis eβ kβ) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> Vis eβ kβ) fun y => bind tβ (ret β y) | case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
β’ (fun r => bind (kβ r) fun a => bind tβ fun x => ret a) = fun r =>
bind (kβ r) fun x => bind tβ (ret β Function.const Rβ x) | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
β’ (bind (Vis eβ kβ) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> Vis eβ kβ) fun y => bind tβ (ret β y)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | funext _ | case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
β’ (fun r => bind (kβ r) fun a => bind tβ fun x => ret a) = fun r =>
bind (kβ r) fun x => bind tβ (ret β Function.const Rβ x) | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (kβ xβ) fun a => bind tβ fun x => ret a) = bind (kβ xβ) fun x => bind tβ (ret β Function.const Rβ x) | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
β’ (fun r => bind (kβ r) fun a => bind tβ fun x => ret a) = fun r =>
bind (kβ r) fun x => bind tβ (ret β Function.const Rβ x)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | simp [ih] | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (kβ xβ) fun a => bind tβ fun x => ret a) = bind (kβ xβ) fun x => bind tβ (ret β Function.const Rβ x) | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (Function.const Rβ <$> kβ xβ) fun y => bind tβ (ret β y)) =
bind (kβ xβ) fun x => bind tβ (ret β Function.const Rβ x) | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (kβ xβ) fun a => bind tβ fun x => ret a) = bind (kβ xβ) fun x => bind tβ (ret β Function.const Rβ x)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqLeft_eq | [27, 1] | [32, 58] | sorry | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (Function.const Rβ <$> kβ xβ) fun y => bind tβ (ret β y)) =
bind (kβ xβ) fun x => bind tβ (ret β Function.const Rβ x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih :
β (a : Tβ),
(bind (kβ a) fun a => bind tβ fun x => ret a) = bind (Function.const Rβ <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (Function.const Rβ <$> kβ xβ) fun y => bind tβ (ret β y)) =
bind (kβ xβ) fun x => bind tβ (ret β Function.const Rβ x)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | simp [SeqRight.seqRight, Seq.seq] | E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (SeqRight.seqRight tβ fun x => tβ) = Seq.seq (Function.const Rβ id <$> tβ) fun x => tβ | E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (bind tβ fun x => tβ) = bind (Function.const Rβ id <$> tβ) fun y => bind tβ (ret β y) | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (SeqRight.seqRight tβ fun x => tβ) = Seq.seq (Function.const Rβ id <$> tβ) fun x => tβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | induction tβ with
| Ret _ =>
simp [Function.const, Function.comp, bind]
| Vis _ _ ih =>
simp [bind]; funext _; simp [ih]; sorry | E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (bind tβ fun x => tβ) = bind (Function.const Rβ id <$> tβ) fun y => bind tβ (ret β y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E Rβ
β’ (bind tβ fun x => tβ) = bind (Function.const Rβ id <$> tβ) fun y => bind tβ (ret β y)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | simp [Function.const, Function.comp, bind] | case Ret
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
rβ : Rβ
β’ (bind (Ret rβ) fun x => tβ) = bind (Function.const Rβ id <$> Ret rβ) fun y => bind tβ (ret β y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Ret
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
rβ : Rβ
β’ (bind (Ret rβ) fun x => tβ) = bind (Function.const Rβ id <$> Ret rβ) fun y => bind tβ (ret β y)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | simp [bind] | case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
β’ (bind (Vis eβ kβ) fun x => tβ) = bind (Function.const Rβ id <$> Vis eβ kβ) fun y => bind tβ (ret β y) | case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
β’ (fun r => bind (kβ r) fun x => tβ) = fun r => bind (kβ r) fun x => bind tβ (ret β id) | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
β’ (bind (Vis eβ kβ) fun x => tβ) = bind (Function.const Rβ id <$> Vis eβ kβ) fun y => bind tβ (ret β y)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | funext _ | case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
β’ (fun r => bind (kβ r) fun x => tβ) = fun r => bind (kβ r) fun x => bind tβ (ret β id) | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (kβ xβ) fun x => tβ) = bind (kβ xβ) fun x => bind tβ (ret β id) | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
β’ (fun r => bind (kβ r) fun x => tβ) = fun r => bind (kβ r) fun x => bind tβ (ret β id)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | simp [ih] | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (kβ xβ) fun x => tβ) = bind (kβ xβ) fun x => bind tβ (ret β id) | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (Function.const Rβ id <$> kβ xβ) fun y => bind tβ (ret β y)) = bind (kβ xβ) fun x => bind tβ (ret β id) | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (kβ xβ) fun x => tβ) = bind (kβ xβ) fun x => bind tβ (ret β id)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seqRight_eq | [34, 1] | [41, 44] | sorry | case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (Function.const Rβ id <$> kβ xβ) fun y => bind tβ (ret β y)) = bind (kβ xβ) fun x => bind tβ (ret β id) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis.h
E : Type β Type
Rβ Rβ : Type
tβ : Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), (bind (kβ a) fun x => tβ) = bind (Function.const Rβ id <$> kβ a) fun y => bind tβ (ret β y)
xβ : Tβ
β’ (bind (Function.const Rβ id <$> kβ xβ) fun y => bind tβ (ret β y)) = bind (kβ xβ) fun x => bind tβ (ret β id)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.seq_assoc | [55, 1] | [58, 8] | sorry | E : Type β Type
Rβ Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E (Rβ β Rβ)
tβ : Fitree E (Rβ β Rβ)
β’ (Seq.seq tβ fun x => Seq.seq tβ fun x => tβ) = Seq.seq (Seq.seq (Function.comp <$> tβ) fun x => tβ) fun x => tβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
Rβ Rβ Rβ : Type
tβ : Fitree E Rβ
tβ : Fitree E (Rβ β Rβ)
tβ : Fitree E (Rβ β Rβ)
β’ (Seq.seq tβ fun x => Seq.seq tβ fun x => tβ) = Seq.seq (Seq.seq (Function.comp <$> tβ) fun x => tβ) fun x => tβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.bind_assoc | [81, 1] | [86, 31] | induction t with
| Ret _ => rfl
| Vis _ _ ih => simp [bind]; | E : Type β Type
Rβ Rβ Rβ : Type
t : Fitree E Rβ
kβ : Rβ β Fitree E Rβ
kβ : Rβ β Fitree E Rβ
β’ bind (bind t kβ) kβ = bind t fun x => bind (kβ x) kβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
E : Type β Type
Rβ Rβ Rβ : Type
t : Fitree E Rβ
kβ : Rβ β Fitree E Rβ
kβ : Rβ β Fitree E Rβ
β’ bind (bind t kβ) kβ = bind t fun x => bind (kβ x) kβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.bind_assoc | [81, 1] | [86, 31] | rfl | case Ret
E : Type β Type
Rβ Rβ Rβ : Type
kβ : Rβ β Fitree E Rβ
kβ : Rβ β Fitree E Rβ
rβ : Rβ
β’ bind (bind (Ret rβ) kβ) kβ = bind (Ret rβ) fun x => bind (kβ x) kβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Ret
E : Type β Type
Rβ Rβ Rβ : Type
kβ : Rβ β Fitree E Rβ
kβ : Rβ β Fitree E Rβ
rβ : Rβ
β’ bind (bind (Ret rβ) kβ) kβ = bind (Ret rβ) fun x => bind (kβ x) kβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/FitreeLaws.lean | Fitree.bind_assoc | [81, 1] | [86, 31] | simp [bind] | case Vis
E : Type β Type
Rβ Rβ Rβ : Type
kβ : Rβ β Fitree E Rβ
kβ : Rβ β Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), bind (bind (kβ a) kβ) kβ = bind (kβ a) fun x => bind (kβ x) kβ
β’ bind (bind (Vis eβ kβ) kβ) kβ = bind (Vis eβ kβ) fun x => bind (kβ x) kβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Vis
E : Type β Type
Rβ Rβ Rβ : Type
kβ : Rβ β Fitree E Rβ
kβ : Rβ β Fitree E Rβ
Tβ : Type
eβ : E Tβ
kβ : Tβ β Fitree E Rβ
ih : β (a : Tβ), bind (bind (kβ a) kβ) kβ = bind (kβ a) fun x => bind (kβ x) kβ
β’ bind (bind (Vis eβ kβ) kβ) kβ = bind (Vis eβ kβ) fun x => bind (kβ x) kβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | reading/tactic.lean | tst3 | [21, 1] | [25, 2] | intros h1 h2 | p q : Prop
β’ p β q β p | p q : Prop
h1 : p
h2 : q
β’ p | Please generate a tactic in lean4 to solve the state.
STATE:
p q : Prop
β’ p β q β p
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | reading/tactic.lean | tst3 | [21, 1] | [25, 2] | assumption | p q : Prop
h1 : p
h2 : q
β’ p | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
p q : Prop
h1 : p
h2 : q
β’ p
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_ge | [40, 1] | [46, 8] | simp [mod2] | a : β€
n : β
β’ mod2 a n β₯ 0 | a : β€
n : β
β’ 0 β€ a % 2 ^ n | Please generate a tactic in lean4 to solve the state.
STATE:
a : β€
n : β
β’ mod2 a n β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_ge | [40, 1] | [46, 8] | apply Int.mod_ge | a : β€
n : β
β’ 0 β€ a % 2 ^ n | case a
a : β€
n : β
β’ a β₯ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
a : β€
n : β
β’ 0 β€ a % 2 ^ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_ge | [40, 1] | [46, 8] | have h := Int.ge_add_ge_right (2^n) (@Int.mod_ge_neg a (2^n)) | case a
a : β€
n : β
β’ a β₯ 0 | case a
a : β€
n : β
h : a % 2 ^ n + 2 ^ n β₯ -2 ^ n + 2 ^ n
β’ a β₯ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case a
a : β€
n : β
β’ a β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_ge | [40, 1] | [46, 8] | rw [Int.add_left_neg] at h | case a
a : β€
n : β
h : a % 2 ^ n + 2 ^ n β₯ -2 ^ n + 2 ^ n
β’ a β₯ 0 | case a
a : β€
n : β
h : a % 2 ^ n + 2 ^ n β₯ 0
β’ a β₯ 0 | Please generate a tactic in lean4 to solve the state.
STATE:
case a
a : β€
n : β
h : a % 2 ^ n + 2 ^ n β₯ -2 ^ n + 2 ^ n
β’ a β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_ge | [40, 1] | [46, 8] | sorry | case a
a : β€
n : β
h : a % 2 ^ n + 2 ^ n β₯ 0
β’ a β₯ 0 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case a
a : β€
n : β
h : a % 2 ^ n + 2 ^ n β₯ 0
β’ a β₯ 0
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_lt | [49, 1] | [51, 35] | simp [mod2] | a : β€
n : β
β’ mod2 a n < 2 ^ n | a : β€
n : β
β’ a % 2 ^ n < 2 ^ n | Please generate a tactic in lean4 to solve the state.
STATE:
a : β€
n : β
β’ mod2 a n < 2 ^ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_lt | [49, 1] | [51, 35] | apply Int.mod_lt Int.two_pow_pos | a : β€
n : β
β’ a % 2 ^ n < 2 ^ n | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : β€
n : β
β’ a % 2 ^ n < 2 ^ n
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_idem | [56, 1] | [60, 34] | intros h | n : β
a : β€
β’ a β₯ 0 β§ a < 2 ^ n β mod2 a n = a | n : β
a : β€
h : a β₯ 0 β§ a < 2 ^ n
β’ mod2 a n = a | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
a : β€
β’ a β₯ 0 β§ a < 2 ^ n β mod2 a n = a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_idem | [56, 1] | [60, 34] | simp [mod2] | n : β
a : β€
h : a β₯ 0 β§ a < 2 ^ n
β’ mod2 a n = a | n : β
a : β€
h : a β₯ 0 β§ a < 2 ^ n
β’ a % 2 ^ n = a | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
a : β€
h : a β₯ 0 β§ a < 2 ^ n
β’ mod2 a n = a
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Util/FinInt.lean | FinInt.mod2_idem | [56, 1] | [60, 34] | simp [Int.mod_bounds _ h.1 h.2] | n : β
a : β€
h : a β₯ 0 β§ a < 2 ^ n
β’ a % 2 ^ n = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n : β
a : β€
h : a β₯ 0 β§ a < 2 ^ n
β’ a % 2 ^ n = a
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.