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/Dialects/ArithSemantics.lean
|
FinInt.sub_add_dist
|
[409, 1]
|
[415, 41]
|
simp [Int.sub_add_dist, Int.sub_assoc]
|
case a.a
sz : ℕ
C X C2 : FinInt sz
⊢ toUint C - (toUint X + toUint C2) = toUint C - toUint C2 - toUint X
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Examples/FinIntBruteforce.lean
|
P₁_tautology8
|
[28, 1]
|
[29, 16]
|
native_decide
|
⊢ isTautologyUpTo2 8 P₁ = true
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Examples/FinIntBruteforce.lean
|
P₂_tautology8
|
[34, 1]
|
[35, 16]
|
native_decide
|
⊢ isTautologyUpTo2 8 P₂ = true
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Examples/FinIntBruteforce.lean
|
P₃_tautology8
|
[41, 1]
|
[42, 16]
|
native_decide
|
⊢ isTautologyUpTo2 8 P₃ = true
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Refinement.lean
|
SSAEnv.refines_set
|
[20, 1]
|
[34, 28]
|
simp [refines, SSAEnv.refines]
|
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
⊢ refines env1 env2 → refines (set name τ val env1) (set name τ val env2)
|
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
⊢ (∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }) →
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v (set name τ val env2) = some { fst := a, snd := b } →
getT v (set name τ val env1) = some { fst := a, snd := b }
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Refinement.lean
|
SSAEnv.refines_set
|
[20, 1]
|
[34, 28]
|
intros Href name' val' Hget
|
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
⊢ (∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }) →
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v (set name τ val env2) = some { fst := a, snd := b } →
getT v (set name τ val env1) = some { fst := a, snd := b }
|
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Refinement.lean
|
SSAEnv.refines_set
|
[20, 1]
|
[34, 28]
|
by_cases H: name = name'
|
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
|
case pos
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : name = name'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
case neg
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : ¬name = name'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Refinement.lean
|
SSAEnv.refines_set
|
[20, 1]
|
[34, 28]
|
. subst H;
rw [SSAEnv.getT_set_eq] <;> try assumption
rw [SSAEnv.getT_set_eq] <;> try assumption
intros K; assumption;
|
case pos
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : name = name'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
case neg
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : ¬name = name'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
|
case neg
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : ¬name = name'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Refinement.lean
|
SSAEnv.refines_set
|
[20, 1]
|
[34, 28]
|
. rw [SSAEnv.getT_set_ne] <;> try assumption
rw [SSAEnv.getT_set_ne] <;> try assumption
intros K;
apply Href; assumption;
|
case neg
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : ¬name = name'
⊢ getT name' (set name τ val env2) = some { fst := val', snd := Hget } →
getT name' (set name τ val env1) = some { fst := val', snd := Hget }
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Refinement.lean
|
SSAEnv.refines_set
|
[20, 1]
|
[34, 28]
|
assumption
|
case neg.a
α✝ σ✝ : Type
ε✝ : σ✝ → Type
δ✝ : Dialect α✝ σ✝ ε✝
env1 env2 : SSAEnv δ✝
name : SSAVal
τ : MLIRType δ✝
val : MLIRType.eval τ
Href :
∀ (v : SSAVal) (a : MLIRType δ✝) (b : MLIRType.eval a),
getT v env2 = some { fst := a, snd := b } → getT v env1 = some { fst := a, snd := b }
name' : SSAVal
val' : MLIRType δ✝
Hget : MLIRType.eval val'
H : ¬name = name'
⊢ name ≠ name'
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_unfold
|
[95, 1]
|
[104, 33]
|
simp [TopM.get]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
⊢ get τ name env =
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
⊢ bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some v => pure v
| none => pure default)
env =
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_unfold
|
[95, 1]
|
[104, 33]
|
simp_monad
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
⊢ bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some v => pure v
| none => pure default)
env =
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
⊢ (match SSAEnv.get name τ env with
| some v => fun s => Except.ok (v, s)
| none => fun s => Except.ok (default, s))
env =
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_unfold
|
[95, 1]
|
[104, 33]
|
cases (env.get name τ) <;> rfl
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
⊢ (match SSAEnv.get name τ env with
| some v => fun s => Except.ok (v, s)
| none => fun s => Except.ok (default, s))
env =
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_unfold
|
[106, 1]
|
[114, 33]
|
simp [TopM.set]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
v : MLIRType.eval τ
⊢ set τ name v env =
match SSAEnv.get name τ env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set name τ v env)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
v : MLIRType.eval τ
⊢ bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
env =
match SSAEnv.get name τ env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set name τ v env)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_unfold
|
[106, 1]
|
[114, 33]
|
simp_monad
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
v : MLIRType.eval τ
⊢ bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
env =
match SSAEnv.get name τ env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set name τ v env)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
v : MLIRType.eval τ
⊢ (match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
match SSAEnv.get name τ env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set name τ v env)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_unfold
|
[106, 1]
|
[114, 33]
|
cases (env.get name τ) <;> rfl
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
v : MLIRType.eval τ
⊢ (match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
match SSAEnv.get name τ env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set name τ v env)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_ok
|
[116, 1]
|
[122, 9]
|
simp [set]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
⊢ set τ name v env = Except.ok r → r = ((), SSAEnv.set name τ v env) ∧ SSAEnv.get name τ env = none
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
⊢ bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
env =
Except.ok r →
r = ((), SSAEnv.set name τ v env) ∧ SSAEnv.get name τ env = none
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_ok
|
[116, 1]
|
[122, 9]
|
simp_monad
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
⊢ bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
env =
Except.ok r →
r = ((), SSAEnv.set name τ v env) ∧ SSAEnv.get name τ env = none
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
⊢ (match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
Except.ok r →
r = ((), SSAEnv.set name τ v env) ∧ SSAEnv.get name τ env = none
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_ok
|
[116, 1]
|
[122, 9]
|
cases (env.get name τ) <;> simp <;> intros H <;> try contradiction
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
⊢ (match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
Except.ok r →
r = ((), SSAEnv.set name τ v env) ∧ SSAEnv.get name τ env = none
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
H : (PUnit.unit, SSAEnv.set name τ v env) = r
⊢ r = ((), SSAEnv.set name τ v env)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_ok
|
[116, 1]
|
[122, 9]
|
rw [H]
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
H : (PUnit.unit, SSAEnv.set name τ v env) = r
⊢ r = ((), SSAEnv.set name τ v env)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_ok
|
[116, 1]
|
[122, 9]
|
contradiction
|
case some
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit × SSAEnv Δ
val✝ : MLIRType.eval τ
H : raiseUB "setting to SSA value twice!" env = Except.ok r
⊢ False
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_env_set_commutes
|
[124, 1]
|
[133, 91]
|
intros τ name env r env' H name' Hne τ' v'
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃τ : MLIRType Δ⦄ ⦃name : SSAVal⦄ ⦃env : SSAEnv Δ⦄ ⦃r : MLIRType.eval τ⦄ ⦃env' : SSAEnv Δ⦄,
get τ name env = Except.ok (r, env') →
∀ ⦃name' : SSAVal⦄,
name' ≠ name →
∀ ⦃τ' : MLIRType Δ⦄ ⦃v' : MLIRType.eval τ'⦄,
get τ name (SSAEnv.set name' τ' v' env) = Except.ok (r, SSAEnv.set name' τ' v' env')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
H : get τ name env = Except.ok (r, env')
name' : SSAVal
Hne : name' ≠ name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ get τ name (SSAEnv.set name' τ' v' env) = Except.ok (r, SSAEnv.set name' τ' v' env')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_env_set_commutes
|
[124, 1]
|
[133, 91]
|
rw [TopM.get_unfold] at *
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
H : get τ name env = Except.ok (r, env')
name' : SSAVal
Hne : name' ≠ name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ get τ name (SSAEnv.set name' τ' v' env) = Except.ok (r, SSAEnv.set name' τ' v' env')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
H :
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env) =
Except.ok (r, env')
name' : SSAVal
Hne : name' ≠ name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ Except.ok
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some v => v
| none => default,
SSAEnv.set name' τ' v' env) =
Except.ok (r, SSAEnv.set name' τ' v' env')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_env_set_commutes
|
[124, 1]
|
[133, 91]
|
simp_monad at *
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
H :
Except.ok
(match SSAEnv.get name τ env with
| some v => v
| none => default,
env) =
Except.ok (r, env')
name' : SSAVal
Hne : name' ≠ name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ Except.ok
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some v => v
| none => default,
SSAEnv.set name' τ' v' env) =
Except.ok (r, SSAEnv.set name' τ' v' env')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
name' : SSAVal
Hne : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
H :
(match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
env = env'
⊢ (match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some v => v
| none => default) =
r ∧
SSAEnv.set name' τ' v' env = SSAEnv.set name' τ' v' env'
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_env_set_commutes
|
[124, 1]
|
[133, 91]
|
simp_ssaenv at *
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
name' : SSAVal
Hne : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
H :
(match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
env = env'
⊢ (match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some v => v
| none => default) =
r ∧
SSAEnv.set name' τ' v' env = SSAEnv.set name' τ' v' env'
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
name' : SSAVal
Hne : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
H :
(match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
env = env'
⊢ (match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
SSAEnv.set name' τ' v' env = SSAEnv.set name' τ' v' env'
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_env_set_commutes
|
[124, 1]
|
[133, 91]
|
revert H
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
name' : SSAVal
Hne : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
H :
(match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
env = env'
⊢ (match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
SSAEnv.set name' τ' v' env = SSAEnv.set name' τ' v' env'
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
name' : SSAVal
Hne : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ (match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
env = env' →
(match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
SSAEnv.set name' τ' v' env = SSAEnv.set name' τ' v' env'
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_env_set_commutes
|
[124, 1]
|
[133, 91]
|
cases (env.get name τ) <;> simp at * <;> intros H1 H2 <;> subst r <;> subst env <;> simp
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
env : SSAEnv Δ
r : MLIRType.eval τ
env' : SSAEnv Δ
name' : SSAVal
Hne : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ (match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
env = env' →
(match SSAEnv.get name τ env with
| some v => v
| none => default) =
r ∧
SSAEnv.set name' τ' v' env = SSAEnv.set name' τ' v' env'
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
intros τ name v env r env' H name' Hname τ' v'
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃τ : MLIRType Δ⦄ ⦃name : SSAVal⦄ ⦃v : MLIRType.eval τ⦄ ⦃env : SSAEnv Δ⦄ ⦃r : Unit⦄ ⦃env' : SSAEnv Δ⦄,
set τ name v env = Except.ok (r, env') →
∀ ⦃name' : SSAVal⦄,
name' ≠ name →
∀ (τ' : MLIRType Δ) (v' : MLIRType.eval τ'),
∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
set τ name v (SSAEnv.set name' τ' v' env) = Except.ok (r, env'')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
H : set τ name v env = Except.ok (r, env')
name' : SSAVal
Hname : name' ≠ name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧ set τ name v (SSAEnv.set name' τ' v' env) = Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
simp [set] at *
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
H : set τ name v env = Except.ok (r, env')
name' : SSAVal
Hname : name' ≠ name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧ set τ name v (SSAEnv.set name' τ' v' env) = Except.ok (r, env'')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
H :
bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
env =
Except.ok (r, env')
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
simp_monad at *
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
H :
bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
env =
Except.ok (r, env')
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
bind StateT.get
(fun s =>
match SSAEnv.get name τ s with
| some val => raiseUB "setting to SSA value twice!"
| none => StateT.set (SSAEnv.set name τ v s))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
H :
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
Except.ok (r, env')
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
revert H
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
H :
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
Except.ok (r, env')
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ (match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
Except.ok (r, env') →
∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
cases Hget: (env.get name τ) <;> simp <;> intros H <;> try contradiction
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
⊢ (match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v env))
env =
Except.ok (r, env') →
∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
H : SSAEnv.set name τ v env = env'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
simp_ssaenv
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
H : SSAEnv.set name τ v env = env'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
H : SSAEnv.set name τ v env = env'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
subst env'
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
H : SSAEnv.set name τ v env = env'
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' (SSAEnv.set name τ v env)) env'' ∧
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
exists (SSAEnv.set name τ v (SSAEnv.set name' τ' v' env))
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' (SSAEnv.set name τ v env)) env'' ∧
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ SSAEnv.equiv (SSAEnv.set name' τ' v' (SSAEnv.set name τ v env)) (SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)) ∧
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env))
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
simp[Hget]
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ SSAEnv.equiv (SSAEnv.set name' τ' v' (SSAEnv.set name τ v env)) (SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)) ∧
(match SSAEnv.get name τ env with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env))
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ SSAEnv.equiv (SSAEnv.set name' τ' v' (SSAEnv.set name τ v env)) (SSAEnv.set name τ v (SSAEnv.set name' τ' v' env))
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
apply SSAEnv.set_commutes
|
case none
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ SSAEnv.equiv (SSAEnv.set name' τ' v' (SSAEnv.set name τ v env)) (SSAEnv.set name τ v (SSAEnv.set name' τ' v' env))
|
case none.a
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ name ≠ name'
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
simp [Ne.symm Hname]
|
case none.a
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
Hget : SSAEnv.get name τ env = none
⊢ name ≠ name'
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_env_set_commutes
|
[135, 1]
|
[150, 23]
|
contradiction
|
case some
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
env : SSAEnv Δ
r : Unit
env' : SSAEnv Δ
name' : SSAVal
Hname : ¬name' = name
τ' : MLIRType Δ
v' : MLIRType.eval τ'
val✝ : MLIRType.eval τ
Hget : SSAEnv.get name τ env = some val✝
H : raiseUB "setting to SSA value twice!" env = Except.ok (r, env')
⊢ ∃ env'',
SSAEnv.equiv (SSAEnv.set name' τ' v' env') env'' ∧
(match SSAEnv.get name τ (SSAEnv.set name' τ' v' env) with
| some val => raiseUB "setting to SSA value twice!"
| none => fun x => Except.ok (PUnit.unit, SSAEnv.set name τ v (SSAEnv.set name' τ' v' env)))
(SSAEnv.set name' τ' v' env) =
Except.ok (r, env'')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
intros env₁ env₂ Hequiv τ name r env₁'
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃env₁ env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∀ ⦃τ : MLIRType Δ⦄ ⦃name : SSAVal⦄ ⦃r : MLIRType.eval τ⦄ ⦃env₁' : SSAEnv Δ⦄,
get τ name env₁ = Except.ok (r, env₁') → get τ name env₂ = Except.ok (r, env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ get τ name env₁ = Except.ok (r, env₁') → get τ name env₂ = Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
repeat rw [TopM.get_unfold]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ get τ name env₁ = Except.ok (r, env₁') → get τ name env₂ = Except.ok (r, env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ Except.ok
(match SSAEnv.get name τ env₁ with
| some v => v
| none => default,
env₁) =
Except.ok (r, env₁') →
Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₂) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
rw [Hequiv]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ Except.ok
(match SSAEnv.get name τ env₁ with
| some v => v
| none => default,
env₁) =
Except.ok (r, env₁') →
Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₂) =
Except.ok (r, env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₁) =
Except.ok (r, env₁') →
Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₂) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
simp_monad
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₁) =
Except.ok (r, env₁') →
Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₂) =
Except.ok (r, env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r →
env₁ = env₁' →
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
intros H _
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r →
env₁ = env₁' →
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
H :
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r
a✝ : env₁ = env₁'
⊢ (match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
rw [H]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
H :
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r
a✝ : env₁ = env₁'
⊢ (match SSAEnv.get name τ env₂ with
| some v => v
| none => default) =
r
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.get_equiv
|
[153, 1]
|
[162, 9]
|
rw [TopM.get_unfold]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ Except.ok
(match SSAEnv.get name τ env₁ with
| some v => v
| none => default,
env₁) =
Except.ok (r, env₁') →
get τ name env₂ = Except.ok (r, env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
r : MLIRType.eval τ
env₁' : SSAEnv Δ
⊢ Except.ok
(match SSAEnv.get name τ env₁ with
| some v => v
| none => default,
env₁) =
Except.ok (r, env₁') →
Except.ok
(match SSAEnv.get name τ env₂ with
| some v => v
| none => default,
env₂) =
Except.ok (r, env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_equiv
|
[164, 1]
|
[172, 42]
|
intros env₁ env₂ Hequiv τ name v r env₁'
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
⊢ ∀ ⦃env₁ env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env₁ env₂ →
∀ ⦃τ : MLIRType Δ⦄ ⦃name : SSAVal⦄ ⦃v : MLIRType.eval τ⦄ ⦃r : Unit⦄ ⦃env₁' : SSAEnv Δ⦄,
set τ name v env₁ = Except.ok (r, env₁') → set τ name v env₂ = Except.ok (r, SSAEnv.set name τ v env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ set τ name v env₁ = Except.ok (r, env₁') → set τ name v env₂ = Except.ok (r, SSAEnv.set name τ v env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_equiv
|
[164, 1]
|
[172, 42]
|
repeat rw [TopM.set_unfold]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ set τ name v env₁ = Except.ok (r, env₁') → set τ name v env₂ = Except.ok (r, SSAEnv.set name τ v env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₁ with
| some val => Except.error ("setting to SSA value twice!", env₁)
| none => Except.ok ((), SSAEnv.set name τ v env₁)) =
Except.ok (r, env₁') →
(match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₂)
| none => Except.ok ((), SSAEnv.set name τ v env₂)) =
Except.ok (r, SSAEnv.set name τ v env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_equiv
|
[164, 1]
|
[172, 42]
|
rw [Hequiv]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₁ with
| some val => Except.error ("setting to SSA value twice!", env₁)
| none => Except.ok ((), SSAEnv.set name τ v env₁)) =
Except.ok (r, env₁') →
(match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₂)
| none => Except.ok ((), SSAEnv.set name τ v env₂)) =
Except.ok (r, SSAEnv.set name τ v env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₁)
| none => Except.ok ((), SSAEnv.set name τ v env₁)) =
Except.ok (r, env₁') →
(match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₂)
| none => Except.ok ((), SSAEnv.set name τ v env₂)) =
Except.ok (r, SSAEnv.set name τ v env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_equiv
|
[164, 1]
|
[172, 42]
|
cases (SSAEnv.get name τ env₂) <;> simp
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₁)
| none => Except.ok ((), SSAEnv.set name τ v env₁)) =
Except.ok (r, env₁') →
(match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₂)
| none => Except.ok ((), SSAEnv.set name τ v env₂)) =
Except.ok (r, SSAEnv.set name τ v env₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
TopM.set_equiv
|
[164, 1]
|
[172, 42]
|
rw [TopM.set_unfold]
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₁ with
| some val => Except.error ("setting to SSA value twice!", env₁)
| none => Except.ok ((), SSAEnv.set name τ v env₁)) =
Except.ok (r, env₁') →
set τ name v env₂ = Except.ok (r, SSAEnv.set name τ v env₂)
|
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
env₁ env₂ : SSAEnv Δ
Hequiv : SSAEnv.equiv env₁ env₂
τ : MLIRType Δ
name : SSAVal
v : MLIRType.eval τ
r : Unit
env₁' : SSAEnv Δ
⊢ (match SSAEnv.get name τ env₁ with
| some val => Except.error ("setting to SSA value twice!", env₁)
| none => Except.ok ((), SSAEnv.set name τ v env₁)) =
Except.ok (r, env₁') →
(match SSAEnv.get name τ env₂ with
| some val => Except.error ("setting to SSA value twice!", env₂)
| none => Except.ok ((), SSAEnv.set name τ v env₂)) =
Except.ok (r, SSAEnv.set name τ v env₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = 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' = 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head✝ :: tail✝) env = Except.ok (r, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
case cons head tail HInd =>
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 r =>
rw [TopM.get_unfold] at Hhead
have ⟨rRes, rEnv⟩ := r; simp at Hhead; cases Hhead; subst rEnv
simp [denoteOpArgs] at HInd
split at H <;> try contradiction
case h_2 tailR HTailR =>
have ⟨tailRes, tailEnv⟩ := tailR
simp at *
specialize HInd HTailR
cases H; subst env'
assumption
|
α₁ σ₁ : 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
⊢ env' = env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = 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' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : [] = r ∧ env = env'
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = 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' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env' : SSAEnv Δ
⊢ env' = env'
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
simp
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
env' : SSAEnv Δ
⊢ env' = env'
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
H : denoteOpArgs Δ (head :: tail) env = Except.ok (r, env')
⊢ env' = 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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') →
env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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') →
env' = 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' = env
env : SSAEnv Δ
r : List (TypedArg Δ)
env' : SSAEnv Δ
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')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
case ok r =>
rw [TopM.get_unfold] at Hhead
have ⟨rRes, rEnv⟩ := r; simp at Hhead; cases Hhead; subst rEnv
simp [denoteOpArgs] at HInd
split at H <;> try contradiction
case h_2 tailR HTailR =>
have ⟨tailRes, tailEnv⟩ := tailR
simp at *
specialize HInd HTailR
cases H; subst env'
assumption
|
α₁ σ₁ : 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok r
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 r.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := r.fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
rw [TopM.get_unfold] at 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
Hhead : TopM.get headτ headName env = Except.ok r
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 r.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := r.fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
Hhead :
Except.ok
(match SSAEnv.get headName headτ env with
| some v => v
| none => default,
env) =
Except.ok r
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 r.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := r.fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
have ⟨rRes, rEnv⟩ := r
|
α₁ σ₁ : 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
Hhead :
Except.ok
(match SSAEnv.get headName headτ env with
| some v => v
| none => default,
env) =
Except.ok r
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 r.snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := r.fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
rEnv : SSAEnv Δ
Hhead :
Except.ok
(match SSAEnv.get headName headτ env with
| some v => v
| none => default,
env) =
Except.ok (rRes, rEnv)
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 (rRes, rEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, rEnv).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
simp at 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
rEnv : SSAEnv Δ
Hhead :
Except.ok
(match SSAEnv.get headName headτ env with
| some v => v
| none => default,
env) =
Except.ok (rRes, rEnv)
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 (rRes, rEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, rEnv).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
rEnv : SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (rRes, rEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, rEnv).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
Hhead :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes ∧
env = rEnv
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
cases 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
rEnv : SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (rRes, rEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, rEnv).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
Hhead :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes ∧
env = rEnv
⊢ env' = 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
rEnv : SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (rRes, rEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, rEnv).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
right✝ : env = rEnv
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
subst rEnv
|
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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
rEnv : SSAEnv Δ
H :
(match
mapM
(fun x s =>
match TopM.get x.snd x.fst s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := x.snd, snd := v.fst }, v.snd))
tail (rRes, rEnv).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, rEnv).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
right✝ : env = rEnv
⊢ env' = 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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
simp [denoteOpArgs] at HInd
|
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' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = 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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
split at H <;> try contradiction
|
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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd with
| Except.error err => Except.error err
| Except.ok v => Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: v.fst, v.snd)) =
Except.ok (r✝, env')
⊢ env' = env
|
case intro.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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd =
Except.ok v✝
H : Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: v✝.fst, v✝.snd) = Except.ok (r✝, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
case h_2 tailR HTailR =>
have ⟨tailRes, tailEnv⟩ := tailR
simp at *
specialize HInd HTailR
cases H; subst env'
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd =
Except.ok tailR
H : Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: tailR.fst, tailR.snd) = Except.ok (r✝, env')
⊢ env' = env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
contradiction
|
case intro.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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd =
Except.error err✝
H : Except.error err✝ = Except.ok (r✝, env')
⊢ env' = env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
have ⟨tailRes, tailEnv⟩ := tailR
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
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 (rRes, env).snd =
Except.ok tailR
H : Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: tailR.fst, tailR.snd) = Except.ok (r✝, env')
⊢ env' = 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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 (rRes, env).snd =
Except.ok (tailRes, tailEnv)
H :
Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: (tailRes, tailEnv).fst, (tailRes, tailEnv).snd) =
Except.ok (r✝, env')
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
simp 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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 (rRes, env).snd =
Except.ok (tailRes, tailEnv)
H :
Except.ok ({ fst := headτ, snd := (rRes, env).fst } :: (tailRes, tailEnv).fst, (tailRes, tailEnv).snd) =
Except.ok (r✝, env')
⊢ env' = 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 Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
H : { fst := headτ, snd := rRes } :: tailRes = r✝ ∧ tailEnv = env'
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
specialize HInd HTailR
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
HInd :
∀ ⦃env : SSAEnv Δ⦄ ⦃r : List (TypedArg Δ)⦄ ⦃env' : SSAEnv Δ⦄,
mapM
(fun x => do
let __do_lift ← TopM.get x.snd x.fst
pure { fst := x.snd, snd := __do_lift })
tail env =
Except.ok (r, env') →
env' = env
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
H : { fst := headτ, snd := rRes } :: tailRes = r✝ ∧ tailEnv = env'
⊢ env' = env
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
H : { fst := headτ, snd := rRes } :: tailRes = r✝ ∧ tailEnv = env'
HInd : tailEnv = env
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
H : { fst := headτ, snd := rRes } :: tailRes = r✝ ∧ tailEnv = env'
HInd : tailEnv = env
⊢ env' = env
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝¹ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
HInd : tailEnv = env
left✝ : { fst := headτ, snd := rRes } :: tailRes = r✝
right✝ : tailEnv = env'
⊢ env' = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
subst env'
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
env' : SSAEnv Δ
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝¹ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
HInd : tailEnv = env
left✝ : { fst := headτ, snd := rRes } :: tailRes = r✝
right✝ : tailEnv = env'
⊢ env' = env
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝¹ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
HInd : tailEnv = env
left✝ : { fst := headτ, snd := rRes } :: tailRes = r✝
⊢ tailEnv = env
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOpArgs_res
|
[678, 1]
|
[703, 15]
|
assumption
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α✝ σ✝ : Type
ε✝ : σ✝ → Type
Δ : Dialect α✝ σ✝ ε✝
S : Semantics Δ
head : TypedSSAVal Δ
tail : List (TypedSSAVal Δ)
env : SSAEnv Δ
r✝ : List (TypedArg Δ)
headName : SSAVal
headτ : MLIRType Δ
r : MLIRType.eval headτ × SSAEnv Δ
rRes : MLIRType.eval headτ
left✝¹ :
(match SSAEnv.get headName headτ env with
| some v => v
| none => default) =
rRes
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
tailR : List (TypedArg Δ) × SSAEnv Δ
tailRes : 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 env =
Except.ok (tailRes, tailEnv)
HInd : tailEnv = env
left✝ : { fst := headτ, snd := rRes } :: tailRes = r✝
⊢ tailEnv = env
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
intros H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
vals : List SSAVal
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
⊢ denoteTypedArgs (argsHead :: argsTail) vals env = Except.ok (res, env') →
∃ valHead valTail,
vals = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
vals : List SSAVal
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
H : denoteTypedArgs (argsHead :: argsTail) vals env = Except.ok (res, env')
⊢ ∃ valHead valTail,
vals = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
simp [denoteTypedArgs] at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
vals : List SSAVal
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
H : denoteTypedArgs (argsHead :: argsTail) vals env = Except.ok (res, env')
⊢ ∃ valHead valTail,
vals = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
vals : List SSAVal
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
H :
(match vals with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valHead valTail,
vals = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
cases vals <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
vals : List SSAVal
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
H :
(match vals with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valHead valTail,
vals = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
head✝ : SSAVal
tail✝ : List SSAVal
H :
(match head✝ :: tail✝ with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valHead valTail,
head✝ :: tail✝ = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
case cons headVal tailVal =>
exists headVal
exists tailVal
simp_monad at *
revert H
split <;> intros H <;> try contradiction
case h_2 v Hv =>
have ⟨fst, snd⟩ := v; cases fst
case unit =>
simp_semantics_monad at *
revert Hv; split <;> intros Hv <;> try contradiction
simp at Hv; subst snd
simp [H]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match headVal :: tailVal with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valHead valTail,
headVal :: tailVal = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead 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 nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
H :
(match [] with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valHead valTail,
[] = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead 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]
|
exists headVal
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match headVal :: tailVal with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valHead valTail,
headVal :: tailVal = valHead :: valTail ∧
TopM.set argsHead.fst valHead argsHead.snd env =
Except.ok ((), SSAEnv.set valHead argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set valHead argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match headVal :: tailVal with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valTail,
headVal :: tailVal = headVal :: valTail ∧
TopM.set argsHead.fst headVal argsHead.snd env =
Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
exists tailVal
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match headVal :: tailVal with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ ∃ valTail,
headVal :: tailVal = headVal :: valTail ∧
TopM.set argsHead.fst headVal argsHead.snd env =
Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) ∧
denoteTypedArgs argsTail valTail (SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok ((), env')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match headVal :: tailVal with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ headVal :: tailVal = headVal :: tailVal ∧
TopM.set argsHead.fst headVal 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match headVal :: tailVal with
| [] => TopM.raiseUB "not enough names in denoteTypedArgs"
| name :: names => do
TopM.set argsHead.fst name argsHead.snd
denoteTypedArgs argsTail names)
env =
Except.ok (res, env')
⊢ headVal :: tailVal = headVal :: tailVal ∧
TopM.set argsHead.fst headVal 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')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match TopM.set argsHead.fst headVal argsHead.snd env with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail tailVal v.snd) =
Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
revert H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
H :
(match TopM.set argsHead.fst headVal argsHead.snd env with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail tailVal v.snd) =
Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
⊢ (match TopM.set argsHead.fst headVal argsHead.snd env with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail tailVal v.snd) =
Except.ok (res, env') →
TopM.set argsHead.fst headVal 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
split <;> intros H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
δ : Dialect α σ ε
argsHead : TypedArg δ
argsTail : TypedArgs δ
env : SSAEnv δ
res : Unit
env' : SSAEnv δ
headVal : SSAVal
tailVal : List SSAVal
⊢ (match TopM.set argsHead.fst headVal argsHead.snd env with
| Except.error err => Except.error err
| Except.ok v => denoteTypedArgs argsTail tailVal v.snd) =
Except.ok (res, env') →
TopM.set argsHead.fst headVal 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')
|
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 δ
heq✝ : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok v✝
H : denoteTypedArgs argsTail tailVal v✝.snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
case h_2 v Hv =>
have ⟨fst, snd⟩ := v; cases fst
case unit =>
simp_semantics_monad at *
revert Hv; split <;> intros Hv <;> try contradiction
simp at Hv; subst snd
simp [H]
|
α₁ σ₁ : 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 δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok v
H : denoteTypedArgs argsTail tailVal v.snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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 δ)
err✝ : String × SSAEnv δ
heq✝ : TopM.set argsHead.fst headVal argsHead.snd env = Except.error err✝
H : Except.error err✝ = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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]
|
have ⟨fst, snd⟩ := v
|
α₁ σ₁ : 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 δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok v
H : denoteTypedArgs argsTail tailVal v.snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
α₁ σ₁ : 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 δ
fst : Unit
snd : SSAEnv δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok (fst, snd)
H : denoteTypedArgs argsTail tailVal (fst, snd).snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
cases fst
|
α₁ σ₁ : 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 δ
fst : Unit
snd : SSAEnv δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok (fst, snd)
H : denoteTypedArgs argsTail tailVal (fst, snd).snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
case unit
α₁ σ₁ : 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 δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok (PUnit.unit, snd)
H : denoteTypedArgs argsTail tailVal (PUnit.unit, snd).snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
case unit =>
simp_semantics_monad at *
revert Hv; split <;> intros Hv <;> try contradiction
simp at Hv; subst snd
simp [H]
|
α₁ σ₁ : 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 δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok (PUnit.unit, snd)
H : denoteTypedArgs argsTail tailVal (PUnit.unit, snd).snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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]
|
simp_semantics_monad at *
|
α₁ σ₁ : 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 δ
Hv : TopM.set argsHead.fst headVal argsHead.snd env = Except.ok (PUnit.unit, snd)
H : denoteTypedArgs argsTail tailVal (PUnit.unit, snd).snd = Except.ok (res, env')
⊢ TopM.set argsHead.fst headVal 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')
|
α₁ σ₁ : 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 δ
Hv :
(match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env)) =
Except.ok (PUnit.unit, snd)
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
⊢ (match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
revert Hv
|
α₁ σ₁ : 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 δ
Hv :
(match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env)) =
Except.ok (PUnit.unit, snd)
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
⊢ (match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => 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')
|
α₁ σ₁ : 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')
⊢ (match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env)) =
Except.ok (PUnit.unit, snd) →
(match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
split <;> intros Hv <;> try contradiction
|
α₁ σ₁ : 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')
⊢ (match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env)) =
Except.ok (PUnit.unit, snd) →
(match SSAEnv.get headVal argsHead.fst env with
| some val => Except.error ("setting to SSA value twice!", env)
| none => 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')
|
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 δ
snd : SSAEnv δ
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
x✝ : Option (MLIRType.eval argsHead.fst)
heq✝ : SSAEnv.get headVal argsHead.fst env = none
Hv : Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok (PUnit.unit, snd)
⊢ 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
simp at Hv
|
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 δ
snd : SSAEnv δ
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
x✝ : Option (MLIRType.eval argsHead.fst)
heq✝ : SSAEnv.get headVal argsHead.fst env = none
Hv : Except.ok ((), SSAEnv.set headVal argsHead.fst argsHead.snd env) = Except.ok (PUnit.unit, snd)
⊢ 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')
|
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 δ
snd : SSAEnv δ
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
x✝ : Option (MLIRType.eval argsHead.fst)
heq✝ : SSAEnv.get headVal argsHead.fst env = none
Hv : SSAEnv.set headVal argsHead.fst argsHead.snd env = snd
⊢ 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')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteTypedArgs_cons_args
|
[705, 1]
|
[729, 11]
|
subst snd
|
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 δ
snd : SSAEnv δ
H : denoteTypedArgs argsTail tailVal snd = Except.ok (res, env')
x✝ : Option (MLIRType.eval argsHead.fst)
heq✝ : SSAEnv.get headVal argsHead.fst env = none
Hv : SSAEnv.set headVal argsHead.fst argsHead.snd env = snd
⊢ 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')
|
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')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.