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/Semantics.lean | mapDenoteRegion_equiv | [970, 1] | [992, 49] | case inl HXX =>
subst HXX;
sorry | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region = TopM.scoped ∘ denoteRegion Δ head
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region = TopM.scoped ∘ denoteRegion Δ head
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | mapDenoteRegion_equiv | [970, 1] | [992, 49] | case inr HXX =>
apply mapDenoteRegion_equiv <;> assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | mapDenoteRegion_equiv | [970, 1] | [992, 49] | subst HXX | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region = TopM.scoped ∘ denoteRegion Δ head
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂') | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : Function.comp TopM.scoped (denoteRegion Δ head) args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ Function.comp TopM.scoped (denoteRegion Δ head) args env₂ = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region = TopM.scoped ∘ denoteRegion Δ head
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | mapDenoteRegion_equiv | [970, 1] | [992, 49] | sorry | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : Function.comp TopM.scoped (denoteRegion Δ head) args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ Function.comp TopM.scoped (denoteRegion Δ head) args env₂ = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : Function.comp TopM.scoped (denoteRegion Δ head) args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ Function.comp TopM.scoped (denoteRegion Δ head) args env₂ = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | mapDenoteRegion_equiv | [970, 1] | [992, 49] | apply mapDenoteRegion_equiv <;> assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HXX : region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | induction args | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
args : List (TypedSSAVal Δ)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ args env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all args fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ args (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ [] env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
tail_ih✝ :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail✝ env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail✝ fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail✝ (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ (head✝ :: tail✝) env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all (head✝ :: tail✝) fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ (head✝ :: tail✝) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
args : List (TypedSSAVal Δ)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ args env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all args fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ args (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | case nil =>
intros env r resEnv H
simp [denoteOpArgs] at *
simp_monad at *
cases H; subst r env; simp | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ [] env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ [] env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | case cons head tail HInd =>
intros env r resEnv H name Hname τ v
simp [denoteOpArgs]; simp [denoteOpArgs] at H
have ⟨headName, headτ⟩ := head
simp_monad at *
cases Hhead: (TopM.get headτ headName env)
case error _ =>
rw [Hhead] at H; contradiction
case ok headRes =>
rw [Hhead] at H
simp [List.all, List.foldr] at Hname
have ⟨Hname_head, _⟩ := Hname
rw [TopM.get_env_set_commutes Hhead Hname_head]
simp at *
split at H <;> try contradiction
case h_2 rTail Htail =>
have ⟨rTailRes, rTailEnv⟩ := rTail
simp at H; have ⟨_, _⟩ := H; subst r resEnv
simp [denoteOpArgs] at *
simp [bind, StateT.bind, Except.bind, pure, StateT.pure, Except.pure] at HInd
rw [HInd] <;> assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | intros env r resEnv H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ [] env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ [] env = Except.ok (r, resEnv)
⊢ ∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ [] env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp [denoteOpArgs] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ [] env = Except.ok (r, resEnv)
⊢ ∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : pure [] env = Except.ok (r, resEnv)
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
pure [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ [] env = Except.ok (r, resEnv)
⊢ ∀ ⦃name : SSAVal⦄,
(List.all [] fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp_monad at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : pure [] env = Except.ok (r, resEnv)
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
pure [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : [] = r ∧ env = resEnv
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = r ∧ SSAEnv.set name τ v env = SSAEnv.set name τ v resEnv | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : pure [] env = Except.ok (r, resEnv)
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
pure [] (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | cases H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : [] = r ∧ env = resEnv
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = r ∧ SSAEnv.set name τ v env = SSAEnv.set name τ v resEnv | case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
left✝ : [] = r
right✝ : env = resEnv
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = r ∧ SSAEnv.set name τ v env = SSAEnv.set name τ v resEnv | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : [] = r ∧ env = resEnv
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = r ∧ SSAEnv.set name τ v env = SSAEnv.set name τ v resEnv
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | subst r env | case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
left✝ : [] = r
right✝ : env = resEnv
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = r ∧ SSAEnv.set name τ v env = SSAEnv.set name τ v resEnv | case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
resEnv : SSAEnv Δ
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = [] ∧ SSAEnv.set name τ v resEnv = SSAEnv.set name τ v resEnv | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
left✝ : [] = r
right✝ : env = resEnv
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = r ∧ SSAEnv.set name τ v env = SSAEnv.set name τ v resEnv
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp | case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
resEnv : SSAEnv Δ
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = [] ∧ SSAEnv.set name τ v resEnv = SSAEnv.set name τ v resEnv | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
resEnv : SSAEnv Δ
⊢ ∀ ⦃name : SSAVal⦄ (τ : MLIRType Δ) (v : MLIRType.eval τ),
[] = [] ∧ SSAEnv.set name τ v resEnv = SSAEnv.set name τ v resEnv
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | intros env r resEnv H name Hname τ v | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv)
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
⊢ denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp [denoteOpArgs] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv)
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
⊢ denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv)
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
⊢ bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv)
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
⊢ denoteOpArgs Δ (head :: tail) (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp [denoteOpArgs] at H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv)
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
⊢ bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
H :
bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
env =
Except.ok (r, resEnv)
⊢ bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, resEnv)
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
⊢ bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | have ⟨headName, headτ⟩ := head | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
H :
bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
env =
Except.ok (r, resEnv)
⊢ bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
Hname : (List.all ((headName, headτ) :: tail) fun arg => decide (name ≠ arg.fst)) = true
H :
bind (TopM.get (headName, headτ).snd (headName, headτ).fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := (headName, headτ).snd, snd := x } :: __do_lift))
env =
Except.ok (r, resEnv)
⊢ bind (TopM.get (headName, headτ).snd (headName, headτ).fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := (headName, headτ).snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
Hname : (List.all (head :: tail) fun arg => decide (name ≠ arg.fst)) = true
τ : MLIRType Δ
v : MLIRType.eval τ
H :
bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
env =
Except.ok (r, resEnv)
⊢ bind (TopM.get head.snd head.fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := head.snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp_monad at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
Hname : (List.all ((headName, headτ) :: tail) fun arg => decide (name ≠ arg.fst)) = true
H :
bind (TopM.get (headName, headτ).snd (headName, headτ).fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := (headName, headτ).snd, snd := x } :: __do_lift))
env =
Except.ok (r, resEnv)
⊢ bind (TopM.get (headName, headτ).snd (headName, headτ).fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := (headName, headτ).snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(List.all tail fun arg => decide (name ≠ arg.fst)) = true →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
Hname : (List.all ((headName, headτ) :: tail) fun arg => decide (name ≠ arg.fst)) = true
H :
bind (TopM.get (headName, headτ).snd (headName, headτ).fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := (headName, headτ).snd, snd := x } :: __do_lift))
env =
Except.ok (r, resEnv)
⊢ bind (TopM.get (headName, headτ).snd (headName, headτ).fst)
(fun x => do
let __do_lift ←
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail
pure ({ fst := (headName, headτ).snd, snd := x } :: __do_lift))
(SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | cases Hhead: (TopM.get headτ headName env) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | case error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | case error _ =>
rw [Hhead] at H; contradiction | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | case ok headRes =>
rw [Hhead] at H
simp [List.all, List.foldr] at Hname
have ⟨Hname_head, _⟩ := Hname
rw [TopM.get_env_set_commutes Hhead Hname_head]
simp at *
split at H <;> try contradiction
case h_2 rTail Htail =>
have ⟨rTailRes, rTailEnv⟩ := rTail
simp at H; have ⟨_, _⟩ := H; subst r resEnv
simp [denoteOpArgs] at *
simp [bind, StateT.bind, Except.bind, pure, StateT.pure, Except.pure] at HInd
rw [HInd] <;> assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | rw [Hhead] at H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
H :
(match Except.error a✝ with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | contradiction | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
H :
(match Except.error a✝ with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
a✝ : String × SSAEnv Δ
H :
(match Except.error a✝ with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.error a✝
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | rw [Hhead] at H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
H :
(match TopM.get headτ headName env with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | have ⟨Hname_head, _⟩ := Hname | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | rw [TopM.get_env_set_commutes Hhead Hname_head] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match Except.ok (headRes.fst, SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match TopM.get headτ headName (SSAEnv.set name τ v env) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match Except.ok (headRes.fst, SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match Except.ok headRes with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match Except.ok (headRes.fst, SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v =>
match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok ({ fst := headτ, snd := v.fst } :: v_1.fst, v_1.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | split at H <;> try contradiction | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
v✝ : List (TypedArg Δ) × SSAEnv Δ
heq✝ :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok v✝
H : Except.ok ({ fst := headτ, snd := headRes.fst } :: v✝.fst, v✝.snd) = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, resEnv)
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | case h_2 rTail Htail =>
have ⟨rTailRes, rTailEnv⟩ := rTail
simp at H; have ⟨_, _⟩ := H; subst r resEnv
simp [denoteOpArgs] at *
simp [bind, StateT.bind, Except.bind, pure, StateT.pure, Except.pure] at HInd
rw [HInd] <;> assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok rTail
H : Except.ok ({ fst := headτ, snd := headRes.fst } :: rTail.fst, rTail.snd) = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok rTail
H : Except.ok ({ fst := headτ, snd := headRes.fst } :: rTail.fst, rTail.snd) = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | contradiction | case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.error err✝
H : Except.error err✝ = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.error err✝
H : Except.error err✝ = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | have ⟨rTailRes, rTailEnv⟩ := rTail | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok rTail
H : Except.ok ({ fst := headτ, snd := headRes.fst } :: rTail.fst, rTail.snd) = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H :
Except.ok ({ fst := headτ, snd := headRes.fst } :: (rTailRes, rTailEnv).fst, (rTailRes, rTailEnv).snd) =
Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok rTail
H : Except.ok ({ fst := headτ, snd := headRes.fst } :: rTail.fst, rTail.snd) = Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp at H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H :
Except.ok ({ fst := headτ, snd := headRes.fst } :: (rTailRes, rTailEnv).fst, (rTailRes, rTailEnv).snd) =
Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : { fst := headτ, snd := headRes.fst } :: rTailRes = r ∧ rTailEnv = resEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H :
Except.ok ({ fst := headτ, snd := headRes.fst } :: (rTailRes, rTailEnv).fst, (rTailRes, rTailEnv).snd) =
Except.ok (r, resEnv)
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | have ⟨_, _⟩ := H | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : { fst := headτ, snd := headRes.fst } :: rTailRes = r ∧ rTailEnv = resEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝¹ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : { fst := headτ, snd := headRes.fst } :: rTailRes = r ∧ rTailEnv = resEnv
left✝ : { fst := headτ, snd := headRes.fst } :: rTailRes = r
right✝ : rTailEnv = resEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : { fst := headτ, snd := headRes.fst } :: rTailRes = r ∧ rTailEnv = resEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | subst r resEnv | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝¹ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : { fst := headτ, snd := headRes.fst } :: rTailRes = r ∧ rTailEnv = resEnv
left✝ : { fst := headτ, snd := headRes.fst } :: rTailRes = r
right✝ : rTailEnv = resEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H :
{ fst := headτ, snd := headRes.fst } :: rTailRes = { fst := headτ, snd := headRes.fst } :: rTailRes ∧
rTailEnv = rTailEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r : List (TypedArg Δ)
resEnv : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝¹ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : { fst := headτ, snd := headRes.fst } :: rTailRes = r ∧ rTailEnv = resEnv
left✝ : { fst := headτ, snd := headRes.fst } :: rTailRes = r
right✝ : rTailEnv = resEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok (r, SSAEnv.set name τ v resEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp [denoteOpArgs] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H :
{ fst := headτ, snd := headRes.fst } :: rTailRes = { fst := headτ, snd := headRes.fst } :: rTailRes ∧
rTailEnv = rTailEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail (SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : True
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
denoteOpArgs Δ tail (SSAEnv.set name τ v env) = Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H :
{ fst := headτ, snd := headRes.fst } :: rTailRes = { fst := headτ, snd := headRes.fst } :: rTailRes ∧
rTailEnv = rTailEnv
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | simp [bind, StateT.bind, Except.bind, pure, StateT.pure, Except.pure] at HInd | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail (SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : True
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail env =
Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : True
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail (SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : True
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteOpArgs_set_commutes | [1001, 1] | [1033, 31] | rw [HInd] <;> assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail env =
Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : True
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
headName : SSAVal
headτ : MLIRType Δ
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃resEnv : SSAEnv Δ⦄,
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail env =
Except.ok (r, resEnv) →
∀ ⦃name : SSAVal⦄,
(∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a) →
∀ (τ : MLIRType Δ) (v : MLIRType.eval τ),
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v env) =
Except.ok (r, SSAEnv.set name τ v resEnv)
Hname : ¬name = headName ∧ ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
headRes : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headRes
Hname_head : ¬name = headName
right✝ : ∀ (a : SSAVal) (b : MLIRType Δ), (a, b) ∈ tail → ¬name = a
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
rTail : List (TypedArg Δ) × SSAEnv Δ
rTailRes : List (TypedArg Δ)
rTailEnv : SSAEnv Δ
Htail :
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail headRes.snd =
Except.ok (rTailRes, rTailEnv)
H : True
⊢ (match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (SSAEnv.set name τ v headRes.snd) with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headRes.fst } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headRes.fst } :: rTailRes, SSAEnv.set name τ v rTailEnv)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | induction regions <;> intros H idx args env res env' Hrun <;> try contradiction | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
⊢ denoteRegionsSetCommutesInvariant name τ v regions →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx regions idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx regions idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head✝ : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail✝ : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
tail_ih✝ :
denoteRegionsSetCommutesInvariant name τ v tail✝ →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail✝ idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail✝ idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head✝ :: tail✝)
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head✝ :: tail✝) idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head✝ :: tail✝) idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
⊢ denoteRegionsSetCommutesInvariant name τ v regions →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx regions idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx regions idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | case cons head tail HInd =>
cases idx
case zero =>
simp at *
specialize (H (by constructor) (by assumption))
assumption
case succ idx' =>
specialize (HInd (by
intros region Hregions args env res env' Hrun
specialize (H (.tail _ Hregions) (by assumption))
assumption
))
simp at Hrun
apply (HInd Hrun) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | contradiction | case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
H : denoteRegionsSetCommutesInvariant name τ v []
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx [] idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx [] idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
H : denoteRegionsSetCommutesInvariant name τ v []
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx [] idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx [] idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | cases idx | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | case zero
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) Nat.zero args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
case succ
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
n✝ : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ n✝) args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ n✝) args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) idx args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | case zero =>
simp at *
specialize (H (by constructor) (by assumption))
assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) Nat.zero args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) Nat.zero args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | case succ idx' =>
specialize (HInd (by
intros region Hregions args env res env' Hrun
specialize (H (.tail _ Hregions) (by assumption))
assumption
))
simp at Hrun
apply (HInd Hrun) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | simp at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) Nat.zero args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) 0 args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) Nat.zero args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | specialize (H (by constructor) (by assumption)) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) 0 args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
H :
∃ env₂', SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ head args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) 0 args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) 0 args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
H :
∃ env₂', SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ head args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) 0 args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
H :
∃ env₂', SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ head args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) 0 args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | constructor | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ?m.2077032 ∈ head :: tail | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ?m.2077032 ∈ head :: tail
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ head ?m.2077034 ?m.2077035 = Except.ok (?m.2077036, ?m.2077037) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ head ?m.2077034 ?m.2077035 = Except.ok (?m.2077036, ?m.2077037)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | specialize (HInd (by
intros region Hregions args env res env' Hrun
specialize (H (.tail _ Hregions) (by assumption))
assumption
)) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
HInd :
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | apply (HInd Hrun) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
HInd :
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
HInd :
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | intros region Hregions args env res env' Hrun | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ denoteRegionsSetCommutesInvariant name τ v tail | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ denoteRegionsSetCommutesInvariant name τ v tail
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | specialize (H (.tail _ Hregions) (by assumption)) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
H :
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
H :
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂') | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
H :
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧ region args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | denoteRegionByIx_set_commutes | [1070, 1] | [1091, 24] | assumption | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
⊢ region ?m.2077124 ?m.2077125 = Except.ok (?m.2077126, ?m.2077127) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name : SSAVal
τ : MLIRType Δ
v : MLIRType.eval τ
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsSetCommutesInvariant name τ v tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∃ env₂',
SSAEnv.equiv (SSAEnv.set name τ v env') env₂' ∧
TopM.denoteRegionsByIx tail idx args (SSAEnv.set name τ v env) = Except.ok (res, env₂')
H : denoteRegionsSetCommutesInvariant name τ v (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ : SSAEnv Δ
idx' : ℕ
Hrun✝ : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args✝ env✝ = Except.ok (res✝, env'✝)
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
Hregions : region ∈ tail
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : region args env = Except.ok (res, env')
⊢ region ?m.2077124 ?m.2077125 = Except.ok (?m.2077126, ?m.2077127)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | simp[run] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
⊢ run
(do
ma
mb)
env =
match run ma env with
| Except.ok (PUnit.unit, env') => run mb env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run mb p.snd) =
match StateT.run ma env with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
⊢ run
(do
ma
mb)
env =
match run ma env with
| Except.ok (PUnit.unit, env') => run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | cases H : StateT.run ma env | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run mb p.snd) =
match StateT.run ma env with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | case error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
a✝ : String × SSAEnv Δ
H : StateT.run ma env = Except.error a✝
⊢ (do
let p ← Except.error a✝
StateT.run mb p.snd) =
match Except.error a✝ with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
a✝ : Unit × SSAEnv Δ
H : StateT.run ma env = Except.ok a✝
⊢ (do
let p ← Except.ok a✝
StateT.run mb p.snd) =
match Except.ok a✝ with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run mb p.snd) =
match StateT.run ma env with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | case error err => {
simp[H];
simp[bind, Except.bind];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | case ok out => {
simp[H, bind, Except.bind];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
out : Unit × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
out : Unit × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
Except.error err | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | simp[bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
Except.error err | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
Except.error err
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_seq | [1167, 1] | [1182, 2] | simp[H, bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
out : Unit × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
β : Type
Δ : Dialect α σ ε
ma : TopM Δ Unit
mb : TopM Δ β
env : SSAEnv Δ
out : Unit × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (PUnit.unit, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | simp[run] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ run
(do
let a ← ma
k a)
env =
match run ma env with
| Except.ok (a, env') => run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run (k p.fst) p.snd) =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ run
(do
let a ← ma
k a)
env =
match run ma env with
| Except.ok (a, env') => run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | cases H : StateT.run ma env | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run (k p.fst) p.snd) =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | case error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
a✝ : String × SSAEnv Δ
H : StateT.run ma env = Except.error a✝
⊢ (do
let p ← Except.error a✝
StateT.run (k p.fst) p.snd) =
match Except.error a✝ with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
a✝ : a × SSAEnv Δ
H : StateT.run ma env = Except.ok a✝
⊢ (do
let p ← Except.ok a✝
StateT.run (k p.fst) p.snd) =
match Except.ok a✝ with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run (k p.fst) p.snd) =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | case error err => {
simp[H];
simp[bind, Except.bind];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | case ok out => {
simp[H, bind, Except.bind];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run (k p.fst) p.snd) =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run (k p.fst) p.snd) =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
Except.error err | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | simp[bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
Except.error err | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run (k p.fst) p.snd) =
Except.error err
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind | [1194, 1] | [1209, 2] | simp[H, bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run (k p.fst) p.snd) =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run (k p.fst) p.snd) =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | simp[run, TopM.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ run (StateT.bind ma k) env =
match run ma env with
| Except.ok (a, env') => run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ StateT.run (StateT.bind ma k) env =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ run (StateT.bind ma k) env =
match run ma env with
| Except.ok (a, env') => run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | cases H : StateT.run ma env | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ StateT.run (StateT.bind ma k) env =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | case error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
a✝ : String × SSAEnv Δ
H : StateT.run ma env = Except.error a✝
⊢ StateT.run (StateT.bind ma k) env =
match Except.error a✝ with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
a✝ : a × SSAEnv Δ
H : StateT.run ma env = Except.ok a✝
⊢ StateT.run (StateT.bind ma k) env =
match Except.ok a✝ with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ StateT.run (StateT.bind ma k) env =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | case error err => {
simp[bind, Except.bind, StateT.bind, StateT.run] at *;
simp[H];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma k) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma k) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | case ok out => {
simp[bind, Except.bind, StateT.bind, StateT.run] at *;
simp[H];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma k) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma k) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | simp[bind, Except.bind, StateT.bind, StateT.run] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma k) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : ma env = Except.error err
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
Except.error err | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma k) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : ma env = Except.error err
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
Except.error err | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : ma env = Except.error err
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
Except.error err
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | simp[bind, Except.bind, StateT.bind, StateT.run] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma k) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : ma env = Except.ok out
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
k out.fst out.snd | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma k) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind2 | [1211, 1] | [1228, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : ma env = Except.ok out
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
k out.fst out.snd | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : ma env = Except.ok out
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
k out.fst out.snd
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | simp[run, TopM.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ run (StateT.bind ma fun x => k x) env =
match run ma env with
| Except.ok (a, env') => run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ run (StateT.bind ma fun x => k x) env =
match run ma env with
| Except.ok (a, env') => run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | cases H : StateT.run ma env | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | case error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
a✝ : String × SSAEnv Δ
H : StateT.run ma env = Except.error a✝
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.error a✝ with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
a✝ : a × SSAEnv Δ
H : StateT.run ma env = Except.ok a✝
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.ok a✝ with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match StateT.run ma env with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | case error err => {
simp[bind, Except.bind, StateT.bind, StateT.run] at *;
simp[H];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | case ok out => {
simp[bind, Except.bind, StateT.bind, StateT.run] at *;
simp[H];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | simp[bind, Except.bind, StateT.bind, StateT.run] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : ma env = Except.error err
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
Except.error err | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.error err with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : ma env = Except.error err
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
Except.error err | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : ma env = Except.error err
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
Except.error err
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | simp[bind, Except.bind, StateT.bind, StateT.run] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : ma env = Except.ok out
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
k out.fst out.snd | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ StateT.run (StateT.bind ma fun x => k x) env =
match Except.ok out with
| Except.ok (a, env') => StateT.run (k a) env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind3 | [1230, 1] | [1247, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : ma env = Except.ok out
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
k out.fst out.snd | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
k : a → TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : ma env = Except.ok out
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => k v.fst v.snd) =
k out.fst out.snd
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | simp[run] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
⊢ run
(do
let __discr ← ma
let x : a := __discr
mb)
env =
match run ma env with
| Except.ok (a_, env') => run mb env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run mb p.snd) =
match StateT.run ma env with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
⊢ run
(do
let __discr ← ma
let x : a := __discr
mb)
env =
match run ma env with
| Except.ok (a_, env') => run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | cases H : StateT.run ma env | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run mb p.snd) =
match StateT.run ma env with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | case error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
a✝ : String × SSAEnv Δ
H : StateT.run ma env = Except.error a✝
⊢ (do
let p ← Except.error a✝
StateT.run mb p.snd) =
match Except.error a✝ with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
a✝ : a × SSAEnv Δ
H : StateT.run ma env = Except.ok a✝
⊢ (do
let p ← Except.ok a✝
StateT.run mb p.snd) =
match Except.ok a✝ with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
⊢ (do
let p ← StateT.run ma env
StateT.run mb p.snd) =
match StateT.run ma env with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | case error err => {
simp[H];
simp[bind, Except.bind];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | case ok out => {
simp[H, bind, Except.bind];
} | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | simp[H] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
Except.error err | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
match Except.error err with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | simp[bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
Except.error err | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
err : String × SSAEnv Δ
H : StateT.run ma env = Except.error err
⊢ (do
let p ← Except.error err
StateT.run mb p.snd) =
Except.error err
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_ | [1252, 1] | [1267, 2] | simp[H, bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
ma : TopM Δ a
mb : TopM Δ b
env : SSAEnv Δ
out : a × SSAEnv Δ
H : StateT.run ma env = Except.ok out
⊢ (do
let p ← Except.ok out
StateT.run mb p.snd) =
match Except.ok out with
| Except.ok (a_, env') => StateT.run mb env'
| Except.error e => Except.error e
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_success | [1270, 1] | [1278, 2] | simp[bind, StateT.bind, Except.bind] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ run (ma >>= a2mb) env = run (a2mb va) env' | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ run
(fun s =>
match ma s with
| Except.error err => Except.error err
| Except.ok v => a2mb v.fst v.snd)
env =
run (a2mb va) env' | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ run (ma >>= a2mb) env = run (a2mb va) env'
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_success | [1270, 1] | [1278, 2] | simp[run, StateT.run] at * | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ run
(fun s =>
match ma s with
| Except.error err => Except.error err
| Except.ok v => a2mb v.fst v.snd)
env =
run (a2mb va) env' | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => a2mb v.fst v.snd) =
a2mb va env' | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ run
(fun s =>
match ma s with
| Except.error err => Except.error err
| Except.ok v => a2mb v.fst v.snd)
env =
run (a2mb va) env'
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_bind_success | [1270, 1] | [1278, 2] | simp[MA] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => a2mb v.fst v.snd) =
a2mb va env' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
a b : Type
Δ : Dialect α σ ε
S : Semantics Δ
ma : TopM Δ a
a2mb : a → TopM Δ b
env : SSAEnv Δ
va : a
env' : SSAEnv Δ
MA : ma env = Except.ok (va, env')
⊢ (match ma env with
| Except.error err => Except.error err
| Except.ok v => a2mb v.fst v.snd) =
a2mb va env'
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_denoteRegion | [1283, 1] | [1293, 31] | simp[denoteRegion] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
args : TypedArgs Δ
env : SSAEnv Δ
name : String
formals : List (TypedSSAVal Δ)
ops : List (Op Δ)
⊢ run (denoteRegion Δ (Region.mk name formals ops) args) env =
run
(do
denoteTypedArgs args (List.map Prod.fst formals)
denoteOps Δ ops)
env | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
args : TypedArgs Δ
env : SSAEnv Δ
name : String
formals : List (TypedSSAVal Δ)
ops : List (Op Δ)
⊢ run (denoteRegion Δ (Region.mk name formals ops) args) env =
run
(do
denoteTypedArgs args (List.map Prod.fst formals)
denoteOps Δ ops)
env
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_denoteTypedArgs_nil | [1298, 1] | [1302, 2] | simp[denoteTypedArgs, pure, run, StateT.run, StateT.pure, Except.pure] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (denoteTypedArgs [] []) env = Except.ok ((), env) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (denoteTypedArgs [] []) env = Except.ok ((), env)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_denoteOps_nil | [1304, 1] | [1309, 2] | simp[denoteOps] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (denoteOps Δ []) env = Except.ok ([], env) | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (pure []) env = Except.ok ([], env) | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (denoteOps Δ []) env = Except.ok ([], env)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_denoteOps_nil | [1304, 1] | [1309, 2] | simp [pure, StateT.pure, run, StateT.run, Except.pure] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (pure []) env = Except.ok ([], env) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
⊢ run (pure []) env = Except.ok ([], env)
TACTIC:
|
https://github.com/opencompl/lean-mlir.git | e43d21592801e5e40477b14b7a554e356060c40c | MLIR/Semantics/Semantics.lean | run_denoteOps_cons | [1311, 1] | [1316, 2] | simp[denoteOps] | α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
op op' : Op Δ
ops : List (Op Δ)
⊢ run (denoteOps Δ (op :: op' :: ops)) env =
run
(do
let __discr ← denoteOp Δ op
let x : TypedArgs Δ := __discr
denoteOps Δ (op' :: ops))
env | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
op op' : Op Δ
ops : List (Op Δ)
⊢ run (denoteOps Δ (op :: op' :: ops)) env =
run
(do
let __discr ← denoteOp Δ op
let x : TypedArgs Δ := __discr
denoteOps Δ (op' :: ops))
env
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.