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
|
|---|---|---|---|---|---|---|---|---|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
simp [H]
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
x✝¹ : Except (String × SSAEnv δ) (Unit × SSAEnv δ)
v : Unit × SSAEnv δ
x✝ : Option (MLIRType.eval argsHead.fst)
heq✝ : SSAEnv.get headVal argsHead.fst env = none
H : denoteTypedArgs argsTail tailVal (SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok (res, env')
⊢ Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) =
Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail tailVal (SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
x✝¹ : Except (String × SSAEnv δ) (Unit × SSAEnv δ)
v : Unit × SSAEnv δ
snd : SSAEnv δ
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
x✝ : Option (MLIRType.eval argsHead.fst)
v✝ : MLIRType.eval argsHead.fst
heq✝ : SSAEnv.get headVal argsHead.fst env = some v✝
Hv : Except.error ("setting to SSA value twice!", env) = Except.ok (PUnit.unit, snd)
⊢ Except.error ("setting to SSA value twice!", env) = Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail tailVal (SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_unfold
|
[732, 1]
|
[737, 25]
|
simp [denoteTypedArgs]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
headVal : SSAVal
tailVal : List SSAVal
headArgs : TypedArg Δ
tailArgs : List (TypedArg Δ)
env : SSAEnv Δ
⊢ denoteTypedArgs (headArgs :: tailArgs) (headVal :: tailVal) env =
bind (TopM.set headArgs.fst headVal headArgs.snd) (fun x => denoteTypedArgs tailArgs tailVal) env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
induction args <;> intros env r env' H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
args : List (TypedSSAVal Δ)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ args env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ args env₂ = Except.ok (r, env₂)
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ [] env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ [] env₂ = Except.ok (r, env₂)
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 Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail✝ env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail✝ env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head✝ :: tail✝) env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ (head✝ :: tail✝) env₂ = Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
case nil =>
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 Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ [] env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ [] env₂ = Except.ok (r, env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
case cons head tail HInd =>
intros env₂ Henv₂
simp [denoteOpArgs]; simp [denoteOpArgs] at H
have ⟨headName, headτ⟩ := head
simp_monad at *
revert H
cases Hhead: TopM.get headτ headName env <;> simp <;> intros H <;> try contradiction
case ok headR =>
have ⟨headR, headEnv⟩ := headR
simp [TopM.get_equiv Henv₂ Hhead]
split at H <;> try contradiction
case h_2 tailR HTailR =>
simp at H; cases H; subst env' r
have ⟨tailR, tailEnv⟩ := tailR; simp at HTailR
have AOEU := HInd HTailR
rw [TopM.get_unfold] at Hhead; simp at Hhead; cases Hhead; subst env
specialize HInd HTailR Henv₂
simp [denoteOpArgs] at HInd
simp_monad at *
simp [HInd]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ (head :: tail) env₂ = Except.ok (r, env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp [denoteOpArgs] at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ [] env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ [] env₂ = Except.ok (r, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : pure [] env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → pure [] env₂ = Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : pure [] env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → pure [] env₂ = Except.ok (r, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : [] = r ∧ env = env'
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → [] = r
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : [] = r ∧ env = env'
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → [] = r
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
left✝ : [] = r
right✝ : env = env'
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → [] = r
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
subst r env
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
left✝ : [] = r
right✝ : env = env'
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → [] = r
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env' : SSAEnv Δ
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env' env₂ → [] = []
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env' : SSAEnv Δ
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env' env₂ → [] = []
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
intros env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
⊢ ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ (head :: tail) env₂ = Except.ok (r, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ denoteOpArgs Δ (head :: tail) env₂ = Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp [denoteOpArgs]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ denoteOpArgs Δ (head :: tail) env₂ = Except.ok (r, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ 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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
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 Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ 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, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
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, env')
⊢ 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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
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 Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
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, env')
⊢ 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, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
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, env')
⊢ 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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
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 Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
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, env')
⊢ 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, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
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, env')
⊢ (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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
revert H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
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, env')
⊢ (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, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
⊢ (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, env') →
(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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
cases Hhead: TopM.get headτ headName env <;> simp <;> intros H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
⊢ (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, env') →
(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, env₂)
|
case ok
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
a✝ : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok a✝
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 a✝.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := a✝.fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
case ok headR =>
have ⟨headR, headEnv⟩ := headR
simp [TopM.get_equiv Henv₂ Hhead]
split at H <;> try contradiction
case h_2 tailR HTailR =>
simp at H; cases H; subst env' r
have ⟨tailR, tailEnv⟩ := tailR; simp at HTailR
have AOEU := HInd HTailR
rw [TopM.get_unfold] at Hhead; simp at Hhead; cases Hhead; subst env
specialize HInd HTailR Henv₂
simp [denoteOpArgs] at HInd
simp_monad at *
simp [HInd]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headR
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 headR.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR.fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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, env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
have ⟨headR, headEnv⟩ := headR
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok headR
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 headR.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR.fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
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 (headR, headEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp [TopM.get_equiv Henv₂ Hhead]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
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 (headR, headEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
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 (headR, headEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
split at H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
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 (headR, headEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: v.fst, v.snd)) =
Except.ok (r, env')
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
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 (headR, headEnv).snd =
Except.ok v✝
H : Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: v✝.fst, v✝.snd) = Except.ok (r, env')
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
case h_2 tailR HTailR =>
simp at H; cases H; subst env' r
have ⟨tailR, tailEnv⟩ := tailR; simp at HTailR
have AOEU := HInd HTailR
rw [TopM.get_unfold] at Hhead; simp at Hhead; cases Hhead; subst env
specialize HInd HTailR Henv₂
simp [denoteOpArgs] at HInd
simp_monad at *
simp [HInd]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
H : Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: tailR.fst, tailR.snd) = Except.ok (r, env')
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
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 (headR, headEnv).snd =
Except.error err✝
H : Except.error err✝ = Except.ok (r, env')
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
H : Except.ok ({ fst := headτ, snd := (headR, headEnv).fst } :: tailR.fst, tailR.snd) = Except.ok (r, env')
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
H : { fst := headτ, snd := headR } :: tailR.fst = r ∧ tailR.snd = env'
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
H : { fst := headτ, snd := headR } :: tailR.fst = r ∧ tailR.snd = env'
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
left✝ : { fst := headτ, snd := headR } :: tailR.fst = r
right✝ : tailR.snd = env'
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
subst env' r
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env : SSAEnv Δ
r : List (TypedArg Δ)
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
left✝ : { fst := headτ, snd := headR } :: tailR.fst = r
right✝ : tailR.snd = env'
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok (r, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: tailR.fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
have ⟨tailR, tailEnv⟩ := tailR
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok tailR
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: tailR.fst, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok (tailR, tailEnv)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp at HTailR
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 (headR, headEnv).snd =
Except.ok (tailR, tailEnv)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
have AOEU := HInd HTailR
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
rw [TopM.get_unfold] at Hhead
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead :
Except.ok
(match SSAEnv.get headName headτ env with
| some v => v
| none => default,
env) =
Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp at Hhead
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
Hhead :
Except.ok
(match SSAEnv.get headName headτ env with
| some v => v
| none => default,
env) =
Except.ok (headR, headEnv)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Hhead :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
headR ∧
env = headEnv
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
cases Hhead
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Hhead :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
headR ∧
env = headEnv
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
headR
right✝ : env = headEnv
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
subst env
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
headR
right✝ : env = headEnv
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
specialize HInd HTailR Henv₂
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
denoteOpArgs Δ tail env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv env env₂ → denoteOpArgs Δ tail env₂ = Except.ok (r, env₂)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
HInd : denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp [denoteOpArgs] at HInd
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
HInd : denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
HInd :
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env₂ =
Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp_monad at *
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
HInd :
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env₂ =
Except.ok (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: (tailR, tailEnv).fst, env₂)
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
HInd :
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 (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: tailR, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_equiv
|
[748, 1]
|
[777, 16]
|
simp [HInd]
|
case intro.intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env₂ : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
headR✝ : MLIRType.eval headτ × SSAEnv Δ
headR : MLIRType.eval headτ
headEnv : SSAEnv Δ
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR✝ : List (TypedArg Δ) × SSAEnv Δ
tailR : List (TypedArg Δ)
tailEnv : SSAEnv Δ
HTailR :
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 headEnv =
Except.ok (tailR, tailEnv)
AOEU : ∀ ⦃env₂ : SSAEnv Δ⦄, SSAEnv.equiv headEnv env₂ → denoteOpArgs Δ tail env₂ = Except.ok (tailR, env₂)
Henv₂ : SSAEnv.equiv headEnv env₂
left✝ :
(match SSAEnv.get headName headτ headEnv with
| some v => v
| none => default) =
headR
HInd :
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 (tailR, env₂)
⊢ (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 env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := headR } :: v.fst, v.snd)) =
Except.ok ({ fst := headτ, snd := headR } :: tailR, env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
induction args
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
args : TypedArgs Δ
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs args vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs args vals env₂ = Except.ok (r, env₂')
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs [] vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ → ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs [] vals env₂ = Except.ok (r, env₂')
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
tail_ih✝ :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs tail✝ vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs tail✝ vals env₂ = Except.ok (r, env₂')
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs (head✝ :: tail✝) vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (head✝ :: tail✝) vals env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
case nil =>
intros val env₁ r env₁' H env₂ Henv₂
simp [denoteTypedArgs] at *
exists env₂
simp_monad at *; subst H; assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs [] vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ → ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs [] vals env₂ = Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
case cons argsHead argsTail HInd =>
intros vals env₁ r env₁' H env₂ Henv₂
have ⟨valsHead, valsTail, HVals, HHead, HTail⟩ := denoteTypedArgs_cons_args H
subst vals
have HHead₂ := TopM.set_equiv Henv₂ HHead
specialize (HInd HTail (by apply SSAEnv.equiv_set Henv₂))
have ⟨env₂', Hequiv₂', Henv₂'⟩ := HInd
exists env₂'
cases r
rw [denoteTypedArgs_cons_unfold]
simp_monad
rw [HHead₂]; simp; rw [Henv₂']
simp; assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs (argsHead :: argsTail) vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) vals env₂ = Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
intros val env₁ r env₁' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs [] vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ → ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs [] vals env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : denoteTypedArgs [] val env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs [] val env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
simp [denoteTypedArgs] at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : denoteTypedArgs [] val env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs [] val env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : pure () env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ pure () env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
exists env₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : pure () env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ pure () env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : pure () env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ SSAEnv.equiv env₁' env₂ ∧ pure () env₂ = Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : pure () env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ SSAEnv.equiv env₁' env₂ ∧ pure () env₂ = Except.ok (r, env₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
H : env₁ = env₁'
⊢ SSAEnv.equiv env₁' env₂
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
subst H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
H : env₁ = env₁'
⊢ SSAEnv.equiv env₁' env₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ SSAEnv.equiv env₁ env₂
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
val : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ SSAEnv.equiv env₁ env₂
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
intros vals env₁ r env₁' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
⊢ ∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs (argsHead :: argsTail) vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) vals env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
vals : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : denoteTypedArgs (argsHead :: argsTail) vals env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) vals env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
have ⟨valsHead, valsTail, HVals, HHead, HTail⟩ := denoteTypedArgs_cons_args H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
vals : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : denoteTypedArgs (argsHead :: argsTail) vals env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) vals env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
vals : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : denoteTypedArgs (argsHead :: argsTail) vals env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HVals : vals = valsHead :: valsTail
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) vals env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
subst vals
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
vals : List SSAVal
env₁ : SSAEnv Δ
r : Unit
env₁' : SSAEnv Δ
H : denoteTypedArgs (argsHead :: argsTail) vals env₁ = Except.ok (r, env₁')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HVals : vals = valsHead :: valsTail
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
⊢ ∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) vals env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
have HHead₂ := TopM.set_equiv Henv₂ HHead
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
specialize (HInd HTail (by apply SSAEnv.equiv_set Henv₂))
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
have ⟨env₂', Hequiv₂', Henv₂'⟩ := HInd
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
exists env₂'
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
⊢ ∃ env₂',
SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
⊢ SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
cases r
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
⊢ SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (r, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (PUnit.unit, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
rw [denoteTypedArgs_cons_unfold]
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₂ = Except.ok (PUnit.unit, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
bind (TopM.set argsHead.fst valsHead argsHead.snd) (fun x => denoteTypedArgs argsTail valsTail) env₂ =
Except.ok (PUnit.unit, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
simp_monad
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
bind (TopM.set argsHead.fst valsHead argsHead.snd) (fun x => denoteTypedArgs argsTail valsTail) env₂ =
Except.ok (PUnit.unit, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
(match TopM.set argsHead.fst valsHead argsHead.snd env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail valsTail v.snd) =
Except.ok (PUnit.unit, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
rw [HHead₂]
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
(match TopM.set argsHead.fst valsHead argsHead.snd env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail valsTail v.snd) =
Except.ok (PUnit.unit, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
(match Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail valsTail v.snd) =
Except.ok (PUnit.unit, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
simp
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
(match Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail valsTail v.snd) =
Except.ok (PUnit.unit, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) =
Except.ok (PUnit.unit, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
rw [Henv₂']
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) =
Except.ok (PUnit.unit, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧ Except.ok ((), env₂') = Except.ok (PUnit.unit, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
simp
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂' ∧ Except.ok ((), env₂') = Except.ok (PUnit.unit, env₂')
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂'
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
assumption
|
case unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
env₁ env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
HInd :
∃ env₂',
SSAEnv.equiv env₁' env₂' ∧
denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
env₂' : SSAEnv Δ
Hequiv₂' : SSAEnv.equiv env₁' env₂'
Henv₂' : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₂) = Except.ok ((), env₂')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (PUnit.unit, env₁')
⊢ SSAEnv.equiv env₁' env₂'
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_equiv
|
[780, 1]
|
[804, 21]
|
apply SSAEnv.equiv_set Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
argsHead : TypedArg Δ
argsTail : List (TypedArg Δ)
HInd :
∀ ⦃vals : List SSAVal⦄ ⦃env₁ : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
denoteTypedArgs argsTail vals env₁ = Except.ok (r, env₁') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∃ env₂', SSAEnv.equiv env₁' env₂' ∧ denoteTypedArgs argsTail vals env₂ = Except.ok (r, env₂')
env₁ : SSAEnv Δ
r : Unit
env₁' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env₁ env₂
valsHead : SSAVal
valsTail : List SSAVal
HHead :
TopM.set argsHead.fst valsHead argsHead.snd env₁ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₁)
HTail : denoteTypedArgs argsTail valsTail (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) = Except.ok ((), env₁')
H : denoteTypedArgs (argsHead :: argsTail) (valsHead :: valsTail) env₁ = Except.ok (r, env₁')
HHead₂ :
TopM.set argsHead.fst valsHead argsHead.snd env₂ = Except.ok ((), SSAEnv.set valsHead argsHead.fst argsHead.snd env₂)
⊢ SSAEnv.equiv (SSAEnv.set valsHead argsHead.fst argsHead.snd env₁) ?m.958985
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
induction regions <;> intros H idx args env res env' Hrun env₂ Henv₂ <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
⊢ denoteRegionsEquivInvariant regions →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx regions idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (res, env₂')
|
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head✝ : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail✝ : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
tail_ih✝ :
denoteRegionsEquivInvariant tail✝ →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail✝ idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail✝ idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head✝ :: tail✝) idx args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
case cons head tail HInd =>
cases idx
case zero =>
simp at *
specialize (H (by constructor) (by assumption) (by assumption))
assumption
case succ idx' =>
specialize (HInd (by
intros region Hregions args env res env' Hrun env₂ Henv₂
specialize (H (.tail _ Hregions) (by assumption) (by assumption))
assumption
))
simp at Hrun
specialize (HInd Hrun Henv₂)
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) idx args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
contradiction
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
H : denoteRegionsEquivInvariant []
idx : ℕ
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
Hrun : TopM.denoteRegionsByIx [] idx args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx [] idx args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
cases idx
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) idx args env₂ = Except.ok (res, env₂')
|
case zero
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) Nat.zero args env₂ = Except.ok (res, env₂')
case succ
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
n✝ : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ n✝) args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ n✝) args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
case zero =>
simp at *
specialize (H (by constructor) (by assumption) (by assumption))
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) Nat.zero args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
case succ idx' =>
specialize (HInd (by
intros region Hregions args env res env' Hrun env₂ Henv₂
specialize (H (.tail _ Hregions) (by assumption) (by assumption))
assumption
))
simp at Hrun
specialize (HInd Hrun Henv₂)
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) Nat.zero args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) Nat.zero args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) 0 args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
specialize (H (by constructor) (by assumption) (by assumption))
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) 0 args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
H : ∃ env₂', SSAEnv.equiv env' env₂' ∧ head args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) 0 args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
H : ∃ env₂', SSAEnv.equiv env' env₂' ∧ head args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) 0 args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
constructor
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ ?m.1012060 ∈ head :: tail
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ head ?m.1012062 ?m.1012063 = Except.ok (?m.1012064, ?m.1012065)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
Hrun : TopM.denoteRegionsByIx (head :: tail) 0 args env = Except.ok (res, env')
⊢ SSAEnv.equiv env ?m.1012067
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
specialize (HInd (by
intros region Hregions args env res env' Hrun env₂ Henv₂
specialize (H (.tail _ Hregions) (by assumption) (by assumption))
assumption
))
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
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 Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
specialize (HInd Hrun Henv₂)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
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 Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
HInd : ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx' args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
HInd : ∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx' args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
intros region Hregions args env res env' Hrun env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
idx' : ℕ
Hrun : TopM.denoteRegionsByIx (head :: tail) (Nat.succ idx') args env = Except.ok (res, env')
⊢ denoteRegionsEquivInvariant tail
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ env₂✝ : SSAEnv Δ
Henv₂✝ : SSAEnv.equiv env✝ env₂✝
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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
specialize (H (.tail _ Hregions) (by assumption) (by assumption))
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ env₂✝ : SSAEnv Δ
Henv₂✝ : SSAEnv.equiv env✝ env₂✝
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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ env₂✝ : SSAEnv Δ
Henv₂✝ : SSAEnv.equiv env✝ env₂✝
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 Δ
Henv₂ : SSAEnv.equiv env env₂
H : ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ env₂✝ : SSAEnv Δ
Henv₂✝ : SSAEnv.equiv env✝ env₂✝
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 Δ
Henv₂ : SSAEnv.equiv env env₂
H : ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ env₂✝ : SSAEnv Δ
Henv₂✝ : SSAEnv.equiv env✝ env₂✝
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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ region ?m.1012165 ?m.1012166 = Except.ok (?m.1012167, ?m.1012168)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegionByIx_equiv
|
[816, 1]
|
[839, 17]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
head : TypedArgs Δ → TopM Δ (TypedArgs Δ)
tail : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
HInd :
denoteRegionsEquivInvariant tail →
∀ ⦃idx : ℕ⦄ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
TopM.denoteRegionsByIx tail idx args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ TopM.denoteRegionsByIx tail idx args env₂ = Except.ok (res, env₂')
H : denoteRegionsEquivInvariant (head :: tail)
args✝ : TypedArgs Δ
env✝ : SSAEnv Δ
res✝ : TypedArgs Δ
env'✝ env₂✝ : SSAEnv Δ
Henv₂✝ : SSAEnv.equiv env✝ env₂✝
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 Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ SSAEnv.equiv env ?m.1012170
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
intros Hregs opM
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
⊢ denoteRegionsEquivInvariant regions →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ → ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions opM env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
opM : OpM Δ (TypedArgs Δ)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ → ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions opM env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
induction opM <;> intros env res env' H env₂ Henv₂ <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
opM : OpM Δ (TypedArgs Δ)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ → ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions opM env₂ = Except.ok (res, env₂')
|
case Ret
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
a✝ : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (Ret a✝) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (Ret a✝) env₂ = Except.ok (res, env₂')
case RunRegion
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
a✝² : ℕ
a✝¹ : TypedArgs Δ
a✝ : TypedArgs Δ → OpM Δ (TypedArgs Δ)
a_ih✝ :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (a✝ a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ → ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (a✝ a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (RunRegion a✝² a✝¹ a✝) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (RunRegion a✝² a✝¹ a✝) env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
case Ret ret =>
unfold OpM.toTopM; unfold OpM.toTopM at H
cases H <;> simp
exists env₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (Ret ret) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (Ret ret) env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
case RunRegion idx args continuation HInd =>
unfold OpM.toTopM; unfold OpM.toTopM at H
have ⟨⟨resReg, envReg⟩, HReg⟩ := ExceptMonad.split H
simp_monad at *
rw [HReg] at H; simp at H
have ⟨env₂', Henv₂', HIx⟩ := denoteRegionByIx_equiv regions Hregs HReg Henv₂
specialize (HInd resReg (by assumption) (by assumption))
rw [HIx]; simp
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (RunRegion idx args continuation) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (RunRegion idx args continuation) env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
contradiction
|
case Error
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
a✝ : String
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (Error a✝) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (Error a✝) env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
unfold OpM.toTopM
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (Ret ret) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (Ret ret) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (Ret ret) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ pure ret env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
unfold OpM.toTopM at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (Ret ret) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ pure ret env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : pure ret env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ pure ret env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
cases H <;> simp
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : pure ret env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ pure ret env₂ = Except.ok (res, env₂')
|
case refl
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env env₂' ∧ pure ret env₂ = Except.ok (ret, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
exists env₂
|
case refl
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
ret : TypedArgs Δ
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env env₂' ∧ pure ret env₂ = Except.ok (ret, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
unfold OpM.toTopM
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (RunRegion idx args continuation) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (RunRegion idx args continuation) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (RunRegion idx args continuation) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env₂ =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
unfold OpM.toTopM at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : toTopM regions (RunRegion idx args continuation) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env₂ =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env =
Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env₂ =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
have ⟨⟨resReg, envReg⟩, HReg⟩ := ExceptMonad.split H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env =
Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env₂ =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env =
Except.ok (res, env')
resReg : TypedArgs Δ
envReg : SSAEnv Δ
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env₂ =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env =
Except.ok (res, env')
resReg : TypedArgs Δ
envReg : SSAEnv Δ
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
Bind.bind (TopM.denoteRegionsByIx regions idx args) (fun ret => toTopM regions (continuation ret)) env₂ =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match TopM.denoteRegionsByIx regions idx args env with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env')
resReg : TypedArgs Δ
envReg : SSAEnv Δ
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
rw [HReg] at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match TopM.denoteRegionsByIx regions idx args env with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env')
resReg : TypedArgs Δ
envReg : SSAEnv Δ
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H :
(match Except.ok (resReg, envReg) with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
simp at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H :
(match Except.ok (resReg, envReg) with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
have ⟨env₂', Henv₂', HIx⟩ := denoteRegionByIx_equiv regions Hregs HReg Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
specialize (HInd resReg (by assumption) (by assumption))
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
HInd : ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.