url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
|---|---|---|---|---|---|---|---|---|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
rw [HIx]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
HInd : ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match TopM.denoteRegionsByIx regions idx args env₂ with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
HInd : ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
⊢ ∃ env₂'_1,
SSAEnv.equiv env' env₂'_1 ∧
(match Except.ok (resReg, env₂') with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂'_1)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
simp
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
HInd : ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
⊢ ∃ env₂'_1,
SSAEnv.equiv env' env₂'_1 ∧
(match Except.ok (resReg, env₂') with
| Except.error err => Except.error err
| Except.ok v => toTopM regions (continuation v.fst) v.snd) =
Except.ok (res, env₂'_1)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
HInd : ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
⊢ ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
HInd : ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
⊢ ∃ env₂'_1, SSAEnv.equiv env' env₂'_1 ∧ toTopM regions (continuation resReg) env₂' = Except.ok (res, env₂'_1)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
⊢ toTopM regions (continuation resReg) ?m.1084400 = Except.ok (?m.1084401, ?m.1084402)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
OpM.toTopM_regions_equiv
|
[841, 1]
|
[868, 15]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
regions : List (TypedArgs Δ → TopM Δ (TypedArgs Δ))
Hregs : denoteRegionsEquivInvariant regions
idx : ℕ
args : TypedArgs Δ
continuation : TypedArgs Δ → OpM Δ (TypedArgs Δ)
HInd :
∀ (a : TypedArgs Δ) ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
toTopM regions (continuation a) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ toTopM regions (continuation a) env₂ = Except.ok (res, env₂')
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
resReg : TypedArgs Δ
envReg : SSAEnv Δ
H : toTopM regions (continuation resReg) envReg = Except.ok (res, env')
HReg : TopM.denoteRegionsByIx regions idx args env = Except.ok (resReg, envReg)
env₂' : SSAEnv Δ
Henv₂' : SSAEnv.equiv envReg env₂'
HIx : TopM.denoteRegionsByIx regions idx args env₂ = Except.ok (resReg, env₂')
⊢ SSAEnv.equiv envReg ?m.1084404
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
unfold denoteOp
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteOp Δ (Op.mk op_name res args regions attrs) env = Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ denoteOp Δ (Op.mk op_name res args regions attrs) env₂ = Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
(let resTy := List.map Prod.snd res;
do
let args ← denoteOpArgs Δ args
let iop : IOp Δ := IOp.mk op_name resTy args (OpM.denoteRegions regions 0) attrs
let ret ← OpM.toTopM (TopM.mapDenoteRegion Δ regions) (Semantics.semantics_op iop)
let __do_jp : Unit → TopM Δ (TypedArgs Δ) := fun y => pure ret
match res with
| [] => do
let y ← pure ()
__do_jp y
| [res] =>
match ret with
| [{ fst := τ, snd := v }] => do
let y ← TopM.set τ res.fst v
__do_jp y
| x => do
let y ←
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString ret ++ toString "'")
__do_jp y
| x => do
let y ← TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
__do_jp y)
env =
Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧
(let resTy := List.map Prod.snd res;
do
let args ← denoteOpArgs Δ args
let iop : IOp Δ := IOp.mk op_name resTy args (OpM.denoteRegions regions 0) attrs
let ret ← OpM.toTopM (TopM.mapDenoteRegion Δ regions) (Semantics.semantics_op iop)
let __do_jp : Unit → TopM Δ (TypedArgs Δ) := fun y => pure ret
match res with
| [] => do
let y ← pure ()
__do_jp y
| [res] =>
match ret with
| [{ fst := τ, snd := v }] => do
let y ← TopM.set τ res.fst v
__do_jp y
| x => do
let y ←
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ret ++ toString "'")
__do_jp y
| x => do
let y ←
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
__do_jp y)
env₂ =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp_monad
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
(let resTy := List.map Prod.snd res;
do
let args ← denoteOpArgs Δ args
let iop : IOp Δ := IOp.mk op_name resTy args (OpM.denoteRegions regions 0) attrs
let ret ← OpM.toTopM (TopM.mapDenoteRegion Δ regions) (Semantics.semantics_op iop)
let __do_jp : Unit → TopM Δ (TypedArgs Δ) := fun y => pure ret
match res with
| [] => do
let y ← pure ()
__do_jp y
| [res] =>
match ret with
| [{ fst := τ, snd := v }] => do
let y ← TopM.set τ res.fst v
__do_jp y
| x => do
let y ←
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString ret ++ toString "'")
__do_jp y
| x => do
let y ← TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
__do_jp y)
env =
Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧
(let resTy := List.map Prod.snd res;
do
let args ← denoteOpArgs Δ args
let iop : IOp Δ := IOp.mk op_name resTy args (OpM.denoteRegions regions 0) attrs
let ret ← OpM.toTopM (TopM.mapDenoteRegion Δ regions) (Semantics.semantics_op iop)
let __do_jp : Unit → TopM Δ (TypedArgs Δ) := fun y => pure ret
match res with
| [] => do
let y ← pure ()
__do_jp y
| [res] =>
match ret with
| [{ fst := τ, snd := v }] => do
let y ← TopM.set τ res.fst v
__do_jp y
| x => do
let y ←
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ret ++ toString "'")
__do_jp y
| x => do
let y ←
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
__do_jp y)
env₂ =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
(match denoteOpArgs Δ args env with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
intros env r env' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃r : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
(match denoteOpArgs Δ args env with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' : SSAEnv Δ
H :
(match denoteOpArgs Δ args env with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
split at H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' : SSAEnv Δ
H :
(match denoteOpArgs Δ args env with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
v✝ : List (TypedArg Δ) × SSAEnv Δ
heq✝ : denoteOpArgs Δ args env = Except.ok v✝
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) v✝.fst (OpM.denoteRegions regions 0) attrs))
v✝.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case h_2 _ argsRes HargsRes =>
have ⟨argRes, argResEnv⟩ := argsRes
have _ := denoteOpArgs_res HargsRes; subst argResEnv
simp [denoteOpArgs_equiv HargsRes Henv₂]
split at H <;> try contradiction
case h_2 regR HregR =>
have ⟨regR, regEnv⟩ := regR
have HRegInd := OpM.toTopM_regions_equiv (TopM.mapDenoteRegion Δ regions)
have ⟨regEnv₂, HregEnv₂, HregR₂⟩ := HRegInd (by sorry) HregR Henv₂ simp [HregR₂]
cases res
case nil =>
simp at *; cases H; exists regEnv₂
subst r env'; simp [HregEnv₂]
sorry case cons headRes tailRes =>
cases tailRes
case cons _ _ => simp at *; cases H
case nil =>
simp
cases regR
case nil => simp at *; cases H
case cons opRHead opRTail =>
cases opRTail
case cons _ _ => simp at *; cases H
case nil =>
simp at *
split at H <;> try contradiction
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
HargsRes : denoteOpArgs Δ args env = Except.ok argsRes
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) argsRes.fst (OpM.denoteRegions regions 0) attrs))
argsRes.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ : denoteOpArgs Δ args env = Except.error err✝
H : Except.error err✝ = Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
have ⟨argRes, argResEnv⟩ := argsRes
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
HargsRes : denoteOpArgs Δ args env = Except.ok argsRes
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) argsRes.fst (OpM.denoteRegions regions 0) attrs))
argsRes.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
argResEnv : SSAEnv Δ
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, argResEnv)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, argResEnv).fst (OpM.denoteRegions regions 0) attrs))
(argRes, argResEnv).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
have _ := denoteOpArgs_res HargsRes
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
argResEnv : SSAEnv Δ
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, argResEnv)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, argResEnv).fst (OpM.denoteRegions regions 0) attrs))
(argRes, argResEnv).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
argResEnv : SSAEnv Δ
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, argResEnv)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, argResEnv).fst (OpM.denoteRegions regions 0) attrs))
(argRes, argResEnv).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
x✝ : argResEnv = env
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
subst argResEnv
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
argResEnv : SSAEnv Δ
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, argResEnv)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, argResEnv).fst (OpM.denoteRegions regions 0) attrs))
(argRes, argResEnv).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
x✝ : argResEnv = env
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp [denoteOpArgs_equiv HargsRes Henv₂]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOpArgs Δ args env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) v.fst (OpM.denoteRegions regions 0) attrs))
v.snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
split at H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
H :
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
v✝ : List (TypedArg Δ) × SSAEnv Δ
heq✝ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok v✝
H :
(match res with
| [] => fun s => Except.ok (v✝.fst, s)
| [res] =>
match v✝.fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (v✝.fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v✝.fst ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (v✝.fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (v✝.fst, v.snd))
v✝.snd =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case h_2 regR HregR =>
have ⟨regR, regEnv⟩ := regR
have HRegInd := OpM.toTopM_regions_equiv (TopM.mapDenoteRegion Δ regions)
have ⟨regEnv₂, HregEnv₂, HregR₂⟩ := HRegInd (by sorry) HregR Henv₂ simp [HregR₂]
cases res
case nil =>
simp at *; cases H; exists regEnv₂
subst r env'; simp [HregEnv₂]
sorry case cons headRes tailRes =>
cases tailRes
case cons _ _ => simp at *; cases H
case nil =>
simp
cases regR
case nil => simp at *; cases H
case cons opRHead opRTail =>
cases opRTail
case cons _ _ => simp at *; cases H
case nil =>
simp at *
split at H <;> try contradiction
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok regR
H :
(match res with
| [] => fun s => Except.ok (regR.fst, s)
| [res] =>
match regR.fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR.fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString regR.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR.fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR.fst, v.snd))
regR.snd =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.error err✝
H : Except.error err✝ = Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
have ⟨regR, regEnv⟩ := regR
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok regR
H :
(match res with
| [] => fun s => Except.ok (regR.fst, s)
| [res] =>
match regR.fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR.fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString regR.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR.fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR.fst, v.snd))
regR.snd =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
have HRegInd := OpM.toTopM_regions_equiv (TopM.mapDenoteRegion Δ regions)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
have ⟨regEnv₂, HregEnv₂, HregR₂⟩ := HRegInd (by sorry) HregR Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases res
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd res) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match res with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd []) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [] ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd []) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd []) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match [] with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [] ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match head✝ :: tail✝ with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (head✝ :: tail✝) ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (head✝ :: tail✝)) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match head✝ :: tail✝ with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (head✝ :: tail✝) ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case nil =>
simp at *; cases H; exists regEnv₂
subst r env'; simp [HregEnv₂]
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd []) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [] ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd []) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd []) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match [] with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [] ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case cons headRes tailRes =>
cases tailRes
case cons _ _ => simp at *; cases H
case nil =>
simp
cases regR
case nil => simp at *; cases H
case cons opRHead opRTail =>
cases opRTail
case cons _ _ => simp at *; cases H
case nil =>
simp at *
split at H <;> try contradiction
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
tailRes : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: tailRes)) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match headRes :: tailRes with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: tailRes) ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: tailRes)) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: tailRes)) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match headRes :: tailRes with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: tailRes) ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
res args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd res) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match res with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString res ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
⊢ denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd []) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [] ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd []) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name (List.map Prod.snd []) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match [] with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [] ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
H : regR = r ∧ regEnv = env'
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
H : regR = r ∧ regEnv = env'
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (r, env₂')
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
left✝ : regR = r
right✝ : regEnv = env'
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
exists regEnv₂
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
left✝ : regR = r
right✝ : regEnv = env'
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (r, env₂')
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
left✝ : regR = r
right✝ : regEnv = env'
⊢ SSAEnv.equiv env' regEnv₂ ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (r, regEnv₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
subst r env'
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
left✝ : regR = r
right✝ : regEnv = env'
⊢ SSAEnv.equiv env' regEnv₂ ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (r, regEnv₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
⊢ SSAEnv.equiv regEnv regEnv₂ ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (regR, regEnv₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp [HregEnv₂]
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
⊢ SSAEnv.equiv regEnv regEnv₂ ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (regR, regEnv₂)
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
⊢ (match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (regR, regEnv₂)
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
sorry
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (regR, regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (regR, regEnv₂)
⊢ (match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v => Except.ok v) =
Except.ok (regR, regEnv₂)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases tailRes
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
tailRes : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: tailRes)) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match headRes :: tailRes with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: tailRes) ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: tailRes)) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: tailRes)) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match headRes :: tailRes with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: tailRes) ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match [headRes] with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0)
attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match headRes :: head✝ :: tail✝ with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0)
attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match headRes :: head✝ :: tail✝ with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case cons _ _ => simp at *; cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0)
attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match headRes :: head✝ :: tail✝ with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0)
attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match headRes :: head✝ :: tail✝ with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case nil =>
simp
cases regR
case nil => simp at *; cases H
case cons opRHead opRTail =>
cases opRTail
case cons _ _ => simp at *; cases H
case nil =>
simp at *
split at H <;> try contradiction
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match [headRes] with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0)
attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match headRes :: head✝ :: tail✝ with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) (argRes, env).fst (OpM.denoteRegions regions 0)
attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd (headRes :: head✝ :: tail✝)) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match headRes :: head✝ :: tail✝ with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (headRes.snd :: head✝.snd :: List.map Prod.snd tail✝) argRes (OpM.denoteRegions regions 0)
attrs))
env =
Except.ok (regR, regEnv)
H :
(match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++ toString "'")
regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR, v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (headRes.snd :: head✝.snd :: List.map Prod.snd tail✝) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (headRes.snd :: head✝.snd :: List.map Prod.snd tail✝) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes head✝ : TypedSSAVal Δ
tail✝ : List (TypedSSAVal Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (headRes.snd :: head✝.snd :: List.map Prod.snd tail✝) argRes (OpM.denoteRegions regions 0)
attrs))
env =
Except.ok (regR, regEnv)
H :
(match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++ toString "'")
regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok (regR, v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (headRes.snd :: head✝.snd :: List.map Prod.snd tail✝) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (headRes.snd :: head✝.snd :: List.map Prod.snd tail✝) argRes (OpM.denoteRegions regions 0)
attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
match
TopM.raiseUB
(toString "denoteOp: expected 0 or 1 results, got '" ++ toString (headRes :: head✝ :: tail✝) ++
toString "'")
v.snd with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) argRes (OpM.denoteRegions regions 0) attrs))
env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match [headRes] with
| [] => fun s => Except.ok (v.fst, s)
| [res] =>
match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ res.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases regR
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR✝ : List (TypedArg Δ) × SSAEnv Δ
regR : List (TypedArg Δ)
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (regR, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((regR, regEnv).fst, s)
| [res] =>
match (regR, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (regR, regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((regR, regEnv).fst, v.snd))
(regR, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (regR, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok ([], regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok (([], regEnv).fst, s)
| [res] =>
match ([], regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ([], regEnv).fst ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd))
([], regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok ([], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (head✝ :: tail✝, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((head✝ :: tail✝, regEnv).fst, s)
| [res] =>
match (head✝ :: tail✝, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (head✝ :: tail✝, regEnv).fst ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((head✝ :: tail✝, regEnv).fst, v.snd))
(head✝ :: tail✝, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (head✝ :: tail✝, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case nil => simp at *; cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok ([], regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok (([], regEnv).fst, s)
| [res] =>
match ([], regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ([], regEnv).fst ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd))
([], regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok ([], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case cons opRHead opRTail =>
cases opRTail
case cons _ _ => simp at *; cases H
case nil =>
simp at *
split at H <;> try contradiction
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
opRTail : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (opRHead :: opRTail, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((opRHead :: opRTail, regEnv).fst, s)
| [res] =>
match (opRHead :: opRTail, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: opRTail, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (opRHead :: opRTail, regEnv).fst ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: opRTail, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: opRTail, regEnv).fst, v.snd))
(opRHead :: opRTail, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (opRHead :: opRTail, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok ([], regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok (([], regEnv).fst, s)
| [res] =>
match ([], regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ([], regEnv).fst ++ toString "'") s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([], regEnv).fst, v.snd))
([], regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok ([], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([], regEnv)
H :
(match TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString [] ++ toString "'") regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok ([], v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([], regEnv)
H :
(match TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString [] ++ toString "'") regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok ([], v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases opRTail
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
opRTail : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (opRHead :: opRTail, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((opRHead :: opRTail, regEnv).fst, s)
| [res] =>
match (opRHead :: opRTail, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: opRTail, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (opRHead :: opRTail, regEnv).fst ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: opRTail, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: opRTail, regEnv).fst, v.snd))
(opRHead :: opRTail, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (opRHead :: opRTail, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case nil
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok ([opRHead], regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok (([opRHead], regEnv).fst, s)
| [res] =>
match ([opRHead], regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ([opRHead], regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd))
([opRHead], regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok ([opRHead], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
case cons
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (opRHead :: head✝ :: tail✝, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, s)
| [res] =>
match (opRHead :: head✝ :: tail✝, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++
toString (opRHead :: head✝ :: tail✝, regEnv).fst ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd))
(opRHead :: head✝ :: tail✝, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (opRHead :: head✝ :: tail✝, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case cons _ _ => simp at *; cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (opRHead :: head✝ :: tail✝, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, s)
| [res] =>
match (opRHead :: head✝ :: tail✝, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++
toString (opRHead :: head✝ :: tail✝, regEnv).fst ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd))
(opRHead :: head✝ :: tail✝, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (opRHead :: head✝ :: tail✝, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case nil =>
simp at *
split at H <;> try contradiction
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok ([opRHead], regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok (([opRHead], regEnv).fst, s)
| [res] =>
match ([opRHead], regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ([opRHead], regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd))
([opRHead], regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok ([opRHead], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok (opRHead :: head✝ :: tail✝, regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, s)
| [res] =>
match (opRHead :: head✝ :: tail✝, regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++
toString (opRHead :: head✝ :: tail✝, regEnv).fst ++
toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok ((opRHead :: head✝ :: tail✝, regEnv).fst, v.snd))
(opRHead :: head✝ :: tail✝, regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok (opRHead :: head✝ :: tail✝, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (opRHead :: head✝ :: tail✝, regEnv)
H :
(match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (opRHead :: head✝ :: tail✝) ++ toString "'")
regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok (opRHead :: head✝ :: tail✝, v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (opRHead :: head✝ :: tail✝, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead head✝ : TypedArg Δ
tail✝ : List (TypedArg Δ)
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok (opRHead :: head✝ :: tail✝, regEnv)
H :
(match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString (opRHead :: head✝ :: tail✝) ++ toString "'")
regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok (opRHead :: head✝ :: tail✝, v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok (opRHead :: head✝ :: tail✝, regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
(argRes, env).snd =
Except.ok ([opRHead], regEnv)
H :
(match [headRes] with
| [] => fun s => Except.ok (([opRHead], regEnv).fst, s)
| [res] =>
match ([opRHead], regEnv).fst with
| [{ fst := τ, snd := v }] => fun s =>
match TopM.set τ res.fst v s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB
(toString "denoteOp: expected 1 return value, got '" ++ toString ([opRHead], regEnv).fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 0 or 1 results, got '" ++ toString [headRes] ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v => Except.ok (([opRHead], regEnv).fst, v.snd))
([opRHead], regEnv).snd =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op
(IOp.mk op_name (List.map Prod.snd [headRes]) (argRes, env).fst (OpM.denoteRegions regions 0) attrs))
env₂ =
Except.ok ([opRHead], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([opRHead], regEnv)
H :
(match TopM.set opRHead.fst headRes.fst opRHead.snd regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok ([opRHead], v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([opRHead], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
split at H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([opRHead], regEnv)
H :
(match TopM.set opRHead.fst headRes.fst opRHead.snd regEnv with
| Except.error err => Except.error err
| Except.ok v => Except.ok ([opRHead], v.snd)) =
Except.ok (r, env')
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([opRHead], regEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝² : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([opRHead], regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([opRHead], regEnv₂)
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
v✝ : Unit × SSAEnv Δ
heq✝ : TopM.set opRHead.fst headRes.fst opRHead.snd regEnv = Except.ok v✝
H : Except.ok ([opRHead], v✝.snd) = Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
case h_2 setRes HSetRes =>
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝² : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([opRHead], regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([opRHead], regEnv₂)
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
setRes : Unit × SSAEnv Δ
HSetRes : TopM.set opRHead.fst headRes.fst opRHead.snd regEnv = Except.ok setRes
H : Except.ok ([opRHead], setRes.snd) = Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝² : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([opRHead], regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([opRHead], regEnv₂)
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ : TopM.set opRHead.fst headRes.fst opRHead.snd regEnv = Except.error err✝
H : Except.error err✝ = Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOp_equiv
|
[871, 1]
|
[915, 20]
|
sorry
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
op_name : String
args : List (TypedSSAVal Δ)
regions : List (Region Δ)
attrs : AttrDict Δ
env : SSAEnv Δ
r : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝² : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
argsRes : List (TypedArg Δ) × SSAEnv Δ
argRes : List (TypedArg Δ)
HargsRes : denoteOpArgs Δ args env = Except.ok (argRes, env)
x✝¹ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
regR : List (TypedArg Δ) × SSAEnv Δ
regEnv : SSAEnv Δ
HRegInd :
denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions) →
∀ ⦃opM : OpM Δ (TypedArgs Δ)⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ OpM.toTopM (TopM.mapDenoteRegion Δ regions) opM env₂ = Except.ok (res, env₂')
regEnv₂ : SSAEnv Δ
HregEnv₂ : SSAEnv.equiv regEnv regEnv₂
headRes : TypedSSAVal Δ
opRHead : TypedArg Δ
HregR :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env =
Except.ok ([opRHead], regEnv)
HregR₂ :
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ =
Except.ok ([opRHead], regEnv₂)
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
setRes : Unit × SSAEnv Δ
HSetRes : TopM.set opRHead.fst headRes.fst opRHead.snd regEnv = Except.ok setRes
H : Except.ok ([opRHead], setRes.snd) = Except.ok (r, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match
OpM.toTopM (TopM.mapDenoteRegion Δ regions)
(Semantics.semantics_op (IOp.mk op_name [headRes.snd] argRes (OpM.denoteRegions regions 0) attrs)) env₂ with
| Except.error err => Except.error err
| Except.ok v =>
(match v.fst with
| [{ fst := τ, snd := v_1 }] => fun s =>
match TopM.set τ headRes.fst v_1 s with
| Except.error err => Except.error err
| Except.ok v_2 => Except.ok (v.fst, v_2.snd)
| x => fun s =>
match
TopM.raiseUB (toString "denoteOp: expected 1 return value, got '" ++ toString v.fst ++ toString "'")
s with
| Except.error err => Except.error err
| Except.ok v_1 => Except.ok (v.fst, v_1.snd))
v.snd) =
Except.ok (r, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
intros env res env' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteOps Δ [] env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ → ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ [] env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : denoteOps Δ [] env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ [] env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp [denoteOps] at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : denoteOps Δ [] env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ [] env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : pure [] env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ pure [] env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : pure [] env = Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ pure [] env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : [] = res ∧ env = env'
⊢ SSAEnv.equiv env' env₂ ∧ [] = res
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
cases H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : [] = res ∧ env = env'
⊢ SSAEnv.equiv env' env₂ ∧ [] = res
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
left✝ : [] = res
right✝ : env = env'
⊢ SSAEnv.equiv env' env₂ ∧ [] = res
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
subst res env
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
left✝ : [] = res
right✝ : env = env'
⊢ SSAEnv.equiv env' env₂ ∧ [] = res
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env' env₂
⊢ SSAEnv.equiv env' env₂ ∧ [] = []
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
constructor <;> simp
|
case intro
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env' env₂
⊢ SSAEnv.equiv env' env₂ ∧ [] = []
|
case intro.left
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env' env₂
⊢ SSAEnv.equiv env' env₂
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
try assumption
|
case intro.left
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env' env₂
⊢ SSAEnv.equiv env' env₂
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
assumption
|
case intro.left
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env' env₂
⊢ SSAEnv.equiv env' env₂
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
intros env res env' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
⊢ ∀ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteOps Δ (head :: tail) env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : denoteOps Δ (head :: tail) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
unfold denoteOps at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : denoteOps Δ (head :: tail) env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match head :: tail with
| [] => pure []
| [stmt] => denoteOp Δ stmt
| stmt :: stmts' => do
let __discr ← denoteOp Δ stmt
let x : TypedArgs Δ := __discr
denoteOps Δ stmts')
env =
Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp_monad at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match head :: tail with
| [] => pure []
| [stmt] => denoteOp Δ stmt
| stmt :: stmts' => do
let __discr ← denoteOp Δ stmt
let x : TypedArgs Δ := __discr
denoteOps Δ stmts')
env =
Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match head :: tail with
| [] => fun s => Except.ok ([], s)
| [stmt] => denoteOp Δ stmt
| stmt :: stmts' => fun s =>
match denoteOp Δ stmt s with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ stmts' v.snd)
env =
Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
match TAIL: tail with
| .nil =>
apply denoteOp_equiv <;> assumption
| .cons head2 tail2 =>
simp [denoteOps] at *; simp_monad at *
split at H <;> try contradiction
case h_2 headR HHeadR =>
have ⟨headR, headEnv⟩ := headR; simp at *
have ⟨envHead, HenvHead, HdenoteHead⟩ := denoteOp_equiv HHeadR Henv₂
simp [HdenoteHead]
rw [←TAIL] at H; rw [←TAIL]
apply denoteOps_equiv H HenvHead
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match head :: tail with
| [] => fun s => Except.ok ([], s)
| [stmt] => denoteOp Δ stmt
| stmt :: stmts' => fun s =>
match denoteOp Δ stmt s with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ stmts' v.snd)
env =
Except.ok (res, env')
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: tail) env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
apply denoteOp_equiv <;> assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match [head] with
| [] => fun s => Except.ok ([], s)
| [stmt] => denoteOp Δ stmt
| stmt :: stmts' => fun s =>
match denoteOp Δ stmt s with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ stmts' v.snd)
env =
Except.ok (res, env')
TAIL : tail = []
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ [head] env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp [denoteOps] at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
H :
(match head :: head2 :: tail2 with
| [] => fun s => Except.ok ([], s)
| [stmt] => denoteOp Δ stmt
| stmt :: stmts' => fun s =>
match denoteOp Δ stmt s with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ stmts' v.snd)
env =
Except.ok (res, env')
TAIL : tail = head2 :: tail2
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head :: head2 :: tail2) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
H :
(match denoteOp Δ head env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env')
TAIL : tail = head2 :: tail2
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
bind (denoteOp Δ head) (fun __discr => denoteOps Δ (head2 :: tail2)) env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
H :
(match denoteOp Δ head env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env')
TAIL : tail = head2 :: tail2
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
bind (denoteOp Δ head) (fun __discr => denoteOps Δ (head2 :: tail2)) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
H :
(match denoteOp Δ head env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env')
TAIL : tail = head2 :: tail2
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
split at H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
H :
(match denoteOp Δ head env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env')
TAIL : tail = head2 :: tail2
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
v✝ : List (TypedArg Δ) × SSAEnv Δ
heq✝ : denoteOp Δ head env = Except.ok v✝
H : denoteOps Δ (head2 :: tail2) v✝.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
case h_2 headR HHeadR =>
have ⟨headR, headEnv⟩ := headR; simp at *
have ⟨envHead, HenvHead, HdenoteHead⟩ := denoteOp_equiv HHeadR Henv₂
simp [HdenoteHead]
rw [←TAIL] at H; rw [←TAIL]
apply denoteOps_equiv H HenvHead
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR : List (TypedArg Δ) × SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok headR
H : denoteOps Δ (head2 :: tail2) headR.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ : denoteOp Δ head env = Except.error err✝
H : Except.error err✝ = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
have ⟨headR, headEnv⟩ := headR
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR : List (TypedArg Δ) × SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok headR
H : denoteOps Δ (head2 :: tail2) headR.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) (headR, headEnv).snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) (headR, headEnv).snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) headEnv = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
have ⟨envHead, HenvHead, HdenoteHead⟩ := denoteOp_equiv HHeadR Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) headEnv = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
simp [HdenoteHead]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteOp Δ head env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ (head2 :: tail2) v.snd) =
Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head2 :: tail2) envHead = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
rw [←TAIL] at H
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ (head2 :: tail2) headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head2 :: tail2) envHead = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ tail headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head2 :: tail2) envHead = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
rw [←TAIL]
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ tail headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ (head2 :: tail2) envHead = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ tail headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ tail envHead = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteOps_equiv
|
[927, 1]
|
[952, 39]
|
apply denoteOps_equiv H HenvHead
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
head : Op Δ
tail : List (Op Δ)
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
head2 : Op Δ
tail2 : List (Op Δ)
TAIL : tail = head2 :: tail2
x✝ : Except (String × SSAEnv Δ) (List (TypedArg Δ) × SSAEnv Δ)
headR✝ : List (TypedArg Δ) × SSAEnv Δ
headR : List (TypedArg Δ)
headEnv : SSAEnv Δ
HHeadR : denoteOp Δ head env = Except.ok (headR, headEnv)
H : denoteOps Δ tail headEnv = Except.ok (res, env')
envHead : SSAEnv Δ
HenvHead : SSAEnv.equiv headEnv envHead
HdenoteHead : denoteOp Δ head env₂ = Except.ok (headR, envHead)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ tail envHead = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
cases region
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
region : Region Δ
⊢ ∀ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteRegion Δ region args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteRegion Δ region args env₂ = Except.ok (res, env₂')
|
case mk
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
name✝ : String
args✝ : List (TypedSSAVal Δ)
ops✝ : List (Op Δ)
⊢ ∀ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteRegion Δ (Region.mk name✝ args✝ ops✝) args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ denoteRegion Δ (Region.mk name✝ args✝ ops✝) args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
case mk rName rArgs rOps =>
intros args env res env' H env₂ Henv₂
simp [denoteRegion] at *; simp_monad at *
(split at H <;> try contradiction); rename_i argsR HargsR
have ⟨argsR, argsEnv⟩ := argsR; cases argsR
have ⟨argsEnv₂, HargsEnv₂, HdenoteArgs⟩ := denoteTypedArgs_equiv HargsR Henv₂
rw [HdenoteArgs]; simp at *
apply denoteOps_equiv (by assumption) (by assumption)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
⊢ ∀ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteRegion Δ (Region.mk rName rArgs rOps) args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ denoteRegion Δ (Region.mk rName rArgs rOps) args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
intros args env res env' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
⊢ ∀ ⦃args : TypedArgs Δ⦄ ⦃env : SSAEnv Δ⦄ ⦃res : TypedArgs Δ⦄ ⦃env' : SSAEnv Δ⦄,
denoteRegion Δ (Region.mk rName rArgs rOps) args env = Except.ok (res, env') →
∀ ⦃env₂ : SSAEnv Δ⦄,
SSAEnv.equiv env env₂ →
∃ env₂',
SSAEnv.equiv env' env₂' ∧ denoteRegion Δ (Region.mk rName rArgs rOps) args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : denoteRegion Δ (Region.mk rName rArgs rOps) args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteRegion Δ (Region.mk rName rArgs rOps) args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
simp [denoteRegion] at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : denoteRegion Δ (Region.mk rName rArgs rOps) args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteRegion Δ (Region.mk rName rArgs rOps) args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : bind (denoteTypedArgs args (List.map Prod.fst rArgs)) (fun x => denoteOps Δ rOps) env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
bind (denoteTypedArgs args (List.map Prod.fst rArgs)) (fun x => denoteOps Δ rOps) env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
simp_monad at *
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H : bind (denoteTypedArgs args (List.map Prod.fst rArgs)) (fun x => denoteOps Δ rOps) env = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
bind (denoteTypedArgs args (List.map Prod.fst rArgs)) (fun x => denoteOps Δ rOps) env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match denoteTypedArgs args (List.map Prod.fst rArgs) env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
(split at H <;> try contradiction)
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match denoteTypedArgs args (List.map Prod.fst rArgs) env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
v✝ : Unit × SSAEnv Δ
heq✝ : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok v✝
H : denoteOps Δ rOps v✝.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
rename_i argsR HargsR
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
v✝ : Unit × SSAEnv Δ
heq✝ : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok v✝
H : denoteOps Δ rOps v✝.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok argsR
H : denoteOps Δ rOps argsR.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
have ⟨argsR, argsEnv⟩ := argsR
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok argsR
H : denoteOps Δ rOps argsR.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR✝ : Unit × SSAEnv Δ
argsR : Unit
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (argsR, argsEnv)
H : denoteOps Δ rOps (argsR, argsEnv).snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
cases argsR
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR✝ : Unit × SSAEnv Δ
argsR : Unit
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (argsR, argsEnv)
H : denoteOps Δ rOps (argsR, argsEnv).snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps (PUnit.unit, argsEnv).snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
have ⟨argsEnv₂, HargsEnv₂, HdenoteArgs⟩ := denoteTypedArgs_equiv HargsR Henv₂
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps (PUnit.unit, argsEnv).snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps (PUnit.unit, argsEnv).snd = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
rw [HdenoteArgs]
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps (PUnit.unit, argsEnv).snd = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps (PUnit.unit, argsEnv).snd = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match Except.ok (PUnit.unit, argsEnv₂) with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
simp at *
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps (PUnit.unit, argsEnv).snd = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match Except.ok (PUnit.unit, argsEnv₂) with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps argsEnv = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ rOps argsEnv₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
apply denoteOps_equiv (by assumption) (by assumption)
|
case h_2.unit
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps argsEnv = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ denoteOps Δ rOps argsEnv₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
split at H <;> try contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
H :
(match denoteTypedArgs args (List.map Prod.fst rArgs) env with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
case h_2
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
v✝ : Unit × SSAEnv Δ
heq✝ : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok v✝
H : denoteOps Δ rOps v✝.snd = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
contradiction
|
case h_1
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
err✝ : String × SSAEnv Δ
heq✝ : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.error err✝
H : Except.error err✝ = Except.ok (res, env')
⊢ ∃ env₂',
SSAEnv.equiv env' env₂' ∧
(match denoteTypedArgs args (List.map Prod.fst rArgs) env₂ with
| Except.error err => Except.error err
| Except.ok v => denoteOps Δ rOps v.snd) =
Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps argsEnv = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ denoteOps Δ rOps ?m.1614925 = Except.ok (res, env')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
denoteRegion_equiv
|
[954, 1]
|
[968, 56]
|
assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
rName : String
rArgs : List (TypedSSAVal Δ)
rOps : List (Op Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
x✝ : Except (String × SSAEnv Δ) (Unit × SSAEnv Δ)
argsR : Unit × SSAEnv Δ
argsEnv : SSAEnv Δ
HargsR : denoteTypedArgs args (List.map Prod.fst rArgs) env = Except.ok (PUnit.unit, argsEnv)
H : denoteOps Δ rOps argsEnv = Except.ok (res, env')
argsEnv₂ : SSAEnv Δ
HargsEnv₂ : SSAEnv.equiv argsEnv argsEnv₂
HdenoteArgs : denoteTypedArgs args (List.map Prod.fst rArgs) env₂ = Except.ok (PUnit.unit, argsEnv₂)
⊢ SSAEnv.equiv argsEnv argsEnv₂
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
mapDenoteRegion_equiv
|
[970, 1]
|
[992, 49]
|
match REGIONS: regions with
| .nil =>
intros region HregIn args env res env' H env₂ Henv₂
contradiction
| .cons head tail =>
intros region HregIn args env res env' H env₂ Henv₂
simp [TopM.mapDenoteRegion] at HregIn
cases HregIn
case inl HXX =>
subst HXX;
sorry
case inr HXX =>
apply mapDenoteRegion_equiv <;> assumption
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
⊢ denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ regions)
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
mapDenoteRegion_equiv
|
[970, 1]
|
[992, 49]
|
intros region HregIn args env res env' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
REGIONS : regions = []
⊢ denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ [])
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
REGIONS : regions = []
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
HregIn : region ∈ TopM.mapDenoteRegion Δ []
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
mapDenoteRegion_equiv
|
[970, 1]
|
[992, 49]
|
contradiction
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
REGIONS : regions = []
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
HregIn : region ∈ TopM.mapDenoteRegion Δ []
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
no goals
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
mapDenoteRegion_equiv
|
[970, 1]
|
[992, 49]
|
intros region HregIn args env res env' H env₂ Henv₂
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
⊢ denoteRegionsEquivInvariant (TopM.mapDenoteRegion Δ (head :: tail))
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
HregIn : region ∈ TopM.mapDenoteRegion Δ (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
mapDenoteRegion_equiv
|
[970, 1]
|
[992, 49]
|
simp [TopM.mapDenoteRegion] at HregIn
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
HregIn : region ∈ TopM.mapDenoteRegion Δ (head :: tail)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HregIn : region = TopM.scoped ∘ denoteRegion Δ head ∨ region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
https://github.com/opencompl/lean-mlir.git
|
e43d21592801e5e40477b14b7a554e356060c40c
|
MLIR/Semantics/Semantics.lean
|
mapDenoteRegion_equiv
|
[970, 1]
|
[992, 49]
|
cases HregIn
|
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
HregIn : region = TopM.scoped ∘ denoteRegion Δ head ∨ region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
case inl
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
h✝ : region = TopM.scoped ∘ denoteRegion Δ head
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
case inr
α₁ σ₁ : Type
ε₁ : σ₁ → Type
δ₁ : Dialect α₁ σ₁ ε₁
α₂ σ₂ : Type
ε₂ : σ₂ → Type
δ₂ : Dialect α₂ σ₂ ε₂
α σ : Type
ε : σ → Type
Δ : Dialect α σ ε
S : Semantics Δ
regions : List (Region Δ)
head : Region Δ
tail : List (Region Δ)
REGIONS : regions = head :: tail
region : TypedArgs Δ → TopM Δ (TypedArgs Δ)
args : TypedArgs Δ
env : SSAEnv Δ
res : TypedArgs Δ
env' : SSAEnv Δ
H : region args env = Except.ok (res, env')
env₂ : SSAEnv Δ
Henv₂ : SSAEnv.equiv env env₂
h✝ : region ∈ TopM.mapDenoteRegion Δ tail
⊢ ∃ env₂', SSAEnv.equiv env' env₂' ∧ region args env₂ = Except.ok (res, env₂')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.