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/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | cases H' | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
β’ hasShape (nested l) s = true | case intro
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
wβ : List β
hβ : s = List.length l :: wβ
β’ hasShape (nested l) s = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
β’ hasShape (nested l) s = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | case intro s_tail Hs =>
rw [Hs]; rw [Hs] at H; clear Hs H'
let H' := inferredShape_list H
simp [hasShape, motive_2 _ H'.2] | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) s = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) s = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | rw [Hs] | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) s = true | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) (List.length l :: s_tail) = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) s = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | rw [Hs] at H | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) (List.length l :: s_tail) = true | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons Hβ
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) (List.length l :: s_tail) = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
H : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons H
s_tail : List β
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) (List.length l :: s_tail) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | clear Hs H' | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons Hβ
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) (List.length l :: s_tail) = true | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
β’ hasShape (nested l) (List.length l :: s_tail) = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
H' : β tail, s = List.length l :: tail := inferredShape_list_to_cons Hβ
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
Hs : s = List.length l :: s_tail
β’ hasShape (nested l) (List.length l :: s_tail) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | let H' := inferredShape_list H | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
β’ hasShape (nested l) (List.length l :: s_tail) = true | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
H' : List.length l = List.length l β§ (List.all l fun x => decide (inferredShape x = some s_tail)) = true :=
inferredShape_list H
β’ hasShape (nested l) (List.length l :: s_tail) = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
β’ hasShape (nested l) (List.length l :: s_tail) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | simp [hasShape, motive_2 _ H'.2] | e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
H' : List.length l = List.length l β§ (List.all l fun x => decide (inferredShape x = some s_tail)) = true :=
inferredShape_list H
β’ hasShape (nested l) (List.length l :: s_tail) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
l : List TensorElem
motive_2 :
β (s : List β),
(List.all l fun x => decide (inferredShape x = some s)) = true β (List.all l fun x => hasShape x s) = true
s : List β
Hβ : inferredShape (nested l) = some s
s_tail : List β
H : inferredShape (nested l) = some (List.length l :: s_tail)
H' : List.length l = List.length l β§ (List.all l fun x => decide (inferredShape x = some s_tail)) = true :=
inferredShape_list H
β’ hasShape (nested l) (List.length l :: s_tail) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | simp [inferredShape] | e : TensorElem
β’ β (s : List β), inferredShape empty = some s β hasShape empty s = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
β’ β (s : List β), inferredShape empty = some s β hasShape empty s = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | intros s H | e : TensorElem
β’ β (s : List β),
(List.all [] fun x => decide (inferredShape x = some s)) = true β (List.all [] fun x => hasShape x s) = true | e : TensorElem
s : List β
H : (List.all [] fun x => decide (inferredShape x = some s)) = true
β’ (List.all [] fun x => hasShape x s) = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
β’ β (s : List β),
(List.all [] fun x => decide (inferredShape x = some s)) = true β (List.all [] fun x => hasShape x s) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | simp [List.all_nil] | e : TensorElem
s : List β
H : (List.all [] fun x => decide (inferredShape x = some s)) = true
β’ (List.all [] fun x => hasShape x s) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
s : List β
H : (List.all [] fun x => decide (inferredShape x = some s)) = true
β’ (List.all [] fun x => hasShape x s) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | intros head tail motive_1 ih s H | e : TensorElem
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β), inferredShape head = some s β hasShape head s = true) β
(β (s : List β),
(List.all tail fun x => decide (inferredShape x = some s)) = true β
(List.all tail fun x => hasShape x s) = true) β
β (s : List β),
(List.all (head :: tail) fun x => decide (inferredShape x = some s)) = true β
(List.all (head :: tail) fun x => hasShape x s) = true | e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
ih :
β (s : List β),
(List.all tail fun x => decide (inferredShape x = some s)) = true β (List.all tail fun x => hasShape x s) = true
s : List β
H : (List.all (head :: tail) fun x => decide (inferredShape x = some s)) = true
β’ (List.all (head :: tail) fun x => hasShape x s) = true | Please generate a tactic in lean4 to solve the state.
STATE:
e : TensorElem
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β), inferredShape head = some s β hasShape head s = true) β
(β (s : List β),
(List.all tail fun x => decide (inferredShape x = some s)) = true β
(List.all tail fun x => hasShape x s) = true) β
β (s : List β),
(List.all (head :: tail) fun x => decide (inferredShape x = some s)) = true β
(List.all (head :: tail) fun x => hasShape x s) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | simp [List.all_cons] at * | e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
ih :
β (s : List β),
(List.all tail fun x => decide (inferredShape x = some s)) = true β (List.all tail fun x => hasShape x s) = true
s : List β
H : (List.all (head :: tail) fun x => decide (inferredShape x = some s)) = true
β’ (List.all (head :: tail) fun x => hasShape x s) = true | e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
s : List β
ih :
β (s : List β),
(β (x : TensorElem), x β tail β inferredShape x = some s) β β (x : TensorElem), x β tail β hasShape x s = true
H : inferredShape head = some s β§ β (x : TensorElem), x β tail β inferredShape x = some s
β’ hasShape head s = true β§ β (x : TensorElem), x β tail β hasShape x s = true | Please generate a tactic in lean4 to solve the state.
STATE:
e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
ih :
β (s : List β),
(List.all tail fun x => decide (inferredShape x = some s)) = true β (List.all tail fun x => hasShape x s) = true
s : List β
H : (List.all (head :: tail) fun x => decide (inferredShape x = some s)) = true
β’ (List.all (head :: tail) fun x => hasShape x s) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | simp [motive_1 _ H.1, ih _ H.2] | e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
s : List β
ih :
β (s : List β),
(β (x : TensorElem), x β tail β inferredShape x = some s) β β (x : TensorElem), x β tail β hasShape x s = true
H : inferredShape head = some s β§ β (x : TensorElem), x β tail β inferredShape x = some s
β’ hasShape head s = true β§ β (x : TensorElem), x β tail β hasShape x s = true | e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
s : List β
ih :
β (s : List β),
(β (x : TensorElem), x β tail β inferredShape x = some s) β β (x : TensorElem), x β tail β hasShape x s = true
H : inferredShape head = some s β§ β (x : TensorElem), x β tail β inferredShape x = some s
β’ β (x : TensorElem), x β tail β hasShape x s = true | Please generate a tactic in lean4 to solve the state.
STATE:
e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
s : List β
ih :
β (s : List β),
(β (x : TensorElem), x β tail β inferredShape x = some s) β β (x : TensorElem), x β tail β hasShape x s = true
H : inferredShape head = some s β§ β (x : TensorElem), x β tail β inferredShape x = some s
β’ hasShape head s = true β§ β (x : TensorElem), x β tail β hasShape x s = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.hasShape_inferredShape | [244, 1] | [276, 10] | sorry | e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
s : List β
ih :
β (s : List β),
(β (x : TensorElem), x β tail β inferredShape x = some s) β β (x : TensorElem), x β tail β hasShape x s = true
H : inferredShape head = some s β§ β (x : TensorElem), x β tail β inferredShape x = some s
β’ β (x : TensorElem), x β tail β hasShape x s = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
e head : TensorElem
tail : List TensorElem
motive_1 : β (s : List β), inferredShape head = some s β hasShape head s = true
s : List β
ih :
β (s : List β),
(β (x : TensorElem), x β tail β inferredShape x = some s) β β (x : TensorElem), x β tail β hasShape x s = true
H : inferredShape head = some s β§ β (x : TensorElem), x β tail β inferredShape x = some s
β’ β (x : TensorElem), x β tail β hasShape x s = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_lift_refines | [332, 1] | [334, 35] | induction S <;> simp | S : List β
β’ shapeRefines S (List.map Dimension.Known S) = true | case cons
headβ : β
tailβ : List β
tail_ihβ : shapeRefines tailβ (List.map Dimension.Known tailβ) = true
β’ shapeRefines tailβ (List.map Dimension.Known tailβ) = true | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
β’ shapeRefines S (List.map Dimension.Known S) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_lift_refines | [332, 1] | [334, 35] | assumption | case cons
headβ : β
tailβ : List β
tail_ihβ : shapeRefines tailβ (List.map Dimension.Known tailβ) = true
β’ shapeRefines tailβ (List.map Dimension.Known tailβ) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
headβ : β
tailβ : List β
tail_ihβ : shapeRefines tailβ (List.map Dimension.Known tailβ) = true
β’ shapeRefines tailβ (List.map Dimension.Known tailβ) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_refines | [336, 1] | [340, 43] | intros h <;> induction D <;> simp | D : DimList
β’ known D = true β shapeRefines (project D) D = true | case cons
headβ : Dimension
tailβ : List Dimension
tail_ihβ : known tailβ = true β shapeRefines (project tailβ) tailβ = true
h : known (headβ :: tailβ) = true
β’ shapeRefines (project (headβ :: tailβ)) (headβ :: tailβ) = true | Please generate a tactic in lean4 to solve the state.
STATE:
D : DimList
β’ known D = true β shapeRefines (project D) D = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_refines | [336, 1] | [340, 43] | case cons head tail ih =>
cases head <;> simp at *; apply (ih h) | head : Dimension
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
h : known (head :: tail) = true
β’ shapeRefines (project (head :: tail)) (head :: tail) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
h : known (head :: tail) = true
β’ shapeRefines (project (head :: tail)) (head :: tail) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_refines | [336, 1] | [340, 43] | cases head <;> simp at * | head : Dimension
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
h : known (head :: tail) = true
β’ shapeRefines (project (head :: tail)) (head :: tail) = true | case Known
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
aβ : β
h : known tail = true
β’ shapeRefines (project tail) tail = true | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
h : known (head :: tail) = true
β’ shapeRefines (project (head :: tail)) (head :: tail) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_refines | [336, 1] | [340, 43] | apply (ih h) | case Known
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
aβ : β
h : known tail = true
β’ shapeRefines (project tail) tail = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case Known
tail : List Dimension
ih : known tail = true β shapeRefines (project tail) tail = true
aβ : β
h : known tail = true
β’ shapeRefines (project tail) tail = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | intros Hknown | D : DimList
S : List β
β’ known D = true β shapeRefines S D = true β D = List.map Dimension.Known S | D : DimList
S : List β
Hknown : known D = true
β’ shapeRefines S D = true β D = List.map Dimension.Known S | Please generate a tactic in lean4 to solve the state.
STATE:
D : DimList
S : List β
β’ known D = true β shapeRefines S D = true β D = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | revert S | D : DimList
S : List β
Hknown : known D = true
β’ shapeRefines S D = true β D = List.map Dimension.Known S | D : DimList
Hknown : known D = true
β’ β {S : List β}, shapeRefines S D = true β D = List.map Dimension.Known S | Please generate a tactic in lean4 to solve the state.
STATE:
D : DimList
S : List β
Hknown : known D = true
β’ shapeRefines S D = true β D = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | induction D <;> intros S Hrefines | D : DimList
Hknown : known D = true
β’ β {S : List β}, shapeRefines S D = true β D = List.map Dimension.Known S | case nil
Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ [] = List.map Dimension.Known S
case cons
headβ : Dimension
tailβ : List Dimension
tail_ihβ : known tailβ = true β β {S : List β}, shapeRefines S tailβ = true β tailβ = List.map Dimension.Known S
Hknown : known (headβ :: tailβ) = true
S : List β
Hrefines : shapeRefines S (headβ :: tailβ) = true
β’ headβ :: tailβ = List.map Dimension.Known S | Please generate a tactic in lean4 to solve the state.
STATE:
D : DimList
Hknown : known D = true
β’ β {S : List β}, shapeRefines S D = true β D = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | case nil =>
cases S; simp [List.map]; simp at Hrefines | Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ [] = List.map Dimension.Known S | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ [] = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | case cons head tail ih =>
cases S; simp at Hrefines
simp [List.map]; cases head <;> simp at *
rw [Hrefines.1, βih Hknown]; apply Hrefines.2 | head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ head :: tail = List.map Dimension.Known S | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ head :: tail = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | cases S | Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ [] = List.map Dimension.Known S | case nil
Hknown : known [] = true
Hrefines : shapeRefines [] [] = true
β’ [] = List.map Dimension.Known []
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ [] = List.map Dimension.Known (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ [] = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | simp [List.map] | case nil
Hknown : known [] = true
Hrefines : shapeRefines [] [] = true
β’ [] = List.map Dimension.Known []
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ [] = List.map Dimension.Known (headβ :: tailβ) | case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ [] = List.map Dimension.Known (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
Hknown : known [] = true
Hrefines : shapeRefines [] [] = true
β’ [] = List.map Dimension.Known []
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ [] = List.map Dimension.Known (headβ :: tailβ)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | simp at Hrefines | case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ [] = List.map Dimension.Known (headβ :: tailβ) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ [] = List.map Dimension.Known (headβ :: tailβ)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | cases S | head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ head :: tail = List.map Dimension.Known S | case nil
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
Hrefines : shapeRefines [] (head :: tail) = true
β’ head :: tail = List.map Dimension.Known []
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = List.map Dimension.Known (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ head :: tail = List.map Dimension.Known S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | simp at Hrefines | case nil
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
Hrefines : shapeRefines [] (head :: tail) = true
β’ head :: tail = List.map Dimension.Known []
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = List.map Dimension.Known (headβ :: tailβ) | case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = List.map Dimension.Known (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
Hrefines : shapeRefines [] (head :: tail) = true
β’ head :: tail = List.map Dimension.Known []
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = List.map Dimension.Known (headβ :: tailβ)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | simp [List.map] | case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = List.map Dimension.Known (headβ :: tailβ) | case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = Dimension.Known headβ :: List.map Dimension.Known tailβ | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = List.map Dimension.Known (headβ :: tailβ)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | cases head <;> simp at * | case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = Dimension.Known headβ :: List.map Dimension.Known tailβ | case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ Dimension.Known aβ :: tail = Dimension.Known headβ :: List.map Dimension.Known tailβ | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ head :: tail = Dimension.Known headβ :: List.map Dimension.Known tailβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | rw [Hrefines.1, βih Hknown] | case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ Dimension.Known aβ :: tail = Dimension.Known headβ :: List.map Dimension.Known tailβ | case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ shapeRefines tailβ tail = true | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ Dimension.Known aβ :: tail = Dimension.Known headβ :: List.map Dimension.Known tailβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_refines_inv | [342, 1] | [350, 50] | apply Hrefines.2 | case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ shapeRefines tailβ tail = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β tail = List.map Dimension.Known S
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ shapeRefines tailβ tail = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_eq | [352, 1] | [357, 35] | intros Hknown Hrefines | S : List β
D : DimList
β’ known D = true β shapeRefines S D = true β project D = S | S : List β
D : DimList
Hknown : known D = true
Hrefines : shapeRefines S D = true
β’ project D = S | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
D : DimList
β’ known D = true β shapeRefines S D = true β project D = S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_eq | [352, 1] | [357, 35] | rw [dim_known_refines_inv Hknown Hrefines] | S : List β
D : DimList
Hknown : known D = true
Hrefines : shapeRefines S D = true
β’ project D = S | S : List β
D : DimList
Hknown : known D = true
Hrefines : shapeRefines S D = true
β’ project (List.map Dimension.Known S) = S | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
D : DimList
Hknown : known D = true
Hrefines : shapeRefines S D = true
β’ project D = S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_eq | [352, 1] | [357, 35] | clear D Hknown Hrefines | S : List β
D : DimList
Hknown : known D = true
Hrefines : shapeRefines S D = true
β’ project (List.map Dimension.Known S) = S | S : List β
β’ project (List.map Dimension.Known S) = S | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
D : DimList
Hknown : known D = true
Hrefines : shapeRefines S D = true
β’ project (List.map Dimension.Known S) = S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_eq | [352, 1] | [357, 35] | induction S <;> simp | S : List β
β’ project (List.map Dimension.Known S) = S | case cons
headβ : β
tailβ : List β
tail_ihβ : project (List.map Dimension.Known tailβ) = tailβ
β’ project (List.map Dimension.Known tailβ) = tailβ | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
β’ project (List.map Dimension.Known S) = S
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_project_eq | [352, 1] | [357, 35] | assumption | case cons
headβ : β
tailβ : List β
tail_ihβ : project (List.map Dimension.Known tailβ) = tailβ
β’ project (List.map Dimension.Known tailβ) = tailβ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
headβ : β
tailβ : List β
tail_ihβ : project (List.map Dimension.Known tailβ) = tailβ
β’ project (List.map Dimension.Known tailβ) = tailβ
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | intros Hknown | S : List β
D : DimList
β’ known D = true β shapeRefines S D = true β shapeProd S = prod D | S : List β
D : DimList
Hknown : known D = true
β’ shapeRefines S D = true β shapeProd S = prod D | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
D : DimList
β’ known D = true β shapeRefines S D = true β shapeProd S = prod D
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | revert S | S : List β
D : DimList
Hknown : known D = true
β’ shapeRefines S D = true β shapeProd S = prod D | D : DimList
Hknown : known D = true
β’ β {S : List β}, shapeRefines S D = true β shapeProd S = prod D | Please generate a tactic in lean4 to solve the state.
STATE:
S : List β
D : DimList
Hknown : known D = true
β’ shapeRefines S D = true β shapeProd S = prod D
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | induction D <;> intros S Hrefines <;> simp | D : DimList
Hknown : known D = true
β’ β {S : List β}, shapeRefines S D = true β shapeProd S = prod D | case nil
Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ shapeProd S = 1
case cons
headβ : Dimension
tailβ : List Dimension
tail_ihβ : known tailβ = true β β {S : List β}, shapeRefines S tailβ = true β shapeProd S = prod tailβ
Hknown : known (headβ :: tailβ) = true
S : List β
Hrefines : shapeRefines S (headβ :: tailβ) = true
β’ shapeProd S = prod (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
D : DimList
Hknown : known D = true
β’ β {S : List β}, shapeRefines S D = true β shapeProd S = prod D
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | case nil =>
cases S; simp; simp at Hrefines | Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ shapeProd S = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ shapeProd S = 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | case cons head tail ih =>
cases S; simp at Hrefines
cases head <;> simp at *
rw [βHrefines.1, βih Hknown Hrefines.2] | head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ shapeProd S = prod (head :: tail) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ shapeProd S = prod (head :: tail)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | cases S | Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ shapeProd S = 1 | case nil
Hknown : known [] = true
Hrefines : shapeRefines [] [] = true
β’ shapeProd [] = 1
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ shapeProd (headβ :: tailβ) = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
Hknown : known [] = true
S : List β
Hrefines : shapeRefines S [] = true
β’ shapeProd S = 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | simp | case nil
Hknown : known [] = true
Hrefines : shapeRefines [] [] = true
β’ shapeProd [] = 1
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ shapeProd (headβ :: tailβ) = 1 | case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ shapeProd (headβ :: tailβ) = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
Hknown : known [] = true
Hrefines : shapeRefines [] [] = true
β’ shapeProd [] = 1
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ shapeProd (headβ :: tailβ) = 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | simp at Hrefines | case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ shapeProd (headβ :: tailβ) = 1 | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
Hknown : known [] = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) [] = true
β’ shapeProd (headβ :: tailβ) = 1
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | cases S | head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ shapeProd S = prod (head :: tail) | case nil
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
Hrefines : shapeRefines [] (head :: tail) = true
β’ shapeProd [] = prod (head :: tail)
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ shapeProd (headβ :: tailβ) = prod (head :: tail) | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
S : List β
Hrefines : shapeRefines S (head :: tail) = true
β’ shapeProd S = prod (head :: tail)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | simp at Hrefines | case nil
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
Hrefines : shapeRefines [] (head :: tail) = true
β’ shapeProd [] = prod (head :: tail)
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ shapeProd (headβ :: tailβ) = prod (head :: tail) | case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ shapeProd (headβ :: tailβ) = prod (head :: tail) | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
Hrefines : shapeRefines [] (head :: tail) = true
β’ shapeProd [] = prod (head :: tail)
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ shapeProd (headβ :: tailβ) = prod (head :: tail)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | cases head <;> simp at * | case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ shapeProd (headβ :: tailβ) = prod (head :: tail) | case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ headβ * shapeProd tailβ = aβ * prod tail | Please generate a tactic in lean4 to solve the state.
STATE:
case cons
head : Dimension
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
Hknown : known (head :: tail) = true
headβ : β
tailβ : List β
Hrefines : shapeRefines (headβ :: tailβ) (head :: tail) = true
β’ shapeProd (headβ :: tailβ) = prod (head :: tail)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.dim_known_prod_refines | [359, 1] | [367, 44] | rw [βHrefines.1, βih Hknown Hrefines.2] | case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ headβ * shapeProd tailβ = aβ * prod tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case cons.Known
tail : List Dimension
ih : known tail = true β β {S : List β}, shapeRefines S tail = true β shapeProd S = prod tail
headβ : β
tailβ : List β
aβ : β
Hknown : known tail = true
Hrefines : headβ = aβ β§ shapeRefines tailβ tail = true
β’ headβ * shapeProd tailβ = aβ * prod tail
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.defaultRefinement_refines | [374, 1] | [378, 37] | induction D <;> simp | D : DimList
β’ shapeRefines (defaultRefinement D) D = true | case cons
headβ : Dimension
tailβ : List Dimension
tail_ihβ : shapeRefines (defaultRefinement tailβ) tailβ = true
β’ shapeRefines (defaultRefinement (headβ :: tailβ)) (headβ :: tailβ) = true | Please generate a tactic in lean4 to solve the state.
STATE:
D : DimList
β’ shapeRefines (defaultRefinement D) D = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.defaultRefinement_refines | [374, 1] | [378, 37] | case cons head _ ih =>
cases head <;> simp <;> apply ih | head : Dimension
tailβ : List Dimension
ih : shapeRefines (defaultRefinement tailβ) tailβ = true
β’ shapeRefines (defaultRefinement (head :: tailβ)) (head :: tailβ) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tailβ : List Dimension
ih : shapeRefines (defaultRefinement tailβ) tailβ = true
β’ shapeRefines (defaultRefinement (head :: tailβ)) (head :: tailβ) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | DimList.defaultRefinement_refines | [374, 1] | [378, 37] | cases head <;> simp <;> apply ih | head : Dimension
tailβ : List Dimension
ih : shapeRefines (defaultRefinement tailβ) tailβ = true
β’ shapeRefines (defaultRefinement (head :: tailβ)) (head :: tailβ) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
head : Dimension
tailβ : List Dimension
ih : shapeRefines (defaultRefinement tailβ) tailβ = true
β’ shapeRefines (defaultRefinement (head :: tailβ)) (head :: tailβ) = true
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_list | [403, 1] | [410, 47] | revert h | Ο : MLIRTy
l : List TensorElem
h : hasType (nested l) Ο = true
β’ flatten (nested l) h = List.join (mapWithType l flatten h) | Ο : MLIRTy
l : List TensorElem
β’ β (h : hasType (nested l) Ο = true), flatten (nested l) h = List.join (mapWithType l flatten h) | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
h : hasType (nested l) Ο = true
β’ flatten (nested l) h = List.join (mapWithType l flatten h)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_list | [403, 1] | [410, 47] | induction l <;> intros h | Ο : MLIRTy
l : List TensorElem
β’ β (h : hasType (nested l) Ο = true), flatten (nested l) h = List.join (mapWithType l flatten h) | case nil
Ο : MLIRTy
h : hasType (nested []) Ο = true
β’ flatten (nested []) h = List.join (mapWithType [] flatten h)
case cons
Ο : MLIRTy
headβ : TensorElem
tailβ : List TensorElem
tail_ihβ : β (h : hasType (nested tailβ) Ο = true), flatten (nested tailβ) h = List.join (mapWithType tailβ flatten h)
h : hasType (nested (headβ :: tailβ)) Ο = true
β’ flatten (nested (headβ :: tailβ)) h = List.join (mapWithType (headβ :: tailβ) flatten h) | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
β’ β (h : hasType (nested l) Ο = true), flatten (nested l) h = List.join (mapWithType l flatten h)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_list | [403, 1] | [410, 47] | case nil =>
simp [flatten, mapWithType, List.join] | Ο : MLIRTy
h : hasType (nested []) Ο = true
β’ flatten (nested []) h = List.join (mapWithType [] flatten h) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
h : hasType (nested []) Ο = true
β’ flatten (nested []) h = List.join (mapWithType [] flatten h)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_list | [403, 1] | [410, 47] | case cons _ _ ih =>
simp [flatten, mapWithType, List.join, ih] | Ο : MLIRTy
headβ : TensorElem
tailβ : List TensorElem
ih : β (h : hasType (nested tailβ) Ο = true), flatten (nested tailβ) h = List.join (mapWithType tailβ flatten h)
h : hasType (nested (headβ :: tailβ)) Ο = true
β’ flatten (nested (headβ :: tailβ)) h = List.join (mapWithType (headβ :: tailβ) flatten h) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
headβ : TensorElem
tailβ : List TensorElem
ih : β (h : hasType (nested tailβ) Ο = true), flatten (nested tailβ) h = List.join (mapWithType tailβ flatten h)
h : hasType (nested (headβ :: tailβ)) Ο = true
β’ flatten (nested (headβ :: tailβ)) h = List.join (mapWithType (headβ :: tailβ) flatten h)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_list | [403, 1] | [410, 47] | simp [flatten, mapWithType, List.join] | Ο : MLIRTy
h : hasType (nested []) Ο = true
β’ flatten (nested []) h = List.join (mapWithType [] flatten h) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
h : hasType (nested []) Ο = true
β’ flatten (nested []) h = List.join (mapWithType [] flatten h)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_list | [403, 1] | [410, 47] | simp [flatten, mapWithType, List.join, ih] | Ο : MLIRTy
headβ : TensorElem
tailβ : List TensorElem
ih : β (h : hasType (nested tailβ) Ο = true), flatten (nested tailβ) h = List.join (mapWithType tailβ flatten h)
h : hasType (nested (headβ :: tailβ)) Ο = true
β’ flatten (nested (headβ :: tailβ)) h = List.join (mapWithType (headβ :: tailβ) flatten h) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
headβ : TensorElem
tailβ : List TensorElem
ih : β (h : hasType (nested tailβ) Ο = true), flatten (nested tailβ) h = List.join (mapWithType tailβ flatten h)
h : hasType (nested (headβ :: tailβ)) Ο = true
β’ flatten (nested (headβ :: tailβ)) h = List.join (mapWithType (headβ :: tailβ) flatten h)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | revert shape | Ο : MLIRTy
e : TensorElem
shape : List β
β’ hasShape e shape = true β β (h : hasType e Ο = true), List.length (flatten e h) = shapeProd shape | Ο : MLIRTy
e : TensorElem
β’ β (shape : List β), hasShape e shape = true β β (h : hasType e Ο = true), List.length (flatten e h) = shapeProd shape | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
e : TensorElem
shape : List β
β’ hasShape e shape = true β β (h : hasType e Ο = true), List.length (flatten e h) = shapeProd shape
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | apply @TensorElem.recOn
(motive_1 := fun e =>
βs, e.hasShape s β (h: e.hasType Ο) β (e.flatten h).length = shapeProd s)
(motive_2 := fun l =>
βs, l.all (TensorElem.hasShape . s) β (h: l.all (hasType . Ο)) β
(mapWithType l flatten (hasType_list_2 h)).join.length = l.length * shapeProd s)
<;> simp <;> clear e | Ο : MLIRTy
e : TensorElem
β’ β (shape : List β), hasShape e shape = true β β (h : hasType e Ο = true), List.length (flatten e h) = shapeProd shape | case int
Ο : MLIRTy
β’ β (a : β€) (s : List β),
hasShape (int a) s = true β β (h : hasType (int a) Ο = true), List.length (flatten (int a) h) = shapeProd s
case float
Ο : MLIRTy
β’ β (a : Float) (s : List β),
hasShape (float a) s = true β β (h : hasType (float a) Ο = true), List.length (flatten (float a) h) = shapeProd s
case bool
Ο : MLIRTy
β’ (β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s) β§
β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
case nested
Ο : MLIRTy
β’ β (a : List TensorElem),
(β (s : List β),
(β (x : TensorElem), x β a β hasShape x s = true) β
β (h : (List.all a fun x => hasType x Ο) = true),
List.length (List.join (mapWithType a flatten (_ : hasType (nested a) Ο = true))) =
List.length a * shapeProd s) β
β (s : List β),
hasShape (nested a) s = true β
β (h : hasType (nested a) Ο = true), List.length (flatten (nested a) h) = shapeProd s
case empty
Ο : MLIRTy
β’ β (s : List β), hasShape empty s = true β β (h : hasType empty Ο = true), List.length (flatten empty h) = shapeProd s
case cons
Ο : MLIRTy
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β),
hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s) β
(β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s) β
β (s : List β),
hasShape head s = true β
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all (head :: tail) fun x => hasType x Ο) = true),
List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
e : TensorElem
β’ β (shape : List β), hasShape e shape = true β β (h : hasType e Ο = true), List.length (flatten e h) = shapeProd shape
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case int =>
intros i s Hshape Htype;
cases Ο <;> simp [hasType] at Htype
cases s <;> simp [flatten, hasShape] at * | Ο : MLIRTy
β’ β (a : β€) (s : List β),
hasShape (int a) s = true β β (h : hasType (int a) Ο = true), List.length (flatten (int a) h) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (a : β€) (s : List β),
hasShape (int a) s = true β β (h : hasType (int a) Ο = true), List.length (flatten (int a) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case float =>
intros i s Hshape Htype;
cases Ο <;> simp [hasType] at Htype
cases s <;> simp [flatten, hasShape] at * | Ο : MLIRTy
β’ β (a : Float) (s : List β),
hasShape (float a) s = true β β (h : hasType (float a) Ο = true), List.length (flatten (float a) h) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (a : Float) (s : List β),
hasShape (float a) s = true β β (h : hasType (float a) Ο = true), List.length (flatten (float a) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case bool =>
constructor;
intros s;
intros Hshape;
intros Htype;
cases Ο <;> simp [hasType] at Htype
cases s <;> simp [flatten, hasShape] at *
sorry | Ο : MLIRTy
β’ (β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s) β§
β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ (β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s) β§
β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case nested =>
intros l motive_2 s Hshape Htype
cases s <;> simp [hasShape] at Hshape
case cons s_head s_tail =>
simp [TensorElem.flatten_list, shapeProd, List.foldr]
simp [motive_2 s_tail Hshape.2 (hasType_list_1 Htype)]
simp [shapeProd, Nat.mul_comm, Hshape.1] | Ο : MLIRTy
β’ β (a : List TensorElem),
(β (s : List β),
(β (x : TensorElem), x β a β hasShape x s = true) β
β (h : (List.all a fun x => hasType x Ο) = true),
List.length (List.join (mapWithType a flatten (_ : hasType (nested a) Ο = true))) =
List.length a * shapeProd s) β
β (s : List β),
hasShape (nested a) s = true β
β (h : hasType (nested a) Ο = true), List.length (flatten (nested a) h) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (a : List TensorElem),
(β (s : List β),
(β (x : TensorElem), x β a β hasShape x s = true) β
β (h : (List.all a fun x => hasType x Ο) = true),
List.length (List.join (mapWithType a flatten (_ : hasType (nested a) Ο = true))) =
List.length a * shapeProd s) β
β (s : List β),
hasShape (nested a) s = true β
β (h : hasType (nested a) Ο = true), List.length (flatten (nested a) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case empty =>
intros s Hshape Htype
simp [hasType] at Htype | Ο : MLIRTy
β’ β (s : List β), hasShape empty s = true β β (h : hasType empty Ο = true), List.length (flatten empty h) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (s : List β), hasShape empty s = true β β (h : hasType empty Ο = true), List.length (flatten empty h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case cons =>
intros head tail motive_1 IH2 s Hshape1 Hshape2 Htype1
simp [List.map, List.join]
rw [Nat.add_comm]
simp [Nat.succ_eq_add_one, Nat.right_distrib]
simp [List.all_cons] at Hshape1
simp [List.all_cons] at Htype1
sorry | Ο : MLIRTy
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β),
hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s) β
(β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s) β
β (s : List β),
hasShape head s = true β
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all (head :: tail) fun x => hasType x Ο) = true),
List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β),
hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s) β
(β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s) β
β (s : List β),
hasShape head s = true β
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all (head :: tail) fun x => hasType x Ο) = true),
List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros i s Hshape Htype | Ο : MLIRTy
β’ β (a : β€) (s : List β),
hasShape (int a) s = true β β (h : hasType (int a) Ο = true), List.length (flatten (int a) h) = shapeProd s | Ο : MLIRTy
i : β€
s : List β
Hshape : hasShape (int i) s = true
Htype : hasType (int i) Ο = true
β’ List.length (flatten (int i) Htype) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (a : β€) (s : List β),
hasShape (int a) s = true β β (h : hasType (int a) Ο = true), List.length (flatten (int a) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases Ο <;> simp [hasType] at Htype | Ο : MLIRTy
i : β€
s : List β
Hshape : hasShape (int i) s = true
Htype : hasType (int i) Ο = true
β’ List.length (flatten (int i) Htype) = shapeProd s | case int
i : β€
s : List β
Hshape : hasShape (int i) s = true
aβΒΉ : Signedness
aβ : β
Htypeβ : hasType (int i) (MLIRType.int aβΒΉ aβ) = true
Htype : FinInt.isInBounds aβΒΉ aβ i = true
β’ List.length (flatten (int i) Htypeβ) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
i : β€
s : List β
Hshape : hasShape (int i) s = true
Htype : hasType (int i) Ο = true
β’ List.length (flatten (int i) Htype) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases s <;> simp [flatten, hasShape] at * | case int
i : β€
s : List β
Hshape : hasShape (int i) s = true
aβΒΉ : Signedness
aβ : β
Htypeβ : hasType (int i) (MLIRType.int aβΒΉ aβ) = true
Htype : FinInt.isInBounds aβΒΉ aβ i = true
β’ List.length (flatten (int i) Htypeβ) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case int
i : β€
s : List β
Hshape : hasShape (int i) s = true
aβΒΉ : Signedness
aβ : β
Htypeβ : hasType (int i) (MLIRType.int aβΒΉ aβ) = true
Htype : FinInt.isInBounds aβΒΉ aβ i = true
β’ List.length (flatten (int i) Htypeβ) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros i s Hshape Htype | Ο : MLIRTy
β’ β (a : Float) (s : List β),
hasShape (float a) s = true β β (h : hasType (float a) Ο = true), List.length (flatten (float a) h) = shapeProd s | Ο : MLIRTy
i : Float
s : List β
Hshape : hasShape (float i) s = true
Htype : hasType (float i) Ο = true
β’ List.length (flatten (float i) Htype) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (a : Float) (s : List β),
hasShape (float a) s = true β β (h : hasType (float a) Ο = true), List.length (flatten (float a) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases Ο <;> simp [hasType] at Htype | Ο : MLIRTy
i : Float
s : List β
Hshape : hasShape (float i) s = true
Htype : hasType (float i) Ο = true
β’ List.length (flatten (float i) Htype) = shapeProd s | case float
i : Float
s : List β
Hshape : hasShape (float i) s = true
aβ : β
Htypeβ : hasType (float i) (MLIRType.float aβ) = true
Htype : True
β’ List.length (flatten (float i) Htypeβ) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
i : Float
s : List β
Hshape : hasShape (float i) s = true
Htype : hasType (float i) Ο = true
β’ List.length (flatten (float i) Htype) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases s <;> simp [flatten, hasShape] at * | case float
i : Float
s : List β
Hshape : hasShape (float i) s = true
aβ : β
Htypeβ : hasType (float i) (MLIRType.float aβ) = true
Htype : True
β’ List.length (flatten (float i) Htypeβ) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case float
i : Float
s : List β
Hshape : hasShape (float i) s = true
aβ : β
Htypeβ : hasType (float i) (MLIRType.float aβ) = true
Htype : True
β’ List.length (flatten (float i) Htypeβ) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | constructor | Ο : MLIRTy
β’ (β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s) β§
β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | case left
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ (β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s) β§
β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros s | case left
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | case left
Ο : MLIRTy
s : List β
β’ hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
case left
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros Hshape | case left
Ο : MLIRTy
s : List β
β’ hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | case left
Ο : MLIRTy
s : List β
Hshape : hasShape (bool false) s = true
β’ β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
case left
Ο : MLIRTy
s : List β
β’ hasShape (bool false) s = true β
β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros Htype | case left
Ο : MLIRTy
s : List β
Hshape : hasShape (bool false) s = true
β’ β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | case left
Ο : MLIRTy
s : List β
Hshape : hasShape (bool false) s = true
Htype : hasType (bool false) Ο = true
β’ List.length (flatten (bool false) Htype) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
case left
Ο : MLIRTy
s : List β
Hshape : hasShape (bool false) s = true
β’ β (h : hasType (bool false) Ο = true), List.length (flatten (bool false) h) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases Ο <;> simp [hasType] at Htype | case left
Ο : MLIRTy
s : List β
Hshape : hasShape (bool false) s = true
Htype : hasType (bool false) Ο = true
β’ List.length (flatten (bool false) Htype) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | case left.int
s : List β
Hshape : hasShape (bool false) s = true
aβΒΉ : Signedness
aβ : β
Htype : hasType (bool false) (MLIRType.int aβΒΉ aβ) = true
β’ List.length (flatten (bool false) Htype) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
case left
Ο : MLIRTy
s : List β
Hshape : hasShape (bool false) s = true
Htype : hasType (bool false) Ο = true
β’ List.length (flatten (bool false) Htype) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases s <;> simp [flatten, hasShape] at * | case left.int
s : List β
Hshape : hasShape (bool false) s = true
aβΒΉ : Signedness
aβ : β
Htype : hasType (bool false) (MLIRType.int aβΒΉ aβ) = true
β’ List.length (flatten (bool false) Htype) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
case left.int
s : List β
Hshape : hasShape (bool false) s = true
aβΒΉ : Signedness
aβ : β
Htype : hasType (bool false) (MLIRType.int aβΒΉ aβ) = true
β’ List.length (flatten (bool false) Htype) = shapeProd s
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | sorry | case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case right
Ο : MLIRTy
β’ β (s : List β),
hasShape (bool true) s = true β
β (h : hasType (bool true) Ο = true), List.length (flatten (bool true) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros l motive_2 s Hshape Htype | Ο : MLIRTy
β’ β (a : List TensorElem),
(β (s : List β),
(β (x : TensorElem), x β a β hasShape x s = true) β
β (h : (List.all a fun x => hasType x Ο) = true),
List.length (List.join (mapWithType a flatten (_ : hasType (nested a) Ο = true))) =
List.length a * shapeProd s) β
β (s : List β),
hasShape (nested a) s = true β
β (h : hasType (nested a) Ο = true), List.length (flatten (nested a) h) = shapeProd s | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
s : List β
Hshape : hasShape (nested l) s = true
Htype : hasType (nested l) Ο = true
β’ List.length (flatten (nested l) Htype) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (a : List TensorElem),
(β (s : List β),
(β (x : TensorElem), x β a β hasShape x s = true) β
β (h : (List.all a fun x => hasType x Ο) = true),
List.length (List.join (mapWithType a flatten (_ : hasType (nested a) Ο = true))) =
List.length a * shapeProd s) β
β (s : List β),
hasShape (nested a) s = true β
β (h : hasType (nested a) Ο = true), List.length (flatten (nested a) h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | cases s <;> simp [hasShape] at Hshape | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
s : List β
Hshape : hasShape (nested l) s = true
Htype : hasType (nested l) Ο = true
β’ List.length (flatten (nested l) Htype) = shapeProd s | case cons
Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
headβ : β
tailβ : List β
Hshape : List.length l = headβ β§ β (x : TensorElem), x β l β hasShape x tailβ = true
β’ List.length (flatten (nested l) Htype) = shapeProd (headβ :: tailβ) | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
s : List β
Hshape : hasShape (nested l) s = true
Htype : hasType (nested l) Ο = true
β’ List.length (flatten (nested l) Htype) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | case cons s_head s_tail =>
simp [TensorElem.flatten_list, shapeProd, List.foldr]
simp [motive_2 s_tail Hshape.2 (hasType_list_1 Htype)]
simp [shapeProd, Nat.mul_comm, Hshape.1] | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (flatten (nested l) Htype) = shapeProd (s_head :: s_tail) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (flatten (nested l) Htype) = shapeProd (s_head :: s_tail)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | simp [TensorElem.flatten_list, shapeProd, List.foldr] | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (flatten (nested l) Htype) = shapeProd (s_head :: s_tail) | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (List.join (mapWithType l flatten Htype)) = s_head * List.foldr (fun x x_1 => x * x_1) 1 s_tail | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (flatten (nested l) Htype) = shapeProd (s_head :: s_tail)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | simp [motive_2 s_tail Hshape.2 (hasType_list_1 Htype)] | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (List.join (mapWithType l flatten Htype)) = s_head * List.foldr (fun x x_1 => x * x_1) 1 s_tail | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length l * shapeProd s_tail = s_head * List.foldr (fun x x_1 => x * x_1) 1 s_tail | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length (List.join (mapWithType l flatten Htype)) = s_head * List.foldr (fun x x_1 => x * x_1) 1 s_tail
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | simp [shapeProd, Nat.mul_comm, Hshape.1] | Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length l * shapeProd s_tail = s_head * List.foldr (fun x x_1 => x * x_1) 1 s_tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
l : List TensorElem
motive_2 :
β (s : List β),
(β (x : TensorElem), x β l β hasShape x s = true) β
β (h : (List.all l fun x => hasType x Ο) = true),
List.length (List.join (mapWithType l flatten (_ : hasType (nested l) Ο = true))) = List.length l * shapeProd s
Htype : hasType (nested l) Ο = true
s_head : β
s_tail : List β
Hshape : List.length l = s_head β§ β (x : TensorElem), x β l β hasShape x s_tail = true
β’ List.length l * shapeProd s_tail = s_head * List.foldr (fun x x_1 => x * x_1) 1 s_tail
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros s Hshape Htype | Ο : MLIRTy
β’ β (s : List β), hasShape empty s = true β β (h : hasType empty Ο = true), List.length (flatten empty h) = shapeProd s | Ο : MLIRTy
s : List β
Hshape : hasShape empty s = true
Htype : hasType empty Ο = true
β’ List.length (flatten empty Htype) = shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (s : List β), hasShape empty s = true β β (h : hasType empty Ο = true), List.length (flatten empty h) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | simp [hasType] at Htype | Ο : MLIRTy
s : List β
Hshape : hasShape empty s = true
Htype : hasType empty Ο = true
β’ List.length (flatten empty Htype) = shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
s : List β
Hshape : hasShape empty s = true
Htype : hasType empty Ο = true
β’ List.length (flatten empty Htype) = shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | intros head tail motive_1 IH2 s Hshape1 Hshape2 Htype1 | Ο : MLIRTy
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β),
hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s) β
(β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s) β
β (s : List β),
hasShape head s = true β
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all (head :: tail) fun x => hasType x Ο) = true),
List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
β’ β (head : TensorElem) (tail : List TensorElem),
(β (s : List β),
hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s) β
(β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s) β
β (s : List β),
hasShape head s = true β
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all (head :: tail) fun x => hasType x Ο) = true),
List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | rw [Nat.add_comm] | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
Nat.succ (List.length tail) * shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (flatten head (_ : hasType head Ο = true)) +
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
Nat.succ (List.length tail) * shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | simp [Nat.succ_eq_add_one, Nat.right_distrib] | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
Nat.succ (List.length tail) * shapeProd s | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
List.length tail * shapeProd s + shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
Nat.succ (List.length tail) * shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | simp [List.all_cons] at Htype1 | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
List.length tail * shapeProd s + shapeProd s | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1β : (List.all (head :: tail) fun x => hasType x Ο) = true
Htype1 : hasType head Ο = true β§ β (x : TensorElem), x β tail β hasType x Ο = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
List.length tail * shapeProd s + shapeProd s | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1 : (List.all (head :: tail) fun x => hasType x Ο) = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
List.length tail * shapeProd s + shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/TensorElem.lean | MLIR.AST.TensorElem.flatten_size | [413, 1] | [462, 10] | sorry | Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1β : (List.all (head :: tail) fun x => hasType x Ο) = true
Htype1 : hasType head Ο = true β§ β (x : TensorElem), x β tail β hasType x Ο = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
List.length tail * shapeProd s + shapeProd s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
Ο : MLIRTy
head : TensorElem
tail : List TensorElem
motive_1 :
β (s : List β), hasShape head s = true β β (h : hasType head Ο = true), List.length (flatten head h) = shapeProd s
IH2 :
β (s : List β),
(β (x : TensorElem), x β tail β hasShape x s = true) β
β (h : (List.all tail fun x => hasType x Ο) = true),
List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) =
List.length tail * shapeProd s
s : List β
Hshape1 : hasShape head s = true
Hshape2 : β (x : TensorElem), x β tail β hasShape x s = true
Htype1β : (List.all (head :: tail) fun x => hasType x Ο) = true
Htype1 : hasType head Ο = true β§ β (x : TensorElem), x β tail β hasType x Ο = true
β’ List.length (List.join (mapWithType tail flatten (_ : hasType (nested tail) Ο = true))) +
List.length (flatten head (_ : hasType head Ο = true)) =
List.length tail * shapeProd s + shapeProd s
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ArithSemantics.lean | th1.equivalent | [364, 1] | [373, 26] | simp [LHS, RHS,
run, StateT.run,
denoteOp, bind, List.mapM, StateT.bind, denoteOpArgs, List.mapM,
List.mapM.loop, Except.bind, TopM.get, StateT.get, pure, Except.pure,
StateT.pure, TopM.mapDenoteRegion, OpM.toTopM, TopM.set, StateT.set, MLIRType.eval,
SSAEnv.get, SSAEnv.getT, cast] | n m : FinInt 32
β’ run β¦ LHS β§
(SSAEnv.One
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }),
(SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m })]) =
run β¦ RHS β§
(SSAEnv.One
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }),
(SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m })]) | n m : FinInt 32
β’ FinInt.add n m = FinInt.add m n β§
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }), (SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m }),
(SSAVal.SSAVal "r", { fst := MLIRType.int Signedness.Signless 32, snd := FinInt.add n m })] =
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }), (SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m }),
(SSAVal.SSAVal "r", { fst := MLIRType.int Signedness.Signless 32, snd := FinInt.add m n })] | Please generate a tactic in lean4 to solve the state.
STATE:
n m : FinInt 32
β’ run β¦ LHS β§
(SSAEnv.One
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }),
(SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m })]) =
run β¦ RHS β§
(SSAEnv.One
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }),
(SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m })])
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ArithSemantics.lean | th1.equivalent | [364, 1] | [373, 26] | simp [FinInt.add_comm'] | n m : FinInt 32
β’ FinInt.add n m = FinInt.add m n β§
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }), (SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m }),
(SSAVal.SSAVal "r", { fst := MLIRType.int Signedness.Signless 32, snd := FinInt.add n m })] =
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }), (SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m }),
(SSAVal.SSAVal "r", { fst := MLIRType.int Signedness.Signless 32, snd := FinInt.add m n })] | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
n m : FinInt 32
β’ FinInt.add n m = FinInt.add m n β§
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }), (SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m }),
(SSAVal.SSAVal "r", { fst := MLIRType.int Signedness.Signless 32, snd := FinInt.add n m })] =
[(SSAVal.SSAVal "n", { fst := MLIRType.i32, snd := n }), (SSAVal.SSAVal "m", { fst := MLIRType.i32, snd := m }),
(SSAVal.SSAVal "r", { fst := MLIRType.int Signedness.Signless 32, snd := FinInt.add m n })]
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ArithSemantics.lean | FinInt.sub_add_dist | [409, 1] | [415, 41] | intros C X C2 | sz : β
β’ β (C X C2 : FinInt sz), C - (X + C2) = C - C2 - X | sz : β
C X C2 : FinInt sz
β’ C - (X + C2) = C - C2 - X | Please generate a tactic in lean4 to solve the state.
STATE:
sz : β
β’ β (C X C2 : FinInt sz), C - (X + C2) = C - C2 - X
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ArithSemantics.lean | FinInt.sub_add_dist | [409, 1] | [415, 41] | apply eq_of_toUint_cong2 | sz : β
C X C2 : FinInt sz
β’ C - (X + C2) = C - C2 - X | case a
sz : β
C X C2 : FinInt sz
β’ toUint (C - (X + C2)) β‘ toUint (C - C2 - X) [2^sz] | Please generate a tactic in lean4 to solve the state.
STATE:
sz : β
C X C2 : FinInt sz
β’ C - (X + C2) = C - C2 - X
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ArithSemantics.lean | FinInt.sub_add_dist | [409, 1] | [415, 41] | simp [cong2, FinInt.sub_toUint, FinInt.add_toUint] | case a
sz : β
C X C2 : FinInt sz
β’ toUint (C - (X + C2)) β‘ toUint (C - C2 - X) [2^sz] | case a
sz : β
C X C2 : FinInt sz
β’ mod2 (toUint C - (toUint X + toUint C2)) sz = mod2 (toUint C - toUint C2 - toUint X) sz | Please generate a tactic in lean4 to solve the state.
STATE:
case a
sz : β
C X C2 : FinInt sz
β’ toUint (C - (X + C2)) β‘ toUint (C - C2 - X) [2^sz]
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Dialects/ArithSemantics.lean | FinInt.sub_add_dist | [409, 1] | [415, 41] | apply FinInt.mod2_fequal | case a
sz : β
C X C2 : FinInt sz
β’ mod2 (toUint C - (toUint X + toUint C2)) sz = mod2 (toUint C - toUint C2 - toUint X) sz | case a.a
sz : β
C X C2 : FinInt sz
β’ toUint C - (toUint X + toUint C2) = toUint C - toUint C2 - toUint X | Please generate a tactic in lean4 to solve the state.
STATE:
case a
sz : β
C X C2 : FinInt sz
β’ mod2 (toUint C - (toUint X + toUint C2)) sz = mod2 (toUint C - toUint C2 - toUint X) sz
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.