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/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | funext r | case mk.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : Config.regs { ip := none, regs := regs } WithIO.io = m
β’ regs = fun x =>
match x with
| WithIO.io => m
| WithIO.internal r => regs (WithIO.internal r) | case mk.refl.h
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : Config.regs { ip := none, regs := regs } WithIO.io = m
r : WithIO R
β’ regs r =
match r with
| WithIO.io => m
| WithIO.internal r => regs (WithIO.internal r) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : Config.regs { ip := none, regs := regs } WithIO.io = m
β’ regs = fun x =>
match x with
| WithIO.io => m
| WithIO.internal r => regs (WithIO.internal r)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | cases r <;> simp at h β’ | case mk.refl.h
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : Config.regs { ip := none, regs := regs } WithIO.io = m
r : WithIO R
β’ regs r =
match r with
| WithIO.io => m
| WithIO.internal r => regs (WithIO.internal r) | case mk.refl.h.io
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : regs WithIO.io = m
β’ regs WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.refl.h
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : Config.regs { ip := none, regs := regs } WithIO.io = m
r : WithIO R
β’ regs r =
match r with
| WithIO.io => m
| WithIO.internal r => regs (WithIO.internal r)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | . exact h | case mk.refl.h.io
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : regs WithIO.io = m
β’ regs WithIO.io = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.refl.h.io
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : regs WithIO.io = m
β’ regs WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | exact h | case mk.refl.h.io
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : regs WithIO.io = m
β’ regs WithIO.io = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.refl.h.io
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : WithIO R β β
h : regs WithIO.io = m
β’ regs WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | rcases h with β¨regs,hβ© | case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
h : β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
β’ Config.regs d WithIO.io = m | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
regs : R β β
h : Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
β’ Config.regs d WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
h : β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
β’ Config.regs d WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | have := halt_is_fixpoint _ h hd | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
regs : R β β
h : Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
β’ Config.regs d WithIO.io = m | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
regs : R β β
h : Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
this : d = Config.haltedOn m regs
β’ Config.regs d WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
regs : R β β
h : Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
β’ Config.regs d WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | clear h hd | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
regs : R β β
h : Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
this : d = Config.haltedOn m regs
β’ Config.regs d WithIO.io = m | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
regs : R β β
this : d = Config.haltedOn m regs
β’ Config.regs d WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
regs : R β β
h : Relation.ReflTransGen (fun c d => step S.prog c = d) d (Config.haltedOn m regs)
this : d = Config.haltedOn m regs
β’ Config.regs d WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | cases this | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
regs : R β β
this : d = Config.haltedOn m regs
β’ Config.regs d WithIO.io = m | case mpr.intro.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : R β β
β’ Config.regs (Config.haltedOn m regs) WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
regs : R β β
this : d = Config.haltedOn m regs
β’ Config.regs d WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp | case mpr.intro.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : R β β
β’ Config.regs (Config.haltedOn m regs) WithIO.io = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c : Config (WithIO R) L
regs : R β β
β’ Config.regs (Config.haltedOn m regs) WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | clear c | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, a [S.prog]==>* Config.haltedOn m regs | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
c d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | unfold eval.aux | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, a [S.prog]==>* Config.haltedOn m regs | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β
False);
eval.aux S.prog c') =
m β
β regs, a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | constructor <;> intro h | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β
False);
eval.aux S.prog c') =
m β
β regs, a [S.prog]==>* Config.haltedOn m regs | case mp
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
β’ β regs, a [S.prog]==>* Config.haltedOn m regs
case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h : β regs, a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β
False);
eval.aux S.prog c') =
m β
β regs, a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | . rcases h with β¨regs,hβ©
split
next ha =>
simp only at *
have := halt_is_fixpoint _ h ha
simp [this]
next ha =>
simp
cases ha_to_b
apply ih.mpr
use regs
have := stepsToTrans_of_not_halts_stepsToTransRefl_halts _ h ?_ ?_
. rcases Relation.TransGen.head'_iff.mp this with β¨e,rfl,heβ©
exact he
. simp at ha; simp [ha]
. simp | case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h : β regs, a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h : β regs, a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | rcases this with β¨regs,hβ© | case mp
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
this : β regs, b [S.prog]==>* Config.haltedOn m regs
β’ β regs, a [S.prog]==>* Config.haltedOn m regs | case mp.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
hβ :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
regs : R β β
h : b [S.prog]==>* Config.haltedOn m regs
β’ β regs, a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
this : β regs, b [S.prog]==>* Config.haltedOn m regs
β’ β regs, a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | use regs | case mp.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
hβ :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
regs : R β β
h : b [S.prog]==>* Config.haltedOn m regs
β’ β regs, a [S.prog]==>* Config.haltedOn m regs | case mp.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
hβ :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
regs : R β β
h : b [S.prog]==>* Config.haltedOn m regs
β’ a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
hβ :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
regs : R β β
h : b [S.prog]==>* Config.haltedOn m regs
β’ β regs, a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | exact .head ha_to_b h | case mp.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
hβ :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
regs : R β β
h : b [S.prog]==>* Config.haltedOn m regs
β’ a [S.prog]==>* Config.haltedOn m regs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
hβ :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
regs : R β β
h : b [S.prog]==>* Config.haltedOn m regs
β’ a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp at * | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
β’ β regs, b [S.prog]==>* Config.haltedOn m regs | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
h :
(match hc : Config.is_halted a with
| true => Config.regs a WithIO.io
| false =>
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) }) =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h :
(match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
β’ β regs, b [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | split at h | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
h :
(match hc : Config.is_halted a with
| true => Config.regs a WithIO.io
| false =>
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) }) =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | case h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
h :
(match hc : Config.is_halted a with
| true => Config.regs a WithIO.io
| false =>
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) }) =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | . apply ih.mp
cases ha_to_b
exact h | case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | have : a = b := halt_is_fixpoint _ (.single ha_to_b) βΉ_βΊ | case h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | case h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
this : a = b
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | cases this | case h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
this : a = b
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | case h_1.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
this : a = b
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | rw [this] | case h_1.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
this : a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x)
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs) | case h_1.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
this : a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x)
β’ β regs,
Relation.ReflTransGen (fun c d => step S.prog c = d) (Config.haltedOn m fun x => Config.regs a (WithIO.internal x))
(Config.haltedOn m regs) | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
this : a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x)
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | refine β¨_, Relation.ReflTransGen.reflβ© | case h_1.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
this : a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x)
β’ β regs,
Relation.ReflTransGen (fun c d => step S.prog c = d) (Config.haltedOn m fun x => Config.regs a (WithIO.internal x))
(Config.haltedOn m regs) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_1.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
this : a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x)
β’ β regs,
Relation.ReflTransGen (fun c d => step S.prog c = d) (Config.haltedOn m fun x => Config.regs a (WithIO.internal x))
(Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | cases a | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
β’ a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x) | case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
heqβ : Config.is_halted { ip := ipβ, regs := regsβ } = true
h : Config.regs { ip := ipβ, regs := regsβ } WithIO.io = m
ha_to_b : { ip := ipβ, regs := regsβ } [S.prog]==> { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
β’ { ip := ipβ, regs := regsβ } = Config.haltedOn m fun x => Config.regs { ip := ipβ, regs := regsβ } (WithIO.internal x) | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = true
h : Config.regs a WithIO.io = m
ha_to_b : a [S.prog]==> a
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) a d
ih :
eval.aux S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) a (Config.haltedOn m regs)
β’ a = Config.haltedOn m fun x => Config.regs a (WithIO.internal x)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp at * | case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
heqβ : Config.is_halted { ip := ipβ, regs := regsβ } = true
h : Config.regs { ip := ipβ, regs := regsβ } WithIO.io = m
ha_to_b : { ip := ipβ, regs := regsβ } [S.prog]==> { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
β’ { ip := ipβ, regs := regsβ } = Config.haltedOn m fun x => Config.regs { ip := ipβ, regs := regsβ } (WithIO.internal x) | case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
β’ { ip := ipβ, regs := regsβ } = Config.haltedOn m fun x => regsβ (WithIO.internal x) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
heqβ : Config.is_halted { ip := ipβ, regs := regsβ } = true
h : Config.regs { ip := ipβ, regs := regsβ } WithIO.io = m
ha_to_b : { ip := ipβ, regs := regsβ } [S.prog]==> { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
β’ { ip := ipβ, regs := regsβ } = Config.haltedOn m fun x => Config.regs { ip := ipβ, regs := regsβ } (WithIO.internal x)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp [Config.haltedOn, *] | case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
β’ { ip := ipβ, regs := regsβ } = Config.haltedOn m fun x => regsβ (WithIO.internal x) | case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
β’ regsβ = fun x =>
match x with
| WithIO.io => m
| WithIO.internal r => regsβ (WithIO.internal r) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
β’ { ip := ipβ, regs := regsβ } = Config.haltedOn m fun x => regsβ (WithIO.internal x)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | funext x | case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
β’ regsβ = fun x =>
match x with
| WithIO.io => m
| WithIO.internal r => regsβ (WithIO.internal r) | case mk.h
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
x : WithIO R
β’ regsβ x =
match x with
| WithIO.io => m
| WithIO.internal r => regsβ (WithIO.internal r) | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
β’ regsβ = fun x =>
match x with
| WithIO.io => m
| WithIO.internal r => regsβ (WithIO.internal r)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | split <;> simp [*] | case mk.h
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
x : WithIO R
β’ regsβ x =
match x with
| WithIO.io => m
| WithIO.internal r => regsβ (WithIO.internal r) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk.h
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
ipβ : Option L
regsβ : WithIO R β β
h : regsβ WithIO.io = m
ha_to_b : step S.prog { ip := ipβ, regs := regsβ } = { ip := ipβ, regs := regsβ }
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) { ip := ipβ, regs := regsβ } d
ih :
eval.aux S.prog
{ config := { ip := ipβ, regs := regsβ },
halts := (_ : β d, ({ ip := ipβ, regs := regsβ } [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) { ip := ipβ, regs := regsβ } (Config.haltedOn m regs)
heqβ : ipβ = none
x : WithIO R
β’ regsβ x =
match x with
| WithIO.io => m
| WithIO.internal r => regsβ (WithIO.internal r)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | apply ih.mp | case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs) | case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | cases ha_to_b | case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m | case h_2.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = false
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) (step S.prog a) (Config.haltedOn m regs)
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) b (Config.haltedOn m regs)
heqβ : Config.is_halted a = false
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | exact h | case h_2.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = false
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) (step S.prog a) (Config.haltedOn m regs)
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h_2.refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
heqβ : Config.is_halted a = false
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, Relation.ReflTransGen (fun c d => step S.prog c = d) (step S.prog a) (Config.haltedOn m regs)
h :
eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
β’ eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | rcases h with β¨regs,hβ© | case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h : β regs, a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
h : β regs, a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | split | case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | case mpr.intro.h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = true
β’ Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io = m
case mpr.intro.h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
β’ (match hc :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config with
| true =>
Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io
| false =>
let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | next ha =>
simp only at *
have := halt_is_fixpoint _ h ha
simp [this] | case mpr.intro.h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = true
β’ Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io = m
case mpr.intro.h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | case mpr.intro.h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.h_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = true
β’ Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io = m
case mpr.intro.h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | next ha =>
simp
cases ha_to_b
apply ih.mpr
use regs
have := stepsToTrans_of_not_halts_stepsToTransRefl_halts _ h ?_ ?_
. rcases Relation.TransGen.head'_iff.mp this with β¨e,rfl,heβ©
exact he
. simp at ha; simp [ha]
. simp | case mpr.intro.h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.h_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
heqβ :
Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp only at * | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = true
β’ Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io = m | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = true
β’ Config.regs a WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = true
β’ Config.regs { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | have := halt_is_fixpoint _ h ha | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = true
β’ Config.regs a WithIO.io = m | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = true
this : a = Config.haltedOn m regs
β’ Config.regs a WithIO.io = m | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = true
β’ Config.regs a WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp [this] | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = true
this : a = Config.haltedOn m regs
β’ Config.regs a WithIO.io = m | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = true
this : a = Config.haltedOn m regs
β’ Config.regs a WithIO.io = m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ (let c' :=
{
config :=
step S.prog { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) };
let_fun this :=
(_ :
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config.ip = none β False);
eval.aux S.prog c') =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | cases ha_to_b | R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m | case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m | Please generate a tactic in lean4 to solve the state.
STATE:
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a b : Config (WithIO R) L
ha_to_b : a [S.prog]==> b
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) b d
ih :
eval.aux S.prog { config := b, halts := (_ : β d, (b [S.prog]==>* d) β§ Config.is_halted d = true) } = m β
β regs, b [S.prog]==>* Config.haltedOn m regs
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | apply ih.mpr | case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m | case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ eval.aux S.prog
{ config := step S.prog a,
halts :=
(_ :
halts S.prog
(step S.prog
{ config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config)) } =
m
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | use regs | case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs | case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | have := stepsToTrans_of_not_halts_stepsToTransRefl_halts _ h ?_ ?_ | case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs | case refl.refine_3
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs
case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | Please generate a tactic in lean4 to solve the state.
STATE:
case refl
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | . rcases Relation.TransGen.head'_iff.mp this with β¨e,rfl,heβ©
exact he | case refl.refine_3
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs
case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_3
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs
case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | . simp at ha; simp [ha] | case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | . simp | case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | rcases Relation.TransGen.head'_iff.mp this with β¨e,rfl,heβ© | case refl.refine_3
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs | case refl.refine_3.intro.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
he : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) (Config.haltedOn m regs)
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_3
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | exact he | case refl.refine_3.intro.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
he : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) (Config.haltedOn m regs)
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_3.intro.intro
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
this : a [S.prog]==>+ Config.haltedOn m regs
he : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) (Config.haltedOn m regs)
β’ step S.prog a [S.prog]==>* Config.haltedOn m regs
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp at ha | case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true | case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = false
β’ Β¬Config.is_halted a = true | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Β¬Config.is_halted a = true
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp [ha] | case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = false
β’ Β¬Config.is_halted a = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_1
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted a = false
β’ Β¬Config.is_halted a = true
TACTIC:
|
https://github.com/JamesGallicchio/lean_rms.git | b2eba106861c05584458e01a241153abd30d0b5b | RegMachine/Basic.lean | RegMachine.Prog.Start.eval_eq | [239, 1] | [308, 15] | simp | case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case refl.refine_2
R L : Type
P : Prog R L
instβ : DecidableEq R
S : Start (WithIO R) L
m : β
d : Config (WithIO R) L
hd : Config.is_halted d = true
a : Config (WithIO R) L
regs : R β β
h : a [S.prog]==>* Config.haltedOn m regs
hb_to_d : Relation.ReflTransGen (stepsTo S.prog) (step S.prog a) d
ih :
eval.aux S.prog
{ config := step S.prog a, halts := (_ : β d, (step S.prog a [S.prog]==>* d) β§ Config.is_halted d = true) } =
m β
β regs, step S.prog a [S.prog]==>* Config.haltedOn m regs
ha : Config.is_halted { config := a, halts := (_ : β d, (a [S.prog]==>* d) β§ Config.is_halted d = true) }.config = false
β’ Config.is_halted (Config.haltedOn m regs) = true
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section03_functions/sheet1.lean | injective_def | [9, 1] | [12, 6] | rfl | X Y Z : Type
f : X β Y
β’ Injective f β β (a b : X), f a = f b β a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X Y Z : Type
f : X β Y
β’ Injective f β β (a b : X), f a = f b β a = b
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section03_functions/sheet1.lean | surjective_def | [14, 1] | [17, 6] | rfl | X Y Z : Type
f : X β Y
β’ Surjective f β β (b : Y), β a, f a = b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X Y Z : Type
f : X β Y
β’ Surjective f β β (b : Y), β a, f a = b
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section03_functions/sheet1.lean | id_eval | [21, 1] | [24, 6] | rfl | X Y Z : Type
x : X
β’ id x = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X Y Z : Type
x : X
β’ id x = x
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section03_functions/sheet1.lean | comp_eval | [28, 1] | [31, 6] | rfl | X Y Z : Type
f : X β Y
g : Y β Z
x : X
β’ (g β f) x = g (f x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
X Y Z : Type
f : X β Y
g : Y β Z
x : X
β’ (g β f) x = g (f x)
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_def | [9, 1] | [13, 6] | rfl | a : β β β
t : β
β’ tends_to a t β β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t : β
β’ tends_to a t β β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_thirtyseven | [17, 1] | [24, 11] | rw [tends_to_def] | β’ tends_to (fun x => 37) 37 | β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |37 - 37| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
β’ tends_to (fun x => 37) 37
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_thirtyseven | [17, 1] | [24, 11] | intro Ξ΅ hΞ΅ | β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |37 - 37| < Ξ΅ | Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |37 - 37| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |37 - 37| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_thirtyseven | [17, 1] | [24, 11] | use 0 | Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |37 - 37| < Ξ΅ | case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β (n : β), 0 β€ n β |37 - 37| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |37 - 37| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_thirtyseven | [17, 1] | [24, 11] | intro n _ | case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β (n : β), 0 β€ n β |37 - 37| < Ξ΅ | case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ |37 - 37| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β (n : β), 0 β€ n β |37 - 37| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_thirtyseven | [17, 1] | [24, 11] | norm_num | case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ |37 - 37| < Ξ΅ | case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ 0 < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ |37 - 37| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_thirtyseven | [17, 1] | [24, 11] | apply hΞ΅ | case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ 0 < Ξ΅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ 0 < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_const | [26, 1] | [33, 11] | rw [tends_to_def] | c : β
β’ tends_to (fun x => c) c | c : β
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |c - c| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
c : β
β’ tends_to (fun x => c) c
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_const | [26, 1] | [33, 11] | intro Ξ΅ hΞ΅ | c : β
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |c - c| < Ξ΅ | c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |c - c| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
c : β
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |c - c| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_const | [26, 1] | [33, 11] | use 0 | c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |c - c| < Ξ΅ | case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β (n : β), 0 β€ n β |c - c| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |c - c| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_const | [26, 1] | [33, 11] | intro n _ | case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β (n : β), 0 β€ n β |c - c| < Ξ΅ | case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ |c - c| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β (n : β), 0 β€ n β |c - c| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_const | [26, 1] | [33, 11] | norm_num | case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ |c - c| < Ξ΅ | case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ 0 < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ |c - c| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_const | [26, 1] | [33, 11] | apply hΞ΅ | case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ 0 < Ξ΅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
c Ξ΅ : β
hΞ΅ : 0 < Ξ΅
n : β
aβ : 0 β€ n
β’ 0 < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | rw [tends_to_def] at * | a : β β β
t c : β
h : tends_to a t
β’ tends_to (fun n => a n + c) (t + c) | a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t c : β
h : tends_to a t
β’ tends_to (fun n => a n + c) (t + c)
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | intro Ξ΅ hΞ΅ | a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | have hΞ΅' := h Ξ΅ $ hΞ΅ | a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
hΞ΅' : β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | obtain β¨B', hΞ΅''β© := hΞ΅' | a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
hΞ΅' : β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | case intro
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
hΞ΅' : β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | use B' | case intro
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅ | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
β’ β (n : β), B' β€ n β |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | intro n hn | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
β’ β (n : β), B' β€ n β |a n + c - (t + c)| < Ξ΅ | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
β’ |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
β’ β (n : β), B' β€ n β |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | have h' := hΞ΅'' n hn | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
β’ |a n + c - (t + c)| < Ξ΅ | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
h' : |a n - t| < Ξ΅
β’ |a n + c - (t + c)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
β’ |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | norm_num | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
h' : |a n - t| < Ξ΅
β’ |a n + c - (t + c)| < Ξ΅ | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
h' : |a n - t| < Ξ΅
β’ |a n - t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
h' : |a n - t| < Ξ΅
β’ |a n + c - (t + c)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet3.lean | tends_to_add_const | [35, 1] | [48, 7] | apply h' | case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
h' : |a n - t| < Ξ΅
β’ |a n - t| < Ξ΅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t c : β
h : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅ : 0 < Ξ΅
B' : β
hΞ΅'' : β (n : β), B' β€ n β |a n - t| < Ξ΅
n : β
hn : B' β€ n
h' : |a n - t| < Ξ΅
β’ |a n - t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | rw [tends_to_def] at * | a : β β β
t : β
ha : tends_to a t
β’ tends_to (fun n => -a n) (-t) | a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t : β
ha : tends_to a t
β’ tends_to (fun n => -a n) (-t)
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | intro Ξ΅ hΞ΅pos | a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅ | a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | obtain β¨N, hβ© := ha Ξ΅ hΞ΅pos | a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅ | case intro
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | use N | case intro
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
β’ β (n : β), N β€ n β |-a n - -t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
β’ β B, β (n : β), B β€ n β |-a n - -t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | intro n hn | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
β’ β (n : β), N β€ n β |-a n - -t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
β’ |-a n - -t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
β’ β (n : β), N β€ n β |-a n - -t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | simp | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
β’ |-a n - -t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
β’ |-a n + t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
β’ |-a n - -t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | have h' := h n hn | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
β’ |-a n + t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |a n - t| < Ξ΅
β’ |-a n + t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
β’ |-a n + t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | rw [β abs_neg] at h' | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |a n - t| < Ξ΅
β’ |-a n + t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |(-(a n - t))| < Ξ΅
β’ |-a n + t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |a n - t| < Ξ΅
β’ |-a n + t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | simp at h' | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |(-(a n - t))| < Ξ΅
β’ |-a n + t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |t - a n| < Ξ΅
β’ |-a n + t| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |(-(a n - t))| < Ξ΅
β’ |-a n + t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | rw [add_comm] | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |t - a n| < Ξ΅
β’ |-a n + t| < Ξ΅ | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |t - a n| < Ξ΅
β’ |t + -a n| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |t - a n| < Ξ΅
β’ |-a n + t| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_neg | [15, 1] | [29, 7] | apply h' | case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |t - a n| < Ξ΅
β’ |t + -a n| < Ξ΅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a : β β β
t : β
ha : β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n - t| < Ξ΅
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
N : β
h : β (n : β), N β€ n β |a n - t| < Ξ΅
n : β
hn : N β€ n
h' : |t - a n| < Ξ΅
β’ |t + -a n| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | rw [tends_to_def] | a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
β’ tends_to (fun n => a n + b n) (t + u) | a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
β’ tends_to (fun n => a n + b n) (t + u)
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | intro Ξ΅ hΞ΅pos | a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
β’ β (Ξ΅ : β), 0 < Ξ΅ β β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | rw [tends_to] at ha | a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β β β
t u : β
ha : tends_to a t
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | have haΞ΅ : 0 < Ξ΅ / 2 :=
by
linarith | a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
haΞ΅ : 0 < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | apply ha at haΞ΅ | a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
haΞ΅ : 0 < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
haΞ΅ : β B, β (n : β), B β€ n β |a n - t| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
haΞ΅ : 0 < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | obtain β¨Na, ha'β© := haΞ΅ | a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
haΞ΅ : β B, β (n : β), B β€ n β |a n - t| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
haΞ΅ : β B, β (n : β), B β€ n β |a n - t| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | have hbΞ΅ : 0 < Ξ΅ / 2 :=
by
linarith | case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
hbΞ΅ : 0 < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | apply hb at hbΞ΅ | case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
hbΞ΅ : 0 < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
hbΞ΅ : β B, β (n : β), B β€ n β |b n - u| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
hbΞ΅ : 0 < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | obtain β¨Nb, hb'β© := hbΞ΅ | case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
hbΞ΅ : β B, β (n : β), B β€ n β |b n - u| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | case intro.intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
hbΞ΅ : β B, β (n : β), B β€ n β |b n - u| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | let Nab := max Na Nb | case intro.intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | case intro.intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | use Nab | case intro.intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅ | case h
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
β’ β (n : β), Nab β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
β’ β B, β (n : β), B β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
https://github.com/rikitoro/FM2023_exercise.git | 5f189bdf83b1e5fba19d25a36272bd87dfcdcc55 | FM2023Exrcise/section02_reals/sheet5.lean | tends_to_add | [32, 1] | [80, 7] | intro n | case h
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
β’ β (n : β), Nab β€ n β |a n + b n - (t + u)| < Ξ΅ | case h
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
n : β
β’ Nab β€ n β |a n + b n - (t + u)| < Ξ΅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
a b : β β β
t u : β
ha : β Ξ΅ > 0, β B, β (n : β), B β€ n β |a n - t| < Ξ΅
hb : tends_to b u
Ξ΅ : β
hΞ΅pos : 0 < Ξ΅
Na : β
ha' : β (n : β), Na β€ n β |a n - t| < Ξ΅ / 2
Nb : β
hb' : β (n : β), Nb β€ n β |b n - u| < Ξ΅ / 2
Nab : β := max Na Nb
β’ β (n : β), Nab β€ n β |a n + b n - (t + u)| < Ξ΅
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.