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